MUI2 Port

dependencies.gradle

@@ -10,6 +10,10 @@ dependencies {
     // Configuration
     jarJar(modApi(forge.configuration.get()))
 
+    // Math Parser
+    jarJar(implementation(libs.mxparser.get()))
+    additionalRuntimeClasspath(libs.mxparser.get())
+
     // Mixin (& Extras)
     annotationProcessor(variantOf(libs.mixin) { classifier("processor") })
     compileOnly(annotationProcessor(forge.mixinExtras.common.get()))
@@ -119,4 +123,6 @@ dependencies {
     modExtraLocalRuntime(forge.ponder)
     modExtraLocalRuntime(variantOf(forge.create) { classifier("slim") })
     modExtraLocalRuntime(forge.flywheel.forge)
+
+    modLocalRuntime(forge.curios)
 }

docs/content/Modpacks/Examples/Example_Coil_Multiblock.md

@@ -0,0 +1,102 @@
+---
+title: "Example Coil Multiblock"
+---
+
+### Superheated Pyrolyzing Oven Multiblock (by Phoenixvine)
+
+
+Below is an example of a multiblock using the CoilWorkableElectricMultiblockMachine class and the pyrolyseOvenOverclock machine logic.
+
+### Multiblock
+=== "JavaScript"
+    ```js title="superheated_pyrolyzing_oven_multiblock.js"
+    // In order to use multiblock logic extending beyond the normal WorkableElectricMultiblockMachine, (This is the multiblock type used by default for kubejs) you need to load a class. Coil multiblocks such as the Electric Blast Furnace, Pyrolyse Oven, and the Cracker use this class.
+    const CoilWorkableElectricMultiblockMachine = Java.loadClass("com.gregtechceu.gtceu.api.machine.multiblock.CoilWorkableElectricMultiblockMachine")
+
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create("superheated_pyrolyzing_oven", "multiblock")
+            .machine((holder) => new CoilWorkableElectricMultiblockMachine(holder))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeTypes('pyrolyse_oven')
+            .recipeModifiers(
+                [
+                    GTRecipeModifiers.PARALLEL_HATCH,  
+                    (machine, recipe) => GTRecipeModifiers.pyrolyseOvenOverclock(machine, recipe)
+                ]
+            )
+            .appearanceBlock(GTBlocks.CASING_STEEL_SOLID)
+            .pattern(definition => FactoryBlockPattern.start()
+                .aisle("BBCCCBB", "BBCDCBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("CCCCCCC", "DFFFFFD", "CFFFFFC", "CGGGGGC", "EAAAAAE", "EHHMHHE")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("BBCCCBB", "BBCICBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .where('A', Predicates.blocks("minecraft:air"))
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks('gtceu:solid_machine_casing').setMinGlobalLimited(10) 
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1))
+                    .or(Predicates.abilities(PartAbility.PARALLEL_HATCH).setMaxGlobalLimited(1))
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes())))
+                .where('D', Predicates.blocks("gtceu:steel_firebox_casing"))
+                .where('E', Predicates.blocks("gtceu:laminated_glass"))
+                .where('F', Predicates.blocks("gtceu:ptfe_pipe_casing"))
+                .where('G', Predicates.heatingCoils())
+                .where('H', Predicates.blocks("gtceu:high_temperature_smelting_casing"))
+                .where('M', Predicates.abilities(PartAbility.MUFFLER).setExactLimit(1))
+                .where('I', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/solid/machine_casing_solid_steel",
+                "gtceu:block/multiblock/pyrolyse_oven");
+
+    })
+    ```
+
+
+=== "Java"
+    ```java title="MultiMachines.java"
+
+    public static final MultiblockMachineDefinition SUPERHEATED_PYROLYZING_OVEN = REGISTRATE
+            .multiblock("superheated_pyrolyzing_oven", (holder) -> new CoilWorkableElectricMultiblockMachine(holder))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(GTRecipeTypes.PYROLYSE_RECIPES)
+            .recipeModifiers(GTRecipeModifiers.PARALLEL_HATCH,
+                (machine, recipe) -> GTRecipeModifiers.pyrolyseOvenOverclock(machine, recipe))
+            .appearanceBlock(GTBlocks.CASING_STEEL_SOLID)
+            .pattern(definition -> FactoryBlockPattern.start()
+                .aisle("BBCCCBB", "BBCDCBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("CCCCCCC", "DFFFFFD", "CFFFFFC", "CGGGGGC", "EAAAAAE", "EHHMHHE")
+                .aisle("CCCCCCC", "CAAFAAC", "CAAFAAC", "CGGGGGC", "EAAAAAE", "EHHHHHE")
+                .aisle("BCCCCCB", "BCAFACB", "BCAFACB", "BCGGGCB", "BEAAAEB", "BEHHHEB")
+                .aisle("BBCCCBB", "BBCICBB", "BBCCCBB", "BBCCCBB", "BBEEEBB", "BBEEEBB")
+                .where('A', Predicates.air())
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks(GTBlocks.CASING_STEEL_SOLID.get()).setMinGlobalLimited(10)
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1))
+                    .or(Predicates.abilities(PartAbility.PARALLEL_HATCH).setMaxGlobalLimited(1))
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes())))
+                .where('D', Predicates.blocks(GTBlocks.FIREBOX_STEEL.get()))
+                .where('E', Predicates.blocks(CASING_LAMINATED_GLASS.get()))
+                .where('F', Predicates.blocks(GTBlocks.CASING_POLYTETRAFLUOROETHYLENE_PIPE.get()))
+                .where('G', Predicates.heatingCoils())
+                .where('H', Predicates.blocks(GCYMBlocks.CASING_HIGH_TEMPERATURE_SMELTING.get()))
+                .where('M', Predicates.abilities(PartAbility.MUFFLER).setExactLimit(1))
+                .where('I', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel(GTCEu.id("block/casings/solid/machine_casing_solid_steel"),
+                 GTCEu.id("block/multiblock/pyrolyse_oven"))
+            .register();
+    ```
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.superheated_pyrolyzing_oven": "Superheated Pyrolyzing Oven",
+}
+```
+
+

docs/content/Modpacks/Examples/Example_Steam_Multiblock.md

@@ -0,0 +1,87 @@
+---
+title: "Example Steam Multiblock"
+---
+
+### Large Steam Compressor Multiblock 
+
+Below is an example of a multiblock using the SteamParallelMultiblockMachine class.
+Steam multiblocks such as the Steam Grinder and Steam Oven use this class.
+
+### Multiblock
+
+=== "JavaScript"
+    ```js title="example_steam_multiblock_multiblock.js"
+
+    // In order to use multiblock logic extending beyond the default multiblock type for KJS (WorkableElectricMultiblockMachine), you need to load a class.
+    const $SteamMulti = Java.loadClass('com.gregtechceu.gtceu.common.machine.multiblock.steam.SteamParallelMultiblockMachine');
+
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create('large_steam_compressor', 'multiblock')
+            .machine((holder) => new $SteamMulti(holder, 4))
+            // The number in holder is the max amount of parallel it can use.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType('compressor')
+            .recipeModifier((machine, recipe) => $SteamMulti.recipeModifier(machine, recipe), true)
+            .pattern(definition => FactoryBlockPattern.start()
+                .aisle("BCCCB", "BBCBB", "BBCBB", "BBBBB", "BBBBB")
+                .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                .aisle("CDDDC", "CBBBC", "CEFEC", "BDDDB", "BBGBB")
+                .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                .aisle("BCCCB", "BBHBB", "BBCBB", "BBBBB", "BBBBB")
+                .where('B', Predicates.any())
+                .where('C', Predicates.blocks('gtceu:steam_machine_casing').setMinGlobalLimited(10)
+                   .or(Predicates.abilities(PartAbility.STEAM_IMPORT_ITEMS).setMaxGlobalLimited(1))
+                   .or(Predicates.abilities(PartAbility.STEAM).setMaxGlobalLimited(1))
+                   .or(Predicates.abilities(PartAbility.STEAM_EXPORT_ITEMS).setMaxGlobalLimited(1)))
+                .where('D', Predicates.blocks("gtceu:industrial_steam_casing"))
+                .where('E', Predicates.blocks("gtceu:bronze_brick_casing"))
+                .where('F', Predicates.blocks("gtceu:bronze_firebox_casing"))
+                .where('G', Predicates.blocks("gtceu:bronze_machine_casing"))
+                .where('H', Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/steam/bronze/bottom",
+                "gtceu:block/machines/compressor")
+    })
+    ```
+
+=== "Java"
+    ```java title="MultiMachines.java"
+    public static final MultiblockMachineDefinition LARGE_STEAM_COMPRESSOR = REGISTRATE
+            .multiblock("large_steam_compressor", (holder) -> new SteamParallelMultiblockMachine(holder, 4))
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(COMPRESSOR_RECIPES)
+            .recipeModifier((machine, recipe) -> SteamParallelMultiblockMachine.recipeModifier(machine, recipe), true)
+            .pattern(definition -> FactoryBlockPattern.start()
+                    .aisle("BCCCB", "BBCBB", "BBCBB", "BBBBB", "BBBBB")
+                    .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                    .aisle("CDDDC", "CBBBC", "CEFEC", "BDDDB", "BBGBB")
+                    .aisle("CDDDC", "BDBDB", "BDEDB", "BBDBB", "BBBBB")
+                    .aisle("BCCCB", "BBHBB", "BBCBB", "BBBBB", "BBBBB")
+                    .where('B', Predicates.any())
+                    .where('C', Predicates.blocks(GTBlocks.CASING_BRONZE_BRICKS.get()).setMinGlobalLimited(10)
+                            .or(Predicates.abilities(PartAbility.STEAM_IMPORT_ITEMS).setMaxGlobalLimited(1))
+                            .or(Predicates.abilities(PartAbility.STEAM).setMaxGlobalLimited(1))
+                            .or(Predicates.abilities(PartAbility.STEAM_EXPORT_ITEMS).setMaxGlobalLimited(1)))
+                    .where('D', Predicates.blocks(GCYMBlocks.CASING_INDUSTRIAL_STEAM.get()))
+                    .where('E', Predicates.blocks(GTBlocks.BRONZE_BRICKS_HULL.get()))
+                    .where('F', Predicates.blocks(GTBlocks.FIREBOX_BRONZE.get()))
+                    .where('G', Predicates.blocks(GTBlocks.BRONZE_HULL.get()))
+                    .where('H', Predicates.controller(Predicates.blocks(definition.get())))
+                    .build())
+            .workableCasingModel(GTCEu.id("block/casings/steam/bronze/bottom"),
+                    GTCEu.id("block/machines/compressor"))
+            .register();
+    ```
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.large_steam_compressor": "Large Steam Compressor",
+}
+```
+
+
+
+
+

