diff options
Diffstat (limited to 'src')
11 files changed, 415 insertions, 11 deletions
diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java index 90252d1426..ebd20d48c0 100644 --- a/src/main/java/gregtech/api/enums/ItemList.java +++ b/src/main/java/gregtech/api/enums/ItemList.java @@ -2013,7 +2013,8 @@ public enum ItemList implements IItemContainer { BasicPhotolithographicFrameworkCasing, ReinforcedPhotolithographicFrameworkCasing, RadiationProofPhotolithographicFrameworkCasing, - InfinityCooledCasing; + InfinityCooledCasing, + Machine_Multi_TranscendentPlasmaMixer; public static final ItemList[] DYE_ONLY_ITEMS = { Color_00, Color_01, Color_02, Color_03, Color_04, Color_05, Color_06, Color_07, Color_08, Color_09, Color_10, Color_11, Color_12, Color_13, Color_14, Color_15 }, diff --git a/src/main/java/gregtech/api/interfaces/IGlobalWirelessEnergy.java b/src/main/java/gregtech/api/interfaces/IGlobalWirelessEnergy.java index 29b32b5d3b..8bb0ed87aa 100644 --- a/src/main/java/gregtech/api/interfaces/IGlobalWirelessEnergy.java +++ b/src/main/java/gregtech/api/interfaces/IGlobalWirelessEnergy.java @@ -7,12 +7,12 @@ import java.util.UUID; import net.minecraft.entity.player.EntityPlayer; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.common.misc.GlobalEnergyWorldSavedData; // If you are adding very late-game content feel free to tap into this interface. // The eventual goal is to bypass laser/dynamo stuff and have energy deposited directly from ultra-endgame // multi-blocks directly into the users network. -@SuppressWarnings("unused") public interface IGlobalWirelessEnergy { // User 0 will join user 1 by calling this function. They will share the same energy network. @@ -57,7 +57,7 @@ public interface IGlobalWirelessEnergy { // If the value goes below 0 it will return false and not perform the operation. // BigIntegers have much slower operations than longs/ints. You should call these methods // as infrequently as possible and bulk store values to add to the global map. - default boolean addEUToGlobalEnergyMap(String user_uuid, BigInteger EU) { + default boolean addEUToGlobalEnergyMap(String userUUID, BigInteger EU) { // Mark the data as dirty and in need of saving. try { @@ -68,15 +68,15 @@ public interface IGlobalWirelessEnergy { } // Get the team UUID. Users are by default in a team with a UUID equal to their player UUID. - String team_uuid = GlobalEnergyTeam.getOrDefault(user_uuid, user_uuid); + String teamUUID = GlobalEnergyTeam.getOrDefault(userUUID, userUUID); // Get the teams total energy stored. If they are not in the map, return 0 EU. - BigInteger total_eu = GlobalEnergy.getOrDefault(team_uuid, BigInteger.ZERO); - total_eu = total_eu.add(EU); + BigInteger totalEU = GlobalEnergy.getOrDefault(teamUUID, BigInteger.ZERO); + totalEU = totalEU.add(EU); // If there is sufficient EU then complete the operation and return true. - if (total_eu.signum() >= 0) { - GlobalEnergy.put(team_uuid, total_eu); + if (totalEU.signum() >= 0) { + GlobalEnergy.put(teamUUID, totalEU); return true; } @@ -137,4 +137,14 @@ public interface IGlobalWirelessEnergy { GlobalEnergyName.clear(); GlobalEnergyTeam.clear(); } + + default String processInitialSettings(final IGregTechTileEntity machine) { + + // UUID and username of the owner. + final String UUID = machine.getOwnerUuid().toString(); + final String name = machine.getOwnerName(); + + strongCheckOrAddUser(UUID, name); + return UUID; + } } diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index 7408701f16..d8a512c954 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -599,7 +599,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec tTime = System.nanoTime() - tTime; if (mTimeStatistics.length > 0) mTimeStatistics[mTimeStatisticsIndex = (mTimeStatisticsIndex + 1) % mTimeStatistics.length] = (int) tTime; - if (tTime > 0 && tTime > (GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING * 1000000L) + if (tTime > 0 && tTime > (GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING * 1_000_000L) && mTickTimer > 1000 && getMetaTileEntity().doTickProfilingMessageDuringThisTick() && mLagWarningCount++ < 10) diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java index e6ea51c59d..80b6723d81 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java @@ -465,7 +465,7 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity } protected long getActualEnergyUsage() { - return ((long) -mEUt * 10000) / Math.max(1000, mEfficiency); + return ((long) -mEUt * 10_000) / Math.max(1000, mEfficiency); } /** @@ -693,7 +693,7 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity /** * Calcualtes the overclockedness using long integers - * + * * @param aEUt - recipe EUt * @param aDuration - recipe Duration * @param mAmperage - should be 1 ? diff --git a/src/main/java/gregtech/api/util/GT_Recipe.java b/src/main/java/gregtech/api/util/GT_Recipe.java index 32d841dfa8..59fd3da31d 100644 --- a/src/main/java/gregtech/api/util/GT_Recipe.java +++ b/src/main/java/gregtech/api/util/GT_Recipe.java @@ -1,6 +1,7 @@ package gregtech.api.util; import static gregtech.api.enums.GT_Values.*; +import static gregtech.api.util.GT_Utility.formatNumbers; import static net.minecraft.util.EnumChatFormatting.GRAY; import java.awt.*; @@ -1728,6 +1729,70 @@ public class GT_Recipe implements Comparable<GT_Recipe> { true).setProgressBar(GT_UITextures.PROGRESSBAR_ARROW, ProgressBar.Direction.RIGHT) .setUsualFluidInputCount(9).setUsualFluidOutputCount(9) .setNEISpecialInfoFormatter(HeatingCoilSpecialValueFormatter.INSTANCE); + + public static final GT_Recipe_Map sTranscendentPlasmaMixerRecipes = new TranscendentPlasmaMixerRecipeMap( + new HashSet<>(20), + "gt.recipe.transcendentplasmamixerrecipes", + "Transcendent Plasma Mixer", + null, + RES_PATH_GUI + "basicmachines/PlasmaForge", + 1, + 0, + 0, + 0, + 1, + "", + 0, + "", + false, + true).setProgressBar(GT_UITextures.PROGRESSBAR_ARROW, ProgressBar.Direction.RIGHT) + .setUsualFluidInputCount(18).setUsualFluidOutputCount(1); + + public static class TranscendentPlasmaMixerRecipeMap extends GT_Recipe_Map_LargeNEI { + + public TranscendentPlasmaMixerRecipeMap(Collection<GT_Recipe> aRecipeList, String aUnlocalizedName, + String aLocalName, String aNEIName, String aNEIGUIPath, int aUsualInputCount, int aUsualOutputCount, + int aMinimalInputItems, int aMinimalInputFluids, int aAmperage, String aNEISpecialValuePre, + int aNEISpecialValueMultiplier, String aNEISpecialValuePost, boolean aShowVoltageAmperageInNEI, + boolean aNEIAllowed) { + super( + aRecipeList, + aUnlocalizedName, + aLocalName, + aNEIName, + aNEIGUIPath, + aUsualInputCount, + aUsualOutputCount, + aMinimalInputItems, + aMinimalInputFluids, + aAmperage, + aNEISpecialValuePre, + aNEISpecialValueMultiplier, + aNEISpecialValuePost, + aShowVoltageAmperageInNEI, + aNEIAllowed); + useModularUI(true); + setNEISpecialInfoFormatter((recipeInfo, applyPrefixAndSuffix) -> { + final GT_Recipe recipe = recipeInfo.recipe; + List<String> result = new ArrayList<>(); + + result.add("Total: " + formatNumbers(1000L * (long) recipe.mEUt) + " EU"); + + result.add("Average: " + formatNumbers((1000L * (long) recipe.mEUt) / recipe.mDuration) + "EU/t"); + + result.add("Time: " + formatNumbers((double) recipe.mDuration / 20L) + "s"); + + return result; + }); + } + + @Override + public void drawNEIDescription(NEIRecipeInfo recipeInfo) { + drawNEISpecialInfo(recipeInfo); + drawNEIRecipeOwnerInfo(recipeInfo); + } + } + public static final GT_Recipe_Map sPrimitiveBlastRecipes = new GT_Recipe_Map( new HashSet<>(200), "gt.recipe.primitiveblastfurnace", diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PlasmaForge.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PlasmaForge.java index c231c6e935..6c22badf9e 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PlasmaForge.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_PlasmaForge.java @@ -881,6 +881,7 @@ public class GT_MetaTileEntity_PlasmaForge extends GT_MetaTileEntity_AbstractMul discount = 1; } + @Override public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) { // Reset running time and discount. diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_TranscendentPlasmaMixer.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_TranscendentPlasmaMixer.java new file mode 100644 index 0000000000..184a99779a --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_TranscendentPlasmaMixer.java @@ -0,0 +1,235 @@ +package gregtech.common.tileentities.machines.multi; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static gregtech.api.enums.GT_HatchElement.*; +import static gregtech.api.enums.GT_Values.AuthorColen; +import static gregtech.api.enums.Textures.BlockIcons.*; +import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_PlasmaForge.*; +import static java.lang.Math.max; +import static net.minecraft.util.EnumChatFormatting.GOLD; +import static net.minecraft.util.EnumChatFormatting.GRAY; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +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 gregtech.api.GregTech_API; +import gregtech.api.interfaces.IGlobalWirelessEnergy; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import gregtech.common.items.GT_IntegratedCircuit_Item; + +public class GT_MetaTileEntity_TranscendentPlasmaMixer + extends GT_MetaTileEntity_EnhancedMultiBlockBase<GT_MetaTileEntity_TranscendentPlasmaMixer> + implements IGlobalWirelessEnergy, ISurvivalConstructable { + + private static final String[][] structure = new String[][] { + { " CAC ", " ABA ", " ABA ", " A~A ", " ABA ", " ABA ", " CAC " }, + { "CBBBC", "A A", "A A", "A A", "A A", "A A", "CBBBC" }, + { "ABBBA", "B B", "B B", "B B", "B B", "B B", "ABBBA" }, + { "CBBBC", "A A", "A A", "A A", "A A", "A A", "CBBBC" }, + { " CAC ", " ABA ", " ABA ", " ABA ", " ABA ", " ABA ", " CAC " } }; + + private static final String STRUCTURE_PIECE_MAIN = "MAIN"; + private static final IStructureDefinition<GT_MetaTileEntity_TranscendentPlasmaMixer> STRUCTURE_DEFINITION = StructureDefinition + .<GT_MetaTileEntity_TranscendentPlasmaMixer>builder().addShape(STRUCTURE_PIECE_MAIN, structure) + .addElement( + 'B', + buildHatchAdder(GT_MetaTileEntity_TranscendentPlasmaMixer.class) + .atLeast(InputHatch, OutputHatch, InputBus, Maintenance).casingIndex(DIM_INJECTION_CASING) + .dot(1).buildAndChain(GregTech_API.sBlockCasings1, DIM_INJECTION_CASING)) + .addElement('A', ofBlock(GregTech_API.sBlockCasings1, DIM_TRANS_CASING)) + .addElement('C', ofBlock(GregTech_API.sBlockCasings1, DIM_BRIDGE_CASING)).build(); + + private String ownerUUID; + + public GT_MetaTileEntity_TranscendentPlasmaMixer(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_TranscendentPlasmaMixer(String aName) { + super(aName); + } + + @Override + public IStructureDefinition<GT_MetaTileEntity_TranscendentPlasmaMixer> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Transcendent Mixer").addInfo("Controller block for the Assembling Line") + .addInfo("Assisting in all your DTPF needs.") + .addInfo("This multiblock will run in parallel according to the circuit provided to the") + .addInfo("controller slot. E.g. 3x Circuit #16 = 48x parallel. All inputs will scale,") + .addInfo("except time. All EU is deducted from wireless EU networks only.").addInfo(AuthorColen) + .addSeparator().beginStructureBlock(5, 7, 5, false) + .addStructureInfo(GOLD + "1+ " + GRAY + "Input Hatch") + .addStructureInfo(GOLD + "1+ " + GRAY + "Output Hatch") + .addStructureInfo(GOLD + "1+ " + GRAY + "Input Bus") + .addStructureInfo(GOLD + "1 " + GRAY + "Maintenance Hatch").toolTipFinisher("Gregtech"); + return tt; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_TranscendentPlasmaMixer(mName); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, + boolean aActive, boolean aRedstone) { + if (aSide == aFacing) { + if (aActive) return new ITexture[] { casingTexturePages[0][DIM_TRANS_CASING], + TextureFactory.builder().addIcon(OVERLAY_DTPF_ON).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FUSION1_GLOW).extFacing().glow().build() }; + return new ITexture[] { casingTexturePages[0][DIM_TRANS_CASING], + TextureFactory.builder().addIcon(OVERLAY_DTPF_OFF).extFacing().build() }; + } + + return new ITexture[] { casingTexturePages[0][DIM_TRANS_CASING] }; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + int multiplier = 1; + + @Override + public boolean checkRecipe(ItemStack aStack) { + if (aStack.getItem() instanceof GT_IntegratedCircuit_Item) { + multiplier = max(1, aStack.getItemDamage()); + } + + return processRecipe(getCompactedInputs(), getCompactedFluids()); + } + + boolean processRecipe(ItemStack[] items, FluidStack[] fluids) { + + GT_Recipe originalRecipe = GT_Recipe.GT_Recipe_Map.sTranscendentPlasmaMixerRecipes + .findRecipe(getBaseMetaTileEntity(), false, Long.MAX_VALUE, fluids, items); + + if (originalRecipe == null) { + return false; + } + + if (!addEUToGlobalEnergyMap(ownerUUID, 1000 * originalRecipe.mEUt * multiplier)) { + return false; + } + + // Fluid handling. + { + // Output items/fluids. + GT_Recipe modifiedRecipe = originalRecipe.copy(); + + // Multiply up the input plasmas. + for (FluidStack fluidStack : modifiedRecipe.mFluidInputs) { + fluidStack.amount *= multiplier; + } + + // Multiply up the output fluid. + modifiedRecipe.mFluidOutputs[0].amount *= multiplier; + + // Takes items/fluids from hatches/busses. + if (!modifiedRecipe.isRecipeInputEqual(true, fluids, items)) return false; + + mOutputFluids = modifiedRecipe.mFluidOutputs; + mOutputItems = modifiedRecipe.mOutputs; + } + + mMaxProgresstime = 100; + mEUt = 0; + + updateSlots(); + + return true; + } + + private static final int HORIZONTAL_OFFSET = 2; + private static final int VERTICAL_OFFSET = 3; + private static final int DEPTH_OFFSET = 0; + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, HORIZONTAL_OFFSET, VERTICAL_OFFSET, DEPTH_OFFSET); + } + + @Override + public String[] getInfoData() { + return new String[] { "test" }; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return new String[] { "gh", "hio" }; + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + return survivialBuildPiece( + STRUCTURE_PIECE_MAIN, + stackSize, + HORIZONTAL_OFFSET, + VERTICAL_OFFSET, + DEPTH_OFFSET, + elementBudget, + env, + false, + true); + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + + // Check the main structure + if (!checkPiece(STRUCTURE_PIECE_MAIN, HORIZONTAL_OFFSET, VERTICAL_OFFSET, DEPTH_OFFSET)) { + return false; + } + + if (mMaintenanceHatches.size() != 1) { + return false; + } + + return true; + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + + super.onPreTick(aBaseMetaTileEntity, aTick); + + if (aBaseMetaTileEntity.isServerSide() && (aTick == 1)) { + // Adds player to the wireless network if they do not already exist on it. + ownerUUID = processInitialSettings(aBaseMetaTileEntity); + } + } +} diff --git a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java index 7ac9d15161..3607df541c 100644 --- a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java +++ b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java @@ -89,6 +89,7 @@ public class GT_MachineRecipeLoader implements Runnable { new ThermalCentrifugeRecipes().run(); new VacuumFreezerRecipes().run(); new WiremillRecipes().run(); + new TranscendentPlasmaMixerRecipes().run(); GT_BauxiteRefineChain.run(); GT_NaniteChain.run(); diff --git a/src/main/java/gregtech/loaders/postload/recipes/TranscendentPlasmaMixerRecipes.java b/src/main/java/gregtech/loaders/postload/recipes/TranscendentPlasmaMixerRecipes.java new file mode 100644 index 0000000000..42e1c2f9b1 --- /dev/null +++ b/src/main/java/gregtech/loaders/postload/recipes/TranscendentPlasmaMixerRecipes.java @@ -0,0 +1,82 @@ +package gregtech.loaders.postload.recipes; + +import static gregtech.api.util.GT_Recipe.GT_Recipe_Map.sTranscendentPlasmaMixerRecipes; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_Utility; + +public class TranscendentPlasmaMixerRecipes implements Runnable { + + private static final int CRUDE_EU_PER_L = 14_514_983; + private static final int PROSAIC_EU_PER_L = 66_768_460; + private static final int RESPLENDENT_EU_PER_L = 269_326_451; + private static final int EXOTIC_EU_PER_L = 1_073_007_393; + + private static void addTranscendentPlasmaMixerRecipe(final FluidStack fluidOutput, final int circuitNumber, + final FluidStack[] fluidInput, final int EUPerL) { + sTranscendentPlasmaMixerRecipes.addRecipe( + false, + new ItemStack[] { GT_Utility.getIntegratedCircuit(circuitNumber) }, + null, + null, + fluidInput, + new FluidStack[] { fluidOutput }, + 100, + EUPerL, // NOT EU/T, I am simply using the field for this purpose. + 0); + } + + @Override + public void run() { + + addTranscendentPlasmaMixerRecipe( + Materials.ExcitedDTCC.getFluid(1000L), + 1, + new FluidStack[] { Materials.Helium.getPlasma(1000), Materials.Iron.getPlasma(1000), + Materials.Calcium.getPlasma(1000), Materials.Niobium.getPlasma(1000) }, + CRUDE_EU_PER_L); + + addTranscendentPlasmaMixerRecipe( + Materials.ExcitedDTPC.getFluid(1000L), + 2, + new FluidStack[] { Materials.Helium.getPlasma(1000), Materials.Iron.getPlasma(1000), + Materials.Calcium.getPlasma(1000), Materials.Niobium.getPlasma(1000), + + Materials.Nitrogen.getPlasma(1000), Materials.Zinc.getPlasma(1000), + Materials.Silver.getPlasma(1000), Materials.Titanium.getPlasma(1000), }, + PROSAIC_EU_PER_L); + + addTranscendentPlasmaMixerRecipe( + Materials.ExcitedDTRC.getFluid(1000L), + 3, + new FluidStack[] { Materials.Helium.getPlasma(1000), Materials.Iron.getPlasma(1000), + Materials.Calcium.getPlasma(1000), Materials.Niobium.getPlasma(1000), + + Materials.Nitrogen.getPlasma(1000), Materials.Zinc.getPlasma(1000), + Materials.Silver.getPlasma(1000), Materials.Titanium.getPlasma(1000), + + Materials.Radon.getPlasma(1000), Materials.Nickel.getPlasma(1000), + Materials.Boron.getPlasma(1000), Materials.Sulfur.getPlasma(1000), }, + RESPLENDENT_EU_PER_L); + + addTranscendentPlasmaMixerRecipe( + Materials.ExcitedDTEC.getFluid(1000L), + 4, + new FluidStack[] { Materials.Helium.getPlasma(1000), Materials.Iron.getPlasma(1000), + Materials.Calcium.getPlasma(1000), Materials.Niobium.getPlasma(1000), + + Materials.Nitrogen.getPlasma(1000), Materials.Zinc.getPlasma(1000), + Materials.Silver.getPlasma(1000), Materials.Titanium.getPlasma(1000), + + Materials.Radon.getPlasma(1000), Materials.Nickel.getPlasma(1000), + Materials.Boron.getPlasma(1000), Materials.Sulfur.getPlasma(1000), + + Materials.Americium.getPlasma(1000), Materials.Bismuth.getPlasma(1000), + Materials.Oxygen.getPlasma(1000), Materials.Tin.getPlasma(1000), }, + EXOTIC_EU_PER_L); + + } +} 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 ae2bc1b5f1..2e2630cfbe 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java @@ -8740,6 +8740,12 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC 1005, "multimachine.largeadvancedgasturbine", "Large Advanced Gas Turbine").getStackForm(1L)); + ItemList.Machine_Multi_TranscendentPlasmaMixer.set( + new GT_MetaTileEntity_TranscendentPlasmaMixer( + 1006, + "multimachine.transcendentplasmamixer", + "Transcedent Plasma Mixer").getStackForm(1)); + ItemList.LargePlasmaTurbine.set( new GT_MetaTileEntity_LargeTurbine_Plasma( 1153, diff --git a/src/main/java/gregtech/nei/IMCForNEI.java b/src/main/java/gregtech/nei/IMCForNEI.java index 8ff9f0f6f5..08f4a6d137 100644 --- a/src/main/java/gregtech/nei/IMCForNEI.java +++ b/src/main/java/gregtech/nei/IMCForNEI.java @@ -12,6 +12,9 @@ public class IMCForNEI { return; } + sendHandler("gt.recipe.transcendentplasmamixerrecipes", "gregtech:gt.blockmachines:1006", 1); + sendCatalyst("gt.recipe.transcendentplasmamixerrecipes", "gregtech:gt.blockmachines:1006"); + sendHandler("gt.recipe.plasmaforge", "gregtech:gt.blockmachines:1004", 1); sendCatalyst("gt.recipe.plasmaforge", "gregtech:gt.blockmachines:1004"); |