Add Void Fluid Drilling Rig for GT, Refactored some machine structure. And add some recipes.

kubejs/assets/gtceu/lang/en_us.json

@@ -38,6 +38,8 @@
     "gtceu.greenhouse": "Greenhouse",
     "block.gtceu.void_miner": "Void Miner",
     "gtceu.void_miner": "Void Miner",
+    "block.gtceu.void_fluid_drilling_rig": "Void Fluid Drilling Rig",
+    "gtceu.void_fluid_drilling_rig": "Void Fluid Drilling Rig",
     "block.gtceu.world_data_scanner": "Dimension Scanner",
     "gtceu.world_data_scanner": "Dimension Scanner",
     "block.gtceu.lv_world_data_scanner": "Basic Dimension Scanner",

kubejs/config/client.properties

@@ -1,9 +1,9 @@
 #KubeJS Client Properties
-#Fri Sep 08 23:03:22 EDT 2023
+#Wed Jan 07 10:33:40 CST 2026
 backgroundColor=2E3440
-barBorderColor=ECEFF4
-exportAtlases=false
 menuBackgroundBrightness=64
+exportAtlases=false
+barBorderColor=ECEFF4
 disableRecipeBook=false
 title=
 barColor=ECEFF4
@@ -12,4 +12,5 @@ fmlLogColor=ECEFF4
 showTagNames=false
 fmlMemoryColor=ECEFF4
 menuBackgroundScale=32.0
+blurScaledPackIcon=true
 menuInnerBackgroundBrightness=32

kubejs/server_scripts/mods/gtceu/cell_assembler.js

@@ -0,0 +1,145 @@
+/*
+ServerEvents.recipes((event) => {
+    const gtr = event.recipes.gtceu
+
+    const cell_assembler = [
+        ["lv", "gtceu:tin_single_cable"],
+        ["mv", "gtceu:copper_single_cable"],
+        ["hv", "gtceu:gold_single_cable"],
+        ["ev", "gtceu:aluminium_single_cable"],
+        ["iv", "gtceu:platinum_single_cable"],
+        ["luv", "gtceu:niobium_titanium_single_cable"],
+        ["zpm", "gtceu:vanadium_gallium_single_cable"],
+        ["uv", "gtceu:yttrium_barium_cuprate_single_cable"]]
+    cell_assembler.forEach((cell) => {
+        event.shaped("gtceu:" + cell[0] + "_cell_assembler", [
+            "CDC",
+            "BAB",
+            "EDE"
+        ], {
+            A: "gtceu:" + cell[0] + "_machine_hull",
+            B: cell[1],
+            C: "gtceu:" + cell[0] + "_electric_piston",
+            D: "#gtceu:circuits/" + cell[0],
+            E: "ae2:controller"
+        })
+    })
+
+
+    const cells = [
+        'ae2:item_storage_cell_1k',
+        'ae2:item_storage_cell_4k',
+        'ae2:item_storage_cell_16k',
+        'ae2:item_storage_cell_64k',
+        'ae2:item_storage_cell_256k',
+        'megacells:item_storage_cell_1m',
+        'megacells:item_storage_cell_4m',
+        'megacells:item_storage_cell_16m',
+        'megacells:item_storage_cell_64m',
+        'megacells:item_storage_cell_256m'
+    ]
+
+    const upgrades = [
+        { id: 'ae2:inverter_card', key: 'inverter' },
+        { id: 'ae2:void_card', key: 'void' },
+        { id: 'ae2:fuzzy_card', key: 'fuzzy' }
+    ]
+
+    cells.forEach(cell => {
+        let cellName = cell.split(':')[1].replace('item_storage_cell_', '')
+
+        upgrades.forEach(upgrade => {
+            let cardName = upgrade.key
+            event.recipes.gtceu.cell_assembler(`install_${cellName}_with_${cardName}`)
+                .circuit(1)
+                .itemInputs(cell, upgrade.id) 
+                .itemOutputs(cell) 
+                .duration(100)
+                .EUt(HV)
+        })
+
+        event.recipes.gtceu.cell_assembler(`remove_card_from_${cellName}`)
+            .circuit(2)
+            .itemInputs(Item.of(cell, { "upgrades": [] }).weakNBT()) 
+            .itemOutputs(cell, 'ae2:advanced_card') 
+            .duration(100)
+            .EUt(HV)
+        })
+
+
+    gtr.cell_assembler('install_bulk_with_comp')
+        .circuit(1)
+        .itemInputs('megacells:bulk_item_cell', 'megacells:compression_card')
+        .itemOutputs('megacells:bulk_item_cell')
+        .duration(100)
+        .EUt(HV)
+
+    gtr.cell_assembler('remove_card_from_bulk')
+        .circuit(2)
+        .itemInputs(Item.of('megacells:bulk_item_cell', { "upgrades": [] }).weakNBT())
+        .itemOutputs('megacells:bulk_item_cell', 'ae2:advanced_card')
+        .duration(100)
+        .EUt(HV)
+})
+        */
+
+
+/**
+ * Rationale:
+ * 1. Performance: Bulk cells act as internal compacting drawers. Internal AE2 retrieval 
+ *  prevents the lag often caused by external storage interfaces.
+ * 2. Throughput: The default MEGA Cells Decompression Module relies on Crafting CPUs. 
+ *  Its parallelization speed cannot handle the rapid decompression needed for 
+ *  Nonuple (9x) compressed blocks in this environment.
+ * 3. Fallback: This recipe replaces a planned GTRecipeModifier implementation which 
+ *  faced critical NBT-copying issues. 
+ */
+ServerEvents.recipes(event => {
+    const BULK_CELL = 'megacells:bulk_item_cell'
+    const COMP_CARD = 'megacells:compression_card'
+    const MATTER_BALL = 'ae2:matter_ball'
+
+    event.shapeless(BULK_CELL, [BULK_CELL, COMP_CARD])
+        .modifyResult((grid, result) => {
+            let cell = grid.find(Item.of(BULK_CELL).ignoreNBT())
+            let nbt = cell.nbt ? cell.nbt.copy() : {}
+
+            if (!nbt.upgrades) nbt.upgrades = []
+
+            let hasCard = false
+            for (let i = 0; i < nbt.upgrades.length; i++) {
+                if (nbt.upgrades[i].id == COMP_CARD) {
+                    hasCard = true
+                    break
+                }
+            }
+
+            if (!hasCard) {
+                nbt.upgrades.push({ id: COMP_CARD, Count: 1 })
+            }
+
+            return cell.withNBT(nbt)
+        })
+        .id('kubejs:ae2_cell_install_card')
+
+    event.shapeless(BULK_CELL, [BULK_CELL, MATTER_BALL])
+        .modifyResult((grid, result) => {
+            let cell = grid.find(Item.of(BULK_CELL).ignoreNBT())
+            if (!cell.nbt) return cell
+            let nbt = cell.nbt.copy()
+
+            if (nbt.upgrades) {
+                let newUpgrades = []
+                for (let i = 0; i < nbt.upgrades.length; i++) {
+                    if (nbt.upgrades[i].id != COMP_CARD) {
+                        newUpgrades.push(nbt.upgrades[i])
+                    }
+                }
+                nbt.upgrades = newUpgrades
+            }
+
+            return cell.withNBT(nbt)
+        })
+        .id('kubejs:ae2_cell_remove_card')
+
+})

