rei + some important recipes

config/roughlyenoughitems/pinyin.properties

@@ -0,0 +1,2 @@
+#Pinyin Options
+#Wed Oct 25 16:00:58 NOVT 2023

config/roughlyenoughitems/pinyin_double.properties

@@ -0,0 +1,3 @@
+#Double Pinyin Options
+#Wed Oct 25 16:00:58 NOVT 2023
+Converter=sougou

config/xaerominimap_entities.json

@@ -10,8 +10,8 @@
   "name": "gui.xaero_entity_category_root",
   "protection": true,
   "settingOverrides": {
-    "displayed": true,
     "displayHeight": 0.0,
+    "displayed": true,
     "heightBasedFade": true,
     "renderOrder": 0.0,
     "color": 13.0,

kubejs/server_scripts/gregtech/loot.js

@@ -10,9 +10,9 @@ const modifyLootGT = (event) => {
                 event.addBlockLootModifier(blockName)
                     .removeLoot(Ingredient.all)
                     .addWeightedLoot([
-                        Item.of(`gtceu:${material}_rich_raw_ore`).withChance(25),
-                        Item.of(`gtceu:${material}_raw_ore`).withChance(50),
-                        Item.of(`gtceu:${material}_poor_raw_ore`).withChance(25)
+                        Item.of(`gtceu:${material}_rich_raw`).withChance(25),
+                        Item.of(`gtceu:raw_${material}`).withChance(50),
+                        Item.of(`gtceu:${material}_poor_raw`).withChance(25)
                     ]);
             }
         })

kubejs/server_scripts/gregtech/recipes.js