docs/content/Modpacks/Examples/Example_Turbine.md

@@ -0,0 +1,94 @@
+---
+title: "Example Turbine"
+---
+
+### Example Turbine
+
+Below is an example of a multiblock using the LargeTurbineMachine class for making custom large turbines.
+
+### Multiblock
+
+=== "JavaScript"
+    ```js title="hyper_gas_turbine.js"
+    // In order to use multiblock logic extending beyond the normal WorkableElectricMultiblockMachine, (This is the multiblock type used by default for kubejs) you need to load a class. LargeTurbineMachines such as the gas, steam, and plasma turbines use this class.
+    const $LargeTurbineMachine = Java.loadClass("com.gregtechceu.gtceu.common.machine.multiblock.generator.LargeTurbineMachine")
+
+    GTCEuStartupEvents.registry('gtceu:machine', event => {
+        event.create('hyper_gas_turbine', 'multiblock')
+            .machine((holder) => new $LargeTurbineMachine(holder, GTValues.LuV)) // The value shows one rotor holder tier above the recommended minimum rotor holder. The tier of rotor holder provides a boost based on the efficiency stat.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeTypes("gas_turbine")
+            .recipeModifiers([GTRecipeModifiers.OC_NON_PERFECT_SUBTICK, GTRecipeModifiers.BATCH_MODE, (machine, recipe) => GTRecipeModifiers.LargeTurbineMachine(machine, recipe)])
+            .appearanceBlock(GTBlocks.CASING_TITANIUM_STABLE)
+            .pattern(definition => FactoryBlockPattern.start()
+                    .aisle("BBBBBBB", "BBBCBBB", "BBBDBBB", "BBBCBBB", "BBBBBBB")
+                    .aisle("BBBCBBB", "BBCACBB", "BBCFCBB", "BBCACBB", "BBBCBBB")
+                    .aisle("BBCCCBB", "BCAAACB", "BCAFACB", "BCAFACB", "BBCCCBB")
+                    .aisle("BCCCCCB", "CAAFAAC", "CFFFFFC", "CAFFFAC", "BCCECCB")
+                    .aisle("BBCCCBB", "BCAAACB", "BCAFACB", "BCAFACB", "BBCCCBB")
+                    .aisle("BBBCBBB", "BBCACBB", "BBCFCBB", "BBCACBB", "BBBCBBB")
+                    .aisle("BBBBBBB", "BBBCBBB", "BBBGBBB", "BBBCBBB", "BBBBBBB")
+                .where("A", Predicates.blocks("minecraft:air"))
+                .where("B", Predicates.any())
+                .where("C", Predicates.blocks("gtceu:stainless_steel_turbine_casing")
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes()))
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1)))
+                .where("D", Predicates.ability(PartAbility.MUFFLER).setExactLimit(1))
+                .where("E", Predicates.ability(PartAbility.ROTOR_HOLDER).setExactLimit(1))
+                .where("F", Predicates.blocks("gtceu:stainless_steel_frame"))
+                .where("G", Predicates.controller(Predicates.blocks(definition.get())))
+                .build())
+            .workableCasingModel("gtceu:block/casings/mechanic/machine_casing_turbine_stainless_steel",
+                "gtceu:block/multiblock/generator/large_gas_turbine")
+    });
+    ```
+
+=== "Java"
+    ```java title="MultiMachines.java"
+    public static final MultiblockMachineDefinition HYPER_GAS_TURBINE = REGISTRATE
+            .multiblock("hyper_gas_turbine", (holder) -> new LargeTurbineMachine(holder, GTValues.LuV, 4)) // The value shows one rotor holder tier above the recommended minimum rotor holder. The tier of rotor holder provides a boost based on the efficiency stat.
+            .rotationState(RotationState.NON_Y_AXIS)
+            .recipeType(GTRecipeTypes.GAS_TURBINE_FUELS)
+            .recipeModifiers(GTRecipeModifiers.OC_NON_PERFECT_SUBTICK, GTRecipeModifiers.BATCH_MODE, LargeTurbineMachine::recipeModifier)
+            .pattern(definition -> FactoryBlockPattern.start()
+                .aisle("BBBBBBB", "BBBCBBB", "BBBDBBB", "BBBCBBB", "BBBBBBB")
+                .aisle("BBBCBBB", "BBCACBB", "BBCECBB", "BBCACBB", "BBBCBBB")
+                .aisle("BBCCCBB", "BCAAACB", "BCAEACB", "BCAEACB", "BBCCCBB")
+                .aisle("BCCCCCB", "CAAEAAC", "CEEEEEC", "CAEEEAC", "BCCFCCB")
+                .aisle("BBCCCBB", "BCAAACB", "BCAEACB", "BCAEACB", "BBCCCBB")
+                .aisle("BBBCBBB", "BBCACBB", "BBCECBB", "BBCACBB", "BBBCBBB")
+                .aisle("BBBBBBB", "BBBCBBB", "BBBGBBB", "BBBCBBB", "BBBBBBB")
+                .where("A", Predicates.blocks("minecraft:air"))
+                .where("B", Predicates.any())
+                .where("C", Predicates.blocks("gtceu:stainless_steel_turbine_casing")
+                    .or(Predicates.autoAbilities(definition.getRecipeTypes()))
+                    .or(Predicates.abilities(PartAbility.MAINTENANCE).setExactLimit(1)))
+                .where("D", Predicates.ability(PartAbility.MUFFLER).setExactLimit(1))
+                .where("F", Predicates.ability(PartAbility.ROTOR_HOLDER).setExactLimit(1))
+                .where("E", Predicates.blocks("gtceu:stainless_steel_frame"))
+                .where("G", Predicates.controller(Predicates.blocks(definition.get())))
+                    .build())
+            .workableCasingModel(GTCEu.id("block/casings/steam/bronze/bottom"),
+                    GTCEu.id("block/machines/compressor"))
+            .register();
+    ```
+
+
+### Lang
+
+```json title="en_us.json"
+{
+    "block.gtceu.hyper_gas_turbine": "Hyper Gas Turbine",
+}
+```
+
+
+
+
+
+
+
+
+
+
+