kubejs/server_scripts/mods/gtceu/drilling_rig.js

@@ -0,0 +1,63 @@
+ServerEvents.recipes((event) => {
+    const gtr = event.recipes.gtceu    
+
+    gtr.assembly_line("gtceu:void_fluid_drilling_rig")
+        .itemInputs("gtceu:mv_fluid_drilling_rig",
+            "gtceu:hv_fluid_drilling_rig",
+            "gtceu:ev_fluid_drilling_rig",
+            "4x gtceu:mv_field_generator",
+            "4x gtceu:hv_field_generator",
+            "4x gtceu:ev_field_generator",
+            "4x #gtceu:circuits/luv",
+            "16x gtceu:hsse_screw",
+            "4x gtceu:long_hssg_rod",
+            "8x gtceu:hsse_plate")
+        .inputFluids("gtceu:soldering_alloy 1440")
+        .itemOutputs("gtceu:void_fluid_drilling_rig")
+        .EUt(GTValues.VA[GTValues.LuV])
+        .duration(600)
+        .researchWithoutRecipe("1x_gtceu_ev_fluid_drilling_rig", "gtceu:data_orb")
+
+    gtr.research_station("1x_gtceu_ev_fluid_drilling_rig")
+        .itemInputs("gtceu:data_orb", "gtceu:ev_fluid_drilling_rig")
+        .itemOutputs(Item.of("gtceu:data_orb", "{assembly_line_research:{research_id:\"1x_gtceu_ev_fluid_drilling_rig\",research_type:\"gtceu:assembly_line\"}}"))
+        .EUt(GTValues.VA[GTValues.LuV])
+        .CWUt(32)
+        .duration(32 * 4000)
+        .data({
+            "hide_duration": 1,
+            "duration_is_total_cwu": 1
+        })
+
+    const overworld_fluids = [
+        ["gtceu:oil_medium 20000", "1"],
+        ["gtceu:oil 20000", "2"],
+        ["gtceu:oil_heavy 15000", "3"],
+        ["gtceu:oil_light 25000", "4"],
+        ["gtceu:natural_gas 15000", "5"],
+        ["gtceu:salt_water 40000", "6"]
+    ]
+
+    overworld_fluids.forEach((overworld_fluid) => {
+        gtr.void_fluid_drilling_rig("overworld_fluid_" + overworld_fluid[1])
+            .notConsumable("kubejs:overworld_data")
+            .outputFluids(overworld_fluid[0])
+            .circuit(overworld_fluid[1])
+            .EUt(GTValues.VA[GTValues.LuV])
+            .duration(20)
+    })
+
+    const nether_fluids = [
+        ["minecraft:lava 65000", "1"],
+        ["gtceu:natural_gas 35000", "2"]
+    ]
+
+    nether_fluids.forEach((nether_fluid) => {
+        gtr.void_fluid_drilling_rig("nether_fluid_" + nether_fluid[1])
+            .notConsumable("2x kubejs:nether_data")
+            .outputFluids(nether_fluid[0])
+            .circuit(nether_fluid[1])
+            .EUt(GTValues.VA[GTValues.LuV])
+            .duration(20)
+    })
+})