@@ -1,9 +1,113 @@
 // priority: 0
 
 const registerGTrecipes = (event) => {
+    GTRegistries.MATERIALS.forEach(material => {
+        if (material.hasProperty($PropertyKey.ORE)) {
+            event.remove({id: `gtceu:forge_hammer/hammer_raw_${material}_to_crushed_ore`})
+            event.remove({id: `gtceu:macerator/macerate_raw_${material}_ore_to_crushed_ore`})
+
+            if (doesMaterialUseNormalFurnace(material)) {
+                event.remove({id: `gtceu:smelting/smelt_raw_${material}_ore_to_ingot`})
+                event.remove({id: `gtceu:blasting/smelt_raw_${material}_ore_to_ingot`})
+            }
+
+            generateRecipesForRawOres(event, material)
+            generateRecipesForOres(event, material)
+        }
+    })
+}
+
+const doesMaterialUseNormalFurnace = (material) => {
+    return !material.hasProperty($PropertyKey.BLAST);
+}
+
+const generateRecipesForRawOres = (event, material) => {
+    const materialOreProperty = material.getProperty($PropertyKey.ORE)
+
+    const ingotPrefix = TagPrefix.getPrefix('ingot')
+    const gemPrefix = TagPrefix.getPrefix('gem')
+    const dustPrefix = TagPrefix.getPrefix('dust')
+    const crushedOrePrefix = TagPrefix.getPrefix('crushedOre')
+
+    const crushedStack = ChemicalHelper.get(crushedOrePrefix, material, 1);
+    
+    let ingotStack;
+    const smeltingMaterial = materialOreProperty.getDirectSmeltResult() == null ? material : materialOreProperty.getDirectSmeltResult();
+    const amountOfCrushedOre = materialOreProperty.getOreMultiplier();
+    
+    if (smeltingMaterial.hasProperty($PropertyKey.INGOT)) {
+        ingotStack = ChemicalHelper.get(ingotPrefix, smeltingMaterial, 1);
+    } else if (smeltingMaterial.hasProperty($PropertyKey.GEM)) {
+        ingotStack = ChemicalHelper.get(gemPrefix, smeltingMaterial, 1);
+    } else {
+        ingotStack = ChemicalHelper.get(dustPrefix, smeltingMaterial, 1);
+    }
+    ingotStack.setCount(ingotStack.getCount() * materialOreProperty.getOreMultiplier());
+    crushedStack.setCount(crushedStack.getCount() * materialOreProperty.getOreMultiplier());
+
+    if (crushedStack.isEmpty()) return;
+
+    const generateRecipes = (tagPrefixWithMaterial, tagPrefix, multiplier) => {
+        let outputItems;
+    
+        if (material.hasProperty($PropertyKey.GEM) && !gemPrefix.isIgnored(material)) {
+            outputItems = `${amountOfCrushedOre * multiplier}x gtceu:${material}_gem`
+        } else {
+            outputItems = `${amountOfCrushedOre * multiplier}x gtceu:${material}_crushed_ore`
+        }
+    
+        const forgeHammerRecipeName = `hammer_${tagPrefixWithMaterial}_to_crushed_ore`
+        const maceratorRecipeName = `macerate_${tagPrefixWithMaterial}_to_crushed_ore`
+    
+        const rawRecipeEntry = `1x gtceu:${tagPrefixWithMaterial}`
+        const crushedRecipeEntry = `${crushedStack.getCount() * multiplier}x gtceu:${material}_crushed_ore`
+        
+        event.recipes.gtceu.forge_hammer(forgeHammerRecipeName)
+            .itemInputs(rawRecipeEntry)
+            .itemOutputs(outputItems)
+            .duration(10).EUt(16);
+        
+        event.recipes.gtceu.macerator(maceratorRecipeName)
+                .itemInputs(rawRecipeEntry)
+                .itemOutputs(crushedRecipeEntry)
+                .chancedOutput(crushedRecipeEntry, 5000, 750)
+                .chancedOutput(crushedRecipeEntry, 2500, 500)
+                .chancedOutput(crushedRecipeEntry, 1250, 250)
+                .duration(10).EUt(16);
+
+        // do not try to add smelting recipes for materials which require blast furnace
+        if (!ingotStack.isEmpty() && doesMaterialUseNormalFurnace(smeltingMaterial) && !tagPrefix.isIgnored(material)) {
+            const xp = Math.round(((1 + materialOreProperty.getOreMultiplier() * 0.33) / 3) * 10) / 10;
+        
+            const smeltRecipeName = `tfg:smelting/smelt_${tagPrefixWithMaterial}_to_ingot`
+            const blastingRecipeName = `tfg:blasting/smelt_${tagPrefixWithMaterial}_to_ingot`
+
+            const inputEntry = `1x gtceu:${tagPrefixWithMaterial}`
+            
+            const dolbaeb = ingotStack.copy()
+            dolbaeb.setCount(dolbaeb.getCount() * multiplier)
+            
+            event.smelting(dolbaeb, inputEntry).id(smeltRecipeName).xp(xp)
+            event.blasting(dolbaeb, inputEntry).id(blastingRecipeName).xp(xp)
+        }
+    }
+
+    const poorRawOrePrefix = TagPrefix.getPrefix(`poor_raw`)
+    const normalRawOrePrefix = TagPrefix.getPrefix(`raw`)
+    const richRawOrePrefix = TagPrefix.getPrefix(`rich_raw`)
+
+    generateRecipes(`${material}_poor_raw`, poorRawOrePrefix, 1)
+    generateRecipes(`raw_${material}`, normalRawOrePrefix, 2)
+    generateRecipes(`${material}_rich_raw`, richRawOrePrefix, 3)
+}
+
+const generateRecipesForOres = (event, material) => {
     
 }
 
+
+
+
 // Ore Raw
 /*
 

kubejs/startup_scripts/gregtech/customTagPrefixes.js

@@ -1,14 +1,14 @@
 // priority: 0
 
 const registerTagPrefixes = (event) => {
-    event.create('poor_raw_ore')
+    event.create('poor_raw')
         .unificationEnabled(true)
         .generateItem(true)
         .materialIconType(GTMaterialIconType.rawOre)
         .generationCondition(ItemGenerationCondition.hasOreProperty)
         .register();
     
-    event.create('rich_raw_ore')
+    event.create('rich_raw')
         .unificationEnabled(true)
         .generateItem(true)
         .materialIconType(GTMaterialIconType.rawOre)