From f985e28ae553428945f3ce3841ac036c98266128 Mon Sep 17 00:00:00 2001 From: MadMan310 <66886359+MadMan310@users.noreply.github.com> Date: Tue, 29 Nov 2022 01:50:58 -0800 Subject: Component Assembly Line (#102) * Initial Commit * Added recipe generator for components LV-IV * Added recipe generator for components LuV and beyond This one took a LONG time to make work... * Added structure and recipe processing * Added Recipes for Controller and Casings * Cleanup * Assline gives proper amount same as assembler * tooltip fix * add support for BW glass and warded glass * Added proper NEI handler * spotless * Spotless apply for branch componentAssemblyLine for #102 (#103) * Update build-and-test.yml * fix missing hatch element (#92) * fix missing hatch element * spotlessApply (#93) Co-authored-by: Yang Xizhi <60341015+GlodBlock@users.noreply.github.com> Co-authored-by: GitHub GTNH Actions <> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * fix bunch of yottank issues (#94) * yot tank/hatch fix * dep * Add better naq fuel recipes to combat fusion spam (#91) * Add higher tier naq fuel recipes * Fix Hypogen (hopefully) * Spotless >:( * Slightly change tooltip on the Precise Assembler (#95) 0.03 mm changed to 7nm * fix 0 stack of nuclear rod (#98) * naq fuel change (#96) * naq fuel change * Spotless apply for branch naqfuel for #96 (#97) * Slightly change tooltip on the Precise Assembler (#95) 0.03 mm changed to 7nm * spotlessApply Co-authored-by: MadMan310 <66886359+MadMan310@users.noreply.github.com> Co-authored-by: Yang Xizhi <60341015+GlodBlock@users.noreply.github.com> Co-authored-by: GitHub GTNH Actions <> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: MadMan310 <66886359+MadMan310@users.noreply.github.com> * Naq Fuel 1,2,3 Changes (#99) * Naq Emulsion line changes * Mk1 recipe change * Fuel value changes * Mk2 fuel recipe changes * Radiation proof plate recipe changes * Fix sludge dust centrifuge amounts * Remove Hafnium recipe for now * Spotless * thorium balance change (#76) * Add implementation for tank info getter (#101) * Add void excess option to yotta fluid tank (#100) * Add void excess option to yotta fluid tank * derp * Added own localization of void excess toggle messages * Update build.gradle * update bc * spotlessApply Co-authored-by: Martin Robertz Co-authored-by: Yang Xizhi <60341015+GlodBlock@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: GDCloud <93287602+GDCloudstrike@users.noreply.github.com> Co-authored-by: MadMan310 <66886359+MadMan310@users.noreply.github.com> Co-authored-by: xSkewer <43712386+xSkewer@users.noreply.github.com> Co-authored-by: Maxim Co-authored-by: GitHub GTNH Actions <> * cleanup handler * Overhauled recipe generator, added circuit wraps, buffed output efficiency * Structure re-tiering * Gravi -> Nuclear for UHV components (due to overflowing) * spotless * added new casings * removed some debug info and added dep * Fixed magnetic samarium fluid and other autogenerations * fixed recipe tiering * Removed Nuclear Star, to be replaced by the GT5U version * spotless * fixed recipe handling Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Martin Robertz Co-authored-by: Yang Xizhi <60341015+GlodBlock@users.noreply.github.com> Co-authored-by: GDCloud <93287602+GDCloudstrike@users.noreply.github.com> Co-authored-by: xSkewer <43712386+xSkewer@users.noreply.github.com> Co-authored-by: Maxim --- build.gradle | 6 +- dependencies.gradle | 36 +- .../blocks/tileEntity/ComponentAssemblyLine.java | 744 +++++++++++++++++++++ .../crossmod/nei/ComponentAssemblyLineHandler.java | 38 ++ .../java/goodgenerator/crossmod/nei/IMCForNEI.java | 9 +- .../goodgenerator/crossmod/nei/NEI_Config.java | 1 + .../loader/ComponentAssemblyLineMiscRecipes.java | 459 +++++++++++++ .../loader/ComponentAssemblyLineRecipeLoader.java | 360 ++++++++++ src/main/java/goodgenerator/loader/Loaders.java | 44 +- src/main/java/goodgenerator/util/ItemRefer.java | 16 + src/main/java/goodgenerator/util/Log.java | 8 + .../java/goodgenerator/util/MyRecipeAdder.java | 111 +++ src/main/java/goodgenerator/util/StackUtils.java | 81 +++ .../resources/assets/goodgenerator/lang/en_US.lang | 32 + .../textures/blocks/compAsslineCasing/0.png | Bin 0 -> 528 bytes .../textures/blocks/compAsslineCasing/1.png | Bin 0 -> 522 bytes .../textures/blocks/compAsslineCasing/10.png | Bin 0 -> 520 bytes .../textures/blocks/compAsslineCasing/11.png | Bin 0 -> 526 bytes .../textures/blocks/compAsslineCasing/12.png | Bin 0 -> 516 bytes .../textures/blocks/compAsslineCasing/13.png | Bin 0 -> 514 bytes .../textures/blocks/compAsslineCasing/2.png | Bin 0 -> 529 bytes .../textures/blocks/compAsslineCasing/3.png | Bin 0 -> 519 bytes .../textures/blocks/compAsslineCasing/4.png | Bin 0 -> 524 bytes .../textures/blocks/compAsslineCasing/5.png | Bin 0 -> 527 bytes .../textures/blocks/compAsslineCasing/6.png | Bin 0 -> 530 bytes .../textures/blocks/compAsslineCasing/7.png | Bin 0 -> 527 bytes .../textures/blocks/compAsslineCasing/8.png | Bin 0 -> 525 bytes .../textures/blocks/compAsslineCasing/9.png | Bin 0 -> 525 bytes .../textures/gui/ComponentAssline.png | Bin 0 -> 2310 bytes .../goodgenerator/textures/items/wraps/0.png | Bin 0 -> 748 bytes .../goodgenerator/textures/items/wraps/1.png | Bin 0 -> 738 bytes .../goodgenerator/textures/items/wraps/10.png | Bin 0 -> 757 bytes .../goodgenerator/textures/items/wraps/11.png | Bin 0 -> 746 bytes .../goodgenerator/textures/items/wraps/12.png | Bin 0 -> 755 bytes .../goodgenerator/textures/items/wraps/13.png | Bin 0 -> 756 bytes .../goodgenerator/textures/items/wraps/14.png | Bin 0 -> 747 bytes .../goodgenerator/textures/items/wraps/2.png | Bin 0 -> 747 bytes .../goodgenerator/textures/items/wraps/3.png | Bin 0 -> 750 bytes .../goodgenerator/textures/items/wraps/4.png | Bin 0 -> 744 bytes .../goodgenerator/textures/items/wraps/5.png | Bin 0 -> 739 bytes .../goodgenerator/textures/items/wraps/6.png | Bin 0 -> 754 bytes .../goodgenerator/textures/items/wraps/7.png | Bin 0 -> 790 bytes .../goodgenerator/textures/items/wraps/8.png | Bin 0 -> 740 bytes .../goodgenerator/textures/items/wraps/9.png | Bin 0 -> 760 bytes 44 files changed, 1923 insertions(+), 22 deletions(-) create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java create mode 100644 src/main/java/goodgenerator/crossmod/nei/ComponentAssemblyLineHandler.java create mode 100644 src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java create mode 100644 src/main/java/goodgenerator/loader/ComponentAssemblyLineRecipeLoader.java create mode 100644 src/main/java/goodgenerator/util/Log.java create mode 100644 src/main/java/goodgenerator/util/StackUtils.java create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/0.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/1.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/10.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/11.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/12.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/13.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/2.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/3.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/4.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/5.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/6.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/7.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/8.png create mode 100644 src/main/resources/assets/goodgenerator/textures/blocks/compAsslineCasing/9.png create mode 100644 src/main/resources/assets/goodgenerator/textures/gui/ComponentAssline.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/0.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/1.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/10.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/11.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/12.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/13.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/14.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/2.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/3.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/4.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/5.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/6.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/7.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/8.png create mode 100644 src/main/resources/assets/goodgenerator/textures/items/wraps/9.png diff --git a/build.gradle b/build.gradle index 9298d9e5a9..89350b8a35 100644 --- a/build.gradle +++ b/build.gradle @@ -1,4 +1,4 @@ -//version: 1667597057 +//version: 1669411416 /* DO NOT CHANGE THIS FILE! Also, you may replace this file at any time if there is an update available. @@ -338,10 +338,10 @@ dependencies { annotationProcessor('org.ow2.asm:asm-debug-all:5.0.3') annotationProcessor('com.google.guava:guava:24.1.1-jre') annotationProcessor('com.google.code.gson:gson:2.8.6') - annotationProcessor('org.spongepowered:mixin:0.8.5-GTNH:processor') + annotationProcessor('com.gtnewhorizon:gtnhmixins:2.1.1:processor') } if (usesMixins.toBoolean() || forceEnableMixins.toBoolean()) { - compile('com.gtnewhorizon:gtnhmixins:2.0.1') + compile('com.gtnewhorizon:gtnhmixins:2.1.1') } } diff --git a/dependencies.gradle b/dependencies.gradle index ffcd89b25d..57e7036f58 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -2,30 +2,34 @@ dependencies { - compile('com.github.GTNewHorizons:GT5-Unofficial:5.09.41.141:dev') - compile('com.github.GTNewHorizons:StructureLib:1.1.7:dev') - compile('com.github.GTNewHorizons:bartworks:0.5.94:dev') - compile('com.github.GTNewHorizons:NotEnoughItems:2.2.28-GTNH:dev') - compile('com.github.GTNewHorizons:TecTech:5.0.37:dev') + compile('com.github.GTNewHorizons:GT5-Unofficial:5.09.41.148:dev') + compile('com.github.GTNewHorizons:StructureLib:1.1.7:dev') + compile('com.github.GTNewHorizons:bartworks:0.5.94:dev') { + exclude group:"com.github.GTNewHorizons", module:"SpongePoweredMixin" + exclude group:"com.github.GTNewHorizons", module:"SpongeMixins" + } + compile('com.github.GTNewHorizons:NotEnoughItems:2.2.28-GTNH:dev') + compile('com.github.GTNewHorizons:TecTech:5.0.37:dev') - compile('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev') - compile('net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev') + compile('thaumcraft:Thaumcraft:1.7.10-4.2.3.5:dev') + compile('net.industrial-craft:industrialcraft-2:2.2.828-experimental:dev') - compileOnly('com.github.GTNewHorizons:EnderCore:0.2.6:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:EnderCore:0.2.6:dev') {transitive = false} compileOnly('com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-97-GTNH:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:GTplusplus:1.7.76:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:AppleCore:3.1.9:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:ForestryMC:4.4.12:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:Railcraft:9.13.9:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:EnderIO:2.3.1.43:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:GTplusplus:1.7.76:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:AppleCore:3.1.9:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:ForestryMC:4.4.12:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:Railcraft:9.13.9:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:EnderIO:2.3.1.43:dev') {transitive = false} compileOnly('com.github.GTNewHorizons:ExtraCells2:2.5.19:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:BuildCraft:7.1.27:dev') {transitive = false} - compileOnly('com.github.GTNewHorizons:ThaumicEnergistics:1.3.19-GTNH:dev') {transitive = false} + + compileOnly('com.github.GTNewHorizons:BuildCraft:7.1.27:dev') {transitive = false} + compileOnly('com.github.GTNewHorizons:ThaumicEnergistics:1.3.19-GTNH:dev') {transitive = false} compileOnly("com.github.GTNewHorizons:ProjectRed:4.7.7-GTNH:dev") {transitive = false} runtime('com.github.GTNewHorizons:NewHorizonsCoreMod:1.9.106:dev') runtime('com.github.GTNewHorizons:ForestryMC:4.4.12:dev') runtime('com.github.GTNewHorizons:GTplusplus:1.7.76:dev') - //compileOnly('com.github.GTNewHorizons:Avaritia:1.28) + //compileOnly('com.github.GTNewHorizons:Avaritia:1.28) } diff --git a/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java b/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java new file mode 100644 index 0000000000..1a9d1b245f --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/ComponentAssemblyLine.java @@ -0,0 +1,744 @@ +package goodgenerator.blocks.tileEntity; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.GT_HatchElement.*; +import static gregtech.api.enums.GT_Values.VN; +import static gregtech.api.enums.Textures.BlockIcons.*; + +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 goodgenerator.loader.Loaders; +import goodgenerator.util.MyRecipeAdder; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +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.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.FluidStack; +import org.apache.commons.lang3.tuple.Pair; + +public class ComponentAssemblyLine extends GT_MetaTileEntity_EnhancedMultiBlockBase + implements ISurvivalConstructable { + + private int casingTier; + private final double log4 = Math.log(4); + private long EU_per_tick = 0; + protected static final String STRUCTURE_PIECE_MAIN = "main"; + private static final IStructureDefinition STRUCTURE_DEFINITION = + StructureDefinition.builder() + .addShape(STRUCTURE_PIECE_MAIN, new String[][] { + { + " ", + " III ", + " HHI~IHH ", + "HH III HH", + "H H", + "H H", + "H JJJ H", + "H N N H", + "H N N H", + "HHHHHHHHH" + }, + { + " ", + " EHHHHHE ", + "E E", + "H H", + "A A", + "A A", + "A HHH A", + "A A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "AG C GA", + "AG GA", + "AG GA", + "AG HHH GA", + "AG GA", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "HG C GH", + "HG GH", + "HG GH", + "HG HHH GH", + "HG GH", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "AG C GA", + "AG GA", + "AG GA", + "AG HHH GA", + "AG GA", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "HG C GH", + "HG GH", + "HG GH", + "HG HHH GH", + "HG GH", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "AG C GA", + "AG GA", + "AG GA", + "AG HHH GA", + "AG GA", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "HG C GH", + "HG GH", + "HG GH", + "HG HHH GH", + "HG GH", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " BBB ", + " EL LE ", + "E GGDGG E", + "HGG D GGH", + "AG C GA", + "AG GA", + "AG GA", + "AG HHH GA", + "AG GA", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A N N A", + "MHHHHHHHM" + }, + { + " HBH ", + " EL LE ", + "E E", + "HC CH", + "AC CA", + "AC CA", + "A D D A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " ", + " EHHHHHE ", + "E E", + "H H", + "A A", + "A A", + "A A", + "A HHH A", + "A A", + "MHHHHHHHM" + }, + { + " ", + " ", + " HHHHHHH ", + "HH HH", + "H H", + "H H", + "H H", + "H H", + "H KKK H", + "HHHHHHHHH" + } + }) + .addElement( + 'A', + ofChain( + ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 5), + ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 13), + ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 14), + ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks", 15), + ofBlockUnlocalizedName("bartworks", "BW_GlasBlocks2", 0))) + .addElement('H', ofBlock(GregTech_API.sBlockCasings8, 7)) + .addElement('C', ofBlock(GregTech_API.sBlockCasings2, 5)) + .addElement('D', ofBlock(GregTech_API.sBlockCasings2, 9)) + .addElement('G', ofBlock(GregTech_API.sBlockCasings9, 0)) + .addElement('E', ofBlock(GregTech_API.sBlockCasings9, 1)) + .addElement('F', ofBlock(GregTech_API.sBlockCasings4, 1)) + .addElement( + 'B', + ofBlocksTiered( + (block, meta) -> block == Loaders.componentAssemblylineCasing ? meta : -1, + IntStream.range(0, 14) + .mapToObj(i -> Pair.of(Loaders.componentAssemblylineCasing, i)) + .collect(Collectors.toList()), + -1, + (t, meta) -> t.casingTier = meta, + t -> t.casingTier)) + .addElement( + 'J', + GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class) + .atLeast(InputBus) + .dot(1) + .casingIndex(183) + .buildAndChain(GregTech_API.sBlockCasings8, 7)) + .addElement( + 'K', + GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class) + .atLeast(OutputBus) + .dot(2) + .casingIndex(183) + .buildAndChain(GregTech_API.sBlockCasings8, 7)) + .addElement( + 'L', + GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class) + .atLeast(Energy, ExoticEnergy) + .dot(3) + .casingIndex(183) + .buildAndChain(GregTech_API.sBlockCasings8, 7)) + .addElement( + 'I', + GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class) + .atLeast(Maintenance) + .dot(4) + .casingIndex(183) + .buildAndChain(GregTech_API.sBlockCasings8, 7)) + .addElement( + 'M', + GT_StructureUtility.buildHatchAdder(ComponentAssemblyLine.class) + .atLeast(InputHatch) + .dot(5) + .casingIndex(183) + .buildAndChain(GregTech_API.sBlockCasings8, 7)) + .addElement('N', GT_StructureUtility.ofFrame(Materials.TungstenSteel)) + .build(); + + public ComponentAssemblyLine(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public ComponentAssemblyLine(String aName) { + super(aName); + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 4, 2, 0); + } + + @Override + public IStructureDefinition getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("High-Capacity Component Assembler") + .addInfo("Controller block for the Component Assembly Line.") + .addInfo("Assembles basic components (motors, pumps, etc.) in large batches.") + .addInfo("The " + EnumChatFormatting.BOLD + EnumChatFormatting.YELLOW + + "Special Component Assembly Line Casing" + EnumChatFormatting.RESET + EnumChatFormatting.GRAY) + .addInfo("limits the recipes the machine can perform. See the NEI pages for details.") + .addInfo("Supports " + EnumChatFormatting.BLUE + "Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + + EnumChatFormatting.GRAY + " laser and multi-amp hatches!") + .addInfo("Supports overclocking beyond MAX!") + .addInfo(EnumChatFormatting.ITALIC + "Much more efficient than other competing brands!") + .beginStructureBlock(9, 10, 33, false) + .addStructureInfo("This structure is too complex! See schematic for details.") + .addOtherStructurePart("Borosilicate Glass", "Can be UV tier or higher") + .addInputBus("Start of conveyor belt", 1) + .addOutputBus("End of conveyor belt", 2) + .addEnergyHatch("Second-top layer", 3) + .addMaintenanceHatch("Around the controller", 4) + .addInputHatch("Bottom left and right corners", 5) + .toolTipFinisher(EnumChatFormatting.AQUA + "MadMan310" + EnumChatFormatting.GRAY + " via " + + EnumChatFormatting.GREEN + "Good Generator"); + + return tt; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new ComponentAssemblyLine(mName); + } + + /** + * Changes and adds new information to the default info data for the scanner. + * */ + @Override + public String[] getInfoData() { + long storedEnergy = 0; + long maxEnergy = 0; + + for (GT_MetaTileEntity_Hatch tHatch : mExoticEnergyHatches) { + if (isValidMetaTileEntity(tHatch)) { + storedEnergy += tHatch.getBaseMetaTileEntity().getStoredEU(); + maxEnergy += tHatch.getBaseMetaTileEntity().getEUCapacity(); + } + } + return new String[] { + "------------ Critical Information ------------", + StatCollector.translateToLocal("GT5U.multiblock.Progress") + ": " + EnumChatFormatting.GREEN + + GT_Utility.formatNumbers(mProgresstime) + EnumChatFormatting.RESET + "t / " + + EnumChatFormatting.YELLOW + + GT_Utility.formatNumbers(mMaxProgresstime) + EnumChatFormatting.RESET + "t", + StatCollector.translateToLocal("GT5U.multiblock.energy") + ": " + EnumChatFormatting.GREEN + + GT_Utility.formatNumbers(storedEnergy) + EnumChatFormatting.RESET + " EU / " + + EnumChatFormatting.YELLOW + + GT_Utility.formatNumbers(maxEnergy) + EnumChatFormatting.RESET + " EU", + StatCollector.translateToLocal("GT5U.multiblock.usage") + ": " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(-EU_per_tick) + EnumChatFormatting.RESET + " EU/t", + StatCollector.translateToLocal("GT5U.multiblock.mei") + ": " + EnumChatFormatting.YELLOW + + GT_Utility.formatNumbers( + GT_ExoticEnergyInputHelper.getMaxInputVoltageMulti(getExoticAndNormalEnergyHatchList())) + + EnumChatFormatting.RESET + " EU/t(*" + EnumChatFormatting.YELLOW + + GT_Utility.formatNumbers( + GT_ExoticEnergyInputHelper.getMaxInputAmpsMulti(getExoticAndNormalEnergyHatchList())) + + EnumChatFormatting.RESET + "A) " + StatCollector.translateToLocal("GT5U.machines.tier") + + ": " + EnumChatFormatting.YELLOW + + VN[ + GT_Utility.getTier(GT_ExoticEnergyInputHelper.getMaxInputVoltageMulti( + getExoticAndNormalEnergyHatchList()))] + + EnumChatFormatting.RESET, + StatCollector.translateToLocal("scanner.info.CASS.tier") + + (casingTier >= 0 ? GT_Values.VN[casingTier + 1] : "None!") + }; + } + + @Override + public ITexture[] getTexture( + IGregTechTileEntity aBaseMetaTileEntity, + byte aSide, + byte aFacing, + byte aColorIndex, + boolean aActive, + boolean aRedstone) { + if (aSide == aFacing) { + if (aActive) + return new ITexture[] { + Textures.BlockIcons.getCasingTextureForId(183), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE_GLOW) + .extFacing() + .glow() + .build() + }; + return new ITexture[] { + Textures.BlockIcons.getCasingTextureForId(183), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_GLOW) + .extFacing() + .glow() + .build() + }; + } + return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(183)}; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public boolean checkRecipe(ItemStack aStack) { + long tVoltage = GT_ExoticEnergyInputHelper.getMaxInputVoltageMulti(getExoticAndNormalEnergyHatchList()); + long tAmps = GT_ExoticEnergyInputHelper.getMaxInputAmpsMulti(getExoticAndNormalEnergyHatchList()); + long totalEU = tVoltage * tAmps; + ItemStack[] tItems = getStoredInputs().toArray(new ItemStack[0]); + FluidStack[] tFluids = getStoredFluids().toArray(new FluidStack[0]); + GT_Recipe foundRecipe = getRecipeMap().findRecipe(getBaseMetaTileEntity(), false, totalEU, tFluids, tItems); + if (foundRecipe == null) return false; + if (foundRecipe.mSpecialValue > casingTier + 1) return false; + if (!foundRecipe.isRecipeInputEqual(true, tFluids, tItems)) return false; + + // Logic for overclocking calculations. + double EU_input_tier = Math.log(totalEU) / log4; + double EU_recipe_tier = Math.log(foundRecipe.mEUt) / log4; + long overclock_count = (long) Math.floor(EU_input_tier - EU_recipe_tier); + + // Vital recipe info. Calculate overclocks here if necessary. + EU_per_tick = (long) -(foundRecipe.mEUt * Math.pow(4, overclock_count)); + + mMaxProgresstime = (int) (foundRecipe.mDuration / Math.pow(2, overclock_count)); + mMaxProgresstime = Math.max(1, mMaxProgresstime); + + mOutputItems = foundRecipe.mOutputs; + updateSlots(); + return true; + } + + @Override + public boolean onRunningTick(ItemStack aStack) { + if (EU_per_tick < 0) { + if (!drainEnergyInput(-EU_per_tick)) { + EU_per_tick = 0; + criticalStopMachine(); + return false; + } + } + return true; + } + + @Override + public boolean drainEnergyInput(long aEU) { + return GT_ExoticEnergyInputHelper.drainEnergy(aEU, getExoticAndNormalEnergyHatchList()); + } + + public List getExoticAndNormalEnergyHatchList() { + List tHatches = new ArrayList<>(); + tHatches.addAll(mExoticEnergyHatches); + tHatches.addAll(mEnergyHatches); + return tHatches; + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + int realBudget = elementBudget >= 200 ? elementBudget : Math.min(200, elementBudget * 5); + return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 4, 2, 0, realBudget, env, false, true); + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + casingTier = -1; + return checkPiece(STRUCTURE_PIECE_MAIN, 4, 2, 0); + } + + @Override + public void clearHatches() { + super.clearHatches(); + mExoticEnergyHatches.clear(); + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public GT_Recipe.GT_Recipe_Map getRecipeMap() { + return MyRecipeAdder.instance.COMPASSLINE_RECIPES; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("casingTier", casingTier); + aNBT.setLong("euPerTick", EU_per_tick); + super.saveNBTData(aNBT); + } + + @Override + public void loadNBTData(final NBTTagCompound aNBT) { + casingTier = aNBT.getInteger("casingTier"); + EU_per_tick = aNBT.getLong("euPerTick"); + super.loadNBTData(aNBT); + } +} diff --git a/src/main/java/goodgenerator/crossmod/nei/ComponentAssemblyLineHandler.java b/src/main/java/goodgenerator/crossmod/nei/ComponentAssemblyLineHandler.java new file mode 100644 index 0000000000..d365434c3f --- /dev/null +++ b/src/main/java/goodgenerator/crossmod/nei/ComponentAssemblyLineHandler.java @@ -0,0 +1,38 @@ +package goodgenerator.crossmod.nei; + +import codechicken.nei.recipe.GuiCraftingRecipe; +import codechicken.nei.recipe.GuiUsageRecipe; +import codechicken.nei.recipe.TemplateRecipeHandler; +import cpw.mods.fml.common.event.FMLInterModComms; +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Recipe; +import gregtech.nei.GT_NEI_DefaultHandler; +import java.awt.*; + +public class ComponentAssemblyLineHandler extends GT_NEI_DefaultHandler { + public ComponentAssemblyLineHandler(GT_Recipe.GT_Recipe_Map aRecipeMap) { + + super(aRecipeMap); + this.transferRects.remove(new RecipeTransferRect(new Rectangle(65, 13, 36, 18), getOverlayIdentifier())); + this.transferRects.add(new RecipeTransferRect(new Rectangle(69, 18, 9, 34), getOverlayIdentifier())); + if (!NEI_Config.isAdded) { + FMLInterModComms.sendRuntimeMessage( + GT_Values.GT, + "NEIPlugins", + "register-crafting-handler", + "gregtech@" + this.getRecipeName() + "@" + this.getOverlayIdentifier()); + GuiCraftingRecipe.craftinghandlers.add(this); + GuiUsageRecipe.usagehandlers.add(this); + } + } + + @Override + public TemplateRecipeHandler newInstance() { + return new ComponentAssemblyLineHandler(this.mRecipeMap); + } + + @Override + protected String getSpecialInfo(int specialValue) { + return this.mRecipeMap.mNEISpecialValuePre + GT_Values.VN[specialValue]; + } +} diff --git a/src/main/java/goodgenerator/crossmod/nei/IMCForNEI.java b/src/main/java/goodgenerator/crossmod/nei/IMCForNEI.java index bcae911545..a4879e9ff6 100644 --- a/src/main/java/goodgenerator/crossmod/nei/IMCForNEI.java +++ b/src/main/java/goodgenerator/crossmod/nei/IMCForNEI.java @@ -33,9 +33,16 @@ public class IMCForNEI { } // sendCatalyst("gt.recipe.complexfusionreactor", "gregtech:gt.blockmachines:32023", -10); // Compact // Fusion MK-V + + sendHandler("goodgenerator.crossmod.nei.ComponentAssemblyLineHandler", "gregtech:gt.blockmachines:32026", 2); + sendCatalyst("gg.recipe.componentassemblyline", "gregtech:gt.blockmachines:32026"); } private static void sendHandler(String aName, String aBlock) { + sendHandler(aName, aBlock, 1); + } + + private static void sendHandler(String aName, String aBlock, int maxRecipesPerPage) { NBTTagCompound aNBT = new NBTTagCompound(); aNBT.setString("handler", aName); aNBT.setString("modName", "Good Generator"); @@ -44,7 +51,7 @@ public class IMCForNEI { aNBT.setString("itemName", aBlock); aNBT.setInteger("handlerHeight", 135); aNBT.setInteger("handlerWidth", 166); - aNBT.setInteger("maxRecipesPerPage", 1); + aNBT.setInteger("maxRecipesPerPage", maxRecipesPerPage); aNBT.setInteger("yShift", 6); FMLInterModComms.sendMessage("NotEnoughItems", "registerHandlerInfo", aNBT); } diff --git a/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java b/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java index b9a8d5cb52..70b31e51ad 100644 --- a/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java +++ b/src/main/java/goodgenerator/crossmod/nei/NEI_Config.java @@ -17,6 +17,7 @@ public class NEI_Config implements IConfigureNEI { new NeutronActivatorHandler(MyRecipeAdder.instance.NA); new ExtremeHeatExchangerHandler(MyRecipeAdder.instance.XHE); new PreciseAssemblerHandler(MyRecipeAdder.instance.PA); + new ComponentAssemblyLineHandler(MyRecipeAdder.instance.COMPASSLINE_RECIPES); NEI_Config.isAdded = true; } diff --git a/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java b/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java new file mode 100644 index 0000000000..41181d858c --- /dev/null +++ b/src/main/java/goodgenerator/loader/ComponentAssemblyLineMiscRecipes.java @@ -0,0 +1,459 @@ +package goodgenerator.loader; + +import static goodgenerator.util.ItemRefer.*; +import static goodgenerator.util.Log.LOGGER; + +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; +import com.github.technus.tectech.recipe.TT_recipeAdder; +import com.google.common.collect.HashBiMap; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.recipe.common.CI; +import java.util.HashMap; +import javax.annotation.Nullable; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import org.apache.logging.log4j.Level; + +public class ComponentAssemblyLineMiscRecipes { + + @SuppressWarnings("deprecation") + public static final Materials[] circuitTierMaterials = { + Materials.Primitive, + Materials.Basic, + Materials.Good, + Materials.Advanced, + Materials.Data, + Materials.Elite, + Materials.Master, + Materials.Ultimate, + Materials.Superconductor, + Materials.Infinite, + Materials.Bio, + Materials.Nano, + Materials.Piko, + Materials.Quantum + }; + + static final HashBiMap MatToTier = HashBiMap.create(); + + static final HashMap CircuitToTier = new HashMap<>(); + + static void run() { + for (int i = 0; i < circuitTierMaterials.length; i++) MatToTier.put(circuitTierMaterials[i], i); + + MatToTier.forEach((mat, tier) -> { + for (ItemStack item : mat.mMaterialItems) CircuitToTier.put(item, tier); + }); + + generateCasingRecipes(); + generateWrapRecipes(); + // Try and find the ZPM Fluid solidifier + ItemStack solidifier; + try { + Class c = Class.forName("com.dreammaster.gthandler.CustomItemList"); + Object maybeSolidifier = c.getMethod("valueOf", String.class).invoke(null, "FluidSolidifierZPM"); + solidifier = + (ItemStack) (c.getMethod("get", long.class, Object[].class).invoke(maybeSolidifier, 16L, null)); + if (GT_Utility.isStackValid(solidifier)) LOGGER.log(Level.INFO, "ZPM Fluid Solidifier found."); + else throw new NullPointerException(); + } catch (Exception e) { + LOGGER.log(Level.ERROR, "ZPM Fluid Solidifier not found, falling back to IV.", e); + solidifier = ItemList.Machine_IV_FluidSolidifier.get(16); + } + + // The controller itself + GT_Values.RA.addAssemblylineRecipe( + ItemList.Machine_Multi_Assemblyline.get(1), + 3600 * 20, + new Object[] { + ItemList.Machine_Multi_Assemblyline.get(16L), + ItemList.Casing_Assembler.get(16L), + ItemList.Casing_Gearbox_TungstenSteel.get(32L), + ComponentType.Robot_Arm.getComponent(8).get(16), + ComponentType.Conveyor_Module.getComponent(8).get(32), + ComponentType.Electric_Motor.getComponent(7).get(32), + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Polybenzimidazole, 16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 32), + solidifier, + getALCircuit(8, 16), + getALCircuit(7, 20), + getALCircuit(6, 24) + }, + new FluidStack[] { + new FluidStack(FluidRegistry.getFluid("molten.indalloy140"), 144 * 12), + Materials.Naquadria.getMolten(144 * 16), + Materials.Lubricant.getFluid(5000) + }, + Component_Assembly_Line.get(1), + 30 * 20, + getV(8) * 2); + } + + /** Recipes for the Component Assembly Line Casings */ + private static void generateCasingRecipes() { + int t = 1; + // lv 1 + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Steel, 4), + ComponentType.Robot_Arm.getComponent(t).get(4), + ComponentType.Electric_Piston.getComponent(t).get(8), + ComponentType.Electric_Motor.getComponent(t).get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Steel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tin, 6), + getCircuit(t, 16), + }, + Materials.SolderingAlloy.getMolten(144 * (t + 3)), + Compassline_Casing_LV.get(1), + 16 * 20, + getV(t)); + // mv 2 + t++; + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Aluminium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Aluminium, 4), + ComponentType.Robot_Arm.getComponent(t).get(4), + ComponentType.Electric_Piston.getComponent(t).get(8), + ComponentType.Electric_Motor.getComponent(t).get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Aluminium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.AnyCopper, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16) + }, + Materials.SolderingAlloy.getMolten(144 * (t + 1)), + Compassline_Casing_MV.get(1), + 16 * 20, + getV(t)); + // hv 3 + t++; + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StainlessSteel, 4), + ComponentType.Robot_Arm.getComponent(t).get(4), + ComponentType.Electric_Piston.getComponent(t).get(8), + ComponentType.Electric_Motor.getComponent(t).get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.StainlessSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Gold, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16) + }, + Materials.SolderingAlloy.getMolten(144 * (t + 1)), + Compassline_Casing_HV.get(1), + 16 * 20, + getV(t)); + // ev 4 + t++; + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Titanium, 4), + ComponentType.Robot_Arm.getComponent(t).get(4), + ComponentType.Electric_Piston.getComponent(t).get(8), + ComponentType.Electric_Motor.getComponent(t).get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Titanium, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16) + }, + Materials.SolderingAlloy.getMolten(144 * (t + 1)), + Compassline_Casing_EV.get(1), + 16 * 20, + getV(t)); + // iv 5 + t++; + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.TungstenSteel, 4), + ComponentType.Robot_Arm.getComponent(t).get(4), + ComponentType.Electric_Piston.getComponent(t).get(8), + ComponentType.Electric_Motor.getComponent(t).get(10), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.TungstenSteel, 4), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 6), + getCircuit(t, 8), + getCircuit(t - 1, 16) + }, + Materials.SolderingAlloy.getMolten(144 * (t + 1)), + Compassline_Casing_IV.get(1), + 16 * 20, + getV(t)); + + Fluid sold = FluidRegistry.getFluid("molten.indalloy140"); + // Assline Recipes! + // luv 6 + t++; + GT_Values.RA.addAssemblylineRecipe( + Compassline_Casing_IV.get(1), + 2250 << t, + new Object[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Europium, 1), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.plateDense, 6), + ComponentType.Robot_Arm.getComponent(t).get(8), + ComponentType.Electric_Piston.getComponent(t).get(10), + ComponentType.Electric_Motor.getComponent(t).get(16), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGt, 4), + WerkstoffLoader.LuVTierMaterial.get(OrePrefixes.gearGtSmall, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.VanadiumGallium, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16) + }, + new FluidStack[] { + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + CI.getAlternativeTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2)) + }, + Compassline_Casing_LuV.get(1), + 30 * 20, + 6000); + // zpm 7 + t++; + GT_Values.RA.addAssemblylineRecipe( + Compassline_Casing_LuV.get(1), + 2250 << t, + new Object[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Iridium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Iridium, 6), + ComponentType.Robot_Arm.getComponent(t).get(8), + ComponentType.Electric_Piston.getComponent(t).get(10), + ComponentType.Electric_Motor.getComponent(t).get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Iridium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Iridium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.Naquadah, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16) + }, + new FluidStack[] { + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + CI.getAlternativeTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2)) + }, + Compassline_Casing_ZPM.get(1), + 30 * 20, + 24000); + // uv 8 + t++; + GT_Values.RA.addAssemblylineRecipe( + Compassline_Casing_ZPM.get(1), + 2250 << t, + new Object[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmium, 6), + ComponentType.Robot_Arm.getComponent(t).get(8), + ComponentType.Electric_Piston.getComponent(t).get(10), + ComponentType.Electric_Motor.getComponent(t).get(16), + GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Osmium, 4), + GT_OreDictUnificator.get(OrePrefixes.gearGtSmall, Materials.Osmium, 16), + GT_OreDictUnificator.get(OrePrefixes.cableGt04, Materials.NaquadahAlloy, 8), + getALCircuit(t, 8), + getALCircuit(t - 1, 16) + }, + new FluidStack[] { + new FluidStack(sold, 144 * t * 4), + CI.getTieredFluid(t, 144 * t * 2), + CI.getAlternativeTieredFluid(t, 144 * t), + Materials.Lubricant.getFluid(1000 * (t - 2)) + }, + Compassline_Casing_UV.get(1), + 30 * 20, + 100000); + // uhv 9 + t++; + TT_recipeAdder.addResearchableAssemblylineRecipe( + Compassline_Casing_UV.get(1), + 375 << (t - 2), + 1 << (t - 3), + 500000, + 1, + new Object[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.CosmicNeutronium, 6), + ComponentType.Robot_Arm.getComponent(t).get(8), + ComponentType.Electric_Piston.getComponent(t).get(10), + ComponentType.Electri