diff --git a/src/main/java/gregtechmod/api/interfaces/IOreRecipeRegistrator.java b/src/main/java/gregtechmod/api/interfaces/IOreRecipeRegistrator.java index e89a726..e880758 100644 --- a/src/main/java/gregtechmod/api/interfaces/IOreRecipeRegistrator.java +++ b/src/main/java/gregtechmod/api/interfaces/IOreRecipeRegistrator.java @@ -10,9 +10,9 @@ public interface IOreRecipeRegistrator { /** * Contains a Code Fragment, used in the OrePrefix to register Recipes. Better than using a switch/case, like I did before. * @param aPrefix always != null - * @param dictEntry TODO + * @param entries TODO */ - public void registerOre(OrePrefixes aPrefix, List dictEntry); + public void registerOre(OrePrefixes aPrefix, List entries); /** * All checks from OrePrefixes and OreDictHandler classes was moved here, execute this method before executing processor diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBattery.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBattery.java index 886ec28..515bf97 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBattery.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBattery.java @@ -20,8 +20,8 @@ public class ProcessingBattery implements IOreRecipeRegistrator { OrePrefixes.battery.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials material = this.getMaterial(aPrefix, entry); if (material == Materials.Lithium && this.isExecutable(aPrefix, material)) { RecipeMaps.ASSEMBLING.factory().EUt(16).duration(12800) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBlock.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBlock.java index 6b88a59..5ef6ce7 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBlock.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBlock.java @@ -25,8 +25,8 @@ public class ProcessingBlock implements IOreRecipeRegistrator { OrePrefixes.block.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) ) { if (GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial) != null) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBolt.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBolt.java index 410876b..3dc5a5c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBolt.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingBolt.java @@ -17,8 +17,8 @@ public class ProcessingBolt implements IOreRecipeRegistrator { OrePrefixes.bolt.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) { RecipeMaps.LATHE.factory().EUt(4).duration(Math.max(aMaterial.getMass() / 8, 1)) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCell.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCell.java index 4c860d7..d78144d 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCell.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCell.java @@ -28,8 +28,8 @@ public class ProcessingCell implements IOreRecipeRegistrator { OrePrefixes.cell.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { if (aMaterial != Materials.Empty) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCellPlasma.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCellPlasma.java index 6b635e7..1b4c8e2 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCellPlasma.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCellPlasma.java @@ -22,11 +22,11 @@ public class ProcessingCellPlasma implements IOreRecipeRegistrator { OrePrefixes.cellPlasma.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { // if (aMaterial == Materials.Empty) { // GT_ModHandler.removeRecipeByOutput(aStack); // } - for (OreDictEntry entry : dictEntry) { + for (OreDictEntry entry : entries) { Materials material = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, material) && material != Materials.Empty) { RecipeFactory factory = RecipeMaps.PLASMA_FUELS.factory().EUt(1); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCircuit.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCircuit.java index 46cdc7b..2f47bc8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCircuit.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCircuit.java @@ -22,8 +22,8 @@ public class ProcessingCircuit implements IOreRecipeRegistrator { } // FIXME removing all circuits crafing recipe, then register new - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { switch (aMaterial) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrafting.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrafting.java index ed09059..de7137b 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrafting.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrafting.java @@ -25,8 +25,8 @@ public class ProcessingCrafting implements IOreRecipeRegistrator { OrePrefixes.crafting.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) { if (entry.oreDictName.equals(GT_OreDictNames.craftingRedstoneTorch.toString())) { RecipeMaps.ASSEMBLING.factory().EUt(16).duration(800).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).input(OrePrefixes.plate, Materials.Iron, 1).output(GregTech_API.getGregTechComponent(30, 1)).buildAndRegister(); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushed.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushed.java index db11647..c347e80 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushed.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushed.java @@ -18,8 +18,8 @@ public class ProcessingCrushed implements IOreRecipeRegistrator { OrePrefixes.crushed.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedCentrifuged.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedCentrifuged.java index de31337..466bb1c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedCentrifuged.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedCentrifuged.java @@ -17,8 +17,8 @@ public class ProcessingCrushedCentrifuged implements IOreRecipeRegistrator { OrePrefixes.crushedCentrifuged.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedPurified.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedPurified.java index 2f119fd..67afda0 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedPurified.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingCrushedPurified.java @@ -18,8 +18,8 @@ public class ProcessingCrushedPurified implements IOreRecipeRegistrator { OrePrefixes.crushedPurified.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java index ba2d0f1..2911923 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDust.java @@ -32,8 +32,8 @@ public class ProcessingDust implements IOreRecipeRegistrator { OrePrefixes.dust.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { RecipeFactory factory; diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustImpure.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustImpure.java index 5ee70a4..16d700d 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustImpure.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustImpure.java @@ -24,8 +24,8 @@ public class ProcessingDustImpure implements IOreRecipeRegistrator { OrePrefixes.dustRefined.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { Materials tByProduct = (Materials) GT_Utility.selectItemInList(aPrefix == OrePrefixes.dustPure ? 1 : (aPrefix == OrePrefixes.dustRefined ? 2 : 0), aMaterial, aMaterial.mOreByProducts); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustSmall.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustSmall.java index 315888d..91cb52a 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustSmall.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustSmall.java @@ -25,8 +25,8 @@ public class ProcessingDustSmall implements IOreRecipeRegistrator { OrePrefixes.dustSmall.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { ItemStack ingot; diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustTiny.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustTiny.java index a3a682b..a2887d8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustTiny.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDustTiny.java @@ -26,8 +26,8 @@ public class ProcessingDustTiny implements IOreRecipeRegistrator { OrePrefixes.dustTiny.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { ItemStack ingot; diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDye.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDye.java index 055aafb..75ae6c9 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDye.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingDye.java @@ -23,8 +23,8 @@ public class ProcessingDye implements IOreRecipeRegistrator { OrePrefixes.dye.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { Dyes aDye = Dyes.get(entry.oreDictName); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGear.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGear.java index a0e4e87..0e00d0d 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGear.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGear.java @@ -22,8 +22,8 @@ public class ProcessingGear implements IOreRecipeRegistrator { } @Override - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java index 9585c5e..ac6637f 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingGem.java @@ -29,8 +29,8 @@ public class ProcessingGem implements IOreRecipeRegistrator { OrePrefixes.gem.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { if ((aMaterial == Materials.Charcoal || aMaterial == Materials.Coal) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Recipes.disabledrecipes, "torchesFromCoal", false)) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java index 0931c61..a43fbe3 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot1.java @@ -19,7 +19,7 @@ public class ProcessingIngot1 implements IOreRecipeRegistrator { OrePrefixes.ingot.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if(aMaterial.mFuelPower > 0) { GregTech_API.sRecipeAdder.addFuel(GT_Utility.copyAmount(1L, new Object[]{aStack}), (ItemStack)null, aMaterial.mFuelPower, aMaterial.mFuelType); } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot2.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot2.java index ef41cc5..b30d3af 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot2.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot2.java @@ -16,7 +16,7 @@ public class ProcessingIngot2 implements IOreRecipeRegistrator { OrePrefixes.ingotDouble.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDouble, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24); GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 4, 1), 24); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot3.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot3.java index 55a1c98..955cfa6 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot3.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot3.java @@ -16,7 +16,7 @@ public class ProcessingIngot3 implements IOreRecipeRegistrator { OrePrefixes.ingotTriple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateTriple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24); GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDense, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 6, 1), 24); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot4.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot4.java index 2a34cd4..572aecc 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot4.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot4.java @@ -16,7 +16,7 @@ public class ProcessingIngot4 implements IOreRecipeRegistrator { OrePrefixes.ingotQuadruple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24); } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot5.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot5.java index 567a413..db53f1d 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot5.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngot5.java @@ -16,7 +16,7 @@ public class ProcessingIngot5 implements IOreRecipeRegistrator { OrePrefixes.ingotQuintuple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24); } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngotHot.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngotHot.java index fc7156d..b45ce84 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngotHot.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingIngotHot.java @@ -18,8 +18,8 @@ public class ProcessingIngotHot implements IOreRecipeRegistrator { OrePrefixes.ingotHot.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { RecipeMaps.VACUUM_FREEZER.factory().EUt(120) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingItem.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingItem.java index c8202a5..c6ffd64 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingItem.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingItem.java @@ -18,8 +18,8 @@ public class ProcessingItem implements IOreRecipeRegistrator { OrePrefixes.item.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) { for (ItemStack aStack : entry.ores) { // TODO fix this shit if (entry.oreDictName.equals("itemManganese")) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLeaves.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLeaves.java index 4606c76..8b43fd5 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLeaves.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLeaves.java @@ -15,8 +15,8 @@ public class ProcessingLeaves implements IOreRecipeRegistrator { OrePrefixes.treeLeaves.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) { for (ItemStack aStack : entry.ores) { if (aStack.getItem() instanceof ItemBlock && GT_Mod.sWoodStackSize < aStack.getMaxStackSize()) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java index 2dca9a6..58d9393 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingLog.java @@ -31,8 +31,8 @@ public class ProcessingLog implements IOreRecipeRegistrator { OrePrefixes.log.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - List logs = dictEntry.stream() + public void registerOre(OrePrefixes aPrefix, List entries) { + List logs = entries.stream() .map(ent -> ent.ores) .flatMap(List::stream) .map(s -> GT_Utility.stackToInt(s)) @@ -42,7 +42,7 @@ public class ProcessingLog implements IOreRecipeRegistrator { RecipeHandler.scheduleSmeltingToRemove((in, out) -> out.isItemEqual(new ItemStack(Items.coal, 1, 1)) && logs.contains(GT_Utility.stackToInt(in))); } - for (OreDictEntry entry : dictEntry) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { RecipeEntry recEntry = RecipeEntry.fromStacks(entry.ores, Match.STRICT); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingNugget.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingNugget.java index 8e35b69..4229a96 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingNugget.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingNugget.java @@ -22,8 +22,8 @@ public class ProcessingNugget implements IOreRecipeRegistrator { OrePrefixes.nugget.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) { RecipeMaps.LATHE.factory().EUt(8) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOre.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOre.java index b130504..724d2c7 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOre.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOre.java @@ -12,185 +12,374 @@ import gregtechmod.api.interfaces.IOreRecipeRegistrator; import gregtechmod.api.util.GT_ModHandler; import gregtechmod.api.util.GT_OreDictUnificator; import gregtechmod.api.util.GT_Utility; +import gregtechmod.api.util.OreDictEntry; + +import gregtechmod.common.RecipeHandler; +import gregtechmod.common.recipe.RecipeEntry; +import gregtechmod.common.recipe.RecipeEntry.Match; +import gregtechmod.common.recipe.RecipeMaps; import java.util.Iterator; +import java.util.List; + import net.minecraft.init.Blocks; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; public class ProcessingOre implements IOreRecipeRegistrator { - public ProcessingOre() { - OrePrefixes.ore.add((IOreRecipeRegistrator)this); - OrePrefixes.oreEnd.add((IOreRecipeRegistrator)this); - OrePrefixes.oreNether.add((IOreRecipeRegistrator)this); - OrePrefixes.oreDense.add((IOreRecipeRegistrator)this); - } + public ProcessingOre() { + OrePrefixes.ore.add(this); + OrePrefixes.oreEnd.add(this); + OrePrefixes.oreNether.add(this); + OrePrefixes.oreDense.add(this); + } - @SuppressWarnings("deprecation") - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - if(aStack.getItem() instanceof ItemBlock && aStack.getItem().getItemStackLimit() > GT_Mod.sOreStackSize) { - aStack.getItem().setMaxStackSize(GT_Mod.sOreStackSize); - } + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { + Materials aMaterial = this.getMaterial(aPrefix, entry); + if (this.isExecutable(aPrefix, aMaterial)) { + int mult = aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense ? 1 : 2; + + if (aMaterial == Materials.Oilsands) { + RecipeMaps.CENTRIFUGE.factory().EUt(5).setShaped(true) + .duration(1000 * mult) + .input(RecipeEntry.fromStacks(2, entry.ores, Match.STRICT)) + .input(GT_Items.Cell_Empty.get(1)) + .output(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, mult)) + .output(new ItemStack(Blocks.sand, 1)) + .buildAndRegister(); + } else { + registerStandardOreRecipes(aPrefix, aMaterial, entry, mult); + } + + ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); + ItemStack tSmeltInto = tIngot == null ? (aMaterial.contains(SubTag.SMELTING_TO_GEM) + ? GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mOreReplacement.mDirectSmelting, + GT_OreDictUnificator.get(OrePrefixes.crystal, aMaterial.mOreReplacement.mDirectSmelting, + GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial.mOreReplacement, + GT_OreDictUnificator.get(OrePrefixes.crystal, aMaterial.mOreReplacement, 1L), 1L), + 1L), + 1L) + : null) : tIngot; + + for (ItemStack aStack : entry.ores) { + if (aMaterial != Materials.Oilsands) + defaultOreRegistration(aPrefix, aMaterial, aStack, mult, tSmeltInto); + if (aStack.getItem() instanceof ItemBlock && aStack.getMaxStackSize() > GT_Mod.sOreStackSize) + aStack.getItem().setMaxStackSize(GT_Mod.sOreStackSize); + } + } + } + } + + private static void defaultOreRegistration(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, int aMultiplier, ItemStack tSmeltInto) { + GT_ModHandler.addValuableOre(aOreStack.copy(), aMaterial.mOreValue); + if (aMaterial.mBlastFurnaceRequired || aMaterial.mDirectSmelting.mBlastFurnaceRequired) { + RecipeHandler.scheduleSmeltingToRemove((in, out) -> in.isItemEqual(aOreStack)); + } else { + GT_ModHandler.addSmeltingRecipe(aOreStack, GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, tSmeltInto)); + } + } + + private static boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, OreDictEntry entry, int aMultiplier) { + if (aMaterial != null) { + Materials tMaterial = aMaterial.mOreReplacement; + Materials tPrimaryByMaterial = null; + Materials tSecondaryByMaterial = null; + aMultiplier = Math.max(1, aMultiplier); + ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); + ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L); + ItemStack tSmeltInto = tIngot == null ? (aMaterial.contains(SubTag.SMELTING_TO_GEM) + ? GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial.mDirectSmelting, + GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial.mDirectSmelting, + GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, + GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial, 1L), 1L), + 1L), + 1L) + : null) : tIngot; + ItemStack tSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMaterial, 1L); + ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L); + ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L); + ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, tMaterial, + (aMaterial.mOreMultiplier * aMultiplier)); + ItemStack tPrimaryByProduct = null; + ItemStack tPrimaryByProductSmall = null; + ItemStack tSecondaryByProduct = null; + ItemStack tSecondaryByProductSmall = null; + if (tCrushed == null) { + tCrushed = GT_OreDictUnificator.get(OrePrefixes.dustImpure, tMaterial, + GT_Utility.copyAmount((aMaterial.mOreMultiplier * aMultiplier), + new Object[] { tCleaned, tDust, tGem }), + (aMaterial.mOreMultiplier * aMultiplier)); + } - if(aMaterial == Materials.Oilsands) { - GregTech_API.sRecipeAdder.addCentrifugeRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), 1, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Oil, aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1L:2L), new ItemStack(Blocks.sand, 1, 0), (ItemStack)null, (ItemStack)null, aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1000:2000); - } else { - registerStandardOreRecipes(aPrefix, aMaterial, GT_Utility.copyAmount(1L, new Object[]{aStack}), aPrefix != OrePrefixes.oreNether && aPrefix != OrePrefixes.oreDense?1:2); - } + Iterator iterator = aMaterial.mOreByProducts.iterator(); - } + while (iterator.hasNext()) { + Materials tMat = (Materials) iterator.next(); + if (tPrimaryByProduct == null) { + tPrimaryByMaterial = tMat; + tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L); + if (tPrimaryByProductSmall == null) { + tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, + GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + } - private static boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, int aMultiplier) { - if(aOreStack != null && aMaterial != null) { - GT_ModHandler.addValuableOre(aOreStack.copy(), aMaterial.mOreValue); - Materials tMaterial = aMaterial.mOreReplacement; - Materials tPrimaryByMaterial = null; - Materials tSecondaryByMaterial = null; - aMultiplier = Math.max(1, aMultiplier); - aOreStack = GT_Utility.copyAmount(1L, new Object[]{aOreStack}); - aOreStack.stackSize = 1; - ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L); - ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, (Object)tMaterial, 1L); - ItemStack tSmeltInto = tIngot == null?(aMaterial.contains(SubTag.SMELTING_TO_GEM)?GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial.mDirectSmelting, GT_OreDictUnificator.get(OrePrefixes.crystal, tMaterial.mDirectSmelting, GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, GT_OreDictUnificator.get(OrePrefixes.crystal, (Object)tMaterial, 1L), 1L), 1L), 1L):null):tIngot; - ItemStack tSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMaterial, 1L); - ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L); - ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L); - ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, (Object)tMaterial, (long)(aMaterial.mOreMultiplier * aMultiplier)); - ItemStack tPrimaryByProduct = null; - ItemStack tPrimaryByProductSmall = null; - ItemStack tSecondaryByProduct = null; - ItemStack tSecondaryByProductSmall = null; - if(tCrushed == null) { - tCrushed = GT_OreDictUnificator.get(OrePrefixes.dustImpure, tMaterial, GT_Utility.copyAmount((long)(aMaterial.mOreMultiplier * aMultiplier), new Object[]{tCleaned, tDust, tGem}), (long)(aMaterial.mOreMultiplier * aMultiplier)); - } + if (tSecondaryByProduct == null || tSecondaryByMaterial == tPrimaryByMaterial) { + tSecondaryByMaterial = tMat; + tSecondaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); + tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L); + if (tSecondaryByProductSmall == null) { + tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, + GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); + } + } + } - Iterator iterator = aMaterial.mOreByProducts.iterator(); + if (tPrimaryByMaterial == null) { + tPrimaryByMaterial = tMaterial; + } - while(iterator.hasNext()) { - Materials tMat = (Materials)iterator.next(); - if(tPrimaryByProduct == null) { - tPrimaryByMaterial = tMat; - tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, (Object)tMat, 1L); - tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMat, 1L); - if(tPrimaryByProductSmall == null) { - tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)tMat, 2L), 2L); - } - } + if (tPrimaryByProduct == null) { + tPrimaryByProduct = tDust; + } - if(tSecondaryByProduct == null || tSecondaryByMaterial == tPrimaryByMaterial) { - tSecondaryByMaterial = tMat; - tSecondaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, (Object)tMat, 1L); - tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, (Object)tMat, 1L); - if(tSecondaryByProductSmall == null) { - tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)tMat, 2L), 2L); - } - } - } + if (tPrimaryByProductSmall == null) { + tPrimaryByProductSmall = tSmall; + } - if(tPrimaryByMaterial == null) { - tPrimaryByMaterial = tMaterial; - } + if (tSecondaryByMaterial == null) { + tSecondaryByMaterial = tPrimaryByMaterial; + } - if(tPrimaryByProduct == null) { - tPrimaryByProduct = tDust; - } + if (tSecondaryByProduct == null) { + tSecondaryByProduct = tPrimaryByProduct; + } - if(tPrimaryByProductSmall == null) { - tPrimaryByProductSmall = tSmall; - } + if (tSecondaryByProductSmall == null) { + tSecondaryByProductSmall = tPrimaryByProductSmall; + } + + RecipeEntry ingr = RecipeEntry.fromStacks(entry.ores, Match.STRICT); + + if (tSmeltInto != null) { + if (!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) { + GT_ModHandler.addInductionSmelterRecipe(entry.ores.get(0), new ItemStack(Blocks.sand, 1), + GT_Utility.mul((aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 1 : 2) * aMaterial.mSmeltingMultiplier), tSmeltInto), + GT_Items.TE_Slag_Rich.get(1), 300 * aMultiplier, 10 * aMultiplier); + GT_ModHandler.addInductionSmelterRecipe(entry.ores.get(0), + GT_Items.TE_Slag_Rich.get(aMultiplier), + GT_Utility.mul((aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 2 : 3) * aMaterial.mSmeltingMultiplier), tSmeltInto), + GT_Items.TE_Slag.get(aMultiplier), 300 * aMultiplier, 95); + } + + if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) { + RecipeMaps.BLAST_FURNANCE.factory() + .minTemperature(1500) + .EUt(120).duration(tSmeltInto.stackSize * 500) + .input(ingr) + .input(OrePrefixes.dust, Materials.Calcite, aMultiplier) + .output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, tSmeltInto)) + .output(GT_Items.TE_Slag.get(1L, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 1L))) + .buildAndRegister(); + } else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) { + RecipeMaps.BLAST_FURNANCE.factory() + .minTemperature(1500) + .EUt(120).duration(tSmeltInto.stackSize * 500) + .input(ingr) + .input(OrePrefixes.dust, Materials.Calcite, aMultiplier) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, tSmeltInto)) + .output(GT_Items.TE_Slag.get(1L, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.DarkAsh, 1L))) + .buildAndRegister(); + } + } - if(tSecondaryByMaterial == null) { - tSecondaryByMaterial = tPrimaryByMaterial; - } + if (tCrushed != null) { + final ItemStack copy = GT_Utility.copy(tCrushed); + if (GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammercrushing, aPrefix.get(aMaterial), true)) { + RecipeHandler.executeOnFinish(() -> GT_ModHandler.addCraftingRecipe(copy, new Object[] { "T", "O", 'T', GT_ToolDictNames.craftingToolHardHammer, 'O', aPrefix.get(aMaterial) })); + } - if(tSecondaryByProduct == null) { - tSecondaryByProduct = tPrimaryByProduct; - } + RecipeMaps.HAMMER.factory().EUt(10) .duration(16).input(ingr).output(tCrushed).buildAndRegister(); + RecipeHandler.scheduleIC2RecipeToRemove(GT_ModHandler.getMaceratorRecipeList(), (in, out) -> in.matches(entry.ores.get(0))); + final ItemStack out1 =tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get(OrePrefixes.crystal, Materials.Cinnabar, GT_Utility.copyAmount(1, tPrimaryByProduct), 1L) : GT_Utility.copyAmount(1, tPrimaryByProduct); + final int val = tPrimaryByProduct == null ? 0 : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier; + RecipeHandler.executeOnFinish(() -> GT_ModHandler.addPulverisationRecipe(entry, 1, GT_Utility.mul(2L, copy), out1, val)); + if (tGem != null) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100) + .input(ingr) + .input(GT_ModHandler.getWater(1000 * aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(tSmall == null + ? GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned) + : GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 6, tSmall)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .buildAndRegister(); + + if (tMaterial.contains(SubTag.WASHING_MERCURY)) { + if (tSmall == null) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tCleaned)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } + + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tDust)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - if(tSecondaryByProductSmall == null) { - tSecondaryByProductSmall = tPrimaryByProductSmall; - } - if(tSmeltInto != null) { - if(!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) { - GT_ModHandler.addInductionSmelterRecipe(aOreStack, new ItemStack(Blocks.sand, 1), GT_Utility.mul((long)(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT)?1:2) * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag_Rich.get(1L, new Object[0]), 300 * aMultiplier, 10 * aMultiplier); - GT_ModHandler.addInductionSmelterRecipe(aOreStack, GT_Items.TE_Slag_Rich.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT)?2:3) * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get((long)aMultiplier, new Object[0]), 300 * aMultiplier, 95); - GT_ModHandler.addSmeltingRecipe(aOreStack, GT_Utility.copyAmount((long)(aMultiplier * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto})); - } else { - GT_ModHandler.removeFurnaceSmelting(aOreStack); - } + if (tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(tSmall == null + ? GT_Utility.mul((aMultiplier * 2 * aMaterial.mOreMultiplier), tCleaned) + : GT_Utility.mul((aMultiplier * 6 * aMaterial.mOreMultiplier), tSmall)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProduct)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } + + if (tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + if (tSmall == null) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tCleaned)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } + + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(GT_Utility.mul(aMultiplier * 3 * aMaterial.mOreMultiplier, tDust)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - if(aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) { - GregTech_API.sRecipeAdder.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Calcite, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get(1L, new Object[]{GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.DarkAsh, 1L)}), tSmeltInto.stackSize * 500, 120, 1500); - } else if(aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) { - GregTech_API.sRecipeAdder.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.Calcite, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mSmeltingMultiplier), new Object[]{tSmeltInto}), GT_Items.TE_Slag.get(1L, new Object[]{GT_OreDictUnificator.get(OrePrefixes.dust, (Object)Materials.DarkAsh, 1L)}), tSmeltInto.stackSize * 500, 120, 1500); - } - } + if (tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier, tGem)) + .output(tSmall == null + ? GT_Utility.mul((aMultiplier * 2 * aMaterial.mOreMultiplier), tCleaned) + : GT_Utility.mul((aMultiplier * 6 * aMaterial.mOreMultiplier), tSmall)) + .output(GT_Utility.mul(aMultiplier * 2 * aMaterial.mByProductMultiplier, tPrimaryByProduct)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } + } else { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100) + .input(ingr) + .input(GT_ModHandler.getWater(1000 * aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall)) + .buildAndRegister(); + if (tMaterial.contains(SubTag.WASHING_MERCURY)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 3, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - if(tCrushed != null) { - if(GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammercrushing, aPrefix.get(aMaterial), true)) { - GT_ModHandler.addCraftingRecipe(GT_Utility.copy(tCrushed), new Object[]{"T", "O", Character.valueOf('T'), GT_ToolDictNames.craftingToolHardHammer, Character.valueOf('O'), aPrefix.get(aMaterial)}); - } + if (tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProduct)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - GregTech_API.sRecipeAdder.addForgeHammerRecipe(aOreStack, GT_Utility.copy(tCrushed), 16, 10); - GT_ModHandler.addPulverisationRecipe(aOreStack, GT_Utility.mul(2L, tCrushed), tMaterial.contains(SubTag.PULVERIZING_CINNABAR)?GT_OreDictUnificator.get(OrePrefixes.crystal, Materials.Cinnabar, GT_Utility.copyAmount(1L, new Object[]{tPrimaryByProduct}), 1L):GT_Utility.copyAmount(1L, new Object[]{tPrimaryByProduct}), tPrimaryByProduct == null?0:tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier, true); - if(tGem != null) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_Items.Cell_Water.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 6), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - if(tSmall == null && tMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } + if (tSecondaryByMaterial.contains(SubTag.WASHING_MERCURY)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProduct)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - if(tMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tDust}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } + if (tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 3, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } - if(tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mOreMultiplier), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * 6 * aMaterial.mOreMultiplier), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } + if (tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProduct)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProductSmall)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } else if (tSecondaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { + RecipeMaps.GRINDER.factory() + .EUt(120).duration(100).setShaped(true) + .input(ingr) + .input(GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, aMultiplier)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mOreMultiplier * 2, tCleaned)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tPrimaryByProductSmall)) + .output(GT_Utility.mul(aMultiplier * aMaterial.mByProductMultiplier, tSecondaryByProduct)) + .output(GT_Items.Cell_Empty.get(aMultiplier)) + .buildAndRegister(); + } + } + } - if(tSmall == null && tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), GT_Utility.mul((long)(aMultiplier * 3 * aMaterial.mOreMultiplier), new Object[]{tDust}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier), new Object[]{tGem}), tSmall == null?GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mOreMultiplier), new Object[]{tCleaned}):GT_Utility.mul((long)(aMultiplier * 6 * aMaterial.mOreMultiplier), new Object[]{tSmall}), GT_Utility.mul((long)(aMultiplier * 2 * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - } else { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_Items.Cell_Water.get((long)aMultiplier, new Object[0]), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - if(tMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 3), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tPrimaryByMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tSecondaryByMaterial.contains(SubTag.WASHING_MERCURY)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.Mercury, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 3), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tPrimaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProduct}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProductSmall}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - - if(tSecondaryByMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { - GregTech_API.sRecipeAdder.addGrinderRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.cell, (Object)Materials.SodiumPersulfate, (long)aMultiplier), GT_Utility.mul((long)(aMultiplier * aMaterial.mOreMultiplier * 2), new Object[]{tCleaned}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tPrimaryByProductSmall}), GT_Utility.mul((long)(aMultiplier * aMaterial.mByProductMultiplier), new Object[]{tSecondaryByProduct}), GT_Items.Cell_Empty.get((long)aMultiplier, new Object[0])); - } - } - } - - return true; - } else { - return false; - } - } + return true; + } else { + return false; + } + } } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOreSmelting.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOreSmelting.java index d416e88..c0aa9eb 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOreSmelting.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingOreSmelting.java @@ -1,56 +1,80 @@ package gregtechmod.loaders.oreprocessing; -import gregtechmod.api.GregTech_API; +import java.util.List; + +import gregtechmod.api.enums.Materials; import gregtechmod.api.enums.OrePrefixes; import gregtechmod.api.enums.SubTag; import gregtechmod.api.interfaces.IOreRecipeRegistrator; import gregtechmod.api.util.GT_ModHandler; import gregtechmod.api.util.GT_OreDictUnificator; import gregtechmod.api.util.GT_Utility; +import gregtechmod.api.util.OreDictEntry; + +import gregtechmod.common.RecipeHandler; +import gregtechmod.common.recipe.RecipeEntry; +import gregtechmod.common.recipe.RecipeMaps; +import gregtechmod.common.recipe.RecipeEntry.Match; + import net.minecraft.item.ItemStack; public class ProcessingOreSmelting implements IOreRecipeRegistrator { - private final OrePrefixes[] mSmeltingPrefixes; + private final static OrePrefixes[] mSmeltingPrefixes = new OrePrefixes[] { + OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.crushedCentrifuged, OrePrefixes.dustImpure, OrePrefixes.dustPure, OrePrefixes.dustRefined + }; + public ProcessingOreSmelting() { + for (OrePrefixes tPrefix : mSmeltingPrefixes) { + tPrefix.add(this); + } + } - public ProcessingOreSmelting() { - this.mSmeltingPrefixes = new OrePrefixes[]{OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.crushedCentrifuged, OrePrefixes.dustImpure, OrePrefixes.dustPure, OrePrefixes.dustRefined}; - OrePrefixes[] arr$ = this.mSmeltingPrefixes; - int len$ = arr$.length; + @Override + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { + Materials aMaterial = this.getMaterial(aPrefix, entry); + if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMELTING)) { + if (!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) { + switch (aPrefix) { + case crushed: + case crushedPurified: + case crushedCentrifuged: + ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, 10L); + if (tStack == null) + tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); - for(int i$ = 0; i$ < len$; ++i$) { - OrePrefixes tPrefix = arr$[i$]; - tPrefix.add((IOreRecipeRegistrator)this); - } - - } - - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - if(!aMaterial.contains(SubTag.NO_SMELTING)) { - if(!aMaterial.mBlastFurnaceRequired && !aMaterial.mDirectSmelting.mBlastFurnaceRequired) { - switch(aPrefix) { - case crushed: - case crushedPurified: - case crushedCentrifuged: - ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.nugget, (Object)aMaterial.mDirectSmelting, 10L); - if(tStack == null) { - tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L); - } - - GT_ModHandler.addSmeltingRecipe(aStack, tStack); - break; - default: - GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial.mDirectSmelting, 1L)); - } - } else { - GT_ModHandler.removeFurnaceSmelting(aStack); - GregTech_API.sRecipeAdder.addBlastRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), (ItemStack)null, aMaterial.mBlastFurnaceTemp > 1750?GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), 1L):GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), (ItemStack)null, Math.max(aMaterial.getMass() / 4, 1) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp); - if(aMaterial.mBlastFurnaceTemp <= 1000) { - GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.ingot, (Object)aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2); - } - } - } - - } + for (ItemStack aStack : entry.ores) + GT_ModHandler.addSmeltingRecipe(aStack, tStack); + break; + default: + for (ItemStack aStack : entry.ores) + GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L)); + } + } else if (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null) { + for (final ItemStack aStack : entry.ores) + RecipeHandler.scheduleSmeltingToRemove((in, out) -> in.isItemEqual(aStack)); + + ItemStack out = aMaterial.mBlastFurnaceTemp > 1750 + ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 1L) + : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L); + + if (out == null) { + System.err.println(aMaterial); + } + + RecipeMaps.BLAST_FURNANCE.factory() + .minTemperature(aMaterial.mBlastFurnaceTemp) + .EUt(120).duration(Math.max(aMaterial.getMass() / 4, 1) * aMaterial.mBlastFurnaceTemp) + .input(RecipeEntry.fromStacks(entry.ores, Match.STRICT)) + .output(out) + .buildAndRegister(); + if (aMaterial.mBlastFurnaceTemp <= 1000) { + for (ItemStack aStack : entry.ores) + GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1, aStack), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2); + } + } + } + } + } } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlank.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlank.java index 6025ac1..001d23c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlank.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlank.java @@ -24,8 +24,8 @@ public class ProcessingPlank implements IOreRecipeRegistrator { OrePrefixes.plank.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { if (aMaterial == Materials.Wood) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate1.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate1.java index 51380a2..2f2879c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate1.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate1.java @@ -19,7 +19,7 @@ public class ProcessingPlate1 implements IOreRecipeRegistrator { OrePrefixes.plate.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); GT_ModHandler.removeRecipe(new ItemStack[]{aStack}); if(aMaterial.mFuelPower > 0) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate2.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate2.java index 6e67a14..2ae9a35 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate2.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate2.java @@ -16,7 +16,7 @@ public class ProcessingPlate2 implements IOreRecipeRegistrator { OrePrefixes.plateDouble.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 24); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate3.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate3.java index d7f16b3..5d3a19c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate3.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate3.java @@ -16,7 +16,7 @@ public class ProcessingPlate3 implements IOreRecipeRegistrator { OrePrefixes.plateTriple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); if(!aMaterial.contains(SubTag.NO_SMASHING)) { GregTech_API.sRecipeAdder.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.plateDense, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 3, 1), 24); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate4.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate4.java index 5872262..8b54a4a 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate4.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate4.java @@ -16,7 +16,7 @@ public class ProcessingPlate4 implements IOreRecipeRegistrator { OrePrefixes.plateQuadruple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); GregTech_API.sRecipeAdder.addCNCRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), GT_OreDictUnificator.get(OrePrefixes.gearGt, (Object)aMaterial, 1L), Math.max(aMaterial.getMass() * 2, 1), 32); if(!aMaterial.contains(SubTag.NO_SMASHING) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammerquadrupleplate, OrePrefixes.plate.get(aMaterial), true)) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate5.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate5.java index 0688c4c..d580c9c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate5.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate5.java @@ -15,7 +15,7 @@ public class ProcessingPlate5 implements IOreRecipeRegistrator { OrePrefixes.plateQuintuple.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); if(!aMaterial.contains(SubTag.NO_SMASHING) && GregTech_API.sRecipeFile.get(GT_ConfigCategories.Tools.hammerquintupleplate, OrePrefixes.plate.get(aMaterial), true)) { GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[]{aStack}), new Object[]{"I", "B", "H", Character.valueOf('H'), GT_ToolDictNames.craftingToolHardHammer, Character.valueOf('I'), OrePrefixes.plateQuadruple.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial)}); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate9.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate9.java index a639f20..8280850 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate9.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlate9.java @@ -10,7 +10,7 @@ public class ProcessingPlate9 implements IOreRecipeRegistrator { OrePrefixes.plateDense.add((IOreRecipeRegistrator)this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { GT_ModHandler.removeRecipeByOutput(aStack); } } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlateAlloy.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlateAlloy.java index 271ff53..861ae04 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlateAlloy.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingPlateAlloy.java @@ -19,8 +19,8 @@ public class ProcessingPlateAlloy implements IOreRecipeRegistrator { OrePrefixes.plateAlloy.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) { if (entry.oreDictName.equals("plateAlloyCarbon")) { RecipeMaps.ASSEMBLING.factory().EUt(8).duration(6400) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRecycling.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRecycling.java index 9a39407..c5b75b4 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRecycling.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRecycling.java @@ -24,9 +24,9 @@ public class ProcessingRecycling implements IOreRecipeRegistrator { } } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { if (aPrefix != OrePrefixes.dust && aPrefix != OrePrefixes.crushed) { - for (OreDictEntry entry : dictEntry) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && aMaterial != Materials.Blaze) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRing.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRing.java index ca26153..320e3fd 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRing.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingRing.java @@ -21,8 +21,8 @@ public class ProcessingRing implements IOreRecipeRegistrator { OrePrefixes.ring.add((IOreRecipeRegistrator) this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSand.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSand.java index 889c5a3..e005986 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSand.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSand.java @@ -24,8 +24,8 @@ public class ProcessingSand implements IOreRecipeRegistrator { OrePrefixes.sand.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) { if (entry.oreDictName.equals("sandCracked")) { RecipeMaps.CENTRIFUGE.factory().EUt(5).duration(2500) diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSaplings.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSaplings.java index f872fb6..64576ab 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSaplings.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSaplings.java @@ -19,8 +19,8 @@ public class ProcessingSaplings implements IOreRecipeRegistrator { OrePrefixes.treeSapling.add((IOreRecipeRegistrator) this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { GT_ModHandler.addPulverisationRecipe(entry, 1, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L), null, 0); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingShaping.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingShaping.java index 18d325b..ddda307 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingShaping.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingShaping.java @@ -41,8 +41,8 @@ public class ProcessingShaping implements IOreRecipeRegistrator { OrePrefixes.ingot.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry e : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry e : entries) { Materials aMaterial = this.getMaterial(aPrefix, e); if (this.isExecutable(aPrefix, aMaterial) && GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null && !aMaterial.contains(SubTag.NO_SMELTING)) { int tAmount = (int)(aPrefix.mMaterialAmount / GregTech_API.MATERIAL_UNIT); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSlab.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSlab.java index cf54e77..cc4ea2c 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSlab.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingSlab.java @@ -25,8 +25,8 @@ public class ProcessingSlab implements IOreRecipeRegistrator { OrePrefixes.slab.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials mat = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, mat) && mat == Materials.Wood) { RecipeMaps.CANINNING.factory().EUt(4).duration(200).input(GT_ModHandler.getRCItem("fluid.creosote.bucket", 1L)).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).outputs(GT_ModHandler.getRCItem("part.tie.wood", 1L), new ItemStack(Items.bucket, 1)).buildAndRegister(); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStick.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStick.java index 3523caa..527ba18 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStick.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStick.java @@ -17,8 +17,8 @@ public class ProcessingStick implements IOreRecipeRegistrator { OrePrefixes.stick.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && (aMaterial.mTypes & 2) != 0) { RecipeMaps.CUTTING.factory().EUt(4).duration(aMaterial.getMass() * 2).input(RecipeEntry.fromStacks(entry.ores, Match.DAMAGE)).output(GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L)).buildAndRegister(); diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStone.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStone.java index c77fc4e..7fc3fd8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStone.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStone.java @@ -25,8 +25,8 @@ public class ProcessingStone implements IOreRecipeRegistrator { } @Override - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial)) { switch (aMaterial) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneCobble.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneCobble.java index b0d5d24..2e0a3fc 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneCobble.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneCobble.java @@ -21,8 +21,8 @@ public class ProcessingStoneCobble implements IOreRecipeRegistrator { } @Override - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry))) RecipeMaps.ASSEMBLING.factory().EUt(1).duration(400).input(OrePrefixes.stick, Materials.Wood).input(RecipeEntry.fromStacks(entry.ores, Match.STRICT)).output(new ItemStack(Blocks.lever, 1)).buildAndRegister(); } diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneVarious.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneVarious.java index 70f9071..544d103 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneVarious.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingStoneVarious.java @@ -26,8 +26,8 @@ public class ProcessingStoneVarious implements IOreRecipeRegistrator { OrePrefixes.stoneSmooth.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadAxe.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadAxe.java index a0ade1d..5995c69 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadAxe.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadAxe.java @@ -20,8 +20,8 @@ public class ProcessingToolHeadAxe implements IOreRecipeRegistrator { OrePrefixes.toolHeadAxe.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadFile.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadFile.java index 35f0bba..8818cc8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadFile.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadFile.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadFile implements IOreRecipeRegistrator { OrePrefixes.toolHeadFile.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHammer.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHammer.java index 6c2dcc2..d9e23f8 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHammer.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHammer.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadHammer implements IOreRecipeRegistrator { OrePrefixes.toolHeadHammer.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHoe.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHoe.java index 5cb0c14..8fbccf6 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHoe.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadHoe.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadHoe implements IOreRecipeRegistrator { OrePrefixes.toolHeadHoe.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadPickaxe.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadPickaxe.java index f43ad06..a584a99 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadPickaxe.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadPickaxe.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadPickaxe implements IOreRecipeRegistrator { OrePrefixes.toolHeadPickaxe.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSaw.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSaw.java index c0b98d4..e1d77e3 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSaw.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSaw.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadSaw implements IOreRecipeRegistrator { OrePrefixes.toolHeadSaw.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadShovel.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadShovel.java index 8acc8a2..aec2c77 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadShovel.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadShovel.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadShovel implements IOreRecipeRegistrator { OrePrefixes.toolHeadShovel.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSword.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSword.java index c73ea04..885a0e6 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSword.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingToolHeadSword.java @@ -19,8 +19,8 @@ public class ProcessingToolHeadSword implements IOreRecipeRegistrator { OrePrefixes.toolHeadSword.add(this); } - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { Materials aMaterial = this.getMaterial(aPrefix, entry); if (this.isExecutable(aPrefix, aMaterial) && !aMaterial.contains(SubTag.NO_SMASHING)) { for (ItemStack aStack : entry.ores) { diff --git a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingWax.java b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingWax.java index c728055..7cabdf1 100644 --- a/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingWax.java +++ b/src/main/java/gregtechmod/loaders/oreprocessing/ProcessingWax.java @@ -15,8 +15,8 @@ public class ProcessingWax implements IOreRecipeRegistrator { } @Override - public void registerOre(OrePrefixes aPrefix, List dictEntry) { - for (OreDictEntry entry : dictEntry) { + public void registerOre(OrePrefixes aPrefix, List entries) { + for (OreDictEntry entry : entries) { if (this.isExecutable(aPrefix, this.getMaterial(aPrefix, entry)) && entry.oreDictName.equals("waxMagical")) { RecipeMaps.MAGIC_FUELS.factory().EUt(6).duration(1).input(RecipeEntry.fromStacks(1, entry.ores)).buildAndRegister(); } diff --git a/src/main/java/gregtechmod/loaders/preload/GT_OreProcessingLoader.java b/src/main/java/gregtechmod/loaders/preload/GT_OreProcessingLoader.java index cf3b5ac..44af350 100644 --- a/src/main/java/gregtechmod/loaders/preload/GT_OreProcessingLoader.java +++ b/src/main/java/gregtechmod/loaders/preload/GT_OreProcessingLoader.java @@ -90,8 +90,8 @@ public class GT_OreProcessingLoader implements Runnable { new ProcessingLeaves(); new ProcessingLog(); new ProcessingNugget(); -// new ProcessingOre(); -// new ProcessingOreSmelting(); + new ProcessingOre(); + new ProcessingOreSmelting(); new ProcessingPlank(); // new ProcessingPlate1(); // new ProcessingPlate2();