gradle/forge.versions.toml

@@ -11,6 +11,7 @@ ae2 = "15.0.18"
 kubejs = "2001.6.5-build.16"
 rhino = "2001.2.3-build.10"
 architectury = "9.2.14"
+clothmath = "+"
 clothconfig = "11.1.136"
 theoneprobe = "1.20.1-10.0.1-3"
 curios = "5.9.1+1.20.1"
@@ -76,6 +77,7 @@ flywheel-forge      = { module = "dev.engine-room.flywheel:flywheel-forge-1.20.1
 kubejs              = { module = "dev.latvian.mods:kubejs-forge", version.ref = "kubejs" }
 rhino               = { module = "dev.latvian.mods:rhino-forge", version.ref = "rhino" }
 architectury        = { module = "dev.architectury:architectury-forge", version.ref = "architectury" }
+clothmath           = { module = "me.shedaniel.cloth:basic-math", version.ref = "clothmath" }
 clothconfig         = { module = "me.shedaniel.cloth:cloth-config-forge", version.ref = "clothconfig" }
 theoneprobe         = { module = "mcjty.theoneprobe:theoneprobe", version.ref = "theoneprobe" }
 curios              = { module = "top.theillusivec4.curios:curios-forge", version.ref = "curios" }
@@ -118,7 +120,7 @@ ftbchunks-cm        = { module = "curse.maven:ftb-chunks-forge-314906", version.
 
 [bundles]
 jei = ["jei-common-api", "jei-forge-api", "jei-forge-impl"]
-rei = ["rei-plugin", "rei-forge"]
+rei = ["rei-plugin", "rei-forge", "clothmath"]
 rei-runtime = ["rei-forge", "architectury", "clothconfig"]
 kjs = ["kubejs", "rhino", "architectury"]
 

gradle/libs.versions.toml

@@ -10,13 +10,15 @@ lombok = "8.14"
 jetbrains-annotations = "26.0.1"
 renderNurse = "0.0.12"
 mixin = "0.8.7"
+mxparser = "6.1.0"
 
 [libraries]
 minecraft               = { module = "com.mojang:minecraft", version.ref = "minecraft" }
 minecraftForge          = { module = "net.minecraftforge:forge", version.ref = "minecraftForge" }
 jetbrains-annotations   = { module = "org.jetbrains:annotations", version.ref = "jetbrains-annotations" }
 renderNurse             = { module = "net.neoforged:render-nurse", version.ref = "renderNurse" }
 mixin                   = { module = "org.spongepowered:mixin", version.ref = "mixin" }
+mxparser                = { module = "org.mariuszgromada.math:MathParser.org-mXparser", version.ref = "mxparser" }
 
 [plugins]
 modDevGradle            = { id = "net.neoforged.moddev.legacyforge", version.ref = "modDevGradle" }

src/generated/resources/assets/gtceu/blockstates/test_mui.json

@@ -0,0 +1,28 @@
+{
+  "variants": {
+    "facing=down": {
+      "model": "gtceu:block/machine/test_mui",
+      "x": 90
+    },
+    "facing=east": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 90
+    },
+    "facing=north": {
+      "model": "gtceu:block/machine/test_mui"
+    },
+    "facing=south": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 180
+    },
+    "facing=up": {
+      "gtceu:z": 180,
+      "model": "gtceu:block/machine/test_mui",
+      "x": 270
+    },
+    "facing=west": {
+      "model": "gtceu:block/machine/test_mui",
+      "y": 270
+    }
+  }
+}