kubejs/server_scripts/mods/gtceu/fluid_solidifier.js

@@ -0,0 +1,11 @@
+ServerEvents.recipes((event) => {
+    const gtr = event.recipes.gtceu
+
+    gtr.fluid_solidifier("gtceu:honey_block")
+        .notConsumable("gtceu:block_casting_mold")
+        .inputFluids("#forge:honey 1000")
+        .itemOutputs("minecraft:honey_block")
+        .duration(10)
+        .EUt(ULV)
+
+})

kubejs/server_scripts/mods/gtceu/greenhouse_recipes.js

@@ -21,15 +21,15 @@ ServerEvents.recipes(allthemods => {
                 .inputFluids(Fluid.of('minecraft:water', 1000))
                 .itemOutputs(output)
                 .duration(duration / 2)
-                .EUt(MV)
+                .EUt(LV)
         } else {
             allthemods.recipes.gtceu.greenhouse(id)
                 .circuit(1)
                 .notConsumable(InputItem.of(input))
                 .inputFluids(Fluid.of('minecraft:water', 1000))
                 .itemOutputs(output)
                 .duration(duration)
-                .EUt(MV)
+                .EUt(LV)
         }
     }
 
@@ -73,7 +73,7 @@ ServerEvents.recipes(allthemods => {
                 } else {
                     var recipeMAXBuilder = allthemods.recipes.gtceu.greenhouse('kubejs:gtceu/greenhouse/' + affix[0] + "/" + affix[1] + "_max")
                     var recipeBuilder = allthemods.recipes.gtceu.greenhouse('kubejs:gtceu/greenhouse/' + affix[0] + "/" + affix[1])
-                    recipeBuilder.EUt(MV)
+                    recipeBuilder.EUt(LV)
                         .notConsumable(InputItem.of(input))
                         .inputFluids(Fluid.of('minecraft:water', 1000))
                         .duration(duration / 4)
@@ -100,7 +100,7 @@ ServerEvents.recipes(allthemods => {
             let affix = input.split(':')
             var recipeMAXBuilder = allthemods.recipes.gtceu.greenhouse('kubejs:gtceu/greenhouse/' + affix[0] + "/" + affix[1] + "_max")
             var recipeBuilder = allthemods.recipes.gtceu.greenhouse('kubejs:gtceu/greenhouse/' + affix[0] + "/" + affix[1])
-            recipeBuilder.EUt(MV)
+            recipeBuilder.EUt(LV)
                 .notConsumable(InputItem.of(input))
                 .inputFluids(Fluid.of('minecraft:water', 1000))
                 .duration(duration / 4)
@@ -237,15 +237,15 @@ ServerEvents.recipes(allthemods => {
             .inputFluids(Fluid.of('minecraft:water', 1000))
             .itemOutputs(boostOut)
             .duration(duration / 2)
-            .EUt(MV)
+            .EUt(LV)
         allthemods.recipes.gtceu.greenhouse(id + '_boosted')
             .circuit(1)
             .notConsumable(InputItem.of(inp))
             .notConsumable(InputItem.of(crux))
             .inputFluids(Fluid.of('minecraft:water', 1000))
             .itemOutputs(out)
             .duration(duration)
-            .EUt(MV)
+            .EUt(LV)
 
         allthemods.recipes.gtceu.greenhouse(id + '_max')
             .circuit(4)

kubejs/server_scripts/mods/gtceu/gtceu.js

@@ -775,6 +775,78 @@ ServerEvents.recipes(allthemods => {
         .chancedOutput('gtceu:stone_dust', 6700, 800)
         .duration(400)
         .EUt(2)
+
+    //heavy water
+    allthemods.recipes.gtceu.centrifuge('heavy_water')
+        .inputFluids("minecraft:water 100000")
+        .outputFluids("mekanism:heavy_water 10000")
+        .duration(160)
+        .EUt(EV)
+
+    //infinity pipe upgrade
+    allthemods.recipes.gtceu.assembler('infinity_upgrade')
+		.itemInputs(
+			[
+				'64x pipez:ultimate_upgrade',
+				'64x allthemodium:unobtainium_block',
+                '64x quarryplus:adv_quarry',
+                '4x allthetweaks:improbable_probability_device'
+			])
+		.itemOutputs('pipez:infinity_upgrade')
+		.circuit(1)
+		.duration(1000)
+		.EUt(HV)
+
+    //UHV laser hatch fix
+    allthemods.remove({id: 'gtceu:assembler/uhv_256a_laser_target_hatch'})
+    allthemods.remove({id: 'gtceu:assembler/uhv_256a_laser_source_hatch'})
+    allthemods.remove({id: 'gtceu:assembler/uhv_1024a_laser_target_hatch'})
+    allthemods.remove({id: 'gtceu:assembler/uhv_1024a_laser_source_hatch'})
+    allthemods.remove({id: 'gtceu:assembler/uhv_4096a_laser_target_hatch'})
+    allthemods.remove({id: 'gtceu:assembler/uhv_4096a_laser_output_hatch'})
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_256a_target_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', 'gtceu:diamond_lens', '2x gtceu:uv_sensor', '2x gtceu:uv_electric_pump', 'gtceu:europium_single_cable'])
+        .itemOutputs('gtceu:uhv_256a_laser_target_hatch')
+        .circuit(1)
+        .duration(300)
+        .EUt(UHV)
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_256a_source_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', 'gtceu:diamond_lens', '2x gtceu:uv_emitter', '2x gtceu:uv_electric_pump', 'gtceu:europium_single_cable'])
+        .itemOutputs('gtceu:uhv_256a_laser_source_hatch')
+        .circuit(1)
+        .duration(300)
+        .EUt(UHV)
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_1024a_target_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', '2x gtceu:diamond_lens', '4x gtceu:uv_sensor', '4x gtceu:uv_electric_pump', 'gtceu:europium_double_cable'])
+        .itemOutputs('gtceu:uhv_1024a_laser_target_hatch')
+        .circuit(2)
+        .duration(600)
+        .EUt(UHV)
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_1024a_source_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', '2x gtceu:diamond_lens', '4x gtceu:uv_emitter', '4x gtceu:uv_electric_pump', 'gtceu:europium_double_cable'])
+        .itemOutputs('gtceu:uhv_1024a_laser_source_hatch')
+        .circuit(2)
+        .duration(600)
+        .EUt(UHV)
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_4096a_target_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', '4x gtceu:diamond_lens', '8x gtceu:uv_sensor', '8x gtceu:uv_electric_pump', 'gtceu:europium_quadruple_cable'])
+        .itemOutputs('gtceu:uhv_4096a_laser_target_hatch')
+        .circuit(3)
+        .duration(1200)
+        .EUt(UHV)
+
+    allthemods.recipes.gtceu.assembler('gtceu:assembler/uhv_4096a_source_hatch')
+        .itemInputs(['gtceu:uhv_machine_hull', '4x gtceu:diamond_lens', '8x gtceu:uv_emitter', '8x gtceu:uv_electric_pump', 'gtceu:europium_quadruple_cable'])
+        .itemOutputs('gtceu:uhv_4096a_laser_source_hatch')
+        .circuit(3)
+        .duration(1200)
+        .EUt(UHV)
+
 })
 
 // This File has been authored by AllTheMods Staff, or a Community contributor for use in AllTheMods - AllTheMods 9.

kubejs/server_scripts/mods/gtceu/miner.js

@@ -24,8 +24,7 @@ ServerEvents.recipes((event) => {
         ["iv", "gtceu:platinum_single_cable"],
         ["luv", "gtceu:niobium_titanium_single_cable"],
         ["zpm", "gtceu:vanadium_gallium_single_cable"],
-        ["uv", "gtceu:yttrium_barium_cuprate_single_cable"],
-        ["uhv", "gtceu:europium_single_cable"]]
+        ["uv", "gtceu:yttrium_barium_cuprate_single_cable"]]
     world_data_scanner.forEach((scanner) => {
         event.shaped("gtceu:" + scanner[0] + "_world_data_scanner", [
             "CDC",