Lang Refactor

dependencies.gradle

@@ -1,5 +1,6 @@
 dependencies {
     compileOnly(libs.jetbrains.annotations)
+    compileOnly(libs.mcdev.annotations)
 
     // Registrate
     jarJar(modApi(forge.registrate.get()))

docs/content/Modpacks/Changes/v7.5.0.md

@@ -102,7 +102,7 @@ Failure reasons are displayed in:
 You are supposed to replace `ModifierFunction.NULL` with `ModifierFunction.cancel(reason)` to tell the machine why the recipe fails to start.
 ```patch
 - return ModifierFunction.NULL;
-+ return ModifierFunction.cancel(Component.translatable("gtceu.recipe_modifier.xxx"));
++ return ModifierFunction.cancel(Component.translatable("recipe_modifier.gtceu.xxx"));
 ```
 
 Also, if you cancel a recipe in `IRecipeLogicMachine#beforeWorking()`, you are supposed to add some custom reason info like:

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",
+}
+```
+
+
+
+
+
+
+
+
+
+
+