diff options
Diffstat (limited to 'src/main/java')
8 files changed, 553 insertions, 11 deletions
diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java b/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java index aca6b16330..3d2b33843c 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/API/BorosilicateGlass.java @@ -4,7 +4,6 @@ import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy; import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAdder; import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta; import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlocksTiered; -import static gregtech.api.enums.Mods.BartWorks; import java.util.ArrayList; import java.util.List; @@ -17,6 +16,7 @@ import net.minecraft.block.Block; import org.apache.commons.lang3.tuple.Pair; +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; import com.google.common.collect.HashBasedTable; import com.google.common.collect.LinkedHashMultimap; import com.google.common.collect.SetMultimap; @@ -25,7 +25,6 @@ import com.gtnewhorizon.structurelib.structure.IStructureElement; import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.LoaderState; -import cpw.mods.fml.common.registry.GameRegistry; /** * API for bartworks borosilicate glass. @@ -38,7 +37,6 @@ import cpw.mods.fml.common.registry.GameRegistry; */ public class BorosilicateGlass { - private static Block block, block2; private static List<Pair<Block, Integer>> representatives; private static SetMultimap<Byte, Pair<Block, Integer>> allLevels; private static final Table<Block, Integer, Byte> allLevelsReverse = HashBasedTable.create(); @@ -48,17 +46,11 @@ public class BorosilicateGlass { } public static Block getGlassBlock() { - if (block == null) { - block = GameRegistry.findBlock(BartWorks.ID, "BW_GlasBlocks"); - } - return block; + return ItemRegistry.bw_realglas; } public static Block getGlassBlock2() { - if (block2 == null) { - block2 = GameRegistry.findBlock(BartWorks.ID, "BW_GlasBlocks2"); - } - return block2; + return ItemRegistry.bw_realglas; } private static void doRegister(byte level, Block block, int meta, @@ -111,6 +103,14 @@ public class BorosilicateGlass { } /** + * ONLY registers borosilicate glass. Without this, {@link #getTier} won't work properly in environments that don't + * have the coremod. + */ + public static void registerBorosilicateGlass() { + getAllLevels(); + } + + /** * Register a new block as valid borosilicate glass with given tier (even if it doesn't contain boron at all) * * Does not support matching by more complex stuff like tile entity! diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java index a5bd2edc12..86927d9add 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/loaders/ItemRegistry.java @@ -183,6 +183,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; import net.minecraft.util.StatCollector; +import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass; import com.github.bartimaeusnek.bartworks.MainMod; import com.github.bartimaeusnek.bartworks.common.blocks.BW_Blocks; import com.github.bartimaeusnek.bartworks.common.blocks.BW_GlasBlocks; @@ -395,6 +396,8 @@ public class ItemRegistry { public static void run() { GameRegistry.registerBlock(ItemRegistry.bw_fake_glasses, "BW_FakeGlasBlock"); GameRegistry.registerBlock(ItemRegistry.bw_fake_glasses2, "BW_FakeGlasBlocks2"); + BorosilicateGlass.registerBorosilicateGlass(); + GameRegistry.registerBlock(ItemRegistry.BW_BLOCKS[2], BW_ItemBlocks.class, "BW_Machinery_Casings"); GameRegistry.registerItem(ItemRegistry.LEATHER_ROTOR, "BW_LeatherRotor"); GameRegistry.registerItem(ItemRegistry.WOOL_ROTOR, "BW_WoolRotor"); diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java index 766525c958..9e4fc04302 100644 --- a/src/main/java/gregtech/api/enums/ItemList.java +++ b/src/main/java/gregtech/api/enums/ItemList.java @@ -2103,6 +2103,7 @@ public enum ItemList implements IItemContainer { BlockQuarkPipe, BlockQuarkReleaseChamber, BlockQuarkContainmentCasing, + LargeFluidExtractor, AcceleratorLV, AcceleratorMV, AcceleratorHV, diff --git a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java index 7793a2f6b2..e51be375d1 100644 --- a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java +++ b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java @@ -625,6 +625,7 @@ public enum MetaTileEntityIDs { CRAFTING_INPUT_SLAVE(2716), INPUT_HATCH_ME(2717), INPUT_BUS_ME(2718), + LARGE_FLUID_EXTRACTOR(2730), INDUSTRIAL_LASER_ENGRAVER_CONTROLLER(3004), INDUSTRIAL_COMPRESSOR_CONTROLLER(3005), HIP_COMPRESSOR_CONTROLLER(3006), diff --git a/src/main/java/gregtech/api/util/GT_StructureUtility.java b/src/main/java/gregtech/api/util/GT_StructureUtility.java index ad3e4e9876..6bbb3e1223 100644 --- a/src/main/java/gregtech/api/util/GT_StructureUtility.java +++ b/src/main/java/gregtech/api/util/GT_StructureUtility.java @@ -47,6 +47,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; import gregtech.common.blocks.GT_Block_Casings5; import gregtech.common.blocks.GT_Block_FrameBox; +import gregtech.common.blocks.GT_Cyclotron_Coils; import gregtech.common.blocks.GT_Item_Machines; public class GT_StructureUtility { @@ -490,6 +491,112 @@ public class GT_StructureUtility { }; } + /** + * Assumes all solenoids are accepted. + * + * @see #ofSolenoidCoil(BiPredicate, Function) + */ + public static <T> IStructureElement<T> ofSolenoidCoil(BiConsumer<T, Byte> aSolenoidTierSetter, + Function<T, Byte> aSolenoidTierGetter) { + return ofSolenoidCoil((t, l) -> { + aSolenoidTierSetter.accept(t, l); + return true; + }, aSolenoidTierGetter); + } + + /** + * Solenoid coil structure element. + * + * @param aSolenoidTierSetter Notify the controller of this new solenoid. Got called exactly once per solenoid. + * Might be + * called less times if structure test fails. If the setter returns false then it assumes + * the solenoid is rejected. + * @param aSolenoidTierGetter Get the solenoid voltage tier. Null means no tier recorded yet. + */ + public static <T> IStructureElement<T> ofSolenoidCoil(BiPredicate<T, Byte> aSolenoidTierSetter, + Function<T, Byte> aSolenoidTierGetter) { + if (aSolenoidTierSetter == null || aSolenoidTierGetter == null) { + throw new IllegalArgumentException(); + } + return new IStructureElement<>() { + + @Override + public boolean check(T t, World world, int x, int y, int z) { + Block block = world.getBlock(x, y, z); + + if (block != GregTech_API.sSolenoidCoilCasings) return false; + + var coils = ((GT_Cyclotron_Coils) GregTech_API.sSolenoidCoilCasings); + + Byte existingLevel = aSolenoidTierGetter.apply(t); + byte newLevel = (byte) (coils.getVoltageTier(world.getBlockMetadata(x, y, z))); + + if (existingLevel == null) { + return aSolenoidTierSetter.test(t, newLevel); + } else { + return newLevel == existingLevel; + } + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI + .hintParticle(world, x, y, z, GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger)); + return true; + } + + private int getMetaFromHint(ItemStack trigger) { + return Math.min(Math.max(trigger.stackSize - 1, 0), 10); + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + return world.setBlock(x, y, z, GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger), 3); + } + + @Override + public BlocksToPlace getBlocksToPlace(T t, World world, int x, int y, int z, ItemStack trigger, + AutoPlaceEnvironment env) { + return BlocksToPlace.create(GregTech_API.sSolenoidCoilCasings, getMetaFromHint(trigger)); + } + + @Override + public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, + IItemSource s, EntityPlayerMP actor, Consumer<IChatComponent> chatter) { + return survivalPlaceBlock( + t, + world, + x, + y, + z, + trigger, + AutoPlaceEnvironment.fromLegacy(s, actor, chatter)); + } + + @Override + public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, + AutoPlaceEnvironment env) { + Block block = world.getBlock(x, y, z); + + boolean isCoil = block == GregTech_API.sSolenoidCoilCasings + && world.getBlockMetadata(x, y, z) == getMetaFromHint(trigger); + + if (isCoil) return SKIP; + + return StructureUtility.survivalPlaceBlock( + GregTech_API.sSolenoidCoilCasings, + getMetaFromHint(trigger), + world, + x, + y, + z, + env.getSource(), + env.getActor(), + env.getChatter()); + } + }; + } + @Nonnull public static Predicate<ItemStack> filterByMTEClass(List<? extends Class<? extends IMetaTileEntity>> list) { return is -> { diff --git a/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java b/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java index d918060298..3c4250540c 100644 --- a/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java +++ b/src/main/java/gregtech/common/blocks/GT_Cyclotron_Coils.java @@ -118,6 +118,10 @@ public class GT_Cyclotron_Coils extends GT_Block_Casings_Abstract { return Textures.BlockIcons.MACHINE_CASING_SOLID_STEEL.getIcon(); } + public int getVoltageTier(int meta) { + return meta + 2; + } + @Override public int colorMultiplier(IBlockAccess aWorld, int aX, int aY, int aZ) { return aWorld.getBlockMetadata(aX, aY, aZ) > 9 ? super.colorMultiplier(aWorld, aX, aY, aZ) diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java new file mode 100644 index 0000000000..c1a5bc3458 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeFluidExtractor.java @@ -0,0 +1,419 @@ +package gregtech.common.tileentities.machines.multi; + +import static com.github.bartimaeusnek.bartworks.util.BW_Util.ofGlassTiered; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.withChannel; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.InputBus; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_HatchElement.OutputBus; +import static gregtech.api.enums.GT_HatchElement.OutputHatch; +import static gregtech.api.enums.GT_Values.VN; +import static gregtech.api.enums.Textures.BlockIcons.getCasingTextureForId; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static gregtech.api.util.GT_StructureUtility.ofCoil; +import static gregtech.api.util.GT_StructureUtility.ofFrame; +import static gregtech.api.util.GT_StructureUtility.ofSolenoidCoil; +import static net.minecraft.util.EnumChatFormatting.RESET; +import static net.minecraft.util.EnumChatFormatting.YELLOW; + +import java.util.ArrayList; +import java.util.Arrays; + +import javax.annotation.Nullable; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +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.math.Alignment; +import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.HeatingCoilLevel; +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.logic.ProcessingLogic; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; + +public class GT_MetaTileEntity_LargeFluidExtractor + extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_LargeFluidExtractor> + implements ISurvivalConstructable { + + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final int CASING_INDEX = 48; // Robust Tungstensteel Machine Casing + private static final int BASE_CASING_COUNT = 24 + 24 + 9; + private static final int MAX_HATCHES_ALLOWED = 16; + + private static final double BASE_SPEED_BONUS = 1.5; + private static final double BASE_EU_MULTIPLIER = 0.8; + + private static final double SPEED_PER_COIL = 0.1; + private static final int PARALLELS_PER_SOLENOID = 8; + private static final double HEATING_COIL_EU_MULTIPLIER = 0.9; + + // spotless:off + private static final IStructureDefinition<GT_MetaTileEntity_LargeFluidExtractor> STRUCTURE_DEFINITION = StructureDefinition + .<GT_MetaTileEntity_LargeFluidExtractor>builder() + .addShape( + STRUCTURE_PIECE_MAIN, + transpose( + new String[][] { + {" ", " ccc ", " ccc ", " ccc ", " "}, + {" ", " f f ", " s ", " f f ", " "}, + {" ", " f f ", " s ", " f f ", " "}, + {" ", " f f ", " s ", " f f ", " "}, + {"ccccc", "ccccc", "ccscc", "ccccc", "ccccc"}, + {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"}, + {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"}, + {"fgggf", "ghhhg", "ghshg", "ghhhg", "fgggf"}, + {"cc~cc", "ccccc", "ccccc", "ccccc", "ccccc"}, + })) + .addElement('c', + buildHatchAdder(GT_MetaTileEntity_LargeFluidExtractor.class) + .atLeast(InputBus, OutputBus, OutputHatch, Energy, Maintenance) + .casingIndex(CASING_INDEX) // Robust Tungstensteel Machine Casing + .dot(1) + .buildAndChain( + onElementPass( + GT_MetaTileEntity_LargeFluidExtractor::onCasingAdded, + ofBlock(GregTech_API.sBlockCasings4, 0))) // Robust Tungstensteel Machine Casing + ) + .addElement( + 'g', + withChannel( + "glass", + ofGlassTiered( + (byte) 1, (byte) 127, (byte) 0, + GT_MetaTileEntity_LargeFluidExtractor::setGlassTier, + GT_MetaTileEntity_LargeFluidExtractor::getGlassTier, + 2)) + ) + .addElement( + 'h', + withChannel( + "coil", + ofCoil( + GT_MetaTileEntity_LargeFluidExtractor::setCoilLevel, + GT_MetaTileEntity_LargeFluidExtractor::getCoilLevel)) + ) + .addElement( + 's', + withChannel( + "solenoid", + ofSolenoidCoil( + GT_MetaTileEntity_LargeFluidExtractor::setSolenoidLevel, + GT_MetaTileEntity_LargeFluidExtractor::getSolenoidLevel)) + ) + .addElement( + 'f', + ofFrame(Materials.BlackSteel) + ) + .build(); + // spotless:on + + private byte mGlassTier = 0; + @Nullable + private HeatingCoilLevel mCoilLevel = null; + @Nullable + private Byte mSolenoidLevel = null; + private int mCasingAmount; + private boolean mStructureBadGlassTier = false, mStructureBadCasingCount = false; + + public GT_MetaTileEntity_LargeFluidExtractor(final int aID, final String aName, final String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_LargeFluidExtractor(String aName) { + super(aName); + } + + @Override + public IStructureDefinition<GT_MetaTileEntity_LargeFluidExtractor> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + public void clearHatches() { + super.clearHatches(); + + mCasingAmount = 0; + mStructureBadGlassTier = false; + mStructureBadCasingCount = false; + mGlassTier = 0; + mCoilLevel = null; + mSolenoidLevel = null; + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + if (!checkPiece(STRUCTURE_PIECE_MAIN, 2, 8, 0)) { + return false; + } + + if (mCasingAmount < (BASE_CASING_COUNT - MAX_HATCHES_ALLOWED)) { + mStructureBadCasingCount = true; + } + + for (var energyHatch : mEnergyHatches) { + if (energyHatch.getBaseMetaTileEntity() == null) { + continue; + } + + if (mGlassTier < 10 && energyHatch.getTierForStructure() > mGlassTier) { + mStructureBadGlassTier = true; + } + } + + return !mStructureBadGlassTier && !mStructureBadCasingCount; + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 8, 0); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + if (mMachine) return -1; + return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 8, 0, elementBudget, env, false, true); + } + + @Override + protected ProcessingLogic createProcessingLogic() { + return new ProcessingLogic(); + } + + @Override + protected void setProcessingLogicPower(ProcessingLogic logic) { + super.setProcessingLogicPower(logic); + logic.setAvailableAmperage(mEnergyHatches.size()); + logic.setEuModifier((float) (getEUMultiplier())); + logic.setMaxParallel(getParallels()); + logic.setSpeedBonus(1.0f / (float) (getSpeedBonus())); + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_LargeFluidExtractor(this.mName); + } + + private void onCasingAdded() { + mCasingAmount++; + } + + private byte getGlassTier() { + return mGlassTier; + } + + private void setGlassTier(byte tier) { + mGlassTier = tier; + } + + private HeatingCoilLevel getCoilLevel() { + return mCoilLevel; + } + + private void setCoilLevel(HeatingCoilLevel level) { + mCoilLevel = level; + } + + private Byte getSolenoidLevel() { + return mSolenoidLevel; + } + + private void setSolenoidLevel(byte level) { + mSolenoidLevel = level; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean active, boolean redstoneLevel) { + if (side == facing) { + if (active) { + return new ITexture[] { getCasingTextureForId(CASING_INDEX), TextureFactory.builder() + .addIcon(TexturesGtBlock.Overlay_Machine_Controller_Advanced_Active) + .extFacing() + .build() }; + } else { + return new ITexture[] { getCasingTextureForId(CASING_INDEX), TextureFactory.builder() + .addIcon(TexturesGtBlock.Overlay_Machine_Controller_Advanced) + .extFacing() + .build() }; + } + } + return new ITexture[] { getCasingTextureForId(CASING_INDEX) }; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + + // spotless:off + tt.addMachineType("Fluid Extractor") + .addInfo("Controller block for the Large Fluid Extractor") + .addInfo(String.format( + "%d%% faster than single block machines of the same voltage", + (int) Math.round((BASE_SPEED_BONUS - 1) * 100) + )) + .addInfo(String.format( + "Only uses %d%% of the EU/t normally required", + (int) Math.round(BASE_EU_MULTIPLIER * 100) + )) + .addInfo(String.format( + "Every coil tier gives a +%d%% speed bonus and a %d%% EU/t discount (multiplicative)", + (int) Math.round(SPEED_PER_COIL * 100), + (int) Math.round((1 - HEATING_COIL_EU_MULTIPLIER) * 100) + )) + .addInfo(String.format( + "Every solenoid tier gives +%d parallels", + (int) PARALLELS_PER_SOLENOID + )) + .addInfo(String.format( + "The EU multiplier is %s%.2f * (%.2f ^ Heating Coil Tier)%s, prior to overclocks", + EnumChatFormatting.ITALIC, + BASE_EU_MULTIPLIER, + HEATING_COIL_EU_MULTIPLIER, + EnumChatFormatting.GRAY + )) + .addInfo("The energy hatch tier is limited by the glass tier. UEV glass unlocks all tiers.") + .addSeparator() + .beginStructureBlock(5, 9, 5, false) + .addController("Front Center (Bottom Layer)") + .addCasingInfoMin("Robust Tungstensteel Machine Casing", BASE_CASING_COUNT - MAX_HATCHES_ALLOWED, false) + .addCasingInfoExactly("Borosilicate Glass (any)", 9 * 4, true) + .addCasingInfoExactly("Solenoid Superconducting Coil (any)", 7, true) + .addCasingInfoExactly("Heating Coils (any)", 8 * 3, true) + .addCasingInfoExactly("Black Steel Frame Box", 3 * 8, false) + .addInputBus("Any Robust Tungstensteel Machine Casing", 1) + .addOutputBus("Any Robust Tungstensteel Machine Casing", 1) + .addOutputHatch("Any Robust Tungstensteel Machine Casing", 1) + .addEnergyHatch("Any Robust Tungstensteel Machine Casing", 1) + .addMaintenanceHatch("Any Robust Tungstensteel Machine Casing", 1) + .toolTipFinisher("GregTech"); + // spotless:on + + return tt; + } + + @Override + protected void drawTexts(DynamicPositionedColumn screenElements, SlotWidget inventorySlot) { + super.drawTexts(screenElements, inventorySlot); + + screenElements.widgets(TextWidget.dynamicString(() -> { + if (mStructureBadCasingCount) { + return String.format( + "%sNot enough casings: need %d, but\nhave %d.%s", + EnumChatFormatting.DARK_RED, + BASE_CASING_COUNT - MAX_HATCHES_ALLOWED, + mCasingAmount, + RESET); + } + + if (mStructureBadGlassTier) { + int hatchTier = 0; + + for (var hatch : mEnergyHatches) { + if (hatch.mTier > hatchTier) hatchTier = hatch.mTier; + } + + return String.format( + "%sEnergy hatch tier (%s) is too high\nfor the glass tier (%s).%s", + EnumChatFormatting.DARK_RED, + VN[hatchTier], + VN[mGlassTier], + RESET); + } + + return ""; + }) + .setTextAlignment(Alignment.CenterLeft)); + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10_000; + } + + @Override + public RecipeMap<?> getRecipeMap() { + return RecipeMaps.fluidExtractionRecipes; + } + + @Override + public boolean supportsVoidProtection() { + return true; + } + + @Override + public boolean supportsBatchMode() { + return true; + } + + @Override + public boolean supportsSingleRecipeLocking() { + return true; + } + + @Override + public String[] getInfoData() { + var data = new ArrayList<String>(); + + data.addAll(Arrays.asList(super.getInfoData())); + + data.add(String.format("Max Parallels: %s%d%s", YELLOW, getParallels(), RESET)); + data.add(String.format("Heating Coil Speed Bonus: +%s%.0f%s %%", YELLOW, getCoilSpeedBonus() * 100, RESET)); + data.add(String.format("Total Speed Multiplier: %s%.0f%s %%", YELLOW, getSpeedBonus() * 100, RESET)); + data.add(String.format("Total EU/t Multiplier: %s%.0f%s %%", YELLOW, getEUMultiplier() * 100, RESET)); + + return data.toArray(new String[data.size()]); + } + + public int getParallels() { + return Math.max(1, mSolenoidLevel == null ? 0 : (PARALLELS_PER_SOLENOID * mSolenoidLevel)); + } + + public float getCoilSpeedBonus() { + return (float) ((mCoilLevel == null ? 0 : SPEED_PER_COIL * mCoilLevel.getTier())); + } + + public float getSpeedBonus() { + return (float) (BASE_SPEED_BONUS + getCoilSpeedBonus()); + } + + public float getEUMultiplier() { + double heatingBonus = (mCoilLevel == null ? 0 : Math.pow(HEATING_COIL_EU_MULTIPLIER, mCoilLevel.getTier())); + + return (float) (BASE_EU_MULTIPLIER * heatingBonus); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java index 856ddf2f82..e7ad9e9337 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java @@ -1048,6 +1048,7 @@ import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_Titanium; import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_TungstenSteel; import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeChemicalReactor; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeFluidExtractor; import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Gas; import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_GasAdvanced; import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_HPSteam; @@ -1658,6 +1659,12 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC MULTI_AUTOCLAVE_CONTROLLER.ID, "multimachine.autoclave", "Industrial Autoclave").getStackForm(1)); + + ItemList.LargeFluidExtractor.set( + new GT_MetaTileEntity_LargeFluidExtractor( + LARGE_FLUID_EXTRACTOR.ID, + "multimachine.fluidextractor", + "Large Fluid Extractor").getStackForm(1)); } private static void registerSteamMachines() { |