From 8a515c7a9f83ca0fe29098d50bc7cab30e137d35 Mon Sep 17 00:00:00 2001 From: BlueWeabo <76872108+BlueWeabo@users.noreply.github.com> Date: Tue, 13 Dec 2022 23:10:17 +0200 Subject: Nanite material and circuit board multi for later tiers (#1513) * Base work for ModularUI compat * Remove useless interface * Add almost all the widgets * Invert method * Refactor NEI stack placement positions * NEI handlers on ModularUI * Add some more docs * AdvDebugStructureWriter * Fix NEI progressbar not working * PrimitiveBlastFurnace * clean * derp * clean * spotlessApply * Boilers * Buffers * clean * N by N slots containers * Fix boilers not having bucket interaction Put opening UI to individual MetaTEs * Maintenance Hatch * clean * spotlessApply * Add dependency * IndustrialApiary * Adapt to ModularUI change * Base work for covers & fix crash with MP * Fix crash with server * Rewrite base work for covers * Send initial cover data on cover GUI open so that the time of showing incorrect data will be eliminated * Covers part 1 * Rename package: ModularUI -> modularui * Rename class: GT_UIInfo -> GT_UIInfos * Fix build * Covers part2 * Fix missing client check with tile UI & fix title overlap * CoverTabLine * Move cover window creators to inner class * Fix crash with null base TE * Close GUI when tile is broken * Color cover window with tile colorization * add nanites as a material * spotless * start the work on the nanites multi * spotless * Change signature of addUIWidgets * FluidFilter cover, FluidDisplaySlotWidget, BasicTank, BasicGenerator, Output Hatch, MicrowaveEnergyTransmitter, Teleporter, DigitalChest, DigitalTank * Add title tab * Move package: modularui -> modularui/widget * add controller recipe and new casing * add prefix and the casing and controller to the item list * add nano forge controller to its item * add nanites to PreLoad * Programmed circuit + IConfigurationCircuitSupport * clean * add nano forge multi - complete with some recipes * new nanite textures * Apply spotless * fix nanites not registering, remove recipe lock on the nano forge, other small fixed no clue why they didn't want to register in run2. * VolumetricFlask * Remove integrated circuit overlay from recipe input slots * Input Hatch & Quadruple Input Hatch * Multiblock * Deprecate old cover GUI * BasicMachines * Finish BasicMachine & NEI * Expand DTPF NEI to 9 slots * Fix ME input bus on MP * Move AESlotWidget to public class * Move GT_Recipe_Map constructors with mNEIUnificateOutput to setter method * Move SteamTexture.Variant to outer enum * Switch to remote repository * oops * Update MUI * Update MUI * Minor refactor for change amount buttons * the start of a new multi, tooltip WIP * Display items and fluids that exceed usual count * blah * use +=, why didn't I do this * add tier 2 and tier 3. add some more checks * Update MUI * Move ModularUI to Base (#1510) * Move ModularUI to Base * Move most of the ModularUI functionality to `BaseTileEntity` (and `CoverableTileEntity`) * `CommonMetaTileEntity` delegates ato the MetaTileEntity * Added several interfaces (with defaults) to indicate if a tile/metatile override/implement certain behaviors. * Moved `IConfigurationCircuitSupport` interface such that it will work with BaseTileEntity or a MetaTileEntity * Address reviews Co-authored-by: miozune * Update MUI * make a single shape rotatable by 90 degrees * Minor changes to NEI * more shapes, more mechanics * Return :facepalm: * IGetTabIconSet override * Some more changes to NEI * Merge texture getter interfaces to new class GUITextureSet * Remove BBF structure picture as it's auto-buildable now * Make unified title tab style of texture angular * Expose some boiler texture getters for addon * Fix crash with cover GUI on pipe * small changes * Lower the number of recipe per page for DTPF & update MUI * Update MUI * Fix crash with middle-clicking slot on circuit selection GUI * Fix circuit selection window not syncing item from base machine * Merge GT_NEI_AssLineHandler into GT_NEI_DefaultHandler * Update MUI * Add in TecTech multi message * Allow changing the way of binding player inventory * Update MUI * Update MUI * Update MUI * Update MUI * Update MUI * Make MUI non-transitive to allow addons to use their own version * Force enable mixin * Format fluid amount tooltip * Add GUITextureSet.STEAM * Add guard against null ModularWindow creation * Add constructors for Muffler Hatch with inventory * Fix output slot on digital chest and tank allowing insertion * Don't log null ModularWindow * add a new material, add some recipes, continue the work on the PCB factory. The first recipe is in! * oops spotless * update bs * rename casings * make material generate plates * add recipes to the pcb factory * nei handling * do some more work on the multi * fixes to recipes. * Update build-and-test.yml * starter work on the PCBFactory GUI. recipe check fully working * finish gui work * spotless thank god drafts don't generate spotless PRs * final touches. tooltip tomorrow * fix typos. and finish PCB multi. * spotless * changes for requests * make consumed amount a constant * fix recipes oopsie * Remove unused textures * Add nanites * fixing recipes * Fix NEI not showing * Make nanites share texture * actually fix recipes and use 2 new lenses * finally circuits work in recipe * Add trans metal block * add default offsets * spotless * make parallels actually work * Downscale nanite texture to 64x64 * improve PCB Factory GUI * finish fixing gui, fix offsets on cooler, apply a new formula for duration * Clean up PCB Factory tooltip * Spotless * Fix typo in Naquadah * make sure the roughness multiplier actually slows down the recipe XD * add a smaller limit to the roughness multipler.... lets not allow for 10x board prodction oops * fix cooler tier 2 using wrong block in its center, fix controller texture on tier 3 * update mui and uodate the button texture * fix one button and prevent null arrays * remove some math. a small rework on recipes * fix and off by 1 * save the change? never heard of it * fix tier 3 not forming * Nano forge tooltip * hopefully fix nano forge. fix neutroni nanite wrong tier in recipe * try 2 to fix structure check * fix nano forge not forming * fix nano forge data stick. we need better error messages * do some fixes. * its 12am, typos.... * never coding at midnight again * try 2 to fix nano forge and pcb factory * fix nano and pcb factory not working. address some reviews * do syncing between client and server. fix recipes asking too much power with multiple upgrades Co-authored-by: miozune Co-authored-by: Jason Mitchell Co-authored-by: Martin Robertz Co-authored-by: GTNH-Colen <54497873+GTNH-Colen@users.noreply.github.com> Co-authored-by: Sampsa --- .../loaders/postload/chains/GT_NaniteChain.java | 146 ++++++ .../postload/chains/GT_PCBFactoryRecipes.java | 577 +++++++++++++++++++++ 2 files changed, 723 insertions(+) create mode 100644 src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java create mode 100644 src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java (limited to 'src/main/java/gregtech/loaders/postload/chains') diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java b/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java new file mode 100644 index 0000000000..bf2b7ecebd --- /dev/null +++ b/src/main/java/gregtech/loaders/postload/chains/GT_NaniteChain.java @@ -0,0 +1,146 @@ +package gregtech.loaders.postload.chains; + +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_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +public class GT_NaniteChain { + + public static void run() { + + ItemStack aUVTierLens = GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0); + ItemStack aUHVTierLens = GT_ModHandler.getModItem("dreamcraft", "item.ChromaticLens", 0); + ItemStack aUEVTierLens = GT_ModHandler.getModItem("dreamcraft", "item.RadoxPolymerLens", 0); + ItemStack aUIVTierLens = ItemList.EnergisedTesseract.get(0); + ItemStack aUMVTierLens = GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Dilithium, 0, false); + + // Carbon Nanite Recipe Before Nano Forge + Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null + ? FluidRegistry.getFluid("molten.indalloy140") + : FluidRegistry.getFluid("molten.solderingalloy"); + + GT_Values.RA.addAssemblylineRecipe( + Materials.Carbon.getNanite(1), + 3600 * 20, + new Object[] { + ItemList.Hull_UV.get(16), + Materials.Carbon.getNanite(16), + ItemList.Field_Generator_ZPM.get(16), + ItemList.Conveyor_Module_UV.get(16), + ItemList.Electric_Motor_UV.get(32), + new Object[] {OrePrefixes.circuit.get(Materials.Master), 16}, + GT_OreDictUnificator.get(OrePrefixes.wireGt08, Materials.Naquadah, 32) + }, + new FluidStack[] { + new FluidStack(solderIndalloy, 144 * 32), + Materials.HSSS.getMolten(144L * 32), + Materials.Osmiridium.getMolten(144L * 16) + }, + ItemList.NanoForge.get(1), + 2400 * 20, + (int) GT_Values.VP[7]); + + GT_Values.RA.addAssemblylineRecipe( + ItemList.Circuit_Crystalmainframe.get(1), + 144000, + new Object[] { + new Object[] {OrePrefixes.circuit.get(Materials.SuperconductorUHV), 16}, + ItemList.Robot_Arm_UV.get(16), + ItemList.Circuit_Chip_Stemcell.get(32), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.NaquadahAlloy, 32), + GT_OreDictUnificator.get(OrePrefixes.stick, Materials.NaquadahAlloy, 16), + Materials.Carbon.getDust(64) + }, + new FluidStack[] {Materials.UUMatter.getFluid(10000), new FluidStack(solderIndalloy, 144 * 32)}, + Materials.Carbon.getNanite(2), + 50 * 20, + (int) GT_Values.VP[8]); + + /* + * General Rules for making nanite recipes: + * 1. Never make a nanite that takes a long time to make and only gives 1, just to be consumed. + * 2. Nanites meant to be consumed should either have a short duration or a big output. + * 3. Nanites which aren't consumed should have a long duration and output less than 16. + * 4. Nanites should always take UUM as a fluid and a lot of power to make. + */ + + // Carbon Nanites - Used to make more Nano Forge Controllers + GT_Values.RA.addNanoForgeRecipe( + new ItemStack[] { + aUVTierLens, + GT_ModHandler.getModItem("bartworks", "bw.werkstoffblockscasingadvanced.01", 8, 31776), + ItemList.Circuit_Chip_SoC.get(64) + }, + new FluidStack[] {Materials.UUMatter.getFluid(200000)}, + new ItemStack[] { + Materials.Carbon.getNanite(64), + }, + null, + null, + 500 * 20, + 10000000, + 1); + + // Silver Nanites - Used in Tier 2 PCB Factory to improve board production + GT_Values.RA.addNanoForgeRecipe( + new ItemStack[] {aUHVTierLens, Materials.Silver.getBlocks(8), ItemList.Circuit_Chip_SoC.get(16)}, + new FluidStack[] {Materials.UUMatter.getFluid(200000)}, + new ItemStack[] {Materials.Silver.getNanite(1)}, + null, + null, + 750 * 20, + 10000000, + 2); + + // Neutronium Nanites - Used to upgrade the Nano Forge to Tier 2 + GT_Values.RA.addNanoForgeRecipe( + new ItemStack[] { + aUEVTierLens, + Materials.Neutronium.getBlocks(8), + ItemList.Circuit_Chip_SoC2.get(64), + ItemList.Circuit_Chip_SoC2.get(32) + }, + new FluidStack[] {Materials.UUMatter.getFluid(200000)}, + new ItemStack[] {Materials.Neutronium.getNanite(1)}, + null, + null, + 100 * 20, + 100000000, + 1); + + // Gold Nanites - Used in Tier 3 PCB Factory to improve board production + GT_Values.RA.addNanoForgeRecipe( + new ItemStack[] {aUIVTierLens, Materials.Gold.getBlocks(8), ItemList.Circuit_Chip_SoC.get(16)}, + new FluidStack[] {Materials.UUMatter.getFluid(300000)}, + new ItemStack[] {Materials.Gold.getNanite(1)}, + null, + null, + 1000 * 20, + 100000000, + 3); + + // Transcendent Metal Nanites - Used to upgrade the Nano Forge to Tier 3 + GT_Values.RA.addNanoForgeRecipe( + new ItemStack[] { + aUMVTierLens, + Materials.TranscendentMetal.getBlocks(8), + ItemList.Circuit_Chip_SoC2.get(64), + ItemList.Circuit_Chip_SoC2.get(64), + ItemList.Circuit_Chip_SoC2.get(64) + }, + new FluidStack[] {Materials.UUMatter.getFluid(2000000)}, + new ItemStack[] {Materials.TranscendentMetal.getNanite(1)}, + null, + null, + 750 * 20, + 1000000000, + 2); + } +} diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java b/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java new file mode 100644 index 0000000000..6c657c2676 --- /dev/null +++ b/src/main/java/gregtech/loaders/postload/chains/GT_PCBFactoryRecipes.java @@ -0,0 +1,577 @@ +package gregtech.loaders.postload.chains; + +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_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_PCBFactoryManager; +import gregtech.api.util.GT_Utility; +import java.util.ArrayList; +import java.util.List; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +@SuppressWarnings("SpellCheckingInspection") +public class GT_PCBFactoryRecipes { + + public static void load() { + final int mBioUpgradeBitMap = 0b1000; + final int mTier3BitMap = 0b100; + final int mTier2BitMap = 0b10; + final int mTier1BitMap = 0b1; + + final Fluid solderLuV = FluidRegistry.getFluid("molten.indalloy140") != null + ? FluidRegistry.getFluid("molten.indalloy140") + : FluidRegistry.getFluid("molten.solderingalloy"); + + // Load Multi Recipes + GT_Values.RA.addAssemblylineRecipe( + ItemList.Circuit_Board_Wetware.get(1), + 3600, + new Object[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 32), + ItemList.Machine_ZPM_CircuitAssembler.get(4), + new Object[] {OrePrefixes.circuit.get(Materials.Master), 16}, + ItemList.Robot_Arm_ZPM.get(8) + }, + new FluidStack[] {new FluidStack(solderLuV, 144 * 36), Materials.Naquadah.getMolten(144 * 18)}, + ItemList.PCBFactory.get(1), + 6000 * 20, + (int) GT_Values.VP[8]); + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 1), + Materials.get("Artherium-Sn").getPlates(6) + }, + null, + ItemList.BasicPhotolithographicFrameworkCasing.get(1), + 30 * 20, + (int) GT_Values.VP[7]); + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 1), + Materials.EnrichedHolmium.getPlates(6) + }, + null, + ItemList.ReinforcedPhotolithographicFrameworkCasing.get(1), + 30 * 20, + (int) GT_Values.VP[9]); + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_ModHandler.getModItem("miscutils", "blockFrameGtCelestialTungsten", 1), + Materials.get("Quantum").getPlates(6) + }, + null, + ItemList.RadiationProofPhotolithographicFrameworkCasing.get(1), + 30 * 20, + (int) GT_Values.VP[11]); + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { + GT_ModHandler.getModItem("miscutils", "blockFrameGtHypogen", 1), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Infinity, 2), + Materials.Thulium.getPlates(6) + }, + Materials.SpaceTime.getMolten(144 * 8), + ItemList.InfinityCooledCasing.get(1), + 10 * 20, + (int) GT_Values.VP[12]); + + // Load CircuitBoard Recipes + + // Plastic Circuit Board + for (int tier = 1; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 1)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(64)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.AnnealedCopper, (long) (16 * (Math.sqrt(tier)))), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), + Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 1.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap); + } + for (int tier = 1; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 0.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(64)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.AnnealedCopper, (long) (16 * (Math.sqrt(tier)))), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), + Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 1.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap); + } + for (int tier = 1; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(64)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Plastic_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.AnnealedCopper, (long) (16 * (Math.sqrt(tier)))), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, (long) (16 * (Math.sqrt(tier)))), + GT_Utility.getIntegratedCircuit(3) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier)))), + Materials.IronIIIChloride.getFluid((long) (250 * (Math.sqrt(tier)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 1.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap); + } + + // Advanced Circuit Board + for (int tier = 2; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 2)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Gold, (long) (16 * (Math.sqrt(tier - 1)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Electrum, (long) (16 * (Math.sqrt(tier - 1)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 1)))), + Materials.IronIIIChloride.getFluid((long) (500 * (Math.sqrt(tier - 1)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 2.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap); + } + for (int tier = 2; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 1.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Gold, (long) (16 * (Math.sqrt(tier - 1)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Electrum, (long) (16 * (Math.sqrt(tier - 1)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 1)))), + Materials.IronIIIChloride.getFluid((long) (500 * (Math.sqrt(tier - 1)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 2.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap); + } + for (int tier = 2; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 1)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Epoxy_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Gold, (long) (16 * (Math.sqrt(tier - 1)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Electrum, (long) (16 * (Math.sqrt(tier - 1)))), + GT_Utility.getIntegratedCircuit(3) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 1)))), + Materials.IronIIIChloride.getFluid((long) (500 * (Math.sqrt(tier - 1)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 2.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap); + } + + // More Advanced Circuit Board + for (int tier = 3; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 3)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Aluminium, (long) (16 * (Math.sqrt(tier - 2)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnergeticAlloy, (long) (16 * (Math.sqrt(tier - 2)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 2)))), + Materials.IronIIIChloride.getFluid((long) (1000 * (Math.sqrt(tier - 2)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 3.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap); + } + for (int tier = 3; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 2.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Aluminium, (long) (16 * (Math.sqrt(tier - 2)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnergeticAlloy, (long) (16 * (Math.sqrt(tier - 2)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 2)))), + Materials.IronIIIChloride.getFluid((long) (1000 * (Math.sqrt(tier - 2)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 3.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap); + } + for (int tier = 3; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 2)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Fiberglass_Advanced.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Aluminium, (long) (16 * (Math.sqrt(tier - 2)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnergeticAlloy, (long) (16 * (Math.sqrt(tier - 2)))), + GT_Utility.getIntegratedCircuit(3) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 2)))), + Materials.IronIIIChloride.getFluid((long) (1000 * (Math.sqrt(tier - 2)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 3.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap); + } + + // Elite Circuit Board + for (int tier = 4; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 4)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Palladium, (long) (16 * (Math.sqrt(tier - 3)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Platinum, (long) (16 * (Math.sqrt(tier - 3)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 3)))), + Materials.IronIIIChloride.getFluid((long) (2000 * (Math.sqrt(tier - 3)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 4.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap); + } + for (int tier = 4; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 3.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Palladium, (long) (16 * (Math.sqrt(tier - 3)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Platinum, (long) (16 * (Math.sqrt(tier - 3)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 3)))), + Materials.IronIIIChloride.getFluid((long) (2000 * (Math.sqrt(tier - 3)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 4.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap); + } + for (int tier = 4; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 3)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Multifiberglass_Elite.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Palladium, (long) (16 * (Math.sqrt(tier - 3)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Platinum, (long) (16 * (Math.sqrt(tier - 3)))), + GT_Utility.getIntegratedCircuit(3) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 3)))), + Materials.IronIIIChloride.getFluid((long) (2000 * (Math.sqrt(tier - 3)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 4.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap); + } + + // Wetware Circuit Board + for (int tier = 5; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnrichedHolmium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.NiobiumTitanium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 4)))), + Materials.IronIIIChloride.getFluid((long) (5000 * (Math.sqrt(tier - 4)))), + Materials.GrowthMediumSterilized.getFluid((long) (2000 * (Math.sqrt(tier - 4)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 5.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap | mBioUpgradeBitMap); + } + for (int tier = 5; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 4.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnrichedHolmium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.NiobiumTitanium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 4)))), + Materials.IronIIIChloride.getFluid((long) (5000 * (Math.sqrt(tier - 4)))), + Materials.GrowthMediumSterilized.getFluid((long) (2000 * (Math.sqrt(tier - 4)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 5.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap | mBioUpgradeBitMap); + } + for (int tier = 5; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 4)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Wetware_Extreme.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.EnrichedHolmium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.NiobiumTitanium, (long) (16 * (Math.sqrt(tier - 4)))), + GT_Utility.getIntegratedCircuit(3) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 4)))), + Materials.IronIIIChloride.getFluid((long) (5000 * (Math.sqrt(tier - 4)))), + Materials.GrowthMediumSterilized.getFluid((long) (2000 * (Math.sqrt(tier - 4)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 5.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap | mBioUpgradeBitMap); + } + + // Bioware Circuit Board + for (int tier = 6; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 6)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Longasssuperconductornameforuvwire, (long) + (16 * (Math.sqrt(tier - 5)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Neutronium, (long) (16 * (Math.sqrt(tier - 5)))), + GT_Utility.getIntegratedCircuit(1) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 5)))), + Materials.IronIIIChloride.getFluid((long) (7500 * (Math.sqrt(tier - 5)))), + Materials.BioMediumSterilized.getFluid((long) (4000 * (Math.sqrt(tier - 5)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(600 / Math.sqrt(Math.pow(1.5, tier - 5.5))), + (int) GT_Values.VP[tier] * 3 / 4, + mTier1BitMap | mTier2BitMap | mTier3BitMap | mBioUpgradeBitMap); + } + for (int tier = 6; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 5.5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Silver), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Longasssuperconductornameforuvwire, (long) + (16 * (Math.sqrt(tier - 5)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Neutronium, (long) (16 * (Math.sqrt(tier - 5)))), + GT_Utility.getIntegratedCircuit(2) + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 5)))), + Materials.IronIIIChloride.getFluid((long) (7500 * (Math.sqrt(tier - 5)))), + Materials.BioMediumSterilized.getFluid((long) (4000 * (Math.sqrt(tier - 5)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(500 / Math.sqrt(Math.pow(1.5, tier - 6.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier2BitMap | mTier3BitMap | mBioUpgradeBitMap); + } + for (int tier = 6; tier <= GT_PCBFactoryManager.mTiersOfPlastics; tier++) { + int amountOfBoards = (int) Math.ceil(8 * (Math.sqrt(Math.pow(2, tier - 5)))); + List aBoards = new ArrayList(); + for (int i = amountOfBoards; i > 64; i -= 64) { + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(i)); + amountOfBoards -= 64; + } + aBoards.add(ItemList.Circuit_Board_Bio_Ultra.get(amountOfBoards)); + GT_Values.RA.addPCBFactoryRecipe( + new ItemStack[] { + GT_Utility.getNaniteAsCatalyst(Materials.Gold), + GT_PCBFactoryManager.getPlasticMaterialFromTier(tier).getPlates(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Longasssuperconductornameforuvwire, (long) + (16 * (Math.sqrt(tier - 5)))), + GT_OreDictUnificator.get( + OrePrefixes.foil, Materials.Neutronium, (long) (16 * (Math.sqrt(tier - 5)))), + GT_Utility.getIntegratedCircuit(3), + }, + new FluidStack[] { + Materials.SulfuricAcid.getFluid((long) (500 * (Math.sqrt(tier - 5)))), + Materials.IronIIIChloride.getFluid((long) (7500 * (Math.sqrt(tier - 5)))), + Materials.BioMediumSterilized.getFluid((long) (4000 * (Math.sqrt(tier - 5)))) + }, + aBoards.toArray(new ItemStack[0]), + (int) Math.ceil(400 / Math.sqrt(Math.pow(1.5, tier - 6.5))), + (int) GT_Values.VP[tier + 1] * 3 / 4, + mTier3BitMap | mBioUpgradeBitMap); + } + } +} -- cgit