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 <miozune@gmail.com>

* 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 <miozune@gmail.com>
Co-authored-by: Jason Mitchell <mitchej@gmail.com>
Co-authored-by: Martin Robertz <dream-master@gmx.net>
Co-authored-by: GTNH-Colen <54497873+GTNH-Colen@users.noreply.github.com>
Co-authored-by: Sampsa <sampo.vanninen@aalto.fi>

2 files changed, 723 insertions, 0 deletions

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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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<ItemStack> aBoards = new ArrayList<ItemStack>();
+            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);
+        }
+    }
+}