diff --git a/common/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/OverclockFancyConfigurator.java b/common/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/OverclockFancyConfigurator.java index b86b34201e..1136341b11 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/OverclockFancyConfigurator.java +++ b/common/src/main/java/com/gregtechceu/gtceu/api/machine/fancyconfigurator/OverclockFancyConfigurator.java @@ -16,7 +16,10 @@ import net.minecraft.network.FriendlyByteBuf; import net.minecraft.network.chat.Component; +import javax.annotation.Nullable; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.function.BiConsumer; import java.util.function.Consumer; @@ -26,12 +29,16 @@ * @implNote OverclockFancyConfigurator */ public class OverclockFancyConfigurator implements IFancyConfigurator { - IOverclockMachine overclockMachine; + protected IOverclockMachine overclockMachine; // runtime - int currentTier; + protected int currentTier; + @Nullable + protected WidgetGroup group; + protected Map lightGroups; public OverclockFancyConfigurator(IOverclockMachine overclockMachine) { this.overclockMachine = overclockMachine; + this.lightGroups = new HashMap<>(); } @Override @@ -41,12 +48,59 @@ public void detectAndSendChange(BiConsumer> s this.currentTier = newTier; sender.accept(0, buf -> buf.writeVarInt(this.currentTier)); } + int min = overclockMachine.getMinOverclockTier(); + int max = overclockMachine.getMaxOverclockTier(); + if (lightGroups.size() != max - min + 1) { + updateLightButton(min, max); + sender.accept(1, buf -> { + buf.writeVarInt(min); + buf.writeVarInt(max); + }); + } else { + for (int i = min; i <= max; i++) { + if (!lightGroups.containsKey(i)) { + updateLightButton(min, max); + sender.accept(1, buf -> { + buf.writeVarInt(min); + buf.writeVarInt(max); + }); + return; + } + } + } + } + + private void updateLightButton(int min, int max) { + if (group != null) { + for (WidgetGroup light : lightGroups.values()) { + group.removeWidget(light); + } + lightGroups.clear(); + int x = 5; + for (int tier = min; tier <= max ; tier++) { + int finalTier = tier; + var lightGroup = new WidgetGroup(x, 27, 8, 8); + lightGroup.addWidget(new ButtonWidget(0, 0, 8, 8, null, cd -> { + if (!cd.isRemote) { + overclockMachine.setOverclockTier(finalTier); + } + })); + lightGroup.addWidget(new ImageWidget(0, 0, 8, 8, () -> currentTier >= finalTier ? GuiTextures.LIGHT_ON : GuiTextures.LIGHT_OFF)); + lightGroups.put(tier, lightGroup); + group.addWidget(lightGroup); + x += 10; + } + } } @Override public void readUpdateInfo(int id, FriendlyByteBuf buf) { if (id == 0) { this.currentTier = buf.readVarInt(); + } else if (id == 1) { + int min = buf.readVarInt(); + int max = buf.readVarInt(); + updateLightButton(min, max); } } @@ -62,7 +116,7 @@ public IGuiTexture getIcon() { @Override public Widget createConfigurator() { - var group = new WidgetGroup(0, 0, 120, 40); + group = new WidgetGroup(0, 0, 120, 40); group.setBackground(GuiTextures.BACKGROUND_INVERSE); group.addWidget(new PredicatedButtonWidget(5, 5, 10, 20, new GuiTextureGroup(GuiTextures.BUTTON, Icons.LEFT.copy().scale(0.7f)), cd -> { if (!cd.isRemote) { @@ -75,20 +129,11 @@ public Widget createConfigurator() { overclockMachine.setOverclockTier(currentTier + 1); } }).setPredicate(() -> currentTier < overclockMachine.getMaxOverclockTier())); - int x = 5; - for (int tier = overclockMachine.getMinOverclockTier(); tier <= overclockMachine.getMaxOverclockTier() ; tier++) { - int finalTier = tier; - group.addWidget(new ButtonWidget(x, 27, 8, 8, null, cd -> { - if (!cd.isRemote) { - overclockMachine.setOverclockTier(finalTier); - } - })); - group.addWidget(new ImageWidget(x, 27, 8, 8, () -> currentTier >= finalTier ? GuiTextures.LIGHT_ON : GuiTextures.LIGHT_OFF)); - x += 10; - } return group; } + + @Override public List getTooltips() { return List.of(Component.translatable(getTitle()), Component.translatable("gtceu.gui.overclock.range", GTValues.VNF[overclockMachine.getMinOverclockTier()], GTValues.VNF[overclockMachine.getMaxOverclockTier()])); diff --git a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/TieredWorkableElectricMultiblockMachine.java b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/TieredWorkableElectricMultiblockMachine.java index 42aca58822..40925c9f1f 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/TieredWorkableElectricMultiblockMachine.java +++ b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/TieredWorkableElectricMultiblockMachine.java @@ -2,6 +2,7 @@ import com.gregtechceu.gtceu.api.GTValues; import com.gregtechceu.gtceu.api.machine.IMachineBlockEntity; +import com.gregtechceu.gtceu.api.machine.feature.IOverclockMachine; import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine; import com.lowdragmc.lowdraglib.syncdata.annotation.Persisted; import com.lowdragmc.lowdraglib.syncdata.field.ManagedFieldHolder; @@ -17,7 +18,7 @@ */ @ParametersAreNonnullByDefault @MethodsReturnNonnullByDefault -public class TieredWorkableElectricMultiblockMachine extends WorkableElectricMultiblockMachine implements ITieredMachine { +public class TieredWorkableElectricMultiblockMachine extends WorkableElectricMultiblockMachine implements ITieredMachine, IOverclockMachine { protected static final ManagedFieldHolder MANAGED_FIELD_HOLDER = new ManagedFieldHolder(TieredWorkableElectricMultiblockMachine.class, WorkableElectricMultiblockMachine.MANAGED_FIELD_HOLDER); private final int tier; @@ -25,8 +26,8 @@ public class TieredWorkableElectricMultiblockMachine extends WorkableElectricMul @Getter protected int overclockTier; - public TieredWorkableElectricMultiblockMachine(IMachineBlockEntity holder, int tier) { - super(holder); + public TieredWorkableElectricMultiblockMachine(IMachineBlockEntity holder, int tier, Object... args) { + super(holder, args); this.tier = tier; } diff --git a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java index fe9c65b364..b7df7bf54f 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java +++ b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableElectricMultiblockMachine.java @@ -1,6 +1,10 @@ package com.gregtechceu.gtceu.api.machine.multiblock; import com.gregtechceu.gtceu.api.GTValues; +import com.gregtechceu.gtceu.api.capability.IEnergyContainer; +import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability; +import com.gregtechceu.gtceu.api.capability.recipe.IO; +import com.gregtechceu.gtceu.api.capability.recipe.IRecipeHandler; import com.gregtechceu.gtceu.api.gui.GuiTextures; import com.gregtechceu.gtceu.api.gui.fancy.IFancyUIProvider; import com.gregtechceu.gtceu.api.gui.fancy.TooltipsPanel; @@ -10,10 +14,6 @@ import com.gregtechceu.gtceu.api.machine.feature.multiblock.IDisplayUIMachine; import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMultiPart; import com.gregtechceu.gtceu.utils.GTUtil; -import com.gregtechceu.gtceu.api.capability.IEnergyContainer; -import com.gregtechceu.gtceu.api.capability.recipe.EURecipeCapability; -import com.gregtechceu.gtceu.api.capability.recipe.IO; -import com.gregtechceu.gtceu.api.capability.recipe.IRecipeHandler; import com.gregtechceu.gtceu.api.machine.feature.ITieredMachine; import com.lowdragmc.lowdraglib.gui.modular.ModularUI; import com.lowdragmc.lowdraglib.gui.widget.*; @@ -38,6 +38,29 @@ public class WorkableElectricMultiblockMachine extends WorkableMultiblockMachine public WorkableElectricMultiblockMachine(IMachineBlockEntity holder, Object... args) { super(holder, args); } + //runtime + private long maxHatchVoltage = -1; + + ////////////////////////////////////// + //*** Multiblock LifeCycle ***// + ////////////////////////////////////// + @Override + public void onStructureInvalid() { + super.onStructureInvalid(); + maxHatchVoltage = -1; + } + + @Override + public void onStructureFormed() { + maxHatchVoltage = -1; + super.onStructureFormed(); + } + + @Override + public void onPartUnload() { + super.onPartUnload(); + maxHatchVoltage = -1; + } ////////////////////////////////////// //********** GUI ***********// @@ -68,7 +91,7 @@ public void addDisplayText(List textList) { // .setStyle(Style.EMPTY.withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, // Component.translatable("gtceu.multiblock.multiple_recipemaps.tooltip"))))); - textList.add(Component.translatable(recipeType.registryName.toLanguageKey()) + textList.add(Component.translatable(getRecipeType().registryName.toLanguageKey()) .setStyle(Style.EMPTY.withColor(ChatFormatting.AQUA) .withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.translatable("gtceu.multiblock.multiple_recipemaps.tooltip"))))); @@ -166,25 +189,31 @@ public int getTier() { return GTUtil.getFloorTierByVoltage(getMaxVoltage()); } - public long getMaxVoltage() { - long maxVoltage = 0L; - var capabilities = capabilitiesProxy.get(IO.IN, EURecipeCapability.CAP); - if (capabilities != null) { - for (IRecipeHandler handler : capabilities) { - if (handler instanceof IEnergyContainer container) { - maxVoltage += container.getInputVoltage() * container.getInputAmperage(); - } - } - } else { - capabilities = capabilitiesProxy.get(IO.OUT, EURecipeCapability.CAP); + public long getMaxHatchVoltage() { + if (maxHatchVoltage < 0) { + maxHatchVoltage = 0L; + var capabilities = capabilitiesProxy.get(IO.IN, EURecipeCapability.CAP); if (capabilities != null) { for (IRecipeHandler handler : capabilities) { if (handler instanceof IEnergyContainer container) { - maxVoltage += container.getOutputVoltage() * container.getOutputAmperage(); + maxHatchVoltage += container.getInputVoltage() * container.getInputAmperage(); + } + } + } else { + capabilities = capabilitiesProxy.get(IO.OUT, EURecipeCapability.CAP); + if (capabilities != null) { + for (IRecipeHandler handler : capabilities) { + if (handler instanceof IEnergyContainer container) { + maxHatchVoltage += container.getOutputVoltage() * container.getOutputAmperage(); + } } } } } - return maxVoltage; + return maxHatchVoltage; + } + + public long getMaxVoltage() { + return getMaxHatchVoltage(); } } diff --git a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java index 171ab1650c..8bcdcce1c1 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java +++ b/common/src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/WorkableMultiblockMachine.java @@ -49,7 +49,7 @@ public abstract class WorkableMultiblockMachine extends MultiblockControllerMach @DescSynced public final RecipeLogic recipeLogic; @Getter - public final GTRecipeType recipeType; + private final GTRecipeType recipeType; @Getter protected final Table, List>> capabilitiesProxy; protected final List traitSubscriptions; diff --git a/common/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableItemStackHandler.java b/common/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableItemStackHandler.java index ae3cc8e65f..40fbca4e43 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableItemStackHandler.java +++ b/common/src/main/java/com/gregtechceu/gtceu/api/machine/trait/NotifiableItemStackHandler.java @@ -8,6 +8,7 @@ import com.lowdragmc.lowdraglib.misc.ItemStackTransfer; import com.lowdragmc.lowdraglib.side.item.IItemTransfer; import com.lowdragmc.lowdraglib.side.item.ItemTransferHelper; +import com.lowdragmc.lowdraglib.syncdata.annotation.DescSynced; import com.lowdragmc.lowdraglib.syncdata.annotation.Persisted; import com.lowdragmc.lowdraglib.syncdata.field.ManagedFieldHolder; import lombok.Getter; @@ -22,6 +23,7 @@ import java.util.List; import java.util.Set; import java.util.function.Function; +import java.util.function.Supplier; /** * @author KilaBash @@ -37,19 +39,23 @@ public class NotifiableItemStackHandler extends NotifiableRecipeHandlerTrait transferFactory) { super(machine); this.timeStamp = Long.MIN_VALUE; this.handlerIO = handlerIO; - this.storage = new ItemStackTransfer(slots); + this.storage = transferFactory.apply(slots); this.capabilityIO = capabilityIO; this.storage.setOnContentsChanged(this::onContentChanged); } + public NotifiableItemStackHandler(MetaMachine machine, int slots, IO handlerIO, IO capabilityIO) { + this(machine, slots, handlerIO, capabilityIO, ItemStackTransfer::new); + } + public NotifiableItemStackHandler(MetaMachine machine, int slots, IO handlerIO) { this(machine, slots, handlerIO, handlerIO); } diff --git a/common/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/ProcessingArrayMachineRenderer.java b/common/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/ProcessingArrayMachineRenderer.java new file mode 100644 index 0000000000..3dede02e3a --- /dev/null +++ b/common/src/main/java/com/gregtechceu/gtceu/client/renderer/machine/ProcessingArrayMachineRenderer.java @@ -0,0 +1,51 @@ +package com.gregtechceu.gtceu.client.renderer.machine; + +import com.gregtechceu.gtceu.api.machine.MachineDefinition; +import com.gregtechceu.gtceu.api.machine.MetaMachine; +import com.gregtechceu.gtceu.common.machine.multiblock.electric.ProcessingArrayMachine; +import com.lowdragmc.lowdraglib.client.bakedpipeline.Quad; +import com.mojang.math.Vector3f; +import net.fabricmc.api.EnvType; +import net.fabricmc.api.Environment; +import net.minecraft.client.renderer.block.model.BakedQuad; +import net.minecraft.client.resources.model.ModelState; +import net.minecraft.core.Direction; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.util.RandomSource; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; + +/** + * @author KilaBash + * @date 2023/7/24 + * @implNote ProcessingArrayMachineRenderer + */ +public class ProcessingArrayMachineRenderer extends WorkableCasingMachineRenderer{ + public ProcessingArrayMachineRenderer(ResourceLocation baseCasing, ResourceLocation workableModel) { + super(baseCasing, workableModel, false); + } + + @Override + @Environment(EnvType.CLIENT) + public void renderMachine(List quads, MachineDefinition definition, @Nullable MetaMachine machine, Direction frontFacing, @Nullable Direction side, RandomSource rand, Direction modelFacing, ModelState modelState) { + super.renderMachine(quads, definition, machine, frontFacing, side, rand, modelFacing, modelState); + // render held machine in the center + if (machine instanceof ProcessingArrayMachine processingArray && processingArray.isFormed()) { + var heldDefinition = processingArray.getMachineDefinition(); + if (heldDefinition != null && heldDefinition.getRenderer() instanceof MachineRenderer machineRenderer) { + List machineQuad = new ArrayList<>(); + machineRenderer.renderMachine(machineQuad, definition, machine, frontFacing, side, rand, modelFacing, modelState); + for (var quad : machineQuad) { + var bakedQuad = Quad.from(quad); + for (int i = 0; i < 4; i++) { + var pos = bakedQuad.getVert(i); + bakedQuad = bakedQuad.withVert(i, new Vector3f(pos.x() - frontFacing.getStepX(), pos.y() + 1, pos.z() - frontFacing.getStepZ())); + } + quads.add(bakedQuad.rebake()); + } + } + } + } +} diff --git a/common/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java b/common/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java index a901fa0ff9..c5ca77c872 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java +++ b/common/src/main/java/com/gregtechceu/gtceu/common/data/GTMachines.java @@ -79,6 +79,8 @@ import net.minecraft.world.level.block.state.BlockBehaviour; import net.minecraft.world.level.block.state.properties.DoubleBlockHalf; import net.minecraft.world.level.material.Fluids; +import net.minecraft.world.phys.shapes.Shapes; +import net.minecraft.world.phys.shapes.VoxelShape; import java.util.*; import java.util.function.BiConsumer; @@ -1284,6 +1286,38 @@ public static BiConsumer> createTankTooltips(String n GTCEu.id("block/casings/solid/machine_casing_robust_tungstensteel"), GTCEu.id("block/multiblock/generator/large_plasma_turbine")); + public final static MultiblockMachineDefinition[] PROCESSING_ARRAY = ConfigHolder.INSTANCE.machines.doProcessingArray ? registerTieredMultis("processing_array", ProcessingArrayMachine::new, + (tier, builder) -> builder + .rotationState(RotationState.NON_Y_AXIS) + .blockProp(p -> p.noOcclusion().isViewBlocking((state, level, pos) -> false)) + .shape(Shapes.box(-0.001, -0.001, -0.001, 1.001, 1.001, 1.001)) + .appearanceBlock(() -> ProcessingArrayMachine.getCasingState(tier)) + .recipeType(GTRecipeTypes.DUMMY_RECIPES) + .recipeModifier(ProcessingArrayMachine::recipeModifier, true) + .pattern(definition -> FactoryBlockPattern.start() + .aisle("XXX", "CCC", "XXX") + .aisle("XXX", "C#C", "XXX") + .aisle("XSX", "CCC", "XXX") + .where('S', Predicates.controller(blocks(definition.getBlock()))) + .where('X', blocks(ProcessingArrayMachine.getCasingState(tier)).setMinGlobalLimited(4) + .or(Predicates.abilities(PartAbility.IMPORT_ITEMS)) + .or(Predicates.abilities(PartAbility.EXPORT_ITEMS)) + .or(Predicates.abilities(PartAbility.IMPORT_FLUIDS)) + .or(Predicates.abilities(PartAbility.EXPORT_FLUIDS)) + .or(Predicates.abilities(PartAbility.INPUT_ENERGY)) + .or(Predicates.abilities(PartAbility.OUTPUT_ENERGY)) + .or(Predicates.autoAbilities(true, false))) + .where('C', blocks(CLEANROOM_GLASS.get())) + .where('#', Predicates.air()) + .build()) + .tooltips(Component.translatable("gtceu.universal.tooltip.parallel", ProcessingArrayMachine.getMachineLimit(tier))) + .renderer(() -> new ProcessingArrayMachineRenderer(tier == IV ? + GTCEu.id("block/casings/solid/machine_casing_robust_tungstensteel") : + GTCEu.id("block/casings/solid/machine_casing_study_hsse"), + GTCEu.id("block/multiblock/processing_array"))) + .register(), + IV, LuV) : null; + ////////////////////////////////////// //********** Misc **********// ////////////////////////////////////// diff --git a/common/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeModifiers.java b/common/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeModifiers.java index 39049910ea..43cf2e68a0 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeModifiers.java +++ b/common/src/main/java/com/gregtechceu/gtceu/common/data/GTRecipeModifiers.java @@ -49,13 +49,15 @@ public class GTRecipeModifiers { * @param modifyDuration should multiply the duration * @return modified recipe and parallel amount */ - public static Tuple fastParallel(IRecipeCapabilityHolder holder, @Nonnull GTRecipe recipe, int maxParallel, boolean modifyDuration) { - while (maxParallel > 0) { - var copied = recipe.copy(ContentModifier.multiplier(maxParallel), modifyDuration); - if (copied.matchRecipe(holder).isSuccess()) { - return new Tuple<>(copied, maxParallel); + public static Tuple fastParallel(MetaMachine machine, @Nonnull GTRecipe recipe, int maxParallel, boolean modifyDuration) { + if (machine instanceof IRecipeCapabilityHolder holder) { + while (maxParallel > 0) { + var copied = recipe.copy(ContentModifier.multiplier(maxParallel), modifyDuration); + if (copied.matchRecipe(holder).isSuccess()) { + return new Tuple<>(copied, maxParallel); + } + maxParallel /= 2; } - maxParallel /= 2; } return new Tuple<>(recipe, 1); }; diff --git a/common/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ProcessingArrayMachine.java b/common/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ProcessingArrayMachine.java new file mode 100644 index 0000000000..c848fa1f17 --- /dev/null +++ b/common/src/main/java/com/gregtechceu/gtceu/common/machine/multiblock/electric/ProcessingArrayMachine.java @@ -0,0 +1,201 @@ +package com.gregtechceu.gtceu.common.machine.multiblock.electric; + +import com.gregtechceu.gtceu.api.GTValues; +import com.gregtechceu.gtceu.api.capability.recipe.IO; +import com.gregtechceu.gtceu.api.gui.GuiTextures; +import com.gregtechceu.gtceu.api.item.MetaMachineItem; +import com.gregtechceu.gtceu.api.machine.IMachineBlockEntity; +import com.gregtechceu.gtceu.api.machine.MachineDefinition; +import com.gregtechceu.gtceu.api.machine.MetaMachine; +import com.gregtechceu.gtceu.api.machine.multiblock.TieredWorkableElectricMultiblockMachine; +import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler; +import com.gregtechceu.gtceu.api.recipe.GTRecipe; +import com.gregtechceu.gtceu.api.recipe.GTRecipeType; +import com.gregtechceu.gtceu.api.recipe.OverclockingLogic; +import com.gregtechceu.gtceu.common.data.GTBlocks; +import com.gregtechceu.gtceu.common.data.GTRecipeModifiers; +import com.gregtechceu.gtceu.common.data.GTRecipeTypes; +import com.gregtechceu.gtceu.utils.GTUtil; +import com.lowdragmc.lowdraglib.gui.widget.SlotWidget; +import com.lowdragmc.lowdraglib.gui.widget.Widget; +import com.lowdragmc.lowdraglib.gui.widget.WidgetGroup; +import com.lowdragmc.lowdraglib.misc.ItemStackTransfer; +import com.lowdragmc.lowdraglib.syncdata.annotation.DescSynced; +import com.lowdragmc.lowdraglib.syncdata.annotation.Persisted; +import com.lowdragmc.lowdraglib.syncdata.field.ManagedFieldHolder; +import net.minecraft.ChatFormatting; +import net.minecraft.MethodsReturnNonnullByDefault; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.Style; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.block.Block; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import javax.annotation.ParametersAreNonnullByDefault; +import java.util.List; + +/** + * @author KilaBash + * @date 2023/7/23 + * @implNote ProcessingArrayMachine + */ +@ParametersAreNonnullByDefault +@MethodsReturnNonnullByDefault +public class ProcessingArrayMachine extends TieredWorkableElectricMultiblockMachine { + + protected static final ManagedFieldHolder MANAGED_FIELD_HOLDER = new ManagedFieldHolder(ProcessingArrayMachine.class, TieredWorkableElectricMultiblockMachine.MANAGED_FIELD_HOLDER); + + @Persisted @DescSynced + public final NotifiableItemStackHandler machineStorage; + //runtime + @Nullable + private GTRecipeType recipeTypeCache; + + public ProcessingArrayMachine(IMachineBlockEntity holder, int tier, Object... args) { + super(holder, tier, args); + this.machineStorage = createMachineStorage(args); + } + + ////////////////////////////////////// + //***** Initialization ******// + ////////////////////////////////////// + @Override + public ManagedFieldHolder getFieldHolder() { + return MANAGED_FIELD_HOLDER; + } + + protected NotifiableItemStackHandler createMachineStorage(Object... args) { + var storage = new NotifiableItemStackHandler(this, 1, IO.NONE, IO.NONE, slots -> new ItemStackTransfer(1) { + @Override + public int getSlotLimit(int slot) { + return getMachineLimit(getDefinition().getTier()); + } + }); + storage.setFilter(this::isMachineStack); + return storage; + } + + protected boolean isMachineStack(ItemStack itemStack) { + if (itemStack.getItem() instanceof MetaMachineItem metaMachineItem) { + var recipeType = metaMachineItem.getDefinition().getRecipeType(); + return recipeType != null && recipeType != GTRecipeTypes.DUMMY_RECIPES; + } + return false; + } + + @Nullable + public MachineDefinition getMachineDefinition() { + if (machineStorage.storage.getStackInSlot(0).getItem() instanceof MetaMachineItem metaMachineItem) { + return metaMachineItem.getDefinition(); + } + return null; + } + + @Override + @Nonnull + public GTRecipeType getRecipeType() { + if (recipeTypeCache == null) { + var definition = getMachineDefinition(); + recipeTypeCache = definition == null ? null : definition.getRecipeType(); + } + if (recipeTypeCache == null) { + recipeTypeCache = GTRecipeTypes.DUMMY_RECIPES; + } + return recipeTypeCache; + } + + @Override + public void onLoad() { + super.onLoad(); + if (!isRemote()) { + machineStorage.addChangedListener(this::onMachineChanged); + } + } + + protected void onMachineChanged() { + recipeTypeCache = null; + if (isFormed) { + if (getRecipeLogic().getLastRecipe() != null) { + getRecipeLogic().markLastRecipeDirty(); + } + getRecipeLogic().updateTickSubscription(); + } + } + + ////////////////////////////////////// + //******* Recipe Logic *******// + ////////////////////////////////////// + + /** + * For available recipe tier, decided by the held machine. + */ + @Override + public int getTier() { + var definition = getMachineDefinition(); + return definition == null ? 0 : definition.getTier(); + } + + @Override + public int getMaxOverclockTier() { + return Math.min(getDefinition().getTier(), GTUtil.getTierByVoltage(getMaxVoltage())); + } + + @Override + public long getMaxVoltage() { + return getMaxHatchVoltage(); + } + + @Nullable + public static GTRecipe recipeModifier(MetaMachine machine, @Nonnull GTRecipe recipe) { + if (machine instanceof ProcessingArrayMachine processingArray && processingArray.machineStorage.storage.getStackInSlot(0).getCount() > 0) { + var limit = processingArray.machineStorage.storage.getStackInSlot(0).getCount(); + // apply parallel first + recipe = GTRecipeModifiers.accurateParallel(machine, recipe, Math.min(limit, getMachineLimit(machine.getDefinition().getTier())), false).getA(); + // apply overclock later + recipe = GTRecipeModifiers.ELECTRIC_OVERCLOCK.apply(OverclockingLogic.NON_PERFECT_OVERCLOCK).apply(machine, recipe); + return recipe; + } + + return null; + } + + ////////////////////////////////////// + //******** Gui ********// + ////////////////////////////////////// + + @Override + public void addDisplayText(List textList) { + super.addDisplayText(textList); + if (isActive()) { + textList.add(Component.translatable("gtceu.machine.machine_hatch.locked").withStyle(Style.EMPTY.withColor(ChatFormatting.RED))); + } + } + + @Override + public Widget createUIWidget() { + var widget = super.createUIWidget(); + if (widget instanceof WidgetGroup group) { + var size = group.getSize(); + group.addWidget(new SlotWidget(machineStorage.storage, 0, size.width - 30, size.height - 30, true, true) + .setBackground(GuiTextures.SLOT)); + } + return widget; + } + + ////////////////////////////////////// + //******** Structure ********// + ////////////////////////////////////// + public static Block getCasingState(int tier) { + if (tier <= GTValues.IV) { + return GTBlocks.CASING_TUNGSTENSTEEL_ROBUST.get(); + } else { + return GTBlocks.CASING_HSSE_STURDY.get(); + } + } + + public static int getMachineLimit(Integer tier) { + return tier <= GTValues.IV ? 16 : 64; + } + +} diff --git a/common/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java b/common/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java index 63682a27eb..bdfdbb1b7e 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java +++ b/common/src/main/java/com/gregtechceu/gtceu/config/ConfigHolder.java @@ -195,6 +195,9 @@ public static class MachineConfigs { @Configurable @Configurable.Comment({"What Kind of material should the bedrock ore miner output?", "Default: \"raw\""}) public String bedrockOreDropTagPrefix = "raw"; + @Configurable + @Configurable.Comment({"Wether to add a \"Processing Array\"", "Default: true"}) + public boolean doProcessingArray = true; } public static class ClientConfigs { diff --git a/common/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java b/common/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java index 14006971ea..6f40bd63d5 100644 --- a/common/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java +++ b/common/src/main/java/com/gregtechceu/gtceu/data/recipe/misc/MetaTileEntityLoader.java @@ -141,7 +141,7 @@ public static void init(Consumer provider) { VanillaRecipeHelper.addShapedRecipe(provider, true, "maintenance_hatch_automatic", GTMachines.AUTO_MAINTENANCE_HATCH.asStack(), "CMC", "RHR", "CMC", 'C', CIRCUIT.getIngredient(GTValues.HV), 'M', GTMachines.MAINTENANCE_HATCH.asStack(), 'R', ROBOT_ARM.getIngredient(GTValues.HV), 'H', GTMachines.HULL[GTValues.HV].asStack()); VanillaRecipeHelper.addShapedRecipe(provider, true, "maintenance_hatch_cleaning", GTMachines.CLEANING_MAINTENANCE_HATCH.asStack(), "CMC", "RHR", "WCW", 'C', CIRCUIT.getIngredient(GTValues.UV), 'M', GTMachines.AUTO_MAINTENANCE_HATCH.asStack(), 'R', ROBOT_ARM.getIngredient(GTValues.UV), 'H', GTMachines.HULL[GTValues.UV].asStack(), 'W', new UnificationEntry(TagPrefix.cableGtSingle, GTMaterials.YttriumBariumCuprate)); - // TODO Processing array + // TODO Access Interface //VanillaRecipeHelper.addShapedRecipe(provider, true, "machine_access_interface", GTMachines.MACHINE_HATCH.getStackForm(), "CHS", 'C', CustomTags.IV), 'H', GTMachines.HULL[GTValues.IV].getStackForm(), 'S', MetaItems.SENSOR_IV.getStackForm()); VanillaRecipeHelper.addShapedRecipe(provider, true, "passthrough_hatch_item", GTMachines.ITEM_PASSTHROUGH_HATCH[GTValues.HV].asStack(), " C ", "GHG", " S ", 'C', GTItems.CONVEYOR_MODULE_HV.asStack(), 'G', new UnificationEntry(TagPrefix.gearSmall, GTMaterials.Steel), 'H', GTMachines.HULL[GTValues.HV].asStack(), 'S', CustomTags.TAG_WOODEN_CHESTS); @@ -211,9 +211,10 @@ public static void init(Consumer provider) { VanillaRecipeHelper.addShapedRecipe(provider, true, "large_chemical_reactor", GTMachines.LARGE_CHEMICAL_REACTOR.asStack(), "CRC", "PMP", "CHC", 'C', CustomTags.HV_CIRCUITS, 'R', ChemicalHelper.get(TagPrefix.rotor, GTMaterials.StainlessSteel), 'P', ChemicalHelper.get(TagPrefix.pipeLargeFluid, GTMaterials.Polytetrafluoroethylene), 'M', GTItems.ELECTRIC_MOTOR_HV.asStack(), 'H', GTMachines.HULL[GTValues.HV].asStack()); - // TODO Processing array - //VanillaRecipeHelper.addShapedRecipe(provider, true, "processing_array", GTMachines.PROCESSING_ARRAY.getStackForm(), "COC", "RHR", "CPC", 'C', CustomTags.IV), 'O', MetaItems.TOOL_DATA_ORB.getStackForm(), 'R', MetaItems.ROBOT_ARM_EV.getStackForm(), 'P', OreDictUnifier.get(TagPrefix.pipeLargeFluid, GTMaterials.StainlessSteel), 'H', GTMachines.HULL[GTValues.EV].getStackForm()); - //VanillaRecipeHelper.addShapedRecipe(provider, true, "advanced_processing_array", GTMachines.ADVANCED_PROCESSING_ARRAY.getStackForm(), "RCR", "SPE", "HNH", 'R', MetaItems.ROBOT_ARM_LuV, 'C', CustomTags.ZPM), 'S', MetaItems.SENSOR_LuV, 'P', GTMachines.PROCESSING_ARRAY.getStackForm(), 'E', MetaItems.EMITTER_LuV, 'H', new UnificationEntry(TagPrefix.plate, GTMaterials.HSSE), 'N', new UnificationEntry(TagPrefix.pipeLargeFluid, GTMaterials.Naquadah)); + if (ConfigHolder.INSTANCE.machines.doProcessingArray) { + VanillaRecipeHelper.addShapedRecipe(provider, true, "processing_array", GTMachines.PROCESSING_ARRAY[0].asStack(), "COC", "RHR", "CPC", 'C', CustomTags.IV_CIRCUITS, 'O', GTItems.TOOL_DATA_ORB.asStack(), 'R', GTItems.ROBOT_ARM_EV.asStack(), 'P', GTBlocks.FLUID_PIPE_BLOCKS.get(TagPrefix.pipeLargeFluid, GTMaterials.StainlessSteel), 'H', GTMachines.HULL[GTValues.EV].asStack()); + VanillaRecipeHelper.addShapedRecipe(provider, true, "advanced_processing_array", GTMachines.PROCESSING_ARRAY[1].asStack(), "RCR", "SPE", "HNH", 'R', GTItems.ROBOT_ARM_LuV.asStack(), 'C', CustomTags.ZPM_CIRCUITS, 'S', GTItems.SENSOR_LuV, 'P', GTMachines.PROCESSING_ARRAY[0].asStack(), 'E', GTItems.EMITTER_LuV.asStack(), 'H', new UnificationEntry(TagPrefix.plate, GTMaterials.HSSE), 'N', new UnificationEntry(TagPrefix.pipeLargeFluid, GTMaterials.Naquadah)); + } // GENERATORS VanillaRecipeHelper.addShapedRecipe(provider, true, "diesel_generator_lv", GTMachines.COMBUSTION[0].asStack(), "PCP", "EME", "GWG", 'M', GTMachines.HULL[GTValues.LV].asStack(), 'P', GTItems.ELECTRIC_PISTON_LV, 'E', GTItems.ELECTRIC_MOTOR_LV, 'C', CustomTags.LV_CIRCUITS, 'W', new UnificationEntry(TagPrefix.cableGtSingle, GTMaterials.Tin), 'G', new UnificationEntry(TagPrefix.gear, GTMaterials.Steel)); diff --git a/fabric/src/generated/resources/assets/gtceu/lang/en_ud.json b/fabric/src/generated/resources/assets/gtceu/lang/en_ud.json index fe5206a6b7..9d1a6c1506 100644 --- a/fabric/src/generated/resources/assets/gtceu/lang/en_ud.json +++ b/fabric/src/generated/resources/assets/gtceu/lang/en_ud.json @@ -380,6 +380,7 @@ "block.gtceu.iv_output_hatch": "ɥɔʇɐH ʇndʇnO ΛIƖ§", "block.gtceu.iv_packer": "ɹ§ ɹǝʞɔɐԀ ǝʇıןƎƖ§", "block.gtceu.iv_polarizer": "ɹ§ ɹǝzıɹɐןoԀ ǝʇıןƎƖ§", + "block.gtceu.iv_processing_array": "ʎɐɹɹⱯ buıssǝɔoɹԀ ʌI", "block.gtceu.iv_quantum_chest": "Λ ʇsǝɥƆ ɯnʇuɐnὉ", "block.gtceu.iv_quantum_tank": "Λ ʞuɐ⟘ ɯnʇuɐnὉ", "block.gtceu.iv_rock_crusher": "ɹ§ ɹǝɥsnɹƆ ʞɔoᴚ ǝʇıןƎƖ§", @@ -465,6 +466,7 @@ "block.gtceu.luv_output_hatch": "ɥɔʇɐH ʇndʇnO ΛnꞀp§", "block.gtceu.luv_packer": "ɹ§II ɹǝʞɔɐԀ ǝʇıןƎp§", "block.gtceu.luv_polarizer": "ɹ§II ɹǝzıɹɐןoԀ ǝʇıןƎp§", + "block.gtceu.luv_processing_array": "ʎɐɹɹⱯ buıssǝɔoɹԀ ʌnꞀ", "block.gtceu.luv_quantum_chest": "IΛ ʇsǝɥƆ ɯnʇuɐnὉ", "block.gtceu.luv_quantum_tank": "IΛ ʞuɐ⟘ ɯnʇuɐnὉ", "block.gtceu.luv_rock_crusher": "ɹ§II ɹǝɥsnɹƆ ʞɔoᴚ ǝʇıןƎp§", diff --git a/fabric/src/generated/resources/assets/gtceu/lang/en_us.json b/fabric/src/generated/resources/assets/gtceu/lang/en_us.json index f24148e14d..2cc6821e62 100644 --- a/fabric/src/generated/resources/assets/gtceu/lang/en_us.json +++ b/fabric/src/generated/resources/assets/gtceu/lang/en_us.json @@ -380,6 +380,7 @@ "block.gtceu.iv_output_hatch": "§1IV Output Hatch", "block.gtceu.iv_packer": "§1Elite Packer §r", "block.gtceu.iv_polarizer": "§1Elite Polarizer §r", + "block.gtceu.iv_processing_array": "Iv Processing Array", "block.gtceu.iv_quantum_chest": "Quantum Chest V", "block.gtceu.iv_quantum_tank": "Quantum Tank V", "block.gtceu.iv_rock_crusher": "§1Elite Rock Crusher §r", @@ -465,6 +466,7 @@ "block.gtceu.luv_output_hatch": "§dLuV Output Hatch", "block.gtceu.luv_packer": "§dElite Packer II§r", "block.gtceu.luv_polarizer": "§dElite Polarizer II§r", + "block.gtceu.luv_processing_array": "Luv Processing Array", "block.gtceu.luv_quantum_chest": "Quantum Chest VI", "block.gtceu.luv_quantum_tank": "Quantum Tank VI", "block.gtceu.luv_rock_crusher": "§dElite Rock Crusher II§r", diff --git a/forge/src/generated/resources/assets/gtceu/lang/en_ud.json b/forge/src/generated/resources/assets/gtceu/lang/en_ud.json index 297ea96beb..9d1a6c1506 100644 --- a/forge/src/generated/resources/assets/gtceu/lang/en_ud.json +++ b/forge/src/generated/resources/assets/gtceu/lang/en_ud.json @@ -146,7 +146,6 @@ "block.gtceu.ev_battery_buffer_16x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x9Ɩ ǝbɐʇןoΛ ǝɯǝɹʇxƎ", "block.gtceu.ev_battery_buffer_4x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ xㄣ ǝbɐʇןoΛ ǝɯǝɹʇxƎ", "block.gtceu.ev_battery_buffer_8x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x8 ǝbɐʇןoΛ ǝɯǝɹʇxƎ", - "block.gtceu.ev_bedrock_ore_miner": "ɹǝuıW ǝɹO ʞɔoɹpǝᗺ pǝɔuɐʌpⱯϛ§", "block.gtceu.ev_bender": "ɹ§III ɹǝpuǝᗺ pǝɔuɐʌpⱯϛ§", "block.gtceu.ev_block_breaker": "ɹ§III ɹǝʞɐǝɹᗺ ʞɔoןᗺ pǝɔuɐʌpⱯϛ§", "block.gtceu.ev_brewery": "ɹ§III ʎɹǝʍǝɹᗺ pǝɔuɐʌpⱯϛ§", @@ -250,7 +249,6 @@ "block.gtceu.hv_battery_buffer_16x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x9Ɩ ǝbɐʇןoΛ ɥbıH", "block.gtceu.hv_battery_buffer_4x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ xㄣ ǝbɐʇןoΛ ɥbıH", "block.gtceu.hv_battery_buffer_8x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x8 ǝbɐʇןoΛ ɥbıH", - "block.gtceu.hv_bedrock_ore_miner": "ɹǝuıW ǝɹO ʞɔoɹpǝᗺ pǝɔuɐʌpⱯ9§", "block.gtceu.hv_bender": "ɹ§II ɹǝpuǝᗺ pǝɔuɐʌpⱯ9§", "block.gtceu.hv_block_breaker": "ɹ§II ɹǝʞɐǝɹᗺ ʞɔoןᗺ pǝɔuɐʌpⱯ9§", "block.gtceu.hv_brewery": "ɹ§II ʎɹǝʍǝɹᗺ pǝɔuɐʌpⱯ9§", @@ -382,6 +380,7 @@ "block.gtceu.iv_output_hatch": "ɥɔʇɐH ʇndʇnO ΛIƖ§", "block.gtceu.iv_packer": "ɹ§ ɹǝʞɔɐԀ ǝʇıןƎƖ§", "block.gtceu.iv_polarizer": "ɹ§ ɹǝzıɹɐןoԀ ǝʇıןƎƖ§", + "block.gtceu.iv_processing_array": "ʎɐɹɹⱯ buıssǝɔoɹԀ ʌI", "block.gtceu.iv_quantum_chest": "Λ ʇsǝɥƆ ɯnʇuɐnὉ", "block.gtceu.iv_quantum_tank": "Λ ʞuɐ⟘ ɯnʇuɐnὉ", "block.gtceu.iv_rock_crusher": "ɹ§ ɹǝɥsnɹƆ ʞɔoᴚ ǝʇıןƎƖ§", @@ -467,6 +466,7 @@ "block.gtceu.luv_output_hatch": "ɥɔʇɐH ʇndʇnO ΛnꞀp§", "block.gtceu.luv_packer": "ɹ§II ɹǝʞɔɐԀ ǝʇıןƎp§", "block.gtceu.luv_polarizer": "ɹ§II ɹǝzıɹɐןoԀ ǝʇıןƎp§", + "block.gtceu.luv_processing_array": "ʎɐɹɹⱯ buıssǝɔoɹԀ ʌnꞀ", "block.gtceu.luv_quantum_chest": "IΛ ʇsǝɥƆ ɯnʇuɐnὉ", "block.gtceu.luv_quantum_tank": "IΛ ʞuɐ⟘ ɯnʇuɐnὉ", "block.gtceu.luv_rock_crusher": "ɹ§II ɹǝɥsnɹƆ ʞɔoᴚ ǝʇıןƎp§", @@ -569,7 +569,6 @@ "block.gtceu.mv_battery_buffer_16x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x9Ɩ ǝbɐʇןoΛ ɯnıpǝW", "block.gtceu.mv_battery_buffer_4x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ xㄣ ǝbɐʇןoΛ ɯnıpǝW", "block.gtceu.mv_battery_buffer_8x": "ɹǝɟɟnᗺ ʎɹǝʇʇɐᗺ x8 ǝbɐʇןoΛ ɯnıpǝW", - "block.gtceu.mv_bedrock_ore_miner": "ɹǝuıW ǝɹO ʞɔoɹpǝᗺ pǝɔuɐʌpⱯq§", "block.gtceu.mv_bender": "ɹ§ ɹǝpuǝᗺ pǝɔuɐʌpⱯq§", "block.gtceu.mv_block_breaker": "ɹ§ ɹǝʞɐǝɹᗺ ʞɔoןᗺ pǝɔuɐʌpⱯq§", "block.gtceu.mv_brewery": "ɹ§ ʎɹǝʍǝɹᗺ pǝɔuɐʌpⱯq§", @@ -3218,7 +3217,6 @@ "material.copernicium": "ɯnıɔıuɹǝdoƆ", "material.copper": "ɹǝddoƆ", "material.creosote": "ǝʇosoǝɹƆ", - "material.crystal_matrix": "xıɹʇɐW ןɐʇsʎɹƆ", "material.cumene": "ǝuǝɯnƆ", "material.cupric_oxide": "ǝpıxO ɔıɹdnƆ", "material.cupronickel": "ןǝʞɔıuoɹdnƆ", @@ -3354,7 +3352,6 @@ "material.indium_phosphide": "ǝpıɥdsoɥԀ ɯnıpuI", "material.indium_tin_barium_titanium_cuprate": "ǝʇɐɹdnƆ ɯnıuɐʇı⟘ ɯnıɹɐᗺ uı⟘ ɯnıpuI", "material.inert_metal_mixture": "ǝɹnʇxıW ןɐʇǝW ʇɹǝuI", - "material.infinity": "ʎʇıuıɟuI", "material.invar": "ɹɐʌuI", "material.iodine": "ǝuıpoI", "material.iridium": "ɯnıpıɹI", diff --git a/forge/src/generated/resources/assets/gtceu/lang/en_us.json b/forge/src/generated/resources/assets/gtceu/lang/en_us.json index 5e3424bc81..2cc6821e62 100644 --- a/forge/src/generated/resources/assets/gtceu/lang/en_us.json +++ b/forge/src/generated/resources/assets/gtceu/lang/en_us.json @@ -146,7 +146,6 @@ "block.gtceu.ev_battery_buffer_16x": "Extreme Voltage 16x Battery Buffer", "block.gtceu.ev_battery_buffer_4x": "Extreme Voltage 4x Battery Buffer", "block.gtceu.ev_battery_buffer_8x": "Extreme Voltage 8x Battery Buffer", - "block.gtceu.ev_bedrock_ore_miner": "§5Advanced Bedrock Ore Miner", "block.gtceu.ev_bender": "§5Advanced Bender III§r", "block.gtceu.ev_block_breaker": "§5Advanced Block Breaker III§r", "block.gtceu.ev_brewery": "§5Advanced Brewery III§r", @@ -250,7 +249,6 @@ "block.gtceu.hv_battery_buffer_16x": "High Voltage 16x Battery Buffer", "block.gtceu.hv_battery_buffer_4x": "High Voltage 4x Battery Buffer", "block.gtceu.hv_battery_buffer_8x": "High Voltage 8x Battery Buffer", - "block.gtceu.hv_bedrock_ore_miner": "§6Advanced Bedrock Ore Miner", "block.gtceu.hv_bender": "§6Advanced Bender II§r", "block.gtceu.hv_block_breaker": "§6Advanced Block Breaker II§r", "block.gtceu.hv_brewery": "§6Advanced Brewery II§r", @@ -382,6 +380,7 @@ "block.gtceu.iv_output_hatch": "§1IV Output Hatch", "block.gtceu.iv_packer": "§1Elite Packer §r", "block.gtceu.iv_polarizer": "§1Elite Polarizer §r", + "block.gtceu.iv_processing_array": "Iv Processing Array", "block.gtceu.iv_quantum_chest": "Quantum Chest V", "block.gtceu.iv_quantum_tank": "Quantum Tank V", "block.gtceu.iv_rock_crusher": "§1Elite Rock Crusher §r", @@ -467,6 +466,7 @@ "block.gtceu.luv_output_hatch": "§dLuV Output Hatch", "block.gtceu.luv_packer": "§dElite Packer II§r", "block.gtceu.luv_polarizer": "§dElite Polarizer II§r", + "block.gtceu.luv_processing_array": "Luv Processing Array", "block.gtceu.luv_quantum_chest": "Quantum Chest VI", "block.gtceu.luv_quantum_tank": "Quantum Tank VI", "block.gtceu.luv_rock_crusher": "§dElite Rock Crusher II§r", @@ -569,7 +569,6 @@ "block.gtceu.mv_battery_buffer_16x": "Medium Voltage 16x Battery Buffer", "block.gtceu.mv_battery_buffer_4x": "Medium Voltage 4x Battery Buffer", "block.gtceu.mv_battery_buffer_8x": "Medium Voltage 8x Battery Buffer", - "block.gtceu.mv_bedrock_ore_miner": "§bAdvanced Bedrock Ore Miner", "block.gtceu.mv_bender": "§bAdvanced Bender §r", "block.gtceu.mv_block_breaker": "§bAdvanced Block Breaker §r", "block.gtceu.mv_brewery": "§bAdvanced Brewery §r",