From 4233fc16e3c9ad1b1051a99e4ff84d64230de8a8 Mon Sep 17 00:00:00 2001 From: Maya <10861407+serenibyss@users.noreply.github.com> Date: Thu, 9 Jan 2025 04:41:26 -0700 Subject: [PATCH] Migrate coremod machines to GT5u (#3767) --- .../java/gregtech/api/enums/ItemList.java | 4 + .../api/gui/modularui/GTUITextures.java | 2 + .../machines/basic/MTENameRemover.java | 259 ++++++++ .../machines/multi/MTEAirFilter1.java | 48 ++ .../machines/multi/MTEAirFilter2.java | 48 ++ .../machines/multi/MTEAirFilter3.java | 48 ++ .../machines/multi/MTEAirFilterBase.java | 609 ++++++++++++++++++ .../postload/PCBFactoryMaterialLoader.java | 1 + .../preload/LoaderMetaTileEntities.java | 23 + .../textures/gui/progressbar/name_remover.png | Bin 0 -> 217 bytes 10 files changed, 1042 insertions(+) create mode 100644 src/main/java/gregtech/common/tileentities/machines/basic/MTENameRemover.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter1.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter2.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter3.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilterBase.java create mode 100644 src/main/resources/assets/gregtech/textures/gui/progressbar/name_remover.png diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java index 60b9e1d9418..f80d13cc6ee 100644 --- a/src/main/java/gregtech/api/enums/ItemList.java +++ b/src/main/java/gregtech/api/enums/ItemList.java @@ -2599,6 +2599,10 @@ public enum ItemList implements IItemContainer { Casing_AirFilter_Turbine_T3, Casing_AirFilter_Vent_T3, Casing_Pyrolyse, + NameRemover, + Machine_Multi_AirFilterT1, + Machine_Multi_AirFilterT2, + Machine_Multi_AirFilterT3, // semicolon after the comment to reduce merge conflicts ; diff --git a/src/main/java/gregtech/api/gui/modularui/GTUITextures.java b/src/main/java/gregtech/api/gui/modularui/GTUITextures.java index 9293b9b1fad..673c04697a9 100644 --- a/src/main/java/gregtech/api/gui/modularui/GTUITextures.java +++ b/src/main/java/gregtech/api/gui/modularui/GTUITextures.java @@ -220,6 +220,8 @@ public class GTUITextures { .fullImage(GregTech.ID, "gui/progressbar/steam_fill"); public static final UITexture PROGRESSBAR_STEAM_FILL_STEEL = UITexture .fullImage(GregTech.ID, "gui/progressbar/steam_fill_steel"); + public static final UITexture PROGRESSBAR_NAME_REMOVER = UITexture + .fullImage(GregTech.ID, "gui/progressbar/name_remover"); public static FallbackableUITexture fallbackableProgressbar(String name, UITexture fallback) { return new FallbackableUITexture(UITexture.fullImage(GregTech.ID, "gui/progressbar/" + name), fallback); diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/MTENameRemover.java b/src/main/java/gregtech/common/tileentities/machines/basic/MTENameRemover.java new file mode 100644 index 00000000000..bc4112dee4b --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/MTENameRemover.java @@ -0,0 +1,259 @@ +package gregtech.common.tileentities.machines.basic; + +import static net.minecraft.util.EnumChatFormatting.BOLD; +import static net.minecraft.util.EnumChatFormatting.RESET; +import static net.minecraft.util.EnumChatFormatting.UNDERLINE; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +import com.gtnewhorizons.modularui.api.drawable.FallbackableUITexture; + +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.CoverableTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEBasicMachine; +import gregtech.api.recipe.BasicUIProperties; +import gregtech.api.render.TextureFactory; +import gregtech.common.items.ItemIntegratedCircuit; + +public class MTENameRemover extends MTEBasicMachine { + + public MTENameRemover(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 1, + "Can fix GT items with broken NBT data, will erase everything!", + 2, + 1, + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_SIDE_DISASSEMBLER_ACTIVE), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_SIDE_DISASSEMBLER_ACTIVE_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_SIDE_DISASSEMBLER), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_SIDE_DISASSEMBLER_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER_ACTIVE), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER_ACTIVE_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_FRONT_DISASSEMBLER_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_TOP_DISASSEMBLER_ACTIVE), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_TOP_DISASSEMBLER_ACTIVE_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_TOP_DISASSEMBLER), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_TOP_DISASSEMBLER_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_BOTTOM_DISASSEMBLER_ACTIVE), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_BOTTOM_DISASSEMBLER_ACTIVE_GLOW) + .glow() + .build()), + TextureFactory.of( + TextureFactory.of(Textures.BlockIcons.OVERLAY_BOTTOM_DISASSEMBLER), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_BOTTOM_DISASSEMBLER_GLOW) + .glow() + .build())); + } + + public MTENameRemover(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 1, aDescription, aTextures, 2, 1); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTENameRemover(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public int checkRecipe() { + if (getInputAt(0) == null) return 0; + ItemStack output = getInputAt(0).copy(); + NBTTagCompound nbt = output.getTagCompound(); + if (nbt != null) { + int circuitSetting = 0; + ItemStack circuit = getInputAt(1); + if (circuit != null && circuit.getItem() instanceof ItemIntegratedCircuit) { + circuitSetting = circuit.getItemDamage(); + } + boolean removeName = false; + boolean removeDisassembly = false; + boolean removeColor = false; + boolean removeRepair = false; + boolean removeDye = false; + boolean removeSpray = false; + boolean removeCovers = false; + switch (circuitSetting) { + case 1: + removeName = true; + break; + case 2: + removeDisassembly = true; + break; + case 3: + removeColor = true; + break; + case 4: + removeRepair = true; + break; + case 5: + removeDye = true; + break; + case 6: + removeSpray = true; + break; + case 24: + removeCovers = true; + default: + removeName = true; + removeDisassembly = true; + removeColor = true; + removeRepair = true; + removeDye = true; + removeSpray = true; + } + if (removeName && nbt.hasKey("display")) { + nbt.getCompoundTag("display") + .removeTag("Name"); + if (nbt.getCompoundTag("display") + .hasNoTags()) { + nbt.removeTag("display"); + } + } + if (removeDisassembly) removeTag(nbt, "GT.CraftingComponents"); + if (removeColor) removeTag(nbt, "color"); + if (removeRepair) removeTag(nbt, "RepairCost"); + if (removeDye && nbt.hasKey("display")) { + nbt.getCompoundTag("display") + .removeTag("color"); + if (nbt.getCompoundTag("display") + .hasNoTags()) { + nbt.removeTag("display"); + } + } + if (removeSpray) removeTag(nbt, "mColor"); + removeTag(nbt, "mTargetStackSize"); // MTEBuffer + removeTag(nbt, "mOutputFluid"); // MTEDigitalTankBase + removeTag(nbt, "mVoidOverflow"); // MTEDigitalTankBase & MTEQuantumChest + removeTag(nbt, "mVoidFluidFull"); // MTEDigitalTankBase + removeTag(nbt, "mLockFluid"); // MTEDigitalTankBase + removeTag(nbt, "lockedFluidName"); // MTEDigitalTankBase + removeTag(nbt, "mAllowInputFromOutputSide"); // MTEDigitalTankBase + removeTag(nbt, "mItemsPerSide"); // MTEItemDistributor + removeTag(nbt, "radiusConfig"); // MTEMiner & MTEPump + removeTag(nbt, "mDisallowRetract"); // MTEPump + removeTag(nbt, "mStrongRedstone"); // BaseMetaTileEntity + if (removeCovers) { // BaseMetaTileEntity + removeTag(nbt, "mMuffler"); + removeTag(nbt, "mLockUpgrade"); + removeTag(nbt, "mCoverSides"); + removeTag(nbt, "gt.covers"); + for (String key : CoverableTileEntity.COVER_DATA_NBT_KEYS) { + removeTag(nbt, key); + } + } + if (nbt.hasNoTags()) { + output.setTagCompound(null); + } + } + if (canOutput(output)) { + getInputAt(0).stackSize = 0; + mEUt = 0; + mMaxProgresstime = 20; + mOutputItems[0] = output; + return 2; + } + return 0; + } + + private static void removeTag(NBTTagCompound nbt, String key) { + if (nbt.hasKey(key)) { + nbt.removeTag(key); + } + } + + @Override + public String[] getDescription() { + List description = new ArrayList<>(); + description.add("Removes various NBT tags as well as covers."); + description.add(" "); + description.add(UNDERLINE + "First Slot" + RESET); + description.add("The item you want to strip of NBT"); + description.add(" "); + description.add(UNDERLINE + "Second Slot" + RESET); + description.add("One of the following circuits:"); + description.add(BOLD + "Circuit 1:" + RESET + " Attempt to fix broken ores by removing the Display Name tag"); + description.add(BOLD + "Circuit 3:" + RESET + " Remove Railcraft stacking tag"); + description.add(BOLD + "Circuit 4:" + RESET + " Remove Anvil repair tag"); + description.add(BOLD + "Circuit 5:" + RESET + " Remove Dye from Leather armor"); + description.add(BOLD + "Circuit 6:" + RESET + " Remove Spray color from GT items"); + description.add( + BOLD + "Circuit 24:" + + RESET + + " Remove everything including covers. Be careful you won't recover the covers!"); + description.add(" "); + description.add(BOLD + "No Circuit:" + RESET + " Remove everything except covers"); + return description.toArray(new String[0]); + } + + @Override + public boolean isElectric() { + return false; + } + + @Override + public long maxEUStore() { + return 0; + } + + @Override + public long getMinimumStoredEU() { + return 0; + } + + @Override + public long maxAmperesIn() { + return 0; + } + + @Override + public long maxAmperesOut() { + return 0; + } + + @Override + protected BasicUIProperties getUIProperties() { + return super.getUIProperties().toBuilder() + .progressBarTexture(new FallbackableUITexture(GTUITextures.PROGRESSBAR_NAME_REMOVER)) + .build(); + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter1.java b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter1.java new file mode 100644 index 00000000000..d533dfc9572 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter1.java @@ -0,0 +1,48 @@ +package gregtech.common.tileentities.machines.multi; + +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public class MTEAirFilter1 extends MTEAirFilterBase { + + public MTEAirFilter1(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + multiTier = 1; + } + + public MTEAirFilter1(String aName) { + super(aName); + multiTier = 1; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEAirFilter1(mName); + } + + @Override + public long getEUt() { + return TierEU.RECIPE_LV; + } + + @Override + public float getBonusByTier() { + return 1.0f; + } + + @Override + public int getCasingIndex() { + return 57; + } + + @Override + public int getPipeMeta() { + return 1; + } + + @Override + public int getCasingMeta() { + return 0; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter2.java b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter2.java new file mode 100644 index 00000000000..08e1c6bcb52 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter2.java @@ -0,0 +1,48 @@ +package gregtech.common.tileentities.machines.multi; + +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public class MTEAirFilter2 extends MTEAirFilterBase { + + public MTEAirFilter2(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + multiTier = 2; + } + + public MTEAirFilter2(String aName) { + super(aName); + multiTier = 2; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEAirFilter2(mName); + } + + @Override + public long getEUt() { + return TierEU.RECIPE_HV; + } + + @Override + public float getBonusByTier() { + return 1.05f; + } + + @Override + public int getCasingIndex() { + return 59; + } + + @Override + public int getPipeMeta() { + return 4; + } + + @Override + public int getCasingMeta() { + return 3; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter3.java b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter3.java new file mode 100644 index 00000000000..5450a5c309a --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilter3.java @@ -0,0 +1,48 @@ +package gregtech.common.tileentities.machines.multi; + +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public class MTEAirFilter3 extends MTEAirFilterBase { + + public MTEAirFilter3(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + multiTier = 3; + } + + public MTEAirFilter3(String aName) { + super(aName); + multiTier = 3; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEAirFilter3(mName); + } + + @Override + public long getEUt() { + return TierEU.RECIPE_IV; + } + + @Override + public float getBonusByTier() { + return 1.1f; + } + + @Override + public int getCasingIndex() { + return 60; + } + + @Override + public int getPipeMeta() { + return 6; + } + + @Override + public int getCasingMeta() { + return 5; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilterBase.java b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilterBase.java new file mode 100644 index 00000000000..632196b8398 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/MTEAirFilterBase.java @@ -0,0 +1,609 @@ +package gregtech.common.tileentities.machines.multi; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.enums.GTValues.VN; +import static gregtech.api.enums.Textures.BlockIcons.TURBINE_NEW; +import static gregtech.api.enums.Textures.BlockIcons.TURBINE_NEW_ACTIVE; +import static gregtech.api.util.GTStructureUtility.ofHatchAdder; +import static gregtech.api.util.GTStructureUtility.ofHatchAdderOptional; +import static gregtech.api.util.GTUtility.filterValidMTEs; +import static java.lang.Math.max; +import static java.lang.Math.min; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.entity.player.EntityPlayer; +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.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import org.jetbrains.annotations.NotNull; + +import com.gtnewhorizon.structurelib.alignment.IAlignmentLimits; +import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTechAPI; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Mods; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.IToolStats; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.MetaGeneratedTool; +import gregtech.api.metatileentity.implementations.MTEEnhancedMultiBlockBase; +import gregtech.api.metatileentity.implementations.MTEHatchMuffler; +import gregtech.api.objects.XSTR; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GTModHandler; +import gregtech.api.util.GTUtility; +import gregtech.api.util.GTUtilityClient; +import gregtech.api.util.MultiblockTooltipBuilder; +import gregtech.common.items.MetaGeneratedTool01; +import gregtech.common.pollution.Pollution; + +public abstract class MTEAirFilterBase extends MTEEnhancedMultiBlockBase { + + // Formerly configurable values + public static final int POLLUTION_THRESHOLD = 10000; + public static final float BOOST_PER_FILTER = 2.0f; + public static final float GLOBAL_MULTIPLIER = 30.0f; + public static final float SCALING_FACTOR = 2.5f; + public static final int USES_PER_FILTER = 30; + + private static final Random RANDOM = new XSTR(); + + protected int baseEff = 0; + protected int multiTier = 0; + protected int chunkIndex = 0; + protected boolean hasPollution = false; + protected int mode = 0; // 0 for processing chunks in order, 1 for processing chunks randomly + protected int size; // current working size of the multi, max is 2*multiTier + 1 + protected boolean isFilterLoaded = false; + protected int filterUsageRemaining = 0; + protected int tickCounter = 0; // because we can't trust the world tick, it may be in a dim with eternal day, etc + private boolean mFormed; + protected static final String STRUCTURE_PIECE_MAIN = "main"; + protected static final ClassValue> STRUCTURE_DEFINITION = new ClassValue<>() { + + @Override + protected IStructureDefinition computeValue(Class type) { + return StructureDefinition.builder() + .addShape( + STRUCTURE_PIECE_MAIN, + transpose( + new String[][] { { "xxx", "xxx", "xxx" }, { "vmv", "m-m", "vmv" }, { "vmv", "m-m", "vmv" }, + { "c~c", "ccc", "ccc" }, })) + .addElement( + 'c', + lazy( + x -> ofChain( + ofBlock(GregTechAPI.sBlockCasingsNH, x.getCasingMeta()), + ofHatchAdder(MTEAirFilterBase::addMaintenanceToMachineList, x.getCasingIndex(), 1), + ofHatchAdder(MTEAirFilterBase::addInputToMachineList, x.getCasingIndex(), 1), + ofHatchAdder(MTEAirFilterBase::addOutputToMachineList, x.getCasingIndex(), 1), + ofHatchAdder(MTEAirFilterBase::addEnergyInputToMachineList, x.getCasingIndex(), 1)))) + .addElement('x', lazy(x -> ofBlock(GregTechAPI.sBlockCasingsNH, x.getCasingMeta()))) + .addElement('v', lazy(x -> ofBlock(GregTechAPI.sBlockCasingsNH, x.getPipeMeta()))) + .addElement( + 'm', + lazy( + x -> ofHatchAdderOptional( + MTEAirFilterBase::addMufflerToMachineList, + x.getCasingIndex(), + 2, + GregTechAPI.sBlockCasingsNH, + x.getCasingMeta()))) + .build(); + } + }; + + @Override + public final IStructureDefinition getStructureDefinition() { + return STRUCTURE_DEFINITION.get(getClass()); + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 1, 3, 0); + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + return checkPiece(STRUCTURE_PIECE_MAIN, 1, 3, 0) && !mMufflerHatches.isEmpty() + && mMaintenanceHatches.size() == 1; + } + + public MTEAirFilterBase(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public MTEAirFilterBase(String aName) { + super(aName); + } + + public abstract long getEUt(); + + public String getCasingString() { + return switch (getCasingMeta()) { + case 0 -> "Air Filter Turbine Casing"; + case 3 -> "Advanced Air Filter Turbine Casing"; + case 5 -> "Super Air Filter Turbine Casing"; + default -> "fill a ticket on github if you read this"; + }; + } + + public String getPipeString() { + return switch (getPipeMeta()) { + case 1 -> "Air Filter Vent Casing"; + case 4 -> "Advanced Air Filter Vent Casing"; + case 6 -> "Super Air Filter Vent Casing"; + default -> "fill a ticket on github if you read this"; + }; + } + + @Override + protected MultiblockTooltipBuilder createTooltip() { + final MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder(); + tt.addMachineType("Air Filter") + .addInfo("Needs a Turbine in the controller") + .addInfo("Can process " + (2 * multiTier + 1) + "x" + (2 * multiTier + 1) + " chunks") + .addInfo("Each muffler hatch reduces pollution in one chunk of the working area by:") + .addInfo( + " " + EnumChatFormatting.WHITE + + GLOBAL_MULTIPLIER + + " * multiTierBonus * turbineEff * FLOOR(" + + SCALING_FACTOR + + "^mufflerTier)") + .addInfo("every second") + .addInfo("- multiTierBonus for this controller is " + getBonusByTier()) + .addInfo("- turbineEff is the efficiency of the Turbine in controller slot") + .addInfo("- Effective muffler tier is limited by energy input tier") + .addInfo("- Uses " + getEUt() + " EU/t while working") + .addSeparator() + .addInfo("Insert Absorption Filter in an input bus") + .addInfo(" to double pollution cleaning amount (30 uses per item)") + .addInfo("Each maintenance issue reduces cleaning amount by 10%") + .beginStructureBlock(3, 4, 3, true) + .addController("Front bottom") + .addOtherStructurePart(getCasingString(), "Top and bottom layers") + .addOtherStructurePart(getPipeString(), "Corners of the middle two layers") + .addOtherStructurePart("Muffler Hatch", "Sides of the middle two layers") + .addEnergyHatch("Any bottom layer casing", 1) + .addMaintenanceHatch("Any bottom layer casing", 1) + .addInputBus("Any bottom layer casing", 1) + .addOutputBus("Any bottom layer casing", 1) + .toolTipFinisher(); + return tt; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + ITexture casingTexture = Textures.BlockIcons.getCasingTextureForId(getCasingIndex()); + if (side == facing) { + if (aActive) { + return new ITexture[] { casingTexture, + TextureFactory.of(Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE), TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_ACTIVE_GLOW) + .glow() + .build() }; + } + return new ITexture[] { casingTexture, TextureFactory.of(Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE), + TextureFactory.builder() + .addIcon(Textures.BlockIcons.OVERLAY_FRONT_DIESEL_ENGINE_GLOW) + .glow() + .build() }; + } + return new ITexture[] { casingTexture }; + } + + public abstract float getBonusByTier(); + + public abstract int getCasingIndex(); + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + if (aStack == null) return false; + if (!(aStack.getItem() instanceof MetaGeneratedTool01 tool)) return false; + if (aStack.getItemDamage() < 170 || aStack.getItemDamage() > 179) return false; + + IToolStats stats = tool.getToolStats(aStack); + if (stats == null || stats.getSpeedMultiplier() <= 0) return false; + + Materials material = MetaGeneratedTool.getPrimaryMaterial(aStack); + return material != null && material.mToolSpeed > 0; + } + + private float getTurbineDamage(ItemStack aStack) { + if (aStack == null || !(aStack.getItem() instanceof MetaGeneratedTool tool)) { + return -1; + } + return tool.getToolCombatDamage(aStack); + } + + @Override + protected IAlignmentLimits getInitialAlignmentLimits() { + // don't rotate it, it's cursed. + return (d, r, f) -> d.offsetY == 0 && r.isNotRotated() && !f.isVerticallyFliped(); + } + + public int getPollutionCleaningRatePerTick(float turbineEff, float multiEff, boolean isRateBoosted) { + return getPollutionCleaningRatePerSecond(turbineEff, multiEff, isRateBoosted) / 20; + } + + public int getPollutionCleaningRatePerSecond(float turbineEff, float multiEff, boolean isRateBoosted) { + long tVoltage = getMaxInputVoltage(); + byte tTier = (byte) max(1, GTUtility.getTier(tVoltage)); + int pollutionPerSecond = 0; + for (MTEHatchMuffler tHatch : filterValidMTEs(mMufflerHatches)) { + // applying scaling factor + pollutionPerSecond += (int) Math.pow(SCALING_FACTOR, min(tTier, tHatch.mTier)); + } + // apply the boost + if (isRateBoosted) { + pollutionPerSecond = (int) (pollutionPerSecond * BOOST_PER_FILTER); + } + // apply the rest of the coefs + pollutionPerSecond = (int) (pollutionPerSecond * turbineEff * multiEff * getBonusByTier() * GLOBAL_MULTIPLIER); + return pollutionPerSecond; + } + + @NotNull + @Override + public CheckRecipeResult checkProcessing() { + mEfficiencyIncrease = 10000; + mEfficiency = 10000 - (getIdealStatus() - getRepairStatus()) * 1000; + // check pollution for next cycle: + hasPollution = getTotalPollution() >= POLLUTION_THRESHOLD; + mMaxProgresstime = 200; + mEUt = (int) -getEUt(); + if (!hasPollution) { + return CheckRecipeResultRegistry.SUCCESSFUL; + } + + ItemStack aStack = getControllerSlot(); + if (!isCorrectMachinePart(aStack)) { + return CheckRecipeResultRegistry.NO_TURBINE_FOUND; + } + + float damage = getTurbineDamage(aStack); + if (damage == -1) { + return CheckRecipeResultRegistry.NO_TURBINE_FOUND; + } + baseEff = GTUtility.safeInt((long) ((50.0F + 10.0F * damage) * 100)); + tickCounter = 0; // resetting the counter in case of a power failure, etc + + // scan the inventory to search for filter if none has been loaded previously + if (!isFilterLoaded) { + ArrayList tInputList = getStoredInputs(); + int tInputList_sS = tInputList.size(); + for (int i = 0; i < tInputList_sS - 1; i++) { + for (int j = i + 1; j < tInputList_sS; j++) { + if (GTUtility.areStacksEqual(tInputList.get(i), tInputList.get(j))) { + if (tInputList.get(i).stackSize >= tInputList.get(j).stackSize) { + tInputList.remove(j--); + tInputList_sS = tInputList.size(); + } else { + tInputList.remove(i--); + tInputList_sS = tInputList.size(); + break; + } + } + } + } + + ItemStack[] tInputs = Arrays.copyOfRange(tInputList.toArray(new ItemStack[0]), 0, 2); + if (!tInputList.isEmpty()) { + ItemStack cleanFilter = getCleanFilter(); + for (ItemStack input : tInputs) { + if (GTUtility.areStacksEqual(input, cleanFilter, true)) { + input.stackSize -= 1; + updateSlots(); + filterUsageRemaining = USES_PER_FILTER; + isFilterLoaded = true; + break; + } + } + } + } + + // if a filter is loaded in + if (isFilterLoaded) { + + // consume one use of the filter + filterUsageRemaining -= 1; + + // when the filter finished its last usage, we give it back in dirty form. + if (filterUsageRemaining == 0) { + mOutputItems = new ItemStack[] { getDirtyFilter() }; + isFilterLoaded = false; + } else { + mOutputItems = null; // no return until the filter has been totally consumed + } + } + + return CheckRecipeResultRegistry.SUCCESSFUL; + } + + // Cache the lookup, but return clean copies of the stacks each time + private ItemStack cleanFilter, dirtyFilter; + + private ItemStack getCleanFilter() { + if (cleanFilter == null) { + if (Mods.NewHorizonsCoreMod.isModLoaded()) { + cleanFilter = GTModHandler.getModItem(Mods.NewHorizonsCoreMod.ID, "item.AdsorptionFilter", 1, 0); + } + if (cleanFilter == null) { + // fallback for dev environment + cleanFilter = new ItemStack(Blocks.stone); + } + } + return cleanFilter.copy(); + } + + private ItemStack getDirtyFilter() { + if (dirtyFilter == null) { + if (Mods.NewHorizonsCoreMod.isModLoaded()) { + dirtyFilter = GTModHandler.getModItem(Mods.NewHorizonsCoreMod.ID, "item.AdsorptionFilterDirty", 1, 0); + } + if (dirtyFilter == null) { + // fallback for dev environment + dirtyFilter = new ItemStack(Blocks.cobblestone); + } + } + return dirtyFilter.copy(); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setInteger("mode", mode); // running mode + aNBT.setInteger("chunkIndex", chunkIndex); // chunk index when running in normal mode + aNBT.setInteger("size", size); // working area + aNBT.setBoolean("isFilterLoaded", isFilterLoaded); + aNBT.setInteger("filterUsageRemaining", filterUsageRemaining); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + mode = aNBT.getInteger("mode"); + chunkIndex = aNBT.getInteger("chunkIndex"); + size = aNBT.getInteger("size"); + isFilterLoaded = aNBT.getBoolean("isFilterLoaded"); + filterUsageRemaining = aNBT.getInteger("filterUsageRemaining"); + } + + public void cleanPollution() { + int cleaningRate = getPollutionCleaningRatePerSecond(baseEff / 10000f, mEfficiency / 10000f, isFilterLoaded); + if (cleaningRate > 0) { + World world = this.getBaseMetaTileEntity() + .getWorld(); + if (mode == 0) { // processing chunk normally + removePollutionFromChunk(cleaningRate, world, chunkIndex); + chunkIndex += 1; + if (chunkIndex >= size * size) { + chunkIndex = 0; + } + } else { // process chunks randomly + // list all the polluted chunks + ArrayList pollutedChunks = new ArrayList<>(); + for (int index = 0; index < size * size; index++) { + if (getPollutionInChunk(world, index) > 0) { + pollutedChunks.add(index); + } + } + // pick the chunk randomly + if (!pollutedChunks.isEmpty()) { + int index = pollutedChunks.get(RANDOM.nextInt(pollutedChunks.size())); + removePollutionFromChunk(cleaningRate, world, index); + } + } + } + } + + protected final int getPollutionInChunk(World world, int chunkIndexIn) { + final int xCoordMulti = this.getBaseMetaTileEntity() + .getXCoord(); + final int zCoordMulti = this.getBaseMetaTileEntity() + .getZCoord(); + final int chunkX = xCoordMulti - 16 * (size / 2 - chunkIndexIn % size) >> 4; + final int chunkZ = zCoordMulti + 16 * (size / 2 - chunkIndexIn / size) >> 4; + return Pollution.getPollution(world, chunkX, chunkZ); + } + + protected final void removePollutionFromChunk(int amount, World world, int chunkIndexIn) { + final int xCoordMulti = this.getBaseMetaTileEntity() + .getXCoord(); + final int zCoordMulti = this.getBaseMetaTileEntity() + .getZCoord(); + final int chunkX = xCoordMulti - 16 * (size / 2 - chunkIndexIn % size) >> 4; + final int chunkZ = zCoordMulti + 16 * (size / 2 - chunkIndexIn / size) >> 4; + Pollution.addPollution(world, chunkX, chunkZ, -amount); + } + + public abstract int getPipeMeta(); + + public abstract int getCasingMeta(); + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (size == 0) { // here in case it's not set by NBT loading + size = 2 * multiTier + 1; + } + super.onPreTick(aBaseMetaTileEntity, aTick); + } + + public int getTotalPollution() { + int pollutionAmount = 0; + World world = this.getBaseMetaTileEntity() + .getWorld(); + for (int i = 0; i < size * size; i++) { + pollutionAmount += getPollutionInChunk(world, i); + + } + return pollutionAmount; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aTick % 200L == 0L) { + // refresh casing on state change + int Xpos = aBaseMetaTileEntity.getXCoord() + aBaseMetaTileEntity.getBackFacing().offsetX; + int Ypos = aBaseMetaTileEntity.getYCoord() + 3; + int Zpos = aBaseMetaTileEntity.getZCoord() + aBaseMetaTileEntity.getBackFacing().offsetZ; + try { + aBaseMetaTileEntity.getWorld() + .markBlockRangeForRenderUpdate(Xpos - 1, Ypos, Zpos - 1, Xpos + 1, Ypos, Zpos + 1); + } catch (Exception ignored) {} + } + super.onPostTick(aBaseMetaTileEntity, aTick); + } + + @Override + public void onValueUpdate(byte aValue) { + mFormed = aValue == 1; + } + + @Override + public byte getUpdateData() { + return (byte) (mMachine ? 1 : 0); + } + + @Override + public boolean renderInWorld(IBlockAccess aWorld, int aX, int aY, int aZ, Block aBlock, RenderBlocks aRenderer) { + if (!mFormed) return false; + int[] xyz = new int[3]; + ExtendedFacing ext = getExtendedFacing(); + ext.getWorldOffset(new int[] { 0, -3, 1 }, xyz); + IIconContainer[] tTextures = getBaseMetaTileEntity().isActive() ? TURBINE_NEW_ACTIVE : TURBINE_NEW; + // we know this multi can only ever face upwards, so just use +y directly + ExtendedFacing direction = ExtendedFacing.of(ForgeDirection.UP); + GTUtilityClient.renderTurbineOverlay( + aWorld, + xyz[0] + aX, + xyz[1] + aY, + xyz[2] + aZ, + aRenderer, + direction, + GregTechAPI.sBlockCasingsNH, + tTextures); + return false; + } + + @Override + public boolean onRunningTick(ItemStack aStack) { + if (tickCounter == 19 && hasPollution) { + cleanPollution(); + tickCounter = 0; + } else { + tickCounter += 1; + } + return super.onRunningTick(aStack); + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + try { + if (isCorrectMachinePart(aStack) && hasPollution) { // no pollution no damage + return getBaseMetaTileEntity().getRandomNumber(2); // expected to be 0.5 damage in long term + } + } catch (Exception e) { + /**/ + } + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (!aPlayer.isSneaking()) { // change mode + mode = mode == 1 ? 0 : 1; + if (mode == 0) { + chunkIndex = 0; + aPlayer.addChatMessage(new ChatComponentText("Electric air filter now running in normal mode")); + } else { + aPlayer.addChatMessage(new ChatComponentText("Electric air filter now running in random mode")); + } + } else { // change radius on sneak + if (size == 1) { + size = 2 * multiTier + 1; + } else { + size -= 2; // always get odd number + } + chunkIndex = 0; + aPlayer.addChatMessage( + new ChatComponentText("Electric air filter is now working in a " + size + "x" + size + " area")); + } + } + + @Override + public String[] getInfoData() { + return new String[] { "Progress:", + EnumChatFormatting.GREEN + Integer.toString(mProgresstime / 20) + + EnumChatFormatting.RESET + + " s / " + + EnumChatFormatting.YELLOW + + mMaxProgresstime / 20 + + EnumChatFormatting.RESET + + " s", + "Stored Energy:", + EnumChatFormatting.GREEN + Long.toString(getBaseMetaTileEntity().getStoredEU()) + + EnumChatFormatting.RESET + + " EU / " + + EnumChatFormatting.YELLOW + + getBaseMetaTileEntity().getEUCapacity() + + EnumChatFormatting.RESET + + " EU", + "Probably uses: " + + // negative EU triggers special EU consumption behavior. however it does not produce power. + EnumChatFormatting.RED + Math.abs(mEUt) + EnumChatFormatting.RESET + " EU/t", + "Max Energy Income: " + EnumChatFormatting.YELLOW + + getMaxInputVoltage() + + EnumChatFormatting.RESET + + " EU/t(*2A) Tier: " + + EnumChatFormatting.YELLOW + + VN[GTUtility.getTier(getMaxInputVoltage())] + + EnumChatFormatting.RESET, + "Problems: " + EnumChatFormatting.RED + + (getIdealStatus() - getRepairStatus()) + + EnumChatFormatting.RESET + + " Efficiency: " + + EnumChatFormatting.YELLOW + + mEfficiency / 100.0F + + EnumChatFormatting.RESET + + " %", + "Pollution reduction: " + EnumChatFormatting.GREEN + + getPollutionCleaningRatePerTick(baseEff / 10000f, mEfficiency / 10000f, isFilterLoaded) + + EnumChatFormatting.RESET + + " gibbl/t", + "Has a filter in it: " + isFilterLoaded, + "remaining cycles for the filter (if present): " + filterUsageRemaining }; + } +} diff --git a/src/main/java/gregtech/loaders/postload/PCBFactoryMaterialLoader.java b/src/main/java/gregtech/loaders/postload/PCBFactoryMaterialLoader.java index 0f6ab52a325..39cf8ff0384 100644 --- a/src/main/java/gregtech/loaders/postload/PCBFactoryMaterialLoader.java +++ b/src/main/java/gregtech/loaders/postload/PCBFactoryMaterialLoader.java @@ -15,5 +15,6 @@ public static void load() { PCBFactoryManager.addPlasticTier(Materials.EpoxidFiberReinforced, 5); PCBFactoryManager.addPlasticTier(Materials.Polybenzimidazole, 6); PCBFactoryManager.addPlasticTier(MaterialsKevlar.Kevlar, 7); + PCBFactoryManager.addPlasticTier(Materials.RadoxPolymer, 8); } } diff --git a/src/main/java/gregtech/loaders/preload/LoaderMetaTileEntities.java b/src/main/java/gregtech/loaders/preload/LoaderMetaTileEntities.java index c02c1d94dfc..b4bcce38d3d 100644 --- a/src/main/java/gregtech/loaders/preload/LoaderMetaTileEntities.java +++ b/src/main/java/gregtech/loaders/preload/LoaderMetaTileEntities.java @@ -1012,6 +1012,7 @@ import gregtech.common.tileentities.machines.basic.MTEMicrowaveEnergyTransmitter; import gregtech.common.tileentities.machines.basic.MTEMiner; import gregtech.common.tileentities.machines.basic.MTEMonsterRepellent; +import gregtech.common.tileentities.machines.basic.MTENameRemover; import gregtech.common.tileentities.machines.basic.MTEPotionBrewer; import gregtech.common.tileentities.machines.basic.MTEPump; import gregtech.common.tileentities.machines.basic.MTEReplicator; @@ -1022,6 +1023,9 @@ import gregtech.common.tileentities.machines.basic.MTEWorldAccelerator; import gregtech.common.tileentities.machines.long_distance.MTELongDistancePipelineFluid; import gregtech.common.tileentities.machines.long_distance.MTELongDistancePipelineItem; +import gregtech.common.tileentities.machines.multi.MTEAirFilter1; +import gregtech.common.tileentities.machines.multi.MTEAirFilter2; +import gregtech.common.tileentities.machines.multi.MTEAirFilter3; import gregtech.common.tileentities.machines.multi.MTEAssemblyLine; import gregtech.common.tileentities.machines.multi.MTEBrickedBlastFurnace; import gregtech.common.tileentities.machines.multi.MTECharcoalPit; @@ -12364,6 +12368,23 @@ private static void registerPlasmaGenerators() { 8).getStackForm(1L)); } + private static void registerNameRemover() { + ItemList.NameRemover + .set(new MTENameRemover(NAME_REMOVER.ID, "fix.name.remover", "Name Remover", 0).getStackForm(1L)); + } + + private static void registerAirFilters() { + ItemList.Machine_Multi_AirFilterT1.set( + new MTEAirFilter1(AIR_FILTER_CONTROLLER_T1.ID, "multimachine.airfilter.01", "Electric Air Filter T1") + .getStackForm(1L)); + ItemList.Machine_Multi_AirFilterT2.set( + new MTEAirFilter2(AIR_FILTER_CONTROLLER_T2.ID, "multimachine.airfilter.02", "Electric Air Filter T2") + .getStackForm(1L)); + ItemList.Machine_Multi_AirFilterT3.set( + new MTEAirFilter3(AIR_FILTER_CONTROLLER_T3.ID, "multimachine.airfilter.03", "Electric Air Filter T3") + .getStackForm(1L)); + } + private static void generateWiresAndPipes() { for (int meta = 0; meta < GregTechAPI.sGeneratedMaterials.length; meta++) { Materials material = GregTechAPI.sGeneratedMaterials[meta]; @@ -12931,6 +12952,8 @@ public void run() { registerUnpackager(); registerPrinter(); registerOven(); + registerNameRemover(); + registerAirFilters(); ItemList.AdvDebugStructureWriter.set( new MTEAdvDebugStructureWriter( diff --git a/src/main/resources/assets/gregtech/textures/gui/progressbar/name_remover.png b/src/main/resources/assets/gregtech/textures/gui/progressbar/name_remover.png new file mode 100644 index 0000000000000000000000000000000000000000..b902ddf029c7209258fd542aabb1b66f3e13463a GIT binary patch literal 217 zcmV;~04D#5P)NklV;asuNW< zzaG8!O*>%bFR+F%b5pt)Bh2eKw3N~exmAAdJEYV!|?17u}+tkLc;mg>|*!Ot@;ub*6 TkWHXF00000NkvXXu0mjfc-~rS literal 0 HcmV?d00001