From b65ace37de4f585b8089ad413ee877b792da11ca Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Sat, 3 Aug 2024 23:21:44 +0200 Subject: Waterline rework (#2577) * Add barebones PurificationPlant class * Make simple 3x3 structure to form purification plant * Add base purification unit class and dummy sifter unit MTE * Make sifter unit form * Fix accidental wildcard import * Implement basic linking of units to controller using data stick * Make linking more robust, save bidirectional links, add scanner output * add linking range, error message and unregister old controller when re-linking * Add link status of purification units to waila body * Disable maintenance issues on purification plant units * spotless * Check structure of linked purification units in main controller * Remove all star imports * Small refactor to avoid updating status from main controller * spotless * Attempt to document current code * Convert some comments to javadoc * Implement basic processing cycle, sync it with linked purification units * Make water purification plant drain power * Calculate power drain from active units and remove controller power drain * spotless * Add very barebones recipemap * Fix recipemap name in lang file * spotless * Fix purification unit recipemap name * spotless * more sane amount of max fluid outputs * add some item outputs to sifter unit * Very simple recipe processing, may be buggy * spotless * Implement recipe failure * Implement void protection for purification units * spotless * buff item output odds slightly * Add WIP grade 1 structure * spotless * Store base success chance in recipe metadata and display it in NEI * Fill sifter plant with water * Add comment * Allow construction sifter unit in survival * Implement water boost * Fix water boost allowing output chance to go over 100% * Implement failed recipes outputting lower tier water * Fix typo * Fix deformed purification unit still drawing power * Slightly refactor recipe check so base class can read result * Create empty ModularUI container for purification plant * The great gui struggle part 1 * More gui struggles, we have a button now * Adjust button text and size * gui wars: the rise of the sync * gui wars: a new hope * fix the sync * is pengu old enough to know exceeder? * Fix being able to link the same unit multiple times * Sync status string to client * Sign sifter with my name * Show status somewhat properly * Adjust sifter base chance and structure * Fully implement sifter unit * More tooltip refactoring * Add structure info to sifter tooltip. * nitpicking tooltips * Adding sound to Purification Plant Main Unit. * fix star imports * Add basic coagulator unit, add recipemap for it * Write coagulator tooltip * comma nitpicking * more tooltip work * small refactor to purification plant controller * start work on custom recipemap frontend * Fully implement coagulator * Update structure requirements in tooltips * Move controller text in structure tooltips to be consistent * fix NPE on world load * Add base ph adjustment unit MTE * Add info to main controller and energy hatch check * Fixing tooltip of Main Controller & Energy/Exotic Hatch check. * Create full pH adjustment structure * disallow any voiding on purification unit * Small custom RecipeMap frontend for ph adjustment * Generate random initial pH value * Implement inserting NaOH and HCl to adjust pH * Add easter egg * Implement pH sensor hatch * Properly consume HCl and round pH value to 2 digits * Write ph adjustment unit tooltip * Tooltip nitpicking * Try to fix some structurelib hints * More trying to fix hints * Add industrial strength concrete casing block * Add water loop sound to the game * Document random initial pH in tooltip * Add glass material base * Fix spotless formatting in Textures docs because I cannot take it anymore * Add glass texture * Try adding transparent glass * Transparent glass working * Create pH resistant glass and update pH structure to use it * Create full structure for main purification plant * Create custom water purification casing block * Properly balance ferrous wastewater reprocessing and reduce input by a factor 10 * Add pH factor to NEI tooltip and fix coagulator structure * Structure tooltip for Purification Plant base * Add GT_Block_Glass2 and properly set maxMeta * Add Tinted Industrial Glass blocks * Fix BlockCasing9 not showing custom tooltip * Register tinted glass as EV glass * Add sterile water plant casing and revert tooltip change * Mention required water in sifter tooltip * Add more textures and casings * Add more textures, sounds and add structure info for pH adjustment * Rename sifter unit to clarifier * Rename coagulation unit to flocculation unit * Add activated carbon line * Fix unintended activated carbon recipe * Add activated carbon filter * Add polyaluminium chloride + solution * Add new custom textures by @BlueHero233 * Wip recipe page with new background for flocculation * Fix flocculation background image mostly * Finally aligned the slots * angery mumbles * Finish flocculation recipe page * All the recipe pages! * Add new reworked textures * Fix ph adjustment being t3 instead of t4 * Fix invisible casing * apply chembalance to polyaluminium chloride properly * Fix ferrous wastewater -> flocculation waste liquid * Move flocculation to grade 3 * create ozonation unit with placeholder blocks * add new blocks for ozonation with placeholder textures * Add water to ozonation structure * Create ozone gas material * Add ozone recipe * Add textures for ozone unit * Add sound loop for ozonation * fix * implement ozonation mechanics * Finalize ozonation tooltip * Create dummy plasma heater multi * Update textures for plasma heater * Add grade 5 recipemap * Add hatches to plasma heater multi * Add basic plasma heating unit variables * Implement plasma heating unit mechanics * Add plasma heater tooltip * Add structure info to plasma heater tooltip * fix ozonation tooltip, add frontend * Fix positioning on ozonation tooltip and fix plasma heater crash * Add UV treatment MTE and structure without textures * Revert accidental addition of debug dependencies * Add initial version of uv unit textures * update naquadria casing, add water color gradient * Some minor cleanup and added docs * Create lens housing bus * Add lens bus to UV treatment unit * Add lens indicator hatch * Merge GT_MetaGeneratedItem_03.java * Add lens indicator hatch * Add the lens cycle, uv treatment recipe map and fix eut of flocculation recipe * Implement lens swapping mechanic * Clean up first lens swap * Fix uv recipemap lang and move lens cycle to recipe * Write uv treatment tooltip * Add sounds for uv and plasma steps * Create empty degasifier class * Create temporary debug structure for degasifier * set temp casing index for degasifier * create degasifier control hatch * create slightly less temporary but still temporary structure for degasifier * Start impl of degasifier * fix fluid consumption and nbt loading of degasifier * Degasifier implementation should work now * Rename and reformat some things and start work on degasser tooltiop * give last bit much lower chance of being on to avoid cheesing * Finish degasifier tooltip * Integrate some deleno lore * hopefully fix all moved casing meta ids after merge * Create finalized degasser structure * Integrate more deleno lore * Add even more lore * Create placeholder particle catalysts and fetch particle items from gt++ * Fix wrong casing and recipemap localization * Create parallel config menu * refactor purification recipecheck slightly * implement parallel amount on water i/o and power * add tooltip info about parallel config * fix text * update block names in structure tooltips * create structure tooltip for degasser * create textureless quark catalyst items * add the purple glass * fix lore typos * fix some casing indices * remove concrete floor from water plant and reword tooltip * fix main plant structure and add placeholder structure for t8 step * fix structurecheck for main plant and add random catalyst generation for t8 * implement basic mechanics for particle extractor (wip) * Create plasma heater frontend * implement final mechanics and bugfixes for particle extractor * add recipes for re-aligning quark catalysts * add simple recipes for catalyst alignment * initial replacement of purified water in engraver recipes * add purified water to all wafer cutting recipes * fix purified water amounts * buff quark cyclotron recipe again * extract t8 unit casings into their own icons * Write initial tooltip for t8 module * add purified water to mask recipes * Add recipe comparator to show low tier purified water recipes first * add min casing check to waterline multis * buff ozone production * update t8 structure * make purified water optional again for naq wafers * Fix blockrenderer for purification plant * fix nei previews * fix nei * really fix nei this time * add t8 lore * fix hatch recipe locking blocking automation on some steps * try to solve weirdness with grade 3 recipe * fix issues with recipecheck * fix missing null check * make ph sensor use a strict inequality check * fix min casings on t5 * significantly nerf purified water usage for beamline masks * disable void protection for waterline * small adjustments to t6 unit * more small adjustments to t6 unit to prevent easy automation cheese * fix degasser redstone output and missing return statement * remove water QFT catalyst recipes --------- Co-authored-by: Tianyou Mei Co-authored-by: OlliedeLeeuw Co-authored-by: Ollie_de_Leeuw <154506304+OlliedeLeeuw@users.noreply.github.com> Co-authored-by: Martin Robertz --- .../gregtech/common/blocks/GT_Block_Casings10.java | 4 + .../gregtech/common/blocks/GT_Block_Casings9.java | 51 +- .../gregtech/common/blocks/GT_Block_Glass1.java | 106 +++ .../blocks/GT_Block_TintedIndustrialGlass.java | 98 +++ .../gregtech/common/blocks/GT_Item_Casings9.java | 14 + .../gregtech/common/blocks/GT_Item_Glass1.java | 15 + .../blocks/GT_Item_TintedIndustrialGlass.java | 10 + .../gui/modularui/widget/TextButtonWidget.java | 57 ++ .../common/items/GT_MetaGenerated_Item_03.java | 65 ++ .../java/gregtech/common/items/ID_MetaItem_03.java | 9 + ...etaTileEntity_Hatch_DegasifierControlHatch.java | 122 +++ .../GT_MetaTileEntity_LensHousing.java | 52 ++ .../GT_MetaTileEntity_LensIndicator.java | 117 +++ .../GT_MetaTileEntity_PurificationPlant.java | 740 ++++++++++++++++++ .../GT_MetaTileEntity_PurificationUnitBase.java | 793 +++++++++++++++++++ ...T_MetaTileEntity_PurificationUnitClarifier.java | 333 ++++++++ ..._MetaTileEntity_PurificationUnitDegasifier.java | 838 +++++++++++++++++++++ ...etaTileEntity_PurificationUnitFlocculation.java | 496 ++++++++++++ ...T_MetaTileEntity_PurificationUnitOzonation.java | 299 ++++++++ ...leEntity_PurificationUnitParticleExtractor.java | 484 ++++++++++++ ...etaTileEntity_PurificationUnitPhAdjustment.java | 609 +++++++++++++++ ...etaTileEntity_PurificationUnitPlasmaHeater.java | 570 ++++++++++++++ ...MetaTileEntity_PurificationUnitUVTreatment.java | 524 +++++++++++++ .../purification/GT_MetaTileEntity_pHSensor.java | 196 +++++ .../multi/purification/LinkedPurificationUnit.java | 125 +++ .../PurificationPlantStructureString.java | 15 + .../multi/purification/PurificationUnitStatus.java | 14 + .../multi/purification/PurifiedWaterHelpers.java | 35 + .../multi/purification/UVTreatmentLensCycle.java | 39 + 29 files changed, 6829 insertions(+), 1 deletion(-) create mode 100644 src/main/java/gregtech/common/blocks/GT_Block_Glass1.java create mode 100644 src/main/java/gregtech/common/blocks/GT_Block_TintedIndustrialGlass.java create mode 100644 src/main/java/gregtech/common/blocks/GT_Item_Glass1.java create mode 100644 src/main/java/gregtech/common/blocks/GT_Item_TintedIndustrialGlass.java create mode 100644 src/main/java/gregtech/common/gui/modularui/widget/TextButtonWidget.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitBase.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitClarifier.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitDegasifier.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitFlocculation.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitOzonation.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitParticleExtractor.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitPhAdjustment.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitPlasmaHeater.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationUnitUVTreatment.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_pHSensor.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/LinkedPurificationUnit.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/PurificationPlantStructureString.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/PurificationUnitStatus.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/PurifiedWaterHelpers.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/purification/UVTreatmentLensCycle.java (limited to 'src/main/java/gregtech/common') diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java b/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java index 660c709886..83219f45ee 100644 --- a/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java +++ b/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java @@ -20,7 +20,10 @@ public class GT_Block_Casings10 extends GT_Block_Casings_Abstract { GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".0.name", "MagTech Casing"); GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".1.name", "Laser Containment Casing"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".2.name", "Quark Exclusion Casing"); + ItemList.Casing_Electromagnetic_Separator.set(new ItemStack(this, 1, 0)); + ItemList.BlockQuarkContainmentCasing.set(new ItemStack(this, 1, 2)); ItemList.Casing_Laser.set(new ItemStack(this, 1, 1)); } @@ -35,6 +38,7 @@ public class GT_Block_Casings10 extends GT_Block_Casings_Abstract { return switch (aMeta) { case 0 -> Textures.BlockIcons.MACHINE_CASING_EMS.getIcon(); case 1 -> Textures.BlockIcons.MACHINE_CASING_LASER.getIcon(); + case 2 -> Textures.BlockIcons.BLOCK_QUARK_CONTAINMENT_CASING.getIcon(); default -> Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon(); }; } diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Casings9.java b/src/main/java/gregtech/common/blocks/GT_Block_Casings9.java index 4441885f30..6f33cda013 100644 --- a/src/main/java/gregtech/common/blocks/GT_Block_Casings9.java +++ b/src/main/java/gregtech/common/blocks/GT_Block_Casings9.java @@ -22,15 +22,51 @@ public class GT_Block_Casings9 extends GT_Block_Casings_Abstract { GT_LanguageManager .addStringLocalization(getUnlocalizedName() + ".1.tooltip", "Less than five 0.1μm particles per m^3"); GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".2.name", "Primitive Wooden Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".3.name", "Superplasticizer-Treated High Strength Concrete"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".4.name", "Sterile Water Plant Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".5.name", "Reinforced Sterile Water Plant Casing"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".6.name", "Slick Sterile Flocculation Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".7.name", "Stabilized Naquadah Water Plant Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".8.name", "Inert Neutralization Water Plant Casing"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".9.name", "Reactive Gas Containment Casing"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".10.name", "Inert Filtration Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".11.name", "Heat-Resistant Trinium Plated Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".12.name", "Naquadria-Reinforced Water Plant Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".13.name", "High Energy Ultraviolet Emitter Casing"); + // placeholder name + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".14.name", "Particle Beam Guidance Pipe Casing"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".15.name", "Femtometer-Calibrated Particle Beam Casing"); ItemList.Casing_Pipe_Polybenzimidazole.set(new ItemStack(this, 1, 0)); ItemList.Casing_Vent_T2.set(new ItemStack(this, 1, 1)); ItemList.WoodenCasing.set(new ItemStack(this, 1, 2)); + ItemList.BlockIndustrialStrengthConcrete.set(new ItemStack(this, 1, 3)); + ItemList.BlockIndustrialWaterPlantCasing.set(new ItemStack(this, 1, 4)); + ItemList.BlockSterileWaterPlantCasing.set(new ItemStack(this, 1, 5)); + ItemList.BlockFlocculationCasing.set(new ItemStack(this, 1, 6)); + ItemList.BlockNaquadahReinforcedWaterPlantCasing.set(new ItemStack(this, 1, 7)); + ItemList.BlockExtremeCorrosionResistantCasing.set(new ItemStack(this, 1, 8)); + ItemList.BlockHighPressureResistantCasing.set(new ItemStack(this, 1, 9)); + ItemList.BlockOzoneCasing.set(new ItemStack(this, 1, 10)); + ItemList.BlockPlasmaHeatingCasing.set(new ItemStack(this, 1, 11)); + ItemList.BlockNaquadriaReinforcedWaterPlantCasing.set(new ItemStack(this, 1, 12)); + ItemList.BlockUltraVioletLaserEmitter.set(new ItemStack(this, 1, 13)); + ItemList.BlockQuarkPipe.set(new ItemStack(this, 1, 14)); + ItemList.BlockQuarkReleaseChamber.set(new ItemStack(this, 1, 15)); } @Override public int getTextureIndex(int aMeta) { - return (1 << 7) | (aMeta + 64); + return (16 << 7) | (aMeta + 16); } @Override @@ -41,6 +77,19 @@ public class GT_Block_Casings9 extends GT_Block_Casings_Abstract { case 1 -> Textures.BlockIcons.MACHINE_CASING_VENT_T2.getIcon(); case 2 -> ordinalSide >= 2 ? Textures.BlockIcons.TEXTURE_METAL_PANEL_E.getIcon() : Textures.BlockIcons.TEXTURE_METAL_PANEL_E_A.getIcon(); + case 3 -> Textures.BlockIcons.INDUSTRIAL_STRENGTH_CONCRETE.getIcon(); + case 4 -> Textures.BlockIcons.MACHINE_CASING_INDUSTRIAL_WATER_PLANT.getIcon(); + case 5 -> Textures.BlockIcons.WATER_PLANT_CONCRETE_CASING.getIcon(); + case 6 -> Textures.BlockIcons.MACHINE_CASING_FLOCCULATION.getIcon(); + case 7 -> Textures.BlockIcons.MACHINE_CASING_NAQUADAH_REINFORCED_WATER_PLANT.getIcon(); + case 8 -> Textures.BlockIcons.MACHINE_CASING_EXTREME_CORROSION_RESISTANT.getIcon(); + case 9 -> Textures.BlockIcons.MACHINE_CASING_HIGH_PRESSURE_RESISTANT.getIcon(); + case 10 -> Textures.BlockIcons.MACHINE_CASING_OZONE.getIcon(); + case 11 -> Textures.BlockIcons.MACHINE_CASING_PLASMA_HEATER.getIcon(); + case 12 -> Textures.BlockIcons.NAQUADRIA_REINFORCED_WATER_PLANT_CASING.getIcon(); + case 13 -> Textures.BlockIcons.UV_BACKLIGHT_STERILIZER_CASING.getIcon(); + case 14 -> Textures.BlockIcons.BLOCK_QUARK_PIPE.getIcon(); + case 15 -> Textures.BlockIcons.BLOCK_QUARK_RELEASE_CHAMBER.getIcon(); default -> Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon(); }; } diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Glass1.java b/src/main/java/gregtech/common/blocks/GT_Block_Glass1.java new file mode 100644 index 0000000000..0665411259 --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Block_Glass1.java @@ -0,0 +1,106 @@ +package gregtech.common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Facing; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.util.GT_LanguageManager; + +/** + * The glass is split into separate files because they are registered as regular blocks, and a regular block can have + * 16 subtypes at most. + * + * This class hosts various special types of tiered glass with not many tiers. + */ +public class GT_Block_Glass1 extends GT_Block_Casings_Abstract { + + public GT_Block_Glass1() { + super(GT_Item_Glass1.class, "gt.blockglass1", Material.glass, 4); + this.opaque = false; + + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".0.name", "Chemical Grade Glass"); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName() + ".0.tooltip", + "Able to resist the most extreme chemical conditions."); + + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".1.name", "Electron-Permeable Neutronium Coated Glass"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".2.name", "Omni-Purpose Infinity Fused Glass"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".3.name", "Non-Photonic Matter Exclusion Glass"); + + ItemList.GlassPHResistant.set(new ItemStack(this, 1, 0)); + ItemList.GlassUVResistant.set(new ItemStack(this, 1, 1)); + ItemList.GlassOmniPurposeInfinityFused.set(new ItemStack(this, 1, 2)); + ItemList.GlassQuarkContainment.set(new ItemStack(this, 1, 3)); + } + + @Override + public int getTextureIndex(int aMeta) { + // Page 16, 0-16 + return (16 << 7) | (aMeta); + } + + @Override + public boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderBlockPass() { + return 1; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int ordinalSide, int aMeta) { + return switch (aMeta) { + case 0 -> Textures.BlockIcons.GLASS_PH_RESISTANT.getIcon(); + case 1 -> Textures.BlockIcons.NEUTRONIUM_COATED_UV_RESISTANT_GLASS.getIcon(); + case 2 -> Textures.BlockIcons.OMNI_PURPOSE_INFINITY_FUSED_GLASS.getIcon(); + case 3 -> Textures.BlockIcons.GLASS_QUARK_CONTAINMENT.getIcon(); + default -> Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon(); + }; + } + + /** + * Returns true if the given side of this block type should be rendered, if the adjacent block is at the given + * coordinates. Args: blockAccess, x, y, z, side + */ + @SideOnly(Side.CLIENT) + @Override + public boolean shouldSideBeRendered(IBlockAccess worldIn, int x, int y, int z, int side) { + Block block = worldIn.getBlock(x, y, z); + + if (worldIn.getBlockMetadata(x, y, z) != worldIn.getBlockMetadata( + x - Facing.offsetsXForSide[side], + y - Facing.offsetsYForSide[side], + z - Facing.offsetsZForSide[side])) { + return true; + } + + if (block == this) { + return false; + } + + return super.shouldSideBeRendered(worldIn, x, y, z, side); + } +} diff --git a/src/main/java/gregtech/common/blocks/GT_Block_TintedIndustrialGlass.java b/src/main/java/gregtech/common/blocks/GT_Block_TintedIndustrialGlass.java new file mode 100644 index 0000000000..93c6ebb298 --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Block_TintedIndustrialGlass.java @@ -0,0 +1,98 @@ +package gregtech.common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Facing; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.oredict.OreDictionary; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.util.GT_LanguageManager; + +public class GT_Block_TintedIndustrialGlass extends GT_Block_Casings_Abstract { + + public GT_Block_TintedIndustrialGlass() { + super(GT_Item_Glass1.class, "gt.blocktintedglass", Material.glass, 4); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".0.name", "Tinted Industrial Glass (White)"); + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".1.name", "Tinted Industrial Glass (Light Gray)"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".2.name", "Tinted Industrial Glass (Gray)"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".3.name", "Tinted Industrial Glass (Black)"); + ItemList.GlassTintedIndustrialWhite.set(new ItemStack(this, 1, 0)); + ItemList.GlassTintedIndustrialLightGray.set(new ItemStack(this, 1, 1)); + ItemList.GlassTintedIndustrialGray.set(new ItemStack(this, 1, 2)); + ItemList.GlassTintedIndustrialBlack.set(new ItemStack(this, 1, 3)); + + // Register tinted industrial glass as EV-Tier glass + OreDictionary.registerOre("blockGlassEV", this); + + this.opaque = false; + } + + @Override + public int getTextureIndex(int aMeta) { + // Page 16, 32-47 + return (16 << 7) | (aMeta + 32); + } + + @Override + public boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderBlockPass() { + return 1; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int ordinalSide, int aMeta) { + return switch (aMeta) { + case 0 -> Textures.BlockIcons.GLASS_TINTED_INDUSTRIAL_WHITE.getIcon(); + case 1 -> Textures.BlockIcons.GLASS_TINTED_INDUSTRIAL_LIGHT_GRAY.getIcon(); + case 2 -> Textures.BlockIcons.GLASS_TINTED_INDUSTRIAL_GRAY.getIcon(); + case 3 -> Textures.BlockIcons.GLASS_TINTED_INDUSTRIAL_BLACK.getIcon(); + default -> Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon(); + }; + } + + /** + * Returns true if the given side of this block type should be rendered, if the adjacent block is at the given + * coordinates. Args: blockAccess, x, y, z, side + */ + @SideOnly(Side.CLIENT) + @Override + public boolean shouldSideBeRendered(IBlockAccess worldIn, int x, int y, int z, int side) { + Block block = worldIn.getBlock(x, y, z); + + if (worldIn.getBlockMetadata(x, y, z) != worldIn.getBlockMetadata( + x - Facing.offsetsXForSide[side], + y - Facing.offsetsYForSide[side], + z - Facing.offsetsZForSide[side])) { + return true; + } + + if (block == this) { + return false; + } + + return super.shouldSideBeRendered(worldIn, x, y, z, side); + } +} diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Casings9.java b/src/main/java/gregtech/common/blocks/GT_Item_Casings9.java index 678a2424be..e9b39ee2cd 100644 --- a/src/main/java/gregtech/common/blocks/GT_Item_Casings9.java +++ b/src/main/java/gregtech/common/blocks/GT_Item_Casings9.java @@ -11,4 +11,18 @@ public class GT_Item_Casings9 extends GT_Item_Casings_Abstract { public GT_Item_Casings9(Block block) { super(block); } + + /* + * @Override + * public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) { + * // Add tooltip info if it was given + * String localizedTooltip = GT_LanguageManager.getTranslation(aStack.getUnlocalizedName() + ".tooltip"); + * // getTranslation returns the key if no translation was found, but this just means + * // no tooltip was set. + * if (localizedTooltip.startsWith("gt.")) { + * aList.add(localizedTooltip); + * } + * super.addInformation(aStack, aPlayer, aList, aF3_H); + * } + */ } diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Glass1.java b/src/main/java/gregtech/common/blocks/GT_Item_Glass1.java new file mode 100644 index 0000000000..7fbb33ff6e --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Item_Glass1.java @@ -0,0 +1,15 @@ +package gregtech.common.blocks; + +import net.minecraft.block.Block; + +/** + * The glass types are split into separate files because they are registered as regular blocks, and a regular block can + * have + * 16 subtypes at most. + */ +public class GT_Item_Glass1 extends GT_Item_Casings_Abstract { + + public GT_Item_Glass1(Block block) { + super(block); + } +} diff --git a/src/main/java/gregtech/common/blocks/GT_Item_TintedIndustrialGlass.java b/src/main/java/gregtech/common/blocks/GT_Item_TintedIndustrialGlass.java new file mode 100644 index 0000000000..9f633922ac --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Item_TintedIndustrialGlass.java @@ -0,0 +1,10 @@ +package gregtech.common.blocks; + +import net.minecraft.block.Block; + +public class GT_Item_TintedIndustrialGlass extends GT_Item_Casings_Abstract { + + public GT_Item_TintedIndustrialGlass(Block block) { + super(block); + } +} diff --git a/src/main/java/gregtech/common/gui/modularui/widget/TextButtonWidget.java b/src/main/java/gregtech/common/gui/modularui/widget/TextButtonWidget.java new file mode 100644 index 0000000000..492eef0a0a --- /dev/null +++ b/src/main/java/gregtech/common/gui/modularui/widget/TextButtonWidget.java @@ -0,0 +1,57 @@ +package gregtech.common.gui.modularui.widget; + +import com.gtnewhorizons.modularui.api.math.Size; +import com.gtnewhorizons.modularui.api.widget.Widget; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.MultiChildWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +public class TextButtonWidget extends MultiChildWidget { + + private ButtonWidget mButton; + private TextWidget mText; + + private int leftMargin; + + public TextButtonWidget(String text) { + mButton = new ButtonWidget(); + mText = new TextWidget(text); + mText.setPos(0, 0); + mButton.setPos(0, 0); + + this.addChild(mButton); + this.addChild(mText); + } + + public ButtonWidget button() { + return mButton; + } + + public TextWidget text() { + return mText; + } + + @Override + public Widget setPos(int x, int y) { + return super.setPos(x, y); + } + + @Override + public Widget setSize(int width, int height) { + this.mButton.setSize(width, height); + this.mText.setSize(width, height); + return super.setSize(width, height); + } + + @Override + public Widget setSize(Size size) { + this.mButton.setSize(size); + return super.setSize(size); + } + + public TextButtonWidget setLeftMargin(int margin) { + this.leftMargin = margin; + this.mText.setPos(this.leftMargin, this.mText.getPos().y); + return this; + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java index 49419aa47f..52a268baf9 100644 --- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java @@ -22,6 +22,7 @@ import static gregtech.client.GT_TooltipHandler.Tier.UV; import static gregtech.client.GT_TooltipHandler.Tier.UXV; import static gregtech.client.GT_TooltipHandler.Tier.ZPM; import static gregtech.client.GT_TooltipHandler.registerTieredTooltip; +import static gregtech.common.items.ID_MetaItem_03.Activated_Carbon_Filter_Mesh; import static gregtech.common.items.ID_MetaItem_03.Circuit_Biomainframe; import static gregtech.common.items.ID_MetaItem_03.Circuit_Bioprocessor; import static gregtech.common.items.ID_MetaItem_03.Circuit_Biowarecomputer; @@ -203,6 +204,14 @@ import static gregtech.common.items.ID_MetaItem_03.NuclearStar; import static gregtech.common.items.ID_MetaItem_03.Optical_Cpu_Containment_Housing; import static gregtech.common.items.ID_MetaItem_03.Optically_Compatible_Memory; import static gregtech.common.items.ID_MetaItem_03.Optically_Perfected_CPU; +import static gregtech.common.items.ID_MetaItem_03.Quark_Catalyst_Housing; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Bottom; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Charm; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Down; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Strange; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Top; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Unaligned; +import static gregtech.common.items.ID_MetaItem_03.Quark_Creation_Catalyst_Up; import static gregtech.common.items.ID_MetaItem_03.Spinneret; import static gregtech.common.items.ID_MetaItem_03.Timepiece; import static gregtech.common.items.ID_MetaItem_03.Transdimensional_Alignment_Matrix; @@ -1103,6 +1112,62 @@ public class GT_MetaGenerated_Item_03 extends GT_MetaGenerated_Item_X32 { "Removing this cover will destroy the linked card", GT_Values.AuthorQuerns))); + ItemList.ActivatedCarbonFilterMesh.set( + addItem( + Activated_Carbon_Filter_Mesh.ID, + "Activated Carbon Filter Mesh", + "The most granular filter you could possibly make.", + SubTag.NO_UNIFICATION)); + + ItemList.Quark_Catalyst_Housing.set( + addItem( + Quark_Catalyst_Housing.ID, + "Empty Quark Release Catalyst Housing", + "Capable of holding Quark Release Catalysts", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Up.set( + addItem( + Quark_Creation_Catalyst_Up.ID, + "Up-Quark Releasing Catalyst", + "Can release up-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Down.set( + addItem( + Quark_Creation_Catalyst_Down.ID, + "Down-Quark Releasing Catalyst", + "Can release down-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Strange.set( + addItem( + Quark_Creation_Catalyst_Strange.ID, + "Strange-Quark Releasing Catalyst", + "Can release strange-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Charm.set( + addItem( + Quark_Creation_Catalyst_Charm.ID, + "Charm-Quark Releasing Catalyst", + "Can release charm-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Bottom.set( + addItem( + Quark_Creation_Catalyst_Bottom.ID, + "Top-Quark Releasing Catalyst", + "Can release top-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Top.set( + addItem( + Quark_Creation_Catalyst_Top.ID, + "Bottom-Quark Releasing Catalyst", + "Can release bottom-quarks into environment to reshape matter", + SubTag.NO_UNIFICATION)); + ItemList.Quark_Creation_Catalyst_Unaligned.set( + addItem( + Quark_Creation_Catalyst_Unaligned.ID, + "Unaligned Quark Releasing Catalyst", + "Needs to be realigned before use", + SubTag.NO_UNIFICATION)); + ItemList.Optical_Cpu_Containment_Housing .set(addItem(Optical_Cpu_Containment_Housing.ID, "Optical CPU Containment Housing", "CPU Housing", o)); ItemList.Optically_Perfected_CPU diff --git a/src/main/java/gregtech/common/items/ID_MetaItem_03.java b/src/main/java/gregtech/common/items/ID_MetaItem_03.java index fac8fd3841..fea5a687df 100644 --- a/src/main/java/gregtech/common/items/ID_MetaItem_03.java +++ b/src/main/java/gregtech/common/items/ID_MetaItem_03.java @@ -183,6 +183,15 @@ public enum ID_MetaItem_03 { NuclearStar(230), IndustrialApiary_Upgrade_UNLIGHT(231), Cover_Metrics_Transmitter(232), + Activated_Carbon_Filter_Mesh(233), + Quark_Catalyst_Housing(234), + Quark_Creation_Catalyst_Up(235), + Quark_Creation_Catalyst_Down(236), + Quark_Creation_Catalyst_Strange(237), + Quark_Creation_Catalyst_Charm(238), + Quark_Creation_Catalyst_Bottom(239), + Quark_Creation_Catalyst_Top(240), + Quark_Creation_Catalyst_Unaligned(241), Circuit_Silicon_Ingot6(721), Circuit_Silicon_Wafer6(722), Circuit_Silicon_Wafer7(723), 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 + 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 mLinkedUnits = new ArrayList<>(); + + private static final IStructureDefinition STRUCTURE_DEFINITION = StructureDefinition + .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.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 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 n