From 7224ac4299098c70efae9dbd04c50a97e3f5f583 Mon Sep 17 00:00:00 2001 From: Blood Asp Date: Thu, 23 Apr 2015 18:14:22 +0200 Subject: Initial Commit --- .../loaders/oreprocessing/ProcessingAll.java | 32 +++ .../loaders/oreprocessing/ProcessingArrows.java | 55 +++++ .../loaders/oreprocessing/ProcessingBattery.java | 33 +++ .../loaders/oreprocessing/ProcessingBeans.java | 31 +++ .../loaders/oreprocessing/ProcessingBlock.java | 103 ++++++++++ .../loaders/oreprocessing/ProcessingBolt.java | 33 +++ .../loaders/oreprocessing/ProcessingCell.java | 108 ++++++++++ .../oreprocessing/ProcessingCellPlasma.java | 39 ++++ .../loaders/oreprocessing/ProcessingCircuit.java | 51 +++++ .../oreprocessing/ProcessingCompressed.java | 33 +++ .../loaders/oreprocessing/ProcessingCrafting.java | 87 ++++++++ .../loaders/oreprocessing/ProcessingCrop.java | 78 +++++++ .../ProcessingCrushedCentrifuged.java | 32 +++ .../oreprocessing/ProcessingCrushedPurified.java | 35 ++++ .../oreprocessing/ProcessingCrystallized.java | 33 +++ .../loaders/oreprocessing/ProcessingDirty.java | 53 +++++ .../loaders/oreprocessing/ProcessingDust.java | 227 +++++++++++++++++++++ .../oreprocessing/ProcessingDustImpure.java | 94 +++++++++ .../loaders/oreprocessing/ProcessingDustSmall.java | 45 ++++ .../loaders/oreprocessing/ProcessingDustTiny.java | 53 +++++ .../loaders/oreprocessing/ProcessingDye.java | 42 ++++ .../loaders/oreprocessing/ProcessingFoil.java | 28 +++ .../loaders/oreprocessing/ProcessingFood.java | 51 +++++ .../loaders/oreprocessing/ProcessingGear.java | 34 +++ .../loaders/oreprocessing/ProcessingGearSmall.java | 32 +++ .../loaders/oreprocessing/ProcessingGem.java | 80 ++++++++ .../oreprocessing/ProcessingGemChipped.java | 36 ++++ .../oreprocessing/ProcessingGemExquisite.java | 37 ++++ .../loaders/oreprocessing/ProcessingGemFlawed.java | 37 ++++ .../oreprocessing/ProcessingGemFlawless.java | 37 ++++ .../loaders/oreprocessing/ProcessingIngot1.java | 80 ++++++++ .../loaders/oreprocessing/ProcessingIngot2.java | 35 ++++ .../loaders/oreprocessing/ProcessingIngot3.java | 35 ++++ .../loaders/oreprocessing/ProcessingIngot4.java | 33 +++ .../loaders/oreprocessing/ProcessingIngot5.java | 33 +++ .../loaders/oreprocessing/ProcessingIngotHot.java | 30 +++ .../loaders/oreprocessing/ProcessingItem.java | 84 ++++++++ .../loaders/oreprocessing/ProcessingLeaves.java | 23 +++ .../loaders/oreprocessing/ProcessingLens.java | 34 +++ .../loaders/oreprocessing/ProcessingLog.java | 106 ++++++++++ .../loaders/oreprocessing/ProcessingNugget.java | 45 ++++ .../loaders/oreprocessing/ProcessingOre.java | 151 ++++++++++++++ .../loaders/oreprocessing/ProcessingOrePoor.java | 54 +++++ .../oreprocessing/ProcessingOreSmelting.java | 65 ++++++ .../loaders/oreprocessing/ProcessingPipeLarge.java | 33 +++ .../oreprocessing/ProcessingPipeMedium.java | 33 +++ .../oreprocessing/ProcessingPipeRestrictive.java | 35 ++++ .../loaders/oreprocessing/ProcessingPipeSmall.java | 33 +++ .../loaders/oreprocessing/ProcessingPlank.java | 73 +++++++ .../loaders/oreprocessing/ProcessingPlate1.java | 103 ++++++++++ .../loaders/oreprocessing/ProcessingPlate2.java | 54 +++++ .../loaders/oreprocessing/ProcessingPlate3.java | 54 +++++ .../loaders/oreprocessing/ProcessingPlate4.java | 53 +++++ .../loaders/oreprocessing/ProcessingPlate5.java | 50 +++++ .../loaders/oreprocessing/ProcessingPlate9.java | 30 +++ .../oreprocessing/ProcessingPlateAlloy.java | 44 ++++ .../loaders/oreprocessing/ProcessingPure.java | 34 +++ .../loaders/oreprocessing/ProcessingRecycling.java | 36 ++++ .../loaders/oreprocessing/ProcessingSand.java | 36 ++++ .../loaders/oreprocessing/ProcessingSaplings.java | 32 +++ .../loaders/oreprocessing/ProcessingShaping.java | 156 ++++++++++++++ .../loaders/oreprocessing/ProcessingSlab.java | 32 +++ .../loaders/oreprocessing/ProcessingStick.java | 38 ++++ .../loaders/oreprocessing/ProcessingStickLong.java | 36 ++++ .../loaders/oreprocessing/ProcessingStone.java | 84 ++++++++ .../oreprocessing/ProcessingStoneCobble.java | 36 ++++ .../oreprocessing/ProcessingStoneVarious.java | 42 ++++ .../oreprocessing/ProcessingToolHeadArrow.java | 32 +++ .../oreprocessing/ProcessingToolHeadAxe.java | 28 +++ .../oreprocessing/ProcessingToolHeadBuzzSaw.java | 32 +++ .../oreprocessing/ProcessingToolHeadChainsaw.java | 38 ++++ .../oreprocessing/ProcessingToolHeadDrill.java | 42 ++++ .../oreprocessing/ProcessingToolHeadFile.java | 33 +++ .../oreprocessing/ProcessingToolHeadHammer.java | 51 +++++ .../oreprocessing/ProcessingToolHeadHoe.java | 28 +++ .../oreprocessing/ProcessingToolHeadPickaxe.java | 28 +++ .../oreprocessing/ProcessingToolHeadPlow.java | 28 +++ .../oreprocessing/ProcessingToolHeadSaw.java | 28 +++ .../oreprocessing/ProcessingToolHeadSense.java | 28 +++ .../oreprocessing/ProcessingToolHeadShovel.java | 28 +++ .../oreprocessing/ProcessingToolHeadSword.java | 28 +++ .../ProcessingToolHeadUniversalSpade.java | 29 +++ .../oreprocessing/ProcessingToolHeadWrench.java | 42 ++++ .../oreprocessing/ProcessingTransforming.java | 58 ++++++ .../loaders/oreprocessing/ProcessingWax.java | 31 +++ .../loaders/oreprocessing/ProcessingWire01.java | 45 ++++ .../loaders/oreprocessing/ProcessingWire02.java | 35 ++++ .../loaders/oreprocessing/ProcessingWire04.java | 35 ++++ .../loaders/oreprocessing/ProcessingWire08.java | 35 ++++ .../loaders/oreprocessing/ProcessingWire12.java | 35 ++++ .../loaders/oreprocessing/ProcessingWire16.java | 31 +++ 91 files changed, 4462 insertions(+) create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingAll.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingBattery.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCell.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCellPlasma.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCrushedCentrifuged.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCrushedPurified.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDust.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDustImpure.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDustSmall.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDustTiny.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingDye.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingFood.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGear.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGearSmall.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGem.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGemChipped.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGemExquisite.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawed.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawless.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngot1.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngot2.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngot3.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngot4.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngot5.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingIngotHot.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingItem.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingLeaves.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingLens.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingLog.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingOre.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPipeLarge.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPipeMedium.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPipeRestrictive.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPipeSmall.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate1.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate2.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate3.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate4.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate5.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlate9.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPlateAlloy.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingPure.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingSand.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingStick.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingStone.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadArrow.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadAxe.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadBuzzSaw.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadChainsaw.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadDrill.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadFile.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHammer.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHoe.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPickaxe.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPlow.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSaw.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSense.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadShovel.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSword.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadUniversalSpade.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadWrench.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWax.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java create mode 100644 main/java/gregtech/loaders/oreprocessing/ProcessingWire16.java (limited to 'main/java/gregtech/loaders/oreprocessing') diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java b/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java new file mode 100644 index 0000000000..0098e1c7d9 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingAll.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import net.minecraft.item.Item; +/* 7: */ import net.minecraft.item.ItemBlock; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingAll +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingAll() +/* 14: */ { +/* 15:12 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 16:12 */ tPrefix.add(this); +/* 17: */ } +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:17 */ if (((aStack.getItem() instanceof ItemBlock)) && (aPrefix.mDefaultStackSize < aStack.getItem().getItemStackLimit(aStack))) { +/* 23:17 */ aStack.getItem().setMaxStackSize(aPrefix.mDefaultStackSize); +/* 24: */ } +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingAll + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java b/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java new file mode 100644 index 0000000000..00d1d8762a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingArrows.java @@ -0,0 +1,55 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enchants.Enchantment_EnderDamage; +/* 4: */ import gregtech.api.enums.GT_Values; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import gregtech.api.util.GT_Utility.ItemNBT; +/* 11: */ import net.minecraft.enchantment.Enchantment; +/* 12: */ import net.minecraft.enchantment.EnchantmentHelper; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class ProcessingArrows +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingArrows() +/* 19: */ { +/* 20:17 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 21:17 */ if (tPrefix.name().startsWith("arrowGt")) { +/* 22:17 */ tPrefix.add(this); +/* 23: */ } +/* 24: */ } +/* 25: */ } +/* 26: */ +/* 27: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 28: */ { +/* 29:23 */ ItemStack tOutput = GT_Utility.copyAmount(1L, new Object[] { aStack });GT_Utility.updateItemStack(tOutput); +/* 30:24 */ GT_Utility.ItemNBT.addEnchantment(tOutput, Enchantment.smite, EnchantmentHelper.getEnchantmentLevel(Enchantment.smite.effectId, tOutput) + 3); +/* 31:25 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.HolyWater.getFluid(25L), tOutput, null, null, null, 100, 2); +/* 32: */ +/* 33:27 */ tOutput = GT_Utility.copyAmount(1L, new Object[] { aStack });GT_Utility.updateItemStack(tOutput); +/* 34:28 */ GT_Utility.ItemNBT.addEnchantment(tOutput, Enchantment.fireAspect, EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, tOutput) + 3); +/* 35:29 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.FierySteel.getFluid(25L), tOutput, null, null, null, 100, 2); +/* 36: */ +/* 37:31 */ tOutput = GT_Utility.copyAmount(1L, new Object[] { aStack });GT_Utility.updateItemStack(tOutput); +/* 38:32 */ GT_Utility.ItemNBT.addEnchantment(tOutput, Enchantment.fireAspect, EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, tOutput) + 1); +/* 39:33 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Blaze.getMolten(18L), tOutput, null, null, null, 100, 2); +/* 40: */ +/* 41:35 */ tOutput = GT_Utility.copyAmount(1L, new Object[] { aStack });GT_Utility.updateItemStack(tOutput); +/* 42:36 */ GT_Utility.ItemNBT.addEnchantment(tOutput, Enchantment.knockback, EnchantmentHelper.getEnchantmentLevel(Enchantment.knockback.effectId, tOutput) + 1); +/* 43:37 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Rubber.getMolten(18L), tOutput, null, null, null, 100, 2); +/* 44: */ +/* 45:39 */ tOutput = GT_Utility.copyAmount(1L, new Object[] { aStack });GT_Utility.updateItemStack(tOutput); +/* 46:40 */ GT_Utility.ItemNBT.addEnchantment(tOutput, Enchantment_EnderDamage.INSTANCE, EnchantmentHelper.getEnchantmentLevel(Enchantment_EnderDamage.INSTANCE.effectId, tOutput) + 1); +/* 47:41 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Mercury.getFluid(25L), tOutput, null, null, null, 100, 2); +/* 48: */ } +/* 49: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingArrows + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingBattery.java b/main/java/gregtech/loaders/oreprocessing/ProcessingBattery.java new file mode 100644 index 0000000000..491fc8ed85 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingBattery.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingBattery +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingBattery() +/* 17: */ { +/* 18:16 */ OrePrefixes.battery.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:21 */ if (aMaterial == Materials.Lithium) { +/* 24:22 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getIC2Item("cropnalyzer", 1L, 32767), ItemList.Tool_Scanner.getAlmostBroken(1L, new Object[0]), 12800, 16); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingBattery + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java b/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java new file mode 100644 index 0000000000..0db3ea72f0 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingBeans.java @@ -0,0 +1,31 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.api.util.GT_OreDictUnificator; +/* 8: */ import gregtech.api.util.GT_Utility; +/* 9: */ import net.minecraft.item.ItemStack; +/* 10: */ +/* 11: */ public class ProcessingBeans +/* 12: */ implements IOreRecipeRegistrator +/* 13: */ { +/* 14: */ public ProcessingBeans() +/* 15: */ { +/* 16:14 */ OrePrefixes.beans.add(this); +/* 17: */ } +/* 18: */ +/* 19: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 20: */ { +/* 21:19 */ if (aOreDictName.equals("beansCocoa")) { +/* 22:19 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L)); +/* 23: */ } +/* 24: */ } +/* 25: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingBeans + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java b/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java new file mode 100644 index 0000000000..041899799a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingBlock.java @@ -0,0 +1,103 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Recipes; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 10: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 11: */ import gregtech.api.util.GT_Config; +/* 12: */ import gregtech.api.util.GT_ModHandler; +/* 13: */ import gregtech.api.util.GT_OreDictUnificator; +/* 14: */ import gregtech.api.util.GT_Utility; + +/* 15: */ import java.io.PrintStream; + +/* 16: */ import net.minecraft.item.ItemStack; +/* 17: */ +/* 18: */ public class ProcessingBlock +/* 19: */ implements IOreRecipeRegistrator +/* 20: */ { +/* 21: */ public ProcessingBlock() +/* 22: */ { +/* 23:19 */ OrePrefixes.block.add(this); +/* 24: */ } +/* 25: */ +/* 26: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 27: */ { +/* 28:24 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 9L), null, (int)Math.max(aMaterial.getMass() * 10L, 1L), 30); +/* 29: */ +/* 30:26 */ ItemStack tStack1 = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L);ItemStack tStack2 = GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L);ItemStack tStack3 = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L); +/* 31: */ +/* 32:28 */ GT_ModHandler.removeRecipe(new ItemStack[] { GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 33:30 */ if (tStack1 != null) { +/* 34:30 */ GT_ModHandler.removeRecipe(new ItemStack[] { tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1, tStack1 }); +/* 35: */ } +/* 36:31 */ if (tStack2 != null) { +/* 37:31 */ GT_ModHandler.removeRecipe(new ItemStack[] { tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2, tStack2 }); +/* 38: */ } +/* 39:32 */ if (tStack3 != null) { +/* 40:32 */ GT_ModHandler.removeRecipe(new ItemStack[] { tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3, tStack3 }); +/* 41: */ } +/* 42:34 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 43:34 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Block.get(0L, new Object[0]), aMaterial.getMolten(1296L), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), 288, 8); +/* 44: */ } +/* 45:36 */ if (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.storageblockcrafting, OrePrefixes.block.get(aMaterial).toString(), false)) +/* 46: */ { +/* 47:37 */ if ((tStack1 == null) && (tStack2 == null) && (tStack3 != null)) { +/* 48:37 */ GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), new Object[] { "XXX", "XXX", "XXX", Character.valueOf('X'), OrePrefixes.dust.get(aMaterial) }); +/* 49: */ } +/* 50:38 */ if (tStack2 != null) { +/* 51:38 */ GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), new Object[] { "XXX", "XXX", "XXX", Character.valueOf('X'), OrePrefixes.gem.get(aMaterial) }); +/* 52: */ } +/* 53:39 */ if (tStack1 != null) { +/* 54:39 */ GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L), new Object[] { "XXX", "XXX", "XXX", Character.valueOf('X'), OrePrefixes.ingot.get(aMaterial) }); +/* 55: */ } +/* 56: */ } +/* 57:42 */ if (tStack1 != null) { +/* 58:42 */ tStack1.stackSize = 9; +/* 59: */ } +/* 60:43 */ if (tStack2 != null) { +/* 61:43 */ tStack2.stackSize = 9; +/* 62: */ } +/* 63:44 */ if (tStack3 != null) { +/* 64:44 */ tStack3.stackSize = 9; +/* 65: */ } +/* 66:46 */ GT_Values.RA.addForgeHammerRecipe(aStack, tStack2, 100, 24); +/* 67:48 */ if (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.storageblockdecrafting, OrePrefixes.block.get(aMaterial).toString(), tStack2 != null)) +/* 68: */ { +/* 69:49 */ if (tStack3 != null) { +/* 70:49 */ GT_ModHandler.addShapelessCraftingRecipe(tStack3, new Object[] { OrePrefixes.block.get(aMaterial) }); +/* 71: */ } +/* 72:50 */ if (tStack2 != null) { +/* 73:50 */ GT_ModHandler.addShapelessCraftingRecipe(tStack2, new Object[] { OrePrefixes.block.get(aMaterial) }); +/* 74: */ } +/* 75:51 */ if (tStack1 != null) { +/* 76:51 */ GT_ModHandler.addShapelessCraftingRecipe(tStack1, new Object[] { OrePrefixes.block.get(aMaterial) }); +/* 77: */ } +/* 78: */ } +/* 79:54 */ switch (aMaterial.ordinal()) +/* 80: */ { +/* 81: */ case 1: +/* 82:56 */ System.err.println("'blockQuickSilver'?, In which Ice Desert can you actually place this as a solid Block?"); +/* 83:57 */ break; +/* 84: */ case 2: +/* 85: */ case 3: +/* 86:59 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Rod.get(0L, new Object[0]), ItemList.IC2_ShaftIron.get(1L, new Object[0]), 640, 120); +/* 87:60 */ GT_Values.RA.addAssemblerRecipe(ItemList.IC2_Compressed_Coal_Ball.get(8L, new Object[0]), GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.IC2_Compressed_Coal_Chunk.get(1L, new Object[0]), 400, 4); +/* 88:61 */ break; +/* 89: */ case 4: +/* 90:63 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Rod.get(0L, new Object[0]), ItemList.IC2_ShaftSteel.get(1L, new Object[0]), 1280, 120); +/* 91:64 */ GT_Values.RA.addAssemblerRecipe(ItemList.IC2_Compressed_Coal_Ball.get(8L, new Object[0]), GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.IC2_Compressed_Coal_Chunk.get(1L, new Object[0]), 400, 4); +/* 92: */ } +/* 93: */ } +/* 94: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingBlock + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java b/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java new file mode 100644 index 0000000000..fba70c47ce --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingBolt.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingBolt +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingBolt() +/* 17: */ { +/* 18:15 */ OrePrefixes.bolt.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 24:20 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.screw, aMaterial, 1L), null, (int)Math.max(aMaterial.getMass() / 8L, 1L), 4); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingBolt + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java new file mode 100644 index 0000000000..2b1218cca0 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java @@ -0,0 +1,108 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.objects.MaterialStack; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import java.util.ArrayList; +/* 14: */ import java.util.Iterator; +/* 15: */ import java.util.List; +/* 16: */ import net.minecraft.item.ItemStack; +/* 17: */ +/* 18: */ public class ProcessingCell +/* 19: */ implements IOreRecipeRegistrator +/* 20: */ { +/* 21: */ public ProcessingCell() +/* 22: */ { +/* 23:21 */ OrePrefixes.cell.add(this); +/* 24: */ } +/* 25: */ +/* 26: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 27: */ { +/* 28:26 */ if (aMaterial == Materials.Empty) +/* 29: */ { +/* 30:27 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 31:28 */ if (aModName.equalsIgnoreCase("AtomicScience")) { +/* 32:28 */ GT_ModHandler.addExtractionRecipe(ItemList.Cell_Empty.get(1L, new Object[0]), aStack); +/* 33: */ } +/* 34: */ } +/* 35: */ else +/* 36: */ { +/* 37:30 */ if (aMaterial.mFuelPower > 0) { +/* 38:30 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.getFluidForFilledItem(aStack, true) == null ? GT_Utility.getContainerItem(aStack, true) : null, aMaterial.mFuelPower, aMaterial.mFuelType); +/* 39: */ } +/* 40:32 */ if ((aMaterial.mMaterialList.size() > 0) && ((aMaterial.mExtraData & 0x3) != 0)) +/* 41: */ { +/* 42:33 */ int tAllAmount = 0; +/* 43: */ MaterialStack tMat2; +/* 44:34 */ for (Iterator i$ = aMaterial.mMaterialList.iterator(); i$.hasNext(); tAllAmount = (int)(tAllAmount + tMat2.mAmount)) { +/* 45:34 */ tMat2 = (MaterialStack)i$.next(); +/* 46: */ } +/* 47:35 */ long tItemAmount = 0L;long tCapsuleCount = GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { aStack }) * -tAllAmount;long tDensityMultiplier = aMaterial.getDensity() > 3628800L ? aMaterial.getDensity() / 3628800L : 1L; +/* 48:36 */ ArrayList tList = new ArrayList(); +/* 49:38 */ for ( MaterialStack tMat : aMaterial.mMaterialList) { +/* 50:38 */ if (tMat.mAmount > 0L) +/* 51: */ { +/* 53: */ ItemStack tStack; +/* 54:39 */ if (tMat.mMaterial == Materials.Air) +/* 55: */ { +/* 56:40 */ tStack = ItemList.Cell_Air.get(tMat.mAmount * tDensityMultiplier / 2L, new Object[0]); +/* 57: */ } +/* 58: */ else +/* 59: */ { +/* 60:42 */ tStack = GT_OreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount); +/* 61:43 */ if (tStack == null) { +/* 62:44 */ tStack = GT_OreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount); +/* 63: */ } +/* 64: */ } +/* 65:46 */ if (tItemAmount + tMat.mAmount * 3628800L <= aStack.getMaxStackSize() * aMaterial.getDensity()) +/* 66: */ { +/* 67:47 */ tItemAmount += tMat.mAmount * 3628800L; +/* 68:48 */ if (tStack != null) +/* 69: */ { +/* 70:49 */ ItemStack tmp397_395 = tStack;tmp397_395.stackSize = ((int)(tmp397_395.stackSize * tDensityMultiplier)); +/* 71:50 */ while ((tStack.stackSize > 64) && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64 < 0L ? tList.size() < 5 : tList.size() < 6) && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64 <= 64L)) +/* 72: */ { +/* 73:51 */ tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64; +/* 74:52 */ tList.add(GT_Utility.copyAmount(64L, new Object[] { tStack })); +/* 75:53 */ tStack.stackSize -= 64; +/* 76: */ } +/* 77:55 */ if (tStack.stackSize > 0) { +/* 78:55 */ if (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { tStack }) <= 64L) { +/* 79:55 */ if (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { tStack }) < 0L ? tList.size() < 5 : tList.size() < 6) +/* 80: */ { +/* 81:56 */ tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { tStack }); +/* 82:57 */ tList.add(tStack); +/* 83: */ } +/* 84: */ } +/* 85: */ } +/* 86: */ } +/* 87: */ } +/* 88: */ } +/* 89: */ } +/* 90:62 */ tItemAmount = (tItemAmount * tDensityMultiplier % aMaterial.getDensity() > 0L ? 1 : 0) + tItemAmount * tDensityMultiplier / aMaterial.getDensity(); +/* 91:63 */ if (tList.size() > 0) +/* 92: */ { +/* 93:64 */ if ((aMaterial.mExtraData & 0x1) != 0) { +/* 94:64 */ GT_Values.RA.addElectrolyzerRecipe(GT_Utility.copyAmount(tItemAmount, new Object[] { aStack }), tCapsuleCount > 0L ? (int)tCapsuleCount : 0, (ItemStack)tList.get(0), tList.size() < 2 ? null : (ItemStack)tList.get(1), tList.size() < 3 ? null : (ItemStack)tList.get(2), tList.size() < 4 ? null : (ItemStack)tList.get(3), tList.size() < 5 ? null : (ItemStack)tList.get(4), tList.size() < 6 ? null : tCapsuleCount < 0L ? ItemList.Cell_Empty.get(-tCapsuleCount, new Object[0]) : (ItemStack)tList.get(5), (int)Math.max(1L, Math.abs(aMaterial.getProtons() * 8L * tItemAmount)), Math.min(4, tList.size()) * 30); +/* 95: */ } +/* 96:65 */ if ((aMaterial.mExtraData & 0x2) != 0) { +/* 97:65 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(tItemAmount, new Object[] { aStack }), tCapsuleCount > 0L ? (int)tCapsuleCount : 0, (ItemStack)tList.get(0), tList.size() < 2 ? null : (ItemStack)tList.get(1), tList.size() < 3 ? null : (ItemStack)tList.get(2), tList.size() < 4 ? null : (ItemStack)tList.get(3), tList.size() < 5 ? null : (ItemStack)tList.get(4), tList.size() < 6 ? null : tCapsuleCount < 0L ? ItemList.Cell_Empty.get(-tCapsuleCount, new Object[0]) : (ItemStack)tList.get(5), (int)Math.max(1L, Math.abs(aMaterial.getMass() * 2L * tItemAmount))); +/* 98: */ } +/* 99: */ } +/* :0: */ } +/* :1: */ } +/* :2: */ } +/* :3: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCell + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCellPlasma.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCellPlasma.java new file mode 100644 index 0000000000..f025410031 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCellPlasma.java @@ -0,0 +1,39 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingCellPlasma +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingCellPlasma() +/* 17: */ { +/* 18:15 */ OrePrefixes.cellPlasma.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (aMaterial == Materials.Empty) +/* 24: */ { +/* 25:21 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 26: */ } +/* 27: */ else +/* 28: */ { +/* 29:23 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.getFluidForFilledItem(aStack, true) == null ? GT_Utility.getContainerItem(aStack, true) : null, (int)Math.max(1024L, 1024L * aMaterial.getMass()), 4); +/* 30:24 */ GT_Values.RA.addVacuumFreezerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L)); +/* 31: */ } +/* 32: */ } +/* 33: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCellPlasma + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java new file mode 100644 index 0000000000..3880140b5e --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCircuit.java @@ -0,0 +1,51 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.ItemList; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OreDictNames; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingCircuit +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingCircuit() +/* 16: */ { +/* 17:14 */ OrePrefixes.circuit.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:19 */ switch (aMaterial.ordinal()) +/* 23: */ { +/* 24: */ case 1: +/* 25: */ case 2: +/* 26: */ case 3: +/* 27: */ case 4: +/* 28: */ case 5: +/* 29: */ case 6: +/* 30:21 */ if (!GT_OreDictUnificator.isBlacklisted(aStack)) { +/* 31:21 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 32: */ } +/* 33: */ break; +/* 34: */ case 7: +/* 35:24 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 36:25 */ GT_ModHandler.addShapelessCraftingRecipe(ItemList.Circuit_Primitive.get(1L, new Object[0]), new Object[] { GT_ModHandler.getIC2Item("casingadviron", 1L), OrePrefixes.wireGt01.get(Materials.RedAlloy), OrePrefixes.wireGt01.get(Materials.RedAlloy), OrePrefixes.wireGt01.get(Materials.Tin) }); +/* 37:26 */ break; +/* 38: */ case 8: +/* 39:28 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 40:29 */ GT_ModHandler.addCraftingRecipe(ItemList.Circuit_Basic.get(1L, new Object[0]), new Object[] { "WWW", "CPC", "WWW", Character.valueOf('C'), OrePrefixes.circuit.get(Materials.Primitive), Character.valueOf('W'), OreDictNames.craftingWireCopper, Character.valueOf('P'), OrePrefixes.plate.get(Materials.Steel) }); +/* 41:30 */ GT_ModHandler.addCraftingRecipe(ItemList.Circuit_Basic.get(1L, new Object[0]), new Object[] { "WCW", "WPW", "WCW", Character.valueOf('C'), OrePrefixes.circuit.get(Materials.Primitive), Character.valueOf('W'), OreDictNames.craftingWireCopper, Character.valueOf('P'), OrePrefixes.plate.get(Materials.Steel) }); +/* 42:31 */ GT_ModHandler.addShapelessCraftingRecipe(ItemList.Circuit_Basic.get(1L, new Object[0]), new Object[] { ItemList.Circuit_Integrated.getWildcard(1L, new Object[0]) }); +/* 43: */ } +/* 44: */ } +/* 45: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCircuit + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java new file mode 100644 index 0000000000..7908db52df --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCompressed.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.objects.GT_RenderedTexture; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingCompressed +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingCompressed() +/* 17: */ { +/* 18:17 */ OrePrefixes.compressed.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:22 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 24:23 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[72], aMaterial.mRGBa, false), null); +/* 25:24 */ GT_RecipeRegistrator.registerUsagesForMaterials(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, false); +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCompressed + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java new file mode 100644 index 0000000000..cf0adcf12d --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java @@ -0,0 +1,87 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OreDictNames; +/* 7: */ import gregtech.api.enums.OrePrefixes; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.init.Blocks; +/* 14: */ import net.minecraft.init.Items; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class ProcessingCrafting +/* 18: */ implements IOreRecipeRegistrator +/* 19: */ { +/* 20: */ public ProcessingCrafting() +/* 21: */ { +/* 22:19 */ OrePrefixes.crafting.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:24 */ if (aOreDictName.equals(OreDictNames.craftingQuartz.toString())) +/* 28: */ { +/* 29:25 */ GT_Values.RA.addAssemblerRecipe(new ItemStack(Blocks.redstone_torch, 3, 32767), GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Concrete.getMolten(144L), new ItemStack(Items.comparator, 1, 0), 800, 1); +/* 30: */ } +/* 31:26 */ else if (aOreDictName.equals(OreDictNames.craftingWireCopper.toString())) +/* 32: */ { +/* 33:27 */ GT_Values.RA.addAssemblerRecipe(ItemList.Circuit_Basic.get(1L, new Object[0]), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getIC2Item("frequencyTransmitter", 1L), 800, 1); +/* 34: */ } +/* 35:28 */ else if (aOreDictName.equals(OreDictNames.craftingWireTin.toString())) +/* 36: */ { +/* 37:29 */ GT_Values.RA.addAssemblerRecipe(ItemList.Circuit_Basic.get(1L, new Object[0]), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getIC2Item("frequencyTransmitter", 1L), 800, 1); +/* 38: */ } +/* 39:30 */ else if (aOreDictName.equals(OreDictNames.craftingLensBlue.toString())) +/* 40: */ { +/* 41:31 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 13), 2000, 1920); +/* 42:32 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 13), 2000, 1920); +/* 43:33 */ GT_Values.RA.addLaserEngraverRecipe(ItemList.IC2_LapotronCrystal.getWildcard(1L, new Object[0]), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Crystal_Chip_Master.get(3L, new Object[0]), 256, 480); +/* 44: */ } +/* 45:34 */ else if (aOreDictName.equals(OreDictNames.craftingLensYellow.toString())) +/* 46: */ { +/* 47:35 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 14), 2000, 1920); +/* 48:36 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 14), 2000, 1920); +/* 49: */ } +/* 50:37 */ else if (aOreDictName.equals(OreDictNames.craftingLensCyan.toString())) +/* 51: */ { +/* 52:38 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 15), 2000, 1920); +/* 53:39 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 15), 2000, 1920); +/* 54: */ } +/* 55:40 */ else if (aOreDictName.equals(OreDictNames.craftingLensRed.toString())) +/* 56: */ { +/* 57:41 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Redstone, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("BuildCraft|Silicon", "redstoneChipset", 1L, 0), 50, 120); +/* 58: */ +/* 59:43 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Copper, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Wiring_Basic.get(1L, new Object[0]), 64, 30); +/* 60:44 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.AnnealedCopper, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Wiring_Basic.get(1L, new Object[0]), 64, 30); +/* 61:45 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Gold, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Wiring_Advanced.get(1L, new Object[0]), 64, 120); +/* 62:46 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Electrum, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Wiring_Advanced.get(1L, new Object[0]), 64, 120); +/* 63:47 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Platinum, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Wiring_Elite.get(1L, new Object[0]), 64, 480); +/* 64: */ } +/* 65:48 */ else if (aOreDictName.equals(OreDictNames.craftingLensGreen.toString())) +/* 66: */ { +/* 67:49 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Olivine, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Crystal_Chip_Elite.get(1L, new Object[0]), 256, 480); +/* 68:50 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Emerald, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), ItemList.Circuit_Parts_Crystal_Chip_Elite.get(1L, new Object[0]), 256, 480); +/* 69: */ } +/* 70:51 */ else if (aOreDictName.equals(OreDictNames.craftingLensWhite.toString())) +/* 71: */ { +/* 72:52 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.Iron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 19), 2000, 1920); +/* 73:53 */ GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.block, Materials.WroughtIron, 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 19), 2000, 1920); +/* 74: */ +/* 75:55 */ GT_Values.RA.addLaserEngraverRecipe(new ItemStack(Blocks.sandstone, 1, 2), GT_Utility.copyAmount(0L, new Object[] { aStack }), new ItemStack(Blocks.sandstone, 1, 1), 50, 16); +/* 76:56 */ GT_Values.RA.addLaserEngraverRecipe(new ItemStack(Blocks.stone, 1, 0), GT_Utility.copyAmount(0L, new Object[] { aStack }), new ItemStack(Blocks.stonebrick, 1, 3), 50, 16); +/* 77:57 */ GT_Values.RA.addLaserEngraverRecipe(new ItemStack(Blocks.quartz_block, 1, 0), GT_Utility.copyAmount(0L, new Object[] { aStack }), new ItemStack(Blocks.quartz_block, 1, 1), 50, 16); +/* 78:58 */ GT_Values.RA.addLaserEngraverRecipe(GT_ModHandler.getModItem("appliedenergistics2", "tile.BlockQuartz", 1L), GT_Utility.copyAmount(0L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "tile.BlockQuartzChiseled", 1L), 50, 16); +/* 79: */ } +/* 80: */ } +/* 81: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCrafting + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java new file mode 100644 index 0000000000..443b271a48 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCrop.java @@ -0,0 +1,78 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ import net.minecraftforge.fluids.FluidRegistry; +/* 14: */ import net.minecraftforge.fluids.FluidStack; +/* 15: */ +/* 16: */ public class ProcessingCrop +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingCrop() +/* 20: */ { +/* 21:17 */ OrePrefixes.crop.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:22 */ GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.IC2_PlantballCompressed.get(1L, new Object[0])); +/* 27:23 */ if (aOreDictName.equals("cropTea")) +/* 28: */ { +/* 29:24 */ GT_Values.RA.addBrewingRecipe(aStack, FluidRegistry.WATER, FluidRegistry.getFluid("potion.tea"), false); +/* 30:25 */ GT_Values.RA.addBrewingRecipe(aStack, GT_ModHandler.getDistilledWater(1L).getFluid(), FluidRegistry.getFluid("potion.tea"), false); +/* 31: */ } +/* 32:26 */ else if (aOreDictName.equals("cropGrape")) +/* 33: */ { +/* 34:27 */ GT_Values.RA.addBrewingRecipe(aStack, FluidRegistry.WATER, FluidRegistry.getFluid("potion.grapejuice"), false); +/* 35:28 */ GT_Values.RA.addBrewingRecipe(aStack, GT_ModHandler.getDistilledWater(1L).getFluid(), FluidRegistry.getFluid("potion.grapejuice"), false); +/* 36: */ } +/* 37:29 */ else if (aOreDictName.equals("cropChilipepper")) +/* 38: */ { +/* 39:30 */ GT_ModHandler.addPulverisationRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chili, 1L)); +/* 40: */ } +/* 41:31 */ else if (aOreDictName.equals("cropCoffee")) +/* 42: */ { +/* 43:32 */ GT_ModHandler.addPulverisationRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coffee, 1L)); +/* 44: */ } +/* 45:33 */ else if (aOreDictName.equals("cropPotato")) +/* 46: */ { +/* 47:34 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Raw_PotatoChips.get(1L, new Object[0]), 64, 4); +/* 48:35 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Stripes.get(0L, new Object[0]), ItemList.Food_Raw_Fries.get(1L, new Object[0]), 64, 4); +/* 49:36 */ GT_Values.RA.addBrewingRecipe(aStack, FluidRegistry.WATER, FluidRegistry.getFluid("potion.potatojuice"), true); +/* 50:37 */ GT_Values.RA.addBrewingRecipe(aStack, GT_ModHandler.getDistilledWater(1L).getFluid(), FluidRegistry.getFluid("potion.potatojuice"), true); +/* 51: */ } +/* 52:38 */ else if (aOreDictName.equals("cropLemon")) +/* 53: */ { +/* 54:39 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Sliced_Lemon.get(4L, new Object[0]), 64, 4); +/* 55:40 */ GT_Values.RA.addBrewingRecipe(aStack, FluidRegistry.WATER, FluidRegistry.getFluid("potion.lemonjuice"), false); +/* 56:41 */ GT_Values.RA.addBrewingRecipe(aStack, GT_ModHandler.getDistilledWater(1L).getFluid(), FluidRegistry.getFluid("potion.lemonjuice"), false); +/* 57:42 */ GT_Values.RA.addBrewingRecipe(aStack, FluidRegistry.getFluid("potion.vodka"), FluidRegistry.getFluid("potion.leninade"), true); +/* 58: */ } +/* 59:43 */ else if (aOreDictName.equals("cropTomato")) +/* 60: */ { +/* 61:44 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Sliced_Tomato.get(4L, new Object[0]), 64, 4); +/* 62: */ } +/* 63:45 */ else if (aOreDictName.equals("cropCucumber")) +/* 64: */ { +/* 65:46 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Sliced_Cucumber.get(4L, new Object[0]), 64, 4); +/* 66: */ } +/* 67:47 */ else if (aOreDictName.equals("cropOnion")) +/* 68: */ { +/* 69:48 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Sliced_Onion.get(4L, new Object[0]), 64, 4); +/* 70: */ } +/* 71: */ } +/* 72: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCrop + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedCentrifuged.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedCentrifuged.java new file mode 100644 index 0000000000..e246d84625 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedCentrifuged.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingCrushedCentrifuged +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingCrushedCentrifuged() +/* 17: */ { +/* 18:15 */ OrePrefixes.crushedCentrifuged.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), 10, 16); +/* 24:21 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, GT_Utility.selectItemInList(2, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L), 10, false); +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCrushedCentrifuged + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedPurified.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedPurified.java new file mode 100644 index 0000000000..5af5f1a253 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCrushedPurified.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingCrushedPurified +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingCrushedPurified() +/* 17: */ { +/* 18:15 */ OrePrefixes.crushedPurified.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_ModHandler.addThermalCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), (int)Math.min(5000L, Math.abs(aMaterial.getMass() * 20L)), new Object[] { GT_OreDictUnificator.get(OrePrefixes.crushedCentrifuged, aMaterial.mMacerateInto, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L) }); +/* 24:21 */ ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L); +/* 25:22 */ if (tGem != null) { +/* 26:22 */ GT_Values.RA.addSifterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, tGem, 1L), GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, tGem, 1L), tGem, GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, tGem, 1L), GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, tGem, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, tGem, 1L) }, new int[] { 100, 400, 1500, 2000, 4000, 5000 }, 800, 16); +/* 27: */ } +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCrushedPurified + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java b/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java new file mode 100644 index 0000000000..c6fc1088ce --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingCrystallized.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingCrystallized +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingCrystallized() +/* 17: */ { +/* 18:15 */ OrePrefixes.crystal.add(this); +/* 19:16 */ OrePrefixes.crystalline.add(this); +/* 20: */ } +/* 21: */ +/* 22: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 23: */ { +/* 24:21 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), 10, 16); +/* 25:22 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), null, 10, false); +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingCrystallized + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java new file mode 100644 index 0000000000..2c41f5a250 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDirty.java @@ -0,0 +1,53 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingDirty +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17: */ public ProcessingDirty() +/* 18: */ { +/* 19:16 */ OrePrefixes.clump.add(this); +/* 20:17 */ OrePrefixes.shard.add(this); +/* 21:18 */ OrePrefixes.crushed.add(this); +/* 22:19 */ OrePrefixes.dirtyGravel.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:24 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial.mMacerateInto, 1L), 10, 16); +/* 28:25 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial.mMacerateInto, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), 1L), GT_OreDictUnificator.get(OrePrefixes.dust, GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L), 10, false); +/* 29:26 */ GT_ModHandler.addOreWasherRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), 1000, new Object[] { GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, GT_Utility.selectItemInList(0, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L) }); +/* 30:27 */ GT_ModHandler.addThermalCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), (int)Math.min(5000L, Math.abs(aMaterial.getMass() * 20L)), new Object[] { GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedCentrifuged : OrePrefixes.dust, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L) }); +/* 31:29 */ if (aMaterial.contains(SubTag.WASHING_MERCURY)) { +/* 32:29 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Mercury.getFluid(1000L), GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new int[] { 10000, 7000, 4000 }, 800, 8); +/* 33: */ } +/* 34:30 */ if (aMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { +/* 35:30 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.SodiumPersulfate.getFluid(1000L), GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new int[] { 10000, 7000, 4000 }, 800, 8); +/* 36: */ } +/* 37:31 */ for (Materials tMaterial : aMaterial.mOreByProducts) +/* 38: */ { +/* 39:32 */ if (tMaterial.contains(SubTag.WASHING_MERCURY)) { +/* 40:32 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Mercury.getFluid(1000L), GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial.mMacerateInto, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new int[] { 10000, 7000, 4000 }, 800, 8); +/* 41: */ } +/* 42:33 */ if (tMaterial.contains(SubTag.WASHING_SODIUMPERSULFATE)) { +/* 43:33 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.SodiumPersulfate.getFluid(1000L), GT_OreDictUnificator.get(aPrefix == OrePrefixes.crushed ? OrePrefixes.crushedPurified : OrePrefixes.dustPure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial.mMacerateInto, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new int[] { 10000, 7000, 4000 }, 800, 8); +/* 44: */ } +/* 45: */ } +/* 46: */ } +/* 47: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingDirty + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java new file mode 100644 index 0000000000..6dc4ebee09 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDust.java @@ -0,0 +1,227 @@ +package gregtech.loaders.oreprocessing; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.ConfigCategories.Recipes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.interfaces.internal.IGT_RecipeAdder; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeRegistrator; +import gregtech.api.util.GT_Utility; + +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +public class ProcessingDust + implements IOreRecipeRegistrator +{ + public ProcessingDust() + { + OrePrefixes.dust.add(this); + } + + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) + { + if (aMaterial.mFuelPower > 0) { + GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower, aMaterial.mFuelType); + } + if (GT_Utility.getFluidForFilledItem(GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), true) == null) { + GT_Values.RA.addCannerRecipe(aStack, ItemList.Cell_Empty.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L), null, 100, 1); + } + GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), ItemList.Crate_Empty.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.crateGtDust, aMaterial, 1L), 100, 8); + GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.crateGtDust, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 16L), ItemList.Crate_Empty.get(1L, new Object[0]), 800, 1); + if (!aMaterial.mBlastFurnaceRequired) + { + GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); + if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { + GT_RecipeRegistrator.registerReverseArcSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack }), aMaterial, aPrefix.mMaterialAmount, null, null, null); + } + } + ItemStack tStack; + if ((null != (tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L))) && (!aMaterial.contains(SubTag.NO_SMELTING))) + { + if (aMaterial.mBlastFurnaceRequired) + { + GT_ModHandler.removeFurnaceSmelting(aStack); + GT_Values.RA.addBlastRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, tStack, 1L) : GT_Utility.copyAmount(1L, new Object[] { tStack }), null, (int)Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp); + if (aMaterial.mBlastFurnaceTemp <= 1000) { + GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.copyAmount(1L, new Object[] { tStack }), aMaterial.mBlastFurnaceTemp); + } + } + else + { + GT_ModHandler.addSmeltingRecipe(aStack, tStack); + } + } + else if (!aMaterial.contains(SubTag.NO_WORKING)) + { + if ((!OrePrefixes.block.isIgnored(aMaterial)) && + (null == GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L))) { + GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); + } + if (((OrePrefixes.block.isIgnored(aMaterial)) || (null == GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L))) && (aMaterial != Materials.GraniteRed) && (aMaterial != Materials.GraniteBlack) && (aMaterial != Materials.Glass) && (aMaterial != Materials.Obsidian) && (aMaterial != Materials.Glowstone) && (aMaterial != Materials.Paper)) { + GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L)); + } + } + if ((aMaterial.mMaterialList.size() > 0) && ((aMaterial.mExtraData & 0x3) != 0)) + { + long tItemAmount = 0L;long tCapsuleCount = 0L;long tDensityMultiplier = aMaterial.getDensity() > 3628800L ? aMaterial.getDensity() / 3628800L : 1L; + ArrayList tList = new ArrayList(); + for (MaterialStack tMat : aMaterial.mMaterialList) { + if (tMat.mAmount > 0L) + { + if (tMat.mMaterial == Materials.Air) + { + tStack = ItemList.Cell_Air.get(tMat.mAmount / 2L, new Object[0]); + } + else + { + tStack = GT_OreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount); + if (tStack == null) { + tStack = GT_OreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount); + } + } + if (tItemAmount + tMat.mAmount * 3628800L <= aStack.getMaxStackSize() * aMaterial.getDensity()) + { + tItemAmount += tMat.mAmount * 3628800L; + if (tStack != null) + { + ItemStack tmp793_791 = tStack;tmp793_791.stackSize = ((int)(tmp793_791.stackSize * tDensityMultiplier)); + while ((tStack.stackSize > 64) && (tList.size() < 6) && (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64 <= 64L)) + { + tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCount(tStack) * 64; + tList.add(GT_Utility.copyAmount(64L, new Object[] { tStack })); + tStack.stackSize -= 64; + } + if ((tStack.stackSize > 0) && (tList.size() < 6)) { + if (tCapsuleCount + GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { tStack }) <= 64L) + { + tCapsuleCount += GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { tStack }); + tList.add(tStack); + } + } + } + } + } + } + tItemAmount = (tItemAmount * tDensityMultiplier % aMaterial.getDensity() > 0L ? 1 : 0) + tItemAmount * tDensityMultiplier / aMaterial.getDensity(); + if (tList.size() > 0) + { + FluidStack tFluid = null; + for (int i = 0; i < tList.size(); i++) { + if ((!ItemList.Cell_Air.isStackEqual(tList.get(i))) && ((tFluid = GT_Utility.getFluidForFilledItem((ItemStack)tList.get(i), true)) != null)) + { + tFluid.amount *= ((ItemStack)tList.get(i)).stackSize; + tCapsuleCount -= GT_ModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(new ItemStack[] { (ItemStack)tList.get(i) }); + tList.remove(i); + break; + } + } + if ((aMaterial.mExtraData & 0x1) != 0) { + GT_Values.RA.addElectrolyzerRecipe(GT_Utility.copyAmount(tItemAmount, new Object[] { aStack }), tCapsuleCount > 0L ? ItemList.Cell_Empty.get(tCapsuleCount, new Object[0]) : null, null, tFluid, (ItemStack)tList.get(0), tList.size() < 2 ? null : (ItemStack)tList.get(1), tList.size() < 3 ? null : (ItemStack)tList.get(2), tList.size() < 4 ? null : (ItemStack)tList.get(3), tList.size() < 5 ? null : (ItemStack)tList.get(4), tList.size() < 6 ? null : (ItemStack)tList.get(5), null, (int)Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount)), Math.min(4, tList.size()) * 30); + } + if ((aMaterial.mExtraData & 0x2) != 0) { + GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(tItemAmount, new Object[] { aStack }), tCapsuleCount > 0L ? ItemList.Cell_Empty.get(tCapsuleCount, new Object[0]) : null, null, tFluid, (ItemStack)tList.get(0), tList.size() < 2 ? null : (ItemStack)tList.get(1), tList.size() < 3 ? null : (ItemStack)tList.get(2), tList.size() < 4 ? null : (ItemStack)tList.get(3), tList.size() < 5 ? null : (ItemStack)tList.get(4), tList.size() < 6 ? null : (ItemStack)tList.get(5), null, (int)Math.max(1L, Math.abs(aMaterial.getMass() * 4L * tItemAmount)), Math.min(4, tList.size()) * 5); + } + } + } + if (aMaterial.contains(SubTag.CRYSTALLISABLE)) + { + GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Water.getFluid(200L), GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), 7000, 2000, 24); + GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getDistilledWater(200L), GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), 9000, 1500, 24); + } + switch (aMaterial) + { + case _NULL: + break; + case Glass: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack(Blocks.glass)); + break; + case NetherQuartz: + case Quartz: + case CertusQuartz: + if (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "QuartzDustSmeltingIntoAESilicon", true)) { + GT_ModHandler.removeFurnaceSmelting(aStack); + } + break; + case MeatRaw: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.MeatCooked, 1L)); + break; + case Mercury: + System.err.println("Quicksilver Dust?, To melt that, you don't even need a Furnace..."); + break; + case Tetrahedrite: + case Chalcopyrite: + case Malachite: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Copper, 6L)); + break; + case Pentlandite: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Nickel, 6L)); + break; + case Garnierite: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Nickel, 1L)); + break; + case Cassiterite: + case CassiteriteSand: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tin, 1L)); + break; + case Magnetite: + case VanadiumMagnetite: + case BasalticMineralSand: + case GraniticMineralSand: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 3L)); + break; + case YellowLimonite: + case BrownLimonite: + case BandedIron: + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Iron, 1L)); + break; + case Coal: + GT_ModHandler.addLiquidTransposerFillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Water.getFluid(125L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.HydratedCoal, 1L), 125); + break; + case HydratedCoal: + GT_ModHandler.addLiquidTransposerEmptyRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Water.getFluid(125L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L), 125); + GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L)); + break; + case Diamond: + GT_Values.RA.addImplosionRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), 32, ItemList.IC2_Industrial_Diamond.get(3L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 16L)); + break; + case Opal: + case Olivine: + case Emerald: + case Ruby: + case Sapphire: + case GreenSapphire: + case Topaz: + case BlueTopaz: + case Tanzanite: + GT_Values.RA.addImplosionRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), 24, GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 12L)); + break; + case FoolsRuby: + case GarnetRed: + case GarnetYellow: + case Jasper: + case Amber: + case Monazite: + case Forcicium: + case Forcillium: + case Force: + GT_Values.RA.addImplosionRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), 16, GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 3L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 8L)); + default: + break; + } + } +} diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDustImpure.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDustImpure.java new file mode 100644 index 0000000000..a9f0fad89e --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDustImpure.java @@ -0,0 +1,94 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ import net.minecraftforge.fluids.FluidStack; +/* 14: */ +/* 15: */ public class ProcessingDustImpure +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingDustImpure() +/* 19: */ { +/* 20:17 */ OrePrefixes.dustPure.add(this); +/* 21:18 */ OrePrefixes.dustImpure.add(this); +/* 22:19 */ OrePrefixes.dustRefined.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:24 */ Materials tByProduct = (Materials)GT_Utility.selectItemInList(aPrefix == OrePrefixes.dustRefined ? 2 : aPrefix == OrePrefixes.dustPure ? 1 : 0, aMaterial, aMaterial.mOreByProducts); +/* 28:26 */ if (aPrefix == OrePrefixes.dustPure) +/* 29: */ { +/* 30:27 */ if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_GOLD)) { +/* 31:27 */ GT_Values.RA.addElectromagneticSeparatorRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Gold, 1L), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L), new int[] { 10000, 4000, 2000 }, 400, 24); +/* 32: */ } +/* 33:28 */ if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_IRON)) { +/* 34:28 */ GT_Values.RA.addElectromagneticSeparatorRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Iron, 1L), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Iron, 1L), new int[] { 10000, 4000, 2000 }, 400, 24); +/* 35: */ } +/* 36:29 */ if (aMaterial.contains(SubTag.ELECTROMAGNETIC_SEPERATION_NEODYMIUM)) { +/* 37:29 */ GT_Values.RA.addElectromagneticSeparatorRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Neodymium, 1L), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Neodymium, 1L), new int[] { 10000, 4000, 2000 }, 400, 24); +/* 38: */ } +/* 39: */ } +/* 40:32 */ if (aMaterial.contains(SubTag.CRYSTALLISABLE)) +/* 41: */ { +/* 42:33 */ GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Water.getFluid(200L), GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), 9000, 2000, 24); +/* 43:34 */ GT_Values.RA.addAutoclaveRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getDistilledWater(200L), GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L), 9500, 1500, 24); +/* 44: */ } +/* 45:37 */ ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tByProduct, GT_OreDictUnificator.get(OrePrefixes.nugget, tByProduct, 1L), 1L); +/* 46:38 */ if (tStack == null) +/* 47: */ { +/* 48:39 */ tStack = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tByProduct, 1L); +/* 49:40 */ if (tStack == null) +/* 50: */ { +/* 51:41 */ tStack = GT_OreDictUnificator.get(OrePrefixes.dust, tByProduct, GT_OreDictUnificator.get(OrePrefixes.gem, tByProduct, 1L), 1L); +/* 52:42 */ if (tStack == null) +/* 53: */ { +/* 54:43 */ tStack = GT_OreDictUnificator.get(OrePrefixes.cell, tByProduct, 1L); +/* 55:44 */ if (tStack == null) +/* 56: */ { +/* 57:45 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), 0, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), null, null, null, null, null, (int)Math.max(1L, aMaterial.getMass())); +/* 58: */ } +/* 59: */ else +/* 60: */ { +/* 61:47 */ FluidStack tFluid = GT_Utility.getFluidForFilledItem(tStack, true); +/* 62:48 */ if (tFluid == null) +/* 63: */ { +/* 64:49 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), 1, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), tStack, null, null, null, null, (int)Math.max(1L, aMaterial.getMass() * 72L)); +/* 65: */ } +/* 66: */ else +/* 67: */ { +/* 68:51 */ tFluid.amount /= 10; +/* 69:52 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, tFluid, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), null, null, null, null, null, null, (int)Math.max(1L, aMaterial.getMass() * 8L), 5); +/* 70: */ } +/* 71: */ } +/* 72: */ } +/* 73: */ else +/* 74: */ { +/* 75:56 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), 0, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 9L), tStack, null, null, null, null, (int)Math.max(1L, aMaterial.getMass() * 72L)); +/* 76: */ } +/* 77: */ } +/* 78: */ else +/* 79: */ { +/* 80:59 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), 0, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L), tStack, null, null, null, null, (int)Math.max(1L, aMaterial.getMass() * 16L)); +/* 81: */ } +/* 82: */ } +/* 83: */ else +/* 84: */ { +/* 85:62 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), 0, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), tStack, null, null, null, null, (int)Math.max(1L, aMaterial.getMass() * 8L)); +/* 86: */ } +/* 87: */ } +/* 88: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingDustImpure + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDustSmall.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDustSmall.java new file mode 100644 index 0000000000..b47d105b7d --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDustSmall.java @@ -0,0 +1,45 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class ProcessingDustSmall +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingDustSmall() +/* 19: */ { +/* 20:17 */ OrePrefixes.dustSmall.add(this); +/* 21: */ } +/* 22: */ +/* 23: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 24: */ { +/* 25:22 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), ItemList.Schematic_Dust.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), 100, 4); +/* 26:23 */ if (!aMaterial.mBlastFurnaceRequired) +/* 27: */ { +/* 28:24 */ GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); +/* 29:25 */ if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { +/* 30:25 */ GT_RecipeRegistrator.registerReverseArcSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack }), aMaterial, aPrefix.mMaterialAmount, null, null, null); +/* 31: */ } +/* 32: */ } +/* 33:28 */ if (aMaterial.mBlastFurnaceRequired) { +/* 34:29 */ GT_Values.RA.addBlastRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), null, (int)Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp); +/* 35: */ } else { +/* 36:31 */ GT_ModHandler.addAlloySmelterRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), ItemList.Shape_Mold_Ingot.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 130, 3, true); +/* 37: */ } +/* 38: */ } +/* 39: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingDustSmall + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDustTiny.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDustTiny.java new file mode 100644 index 0000000000..a3cb2263c8 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDustTiny.java @@ -0,0 +1,53 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.enums.SubTag; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ +/* 16: */ public class ProcessingDustTiny +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingDustTiny() +/* 20: */ { +/* 21:18 */ OrePrefixes.dustTiny.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:23 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), ItemList.Schematic_Dust.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), 100, 4); +/* 27:24 */ if (!aMaterial.mBlastFurnaceRequired) +/* 28: */ { +/* 29:25 */ GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); +/* 30:26 */ if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { +/* 31:26 */ GT_RecipeRegistrator.registerReverseArcSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack }), aMaterial, aPrefix.mMaterialAmount, null, null, null); +/* 32: */ } +/* 33: */ } +/* 34:29 */ if (!aMaterial.contains(SubTag.NO_SMELTING)) { +/* 35:30 */ if (aMaterial.mBlastFurnaceRequired) +/* 36: */ { +/* 37:31 */ GT_Values.RA.addBlastRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial.mSmeltInto, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), null, (int)Math.max(aMaterial.getMass() / 40L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp); +/* 38:32 */ GT_ModHandler.removeFurnaceSmelting(aStack); +/* 39: */ } +/* 40: */ else +/* 41: */ { +/* 42:34 */ GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mSmeltInto, 1L)); +/* 43:35 */ GT_ModHandler.addAlloySmelterRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), ItemList.Shape_Mold_Ingot.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 130, 3, true); +/* 44: */ } +/* 45: */ } +/* 46: */ } +/* 47: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingDustTiny + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java b/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java new file mode 100644 index 0000000000..eb598aece2 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingDye.java @@ -0,0 +1,42 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +/* 4: */ import gregtech.api.enums.GT_Values; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.init.Blocks; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ import net.minecraftforge.fluids.FluidRegistry; +/* 15: */ +/* 16: */ public class ProcessingDye +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingDye() +/* 20: */ { +/* 21:20 */ OrePrefixes.dye.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:25 */ Dyes aDye = Dyes.get(aOreDictName); +/* 27:26 */ if ((aDye.mIndex >= 0) && (aDye.mIndex < 16) && +/* 28:27 */ (GT_Utility.getContainerItem(aStack, true) == null)) +/* 29: */ { +/* 30:28 */ GT_ModHandler.addAlloySmelterRecipe(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Glass, 8L), GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack(Blocks.stained_glass, 8, 15 - aDye.mIndex), 200, 8, false); +/* 31:29 */ GT_ModHandler.addAlloySmelterRecipe(new ItemStack(Blocks.glass, 8, 32767), GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack(Blocks.stained_glass, 8, 15 - aDye.mIndex), 200, 8, false); +/* 32:30 */ GT_Values.RA.addMixerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, null, Materials.Water.getFluid(144L), FluidRegistry.getFluidStack("dye.watermixed." + aDye.name().toLowerCase(), 144), null, 16, 4); +/* 33:31 */ GT_Values.RA.addMixerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, null, GT_ModHandler.getDistilledWater(144L), FluidRegistry.getFluidStack("dye.watermixed." + aDye.name().toLowerCase(), 144), null, 16, 4); +/* 34: */ } +/* 35: */ } +/* 36: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingDye + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java b/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java new file mode 100644 index 0000000000..5d44007587 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingFoil.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.objects.GT_RenderedTexture; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingFoil +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingFoil() +/* 14: */ { +/* 15:14 */ OrePrefixes.foil.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:19 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[70], aMaterial.mRGBa, false), null); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingFoil + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java b/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java new file mode 100644 index 0000000000..78dd0196a3 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingFood.java @@ -0,0 +1,51 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.objects.ItemData; +/* 10: */ import gregtech.api.objects.MaterialStack; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_OreDictUnificator; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ +/* 16: */ public class ProcessingFood +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingFood() +/* 20: */ { +/* 21:18 */ OrePrefixes.food.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:23 */ if (aOreDictName.equals("foodCheese")) +/* 27: */ { +/* 28:24 */ GT_Values.RA.addSlicerRecipe(aStack, ItemList.Shape_Slicer_Flat.get(0L, new Object[0]), ItemList.Food_Sliced_Cheese.get(4L, new Object[0]), 64, 4); +/* 29:25 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Cheese, 3628800L, new MaterialStack[0])); +/* 30: */ } +/* 31:26 */ else if (aOreDictName.equals("foodDough")) +/* 32: */ { +/* 33:27 */ GT_ModHandler.removeFurnaceSmelting(aStack); +/* 34:28 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Food_Flat_Dough.get(1L, new Object[0]), 16, 4); +/* 35: */ +/* 36:30 */ GT_Values.RA.addMixerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sugar, 1L), null, null, null, null, ItemList.Food_Dough_Sugar.get(2L, new Object[0]), 32, 8); +/* 37:31 */ GT_Values.RA.addMixerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L), null, null, null, null, ItemList.Food_Dough_Chocolate.get(2L, new Object[0]), 32, 8); +/* 38:32 */ GT_Values.RA.addMixerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Chocolate, 1L), null, null, null, null, ItemList.Food_Dough_Chocolate.get(2L, new Object[0]), 32, 8); +/* 39: */ +/* 40:34 */ GT_Values.RA.addFormingPressRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Mold_Bun.get(0L, new Object[0]), ItemList.Food_Raw_Bun.get(1L, new Object[0]), 128, 4); +/* 41:35 */ GT_Values.RA.addFormingPressRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Bread.get(0L, new Object[0]), ItemList.Food_Raw_Bread.get(1L, new Object[0]), 256, 4); +/* 42:36 */ GT_Values.RA.addFormingPressRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), ItemList.Shape_Mold_Baguette.get(0L, new Object[0]), ItemList.Food_Raw_Baguette.get(1L, new Object[0]), 384, 4); +/* 43: */ } +/* 44: */ } +/* 45: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingFood + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java new file mode 100644 index 0000000000..41d58e565f --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGear.java @@ -0,0 +1,34 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingGear +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingGear() +/* 17: */ { +/* 18:16 */ OrePrefixes.gearGt.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:21 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 24:22 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 25:22 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Gear.get(0L, new Object[0]), aMaterial.getMolten(576L), GT_OreDictUnificator.get(aPrefix, aMaterial, 1L), 128, 8); +/* 26: */ } +/* 27: */ } +/* 28: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGear + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGearSmall.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGearSmall.java new file mode 100644 index 0000000000..4d27d47967 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGearSmall.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingGearSmall +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingGearSmall() +/* 16: */ { +/* 17:15 */ OrePrefixes.gearGtSmall.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 23:20 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Gear_Small.get(0L, new Object[0]), aMaterial.getMolten(144L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 16, 8); +/* 24: */ } +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGearSmall + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java new file mode 100644 index 0000000000..7b39b07404 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java @@ -0,0 +1,80 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Recipes; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +/* 10: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 11: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 12: */ import gregtech.api.util.GT_Config; +/* 13: */ import gregtech.api.util.GT_ModHandler; +/* 14: */ import gregtech.api.util.GT_OreDictUnificator; +/* 15: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 16: */ import gregtech.api.util.GT_Utility; +/* 17: */ import net.minecraft.init.Items; +/* 18: */ import net.minecraft.item.ItemStack; +/* 19: */ +/* 20: */ public class ProcessingGem +/* 21: */ implements IOreRecipeRegistrator +/* 22: */ { +/* 23: */ public ProcessingGem() +/* 24: */ { +/* 25:18 */ OrePrefixes.gem.add(this); +/* 26: */ } +/* 27: */ +/* 28: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 29: */ { +/* 30:23 */ if (aMaterial.mFuelPower > 0) { +/* 31:23 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower * 2, aMaterial.mFuelType); +/* 32: */ } +/* 33:25 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), ItemList.Crate_Empty.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.crateGtGem, aMaterial, 1L), 100, 8); +/* 34:26 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.crateGtGem, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 16L), ItemList.Crate_Empty.get(1L, new Object[0]), 800, 1); +/* 35:28 */ if (!OrePrefixes.block.isIgnored(aMaterial)) { +/* 36:28 */ GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); +/* 37: */ } +/* 38:29 */ if (!aMaterial.contains(SubTag.NO_SMELTING)) { +/* 39:29 */ GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L)); +/* 40: */ } +/* 41:31 */ if (aMaterial.contains(SubTag.NO_SMASHING)) +/* 42: */ { +/* 43:32 */ GT_Values.RA.addForgeHammerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 2L), 64, 16); +/* 44: */ } +/* 45: */ else +/* 46: */ { +/* 47:34 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int)Math.max(aMaterial.getMass(), 1L), 16); +/* 48:35 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 24); +/* 49:36 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 96); +/* 50:37 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L), 96); +/* 51:38 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 4L, 1L), 96); +/* 52:39 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 5L, 1L), 96); +/* 53:40 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 9L, 1L), 96); +/* 54: */ } +/* 55:43 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 56:43 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L), (int)Math.max(aMaterial.getMass(), 1L), 16); +/* 57: */ } +/* 58:45 */ GT_RecipeRegistrator.registerUsagesForMaterials(GT_Utility.copyAmount(1L, new Object[] { aStack }), OrePrefixes.plate.get(aMaterial).toString(), !aMaterial.contains(SubTag.NO_SMASHING)); +/* 59:47 */ switch (aMaterial.ordinal()) +/* 60: */ { +/* 61: */ case 1: +/* 62: */ break; +/* 63: */ case 2: +/* 64: */ case 3: +/* 65:50 */ if (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "torchesFromCoal", false)) { +/* 66:50 */ GT_ModHandler.removeRecipe(new ItemStack[] { GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, new ItemStack(Items.stick, 1, 0) }); +/* 67: */ } +/* 68: */ break; +/* 69: */ case 4: +/* 70:53 */ GT_Values.RA.addElectrolyzerRecipe(aStack, 0, GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 1), null, null, null, null, null, 2000, 30); +/* 71: */ } +/* 72: */ } +/* 73: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGem + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGemChipped.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGemChipped.java new file mode 100644 index 0000000000..3ce8a5b08a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGemChipped.java @@ -0,0 +1,36 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingGemChipped +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingGemChipped() +/* 17: */ { +/* 18:15 */ OrePrefixes.gemChipped.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (aMaterial.mFuelPower > 0) { +/* 24:20 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower / 2, aMaterial.mFuelType); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 27:21 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L), (int)Math.max(aMaterial.getMass(), 1L), 8); +/* 28: */ } +/* 29: */ } +/* 30: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGemChipped + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGemExquisite.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGemExquisite.java new file mode 100644 index 0000000000..4f5388c348 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGemExquisite.java @@ -0,0 +1,37 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingGemExquisite +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingGemExquisite() +/* 17: */ { +/* 18:15 */ OrePrefixes.gemExquisite.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (aMaterial.mFuelPower > 0) { +/* 24:20 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower * 8, aMaterial.mFuelType); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 27:21 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 3L), GT_OreDictUnificator.getDust(aMaterial, aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount * 3L), (int)Math.max(aMaterial.getMass() * 10L, 1L), 16); +/* 28: */ } +/* 29:22 */ GT_Values.RA.addForgeHammerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 2L), 64, 16); +/* 30: */ } +/* 31: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGemExquisite + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawed.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawed.java new file mode 100644 index 0000000000..aa17668fce --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawed.java @@ -0,0 +1,37 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingGemFlawed +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingGemFlawed() +/* 17: */ { +/* 18:15 */ OrePrefixes.gemFlawed.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (aMaterial.mFuelPower > 0) { +/* 24:20 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower, aMaterial.mFuelType); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 27:21 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 2L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L), (int)Math.max(aMaterial.getMass(), 1L), 12); +/* 28: */ } +/* 29:22 */ GT_Values.RA.addForgeHammerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, 2L), 64, 16); +/* 30: */ } +/* 31: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGemFlawed + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawless.java b/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawless.java new file mode 100644 index 0000000000..c9a8652df3 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingGemFlawless.java @@ -0,0 +1,37 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingGemFlawless +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingGemFlawless() +/* 17: */ { +/* 18:15 */ OrePrefixes.gemFlawless.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (aMaterial.mFuelPower > 0) { +/* 24:20 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower * 4, aMaterial.mFuelType); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 27:21 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L), GT_OreDictUnificator.getDust(aMaterial, aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount), (int)Math.max(aMaterial.getMass() * 5L, 1L), 16); +/* 28: */ } +/* 29:22 */ GT_Values.RA.addForgeHammerRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 2L), 64, 16); +/* 30: */ } +/* 31: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingGemFlawless + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngot1.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot1.java new file mode 100644 index 0000000000..5f3b4177a3 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot1.java @@ -0,0 +1,80 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.enums.SubTag; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 14: */ import java.io.PrintStream; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class ProcessingIngot1 +/* 18: */ implements IOreRecipeRegistrator +/* 19: */ { +/* 20: */ public ProcessingIngot1() +/* 21: */ { +/* 22:19 */ OrePrefixes.ingot.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:24 */ if (aMaterial.mFuelPower > 0) { +/* 28:24 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower, aMaterial.mFuelType); +/* 29: */ } +/* 30:26 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), ItemList.Crate_Empty.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.crateGtIngot, aMaterial, 1L), 100, 8); +/* 31:27 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.crateGtIngot, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 16L), ItemList.Crate_Empty.get(1L, new Object[0]), 800, 1); +/* 32:29 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 33:29 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Ingot.get(0L, new Object[0]), aMaterial.getMolten(144L), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 32, 8); +/* 34: */ } +/* 35:30 */ GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); +/* 36:31 */ GT_RecipeRegistrator.registerReverseMacerating(aStack, aMaterial, aPrefix.mMaterialAmount, null, null, null, false); +/* 37:32 */ if (aMaterial.mSmeltInto.mArcSmeltInto != aMaterial) { +/* 38:32 */ GT_RecipeRegistrator.registerReverseArcSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack }), aMaterial, aPrefix.mMaterialAmount, null, null, null); +/* 39: */ } +/* 40:34 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 41: */ { +/* 42:35 */ GT_Values.RA.addWiremillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.copy(new Object[] { GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 2L), GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 8L) }), 100, 4); +/* 43:36 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int)Math.max(aMaterial.getMass(), 1L), 16); +/* 44:37 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 24); +/* 45:38 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 96); +/* 46:39 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L), 96); +/* 47:40 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 4L, 1L), 96); +/* 48:41 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 5L, 1L), 96); +/* 49:42 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 9L, 1L), 96); +/* 50: */ } +/* 51:47 */ if (!OrePrefixes.block.isIgnored(aMaterial)) { +/* 52:47 */ GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L)); +/* 53: */ } +/* 54:48 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 55:48 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial.mMacerateInto, 2L), (int)Math.max(aMaterial.getMass() * 5L, 1L), 16); +/* 56: */ } +/* 57:49 */ if (!aMaterial.contains(SubTag.NO_SMELTING)) +/* 58: */ { +/* 59:50 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Mold_Nugget.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 9L), 100, 1); +/* 60:51 */ if ((GT_ModHandler.getSmeltingOutput(aStack, false, null) == null) && (GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mSmeltInto, 1L) != null) && (!GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mSmeltInto, 9L)))) { +/* 61:51 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mSmeltInto, 9L), new Object[] { aOreDictName }); +/* 62: */ } +/* 63: */ } +/* 64: */ ItemStack tStack; +/* 65:53 */ if ((null != (tStack = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L))) && ( +/* 66:54 */ (aMaterial.mBlastFurnaceRequired) || (aMaterial.contains(SubTag.NO_SMELTING)))) { +/* 67:54 */ GT_ModHandler.removeFurnaceSmelting(tStack); +/* 68: */ } +/* 69:57 */ GT_RecipeRegistrator.registerUsagesForMaterials(GT_Utility.copyAmount(1L, new Object[] { aStack }), OrePrefixes.plate.get(aMaterial).toString(), !aMaterial.contains(SubTag.NO_SMASHING)); +/* 70:59 */ if (aMaterial == Materials.Mercury) { +/* 71:60 */ System.err.println("Quicksilver Ingots?, Don't tell me there is an Armor made of that highly toxic and very likely to be melting Material!"); +/* 72: */ } +/* 73: */ } +/* 74: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngot1 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngot2.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot2.java new file mode 100644 index 0000000000..6556ca946c --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot2.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingIngot2 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingIngot2() +/* 17: */ { +/* 18:15 */ OrePrefixes.ingotDouble.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 24: */ { +/* 25:21 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 96); +/* 26:22 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 96); +/* 27: */ } +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngot2 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngot3.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot3.java new file mode 100644 index 0000000000..2dcbf5dbaf --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot3.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingIngot3 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingIngot3() +/* 17: */ { +/* 18:15 */ OrePrefixes.ingotTriple.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 24: */ { +/* 25:21 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 96); +/* 26:22 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L), 96); +/* 27: */ } +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngot3 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngot4.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot4.java new file mode 100644 index 0000000000..ac3ae01a27 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot4.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingIngot4 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingIngot4() +/* 17: */ { +/* 18:15 */ OrePrefixes.ingotQuadruple.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) { +/* 24:21 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 96); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngot4 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngot5.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot5.java new file mode 100644 index 0000000000..0b9d7fd528 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngot5.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingIngot5 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingIngot5() +/* 17: */ { +/* 18:15 */ OrePrefixes.ingotQuintuple.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) { +/* 24:21 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 96); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngot5 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingIngotHot.java b/main/java/gregtech/loaders/oreprocessing/ProcessingIngotHot.java new file mode 100644 index 0000000000..de335e17f0 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingIngotHot.java @@ -0,0 +1,30 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_OreDictUnificator; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingIngotHot +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingIngotHot() +/* 16: */ { +/* 17:14 */ OrePrefixes.ingotHot.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:19 */ GT_Values.RA.addVacuumFreezerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L)); +/* 23: */ } +/* 24: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingIngotHot + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java b/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java new file mode 100644 index 0000000000..c2d65ed174 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingItem.java @@ -0,0 +1,84 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.objects.ItemData; +/* 9: */ import gregtech.api.objects.MaterialStack; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import java.io.PrintStream; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ +/* 16: */ public class ProcessingItem +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingItem() +/* 20: */ { +/* 21:18 */ OrePrefixes.item.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:23 */ if (GT_OreDictUnificator.getItemData(aStack) == null) { +/* 27:26 */ if (!aOreDictName.equals("itemCertusQuartz")) { +/* 28:29 */ if (!aOreDictName.equals("itemNetherQuartz")) { +/* 29:32 */ if (aOreDictName.equals("itemSilicon")) +/* 30: */ { +/* 31:33 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Silicon, 3628800L, new MaterialStack[0])); +/* 32:34 */ GT_Values.RA.addFormingPressRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 0L, 19), GT_ModHandler.getModItem("appliedenergistics2", "item.ItemMultiMaterial", 1L, 20), 200, 16); +/* 33: */ } +/* 34:36 */ else if (aOreDictName.equals("itemWheat")) +/* 35: */ { +/* 36:37 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Wheat, 3628800L, new MaterialStack[0])); +/* 37: */ } +/* 38:39 */ else if (aOreDictName.equals("itemManganese")) +/* 39: */ { +/* 40:40 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Manganese, 3628800L, new MaterialStack[0])); +/* 41: */ } +/* 42:42 */ else if (aOreDictName.equals("itemSalt")) +/* 43: */ { +/* 44:43 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Salt, 3628800L, new MaterialStack[0])); +/* 45: */ } +/* 46:45 */ else if (aOreDictName.equals("itemMagnesium")) +/* 47: */ { +/* 48:46 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Magnesium, 3628800L, new MaterialStack[0])); +/* 49: */ } +/* 50:48 */ else if ((aOreDictName.equals("itemPhosphorite")) || (aOreDictName.equals("itemPhosphorus"))) +/* 51: */ { +/* 52:49 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Phosphorus, 3628800L, new MaterialStack[0])); +/* 53: */ } +/* 54:51 */ else if (aOreDictName.equals("itemSulfur")) +/* 55: */ { +/* 56:52 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Sulfur, 3628800L, new MaterialStack[0])); +/* 57: */ } +/* 58:54 */ else if ((aOreDictName.equals("itemAluminum")) || (aOreDictName.equals("itemAluminium"))) +/* 59: */ { +/* 60:55 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Aluminium, 3628800L, new MaterialStack[0])); +/* 61: */ } +/* 62:57 */ else if (aOreDictName.equals("itemSaltpeter")) +/* 63: */ { +/* 64:58 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Saltpeter, 3628800L, new MaterialStack[0])); +/* 65: */ } +/* 66:60 */ else if (aOreDictName.equals("itemUranium")) +/* 67: */ { +/* 68:61 */ GT_OreDictUnificator.addItemData(aStack, new ItemData(Materials.Uranium, 3628800L, new MaterialStack[0])); +/* 69: */ } +/* 70: */ else +/* 71: */ { +/* 72:64 */ System.out.println("Item Name: " + aOreDictName + " !!!Unknown Item detected!!! Please report to GregTech Intergalactical for additional compatiblity. This is not an Error, it's just an Information."); +/* 73: */ } +/* 74: */ } +/* 75: */ } +/* 76: */ } +/* 77: */ } +/* 78: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingItem + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingLeaves.java b/main/java/gregtech/loaders/oreprocessing/ProcessingLeaves.java new file mode 100644 index 0000000000..4f394ac67a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingLeaves.java @@ -0,0 +1,23 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import net.minecraft.item.ItemStack; +/* 7: */ +/* 8: */ public class ProcessingLeaves +/* 9: */ implements IOreRecipeRegistrator +/* 10: */ { +/* 11: */ public ProcessingLeaves() +/* 12: */ { +/* 13:11 */ OrePrefixes.treeLeaves.add(this); +/* 14: */ } +/* 15: */ +/* 16: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) {} +/* 17: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingLeaves + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java b/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java new file mode 100644 index 0000000000..fc00720c8e --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingLens.java @@ -0,0 +1,34 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +/* 4: */ import gregtech.api.enums.Dyes; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +/* 7: */ import gregtech.api.enums.Textures.BlockIcons; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.ITexture; +/* 10: */ import gregtech.api.objects.GT_MultiTexture; +/* 11: */ import gregtech.api.objects.GT_RenderedTexture; +/* 12: */ import gregtech.common.covers.GT_Cover_Lens; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class ProcessingLens +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingLens() +/* 19: */ { +/* 20:16 */ OrePrefixes.lens.add(this); +/* 21: */ } +/* 22: */ +/* 23: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 24: */ { +/* 25:21 */ GregTech_API.registerCover(aStack, new GT_MultiTexture(new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[2][0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_LENS, aMaterial.mRGBa, false) }), new GT_Cover_Lens(aMaterial.mColor.mIndex)); +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingLens + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java b/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java new file mode 100644 index 0000000000..14eef12e60 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingLog.java @@ -0,0 +1,106 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.GT_Mod; +/* 4: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 5: */ import gregtech.api.enums.ConfigCategories.Recipes; +/* 6: */ import gregtech.api.enums.GT_Values; +/* 7: */ import gregtech.api.enums.ItemList; +/* 8: */ import gregtech.api.enums.Materials; +/* 9: */ import gregtech.api.enums.OrePrefixes; +/* 10: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 11: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 12: */ import gregtech.api.util.GT_Config; +/* 13: */ import gregtech.api.util.GT_ModHandler; +/* 14: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 15: */ import gregtech.api.util.GT_OreDictUnificator; +/* 16: */ import gregtech.api.util.GT_Utility; +/* 17: */ import gregtech.common.GT_Proxy; +/* 18: */ import net.minecraft.init.Items; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingLog +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingLog() +/* 25: */ { +/* 26:23 */ OrePrefixes.log.add(this); +/* 27: */ } +/* 28: */ +/* 29: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 30: */ { +/* 31:28 */ if (aOreDictName.equals("logRubber")) +/* 32: */ { +/* 33:29 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, Materials.Methane.getGas(60L), ItemList.IC2_Resin.get(1L, new Object[0]), GT_ModHandler.getIC2Item("plantBall", 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Carbon, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L), null, null, new int[] { 5000, 3750, 2500, 2500 }, 200, 20); +/* 34:30 */ GT_ModHandler.addSawmillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.IC2_Resin.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 16L)); +/* 35:31 */ GT_ModHandler.addExtractionRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Rubber, 1L)); +/* 36:32 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 6L), ItemList.IC2_Resin.get(1L, new Object[0]), 33, false); +/* 37: */ } +/* 38: */ else +/* 39: */ { +/* 40:34 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 6L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L), 80, false); +/* 41: */ } +/* 42:37 */ GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Wood, 2L), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "sLf", Character.valueOf('L'), GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 43:38 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.Wood, 4L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), 160, 8); +/* 44:39 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 2L, new Object[0]), Materials.SeedOil.getFluid(50L), ItemList.FR_Stick.get(1L, new Object[0]), 16, 8); +/* 45:40 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]), Materials.SeedOil.getFluid(250L), ItemList.FR_Casing_Impregnated.get(1L, new Object[0]), 64, 16); +/* 46:41 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Creosote.getFluid(1000L), GT_ModHandler.getModItem("Railcraft", "tile.railcraft.cube", 1L, 8), null, null, null, 16, 16); +/* 47: */ +/* 48:43 */ int aMeta = aStack.getItemDamage(); +/* 49:45 */ if (aMeta == 32767) +/* 50: */ { +/* 51:46 */ if ((GT_Utility.areStacksEqual(GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1L, new Object[] { aStack }), false, null), new ItemStack(Items.coal, 1, 1))) && +/* 52:47 */ (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", false))) { +/* 53:47 */ GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack })); +/* 54: */ } +/* 55:49 */ for (int i = 0; i < 16; i++) +/* 56: */ { +/* 57:50 */ if ((GT_Utility.areStacksEqual(GT_ModHandler.getSmeltingOutput(new ItemStack(aStack.getItem(), 1, i), false, null), new ItemStack(Items.coal, 1, 1))) && +/* 58:51 */ (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", false))) { +/* 59:51 */ GT_ModHandler.removeFurnaceSmelting(new ItemStack(aStack.getItem(), 1, i)); +/* 60: */ } +/* 61:53 */ ItemStack tStack = GT_ModHandler.getRecipeOutput(new ItemStack[] { new ItemStack(aStack.getItem(), 1, i) }); +/* 62:54 */ if (tStack != null) +/* 63: */ { +/* 64:55 */ ItemStack tPlanks = GT_Utility.copy(new Object[] { tStack }); +/* 65:56 */ tPlanks.stackSize = (tPlanks.stackSize * 3 / 2); +/* 66:57 */ GT_Values.RA.addCutterRecipe(new ItemStack(aStack.getItem(), 1, i), Materials.Lubricant.getFluid(1L), GT_Utility.copy(new Object[] { tPlanks }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L), 200, 8); +/* 67:58 */ GT_Values.RA.addCutterRecipe(new ItemStack(aStack.getItem(), 1, i), GT_Utility.copyAmount(GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, new Object[] { tStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), 200, 8); +/* 68:59 */ GT_ModHandler.addSawmillRecipe(new ItemStack(aStack.getItem(), 1, i), tPlanks, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)); +/* 69:60 */ GT_ModHandler.removeRecipe(new ItemStack[] { new ItemStack(aStack.getItem(), 1, i) }); +/* 70:61 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, new Object[] { tStack }), new Object[] { "s", "L", Character.valueOf('L'), new ItemStack(aStack.getItem(), 1, i) }); +/* 71:62 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(tStack.stackSize / (GT_Mod.gregtechproxy.mNerfedWoodPlank ? 2 : 1), new Object[] { tStack }), new Object[] { new ItemStack(aStack.getItem(), 1, i) }); +/* 72: */ } +/* 73: */ } +/* 74: */ } +/* 75: */ else +/* 76: */ { +/* 77:66 */ if ((GT_Utility.areStacksEqual(GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1L, new Object[] { aStack }), false, null), new ItemStack(Items.coal, 1, 1))) && +/* 78:67 */ (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", false))) { +/* 79:67 */ GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack })); +/* 80: */ } +/* 81:69 */ ItemStack tStack = GT_ModHandler.getRecipeOutput(new ItemStack[] { GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 82:70 */ if (tStack != null) +/* 83: */ { +/* 84:71 */ ItemStack tPlanks = GT_Utility.copy(new Object[] { tStack }); +/* 85:72 */ tPlanks.stackSize = (tPlanks.stackSize * 3 / 2); +/* 86:73 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.Lubricant.getFluid(1L), GT_Utility.copy(new Object[] { tPlanks }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L), 200, 8); +/* 87:74 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.copyAmount(GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, new Object[] { tStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), 200, 8); +/* 88:75 */ GT_ModHandler.addSawmillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), tPlanks, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)); +/* 89:76 */ GT_ModHandler.removeRecipe(new ItemStack[] { GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 90:77 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(GT_Mod.gregtechproxy.mNerfedWoodPlank ? tStack.stackSize : tStack.stackSize * 5 / 4, new Object[] { tStack }), new Object[] { "s", "L", Character.valueOf('L'), GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 91:78 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(tStack.stackSize / (GT_Mod.gregtechproxy.mNerfedWoodPlank ? 2 : 1), new Object[] { tStack }), new Object[] { GT_Utility.copyAmount(1L, new Object[] { aStack }) }); +/* 92: */ } +/* 93: */ } +/* 94:82 */ if ((GT_Utility.areStacksEqual(GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(1L, new Object[] { aStack }), false, null), new ItemStack(Items.coal, 1, 1))) && +/* 95:83 */ (GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.disabledrecipes, "wood2charcoalsmelting", false))) { +/* 96:83 */ GT_ModHandler.removeFurnaceSmelting(GT_Utility.copyAmount(1L, new Object[] { aStack })); +/* 97: */ } +/* 98: */ } +/* 99: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingLog + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java b/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java new file mode 100644 index 0000000000..cf1435c7c5 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingNugget.java @@ -0,0 +1,45 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.enums.SubTag; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_RecipeRegistrator; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ +/* 16: */ public class ProcessingNugget +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingNugget() +/* 20: */ { +/* 21:19 */ OrePrefixes.nugget.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:24 */ if (aMaterial == Materials.Iron) { +/* 27:24 */ GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.WroughtIron, 1L)); +/* 28: */ } +/* 29:25 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 30:25 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.round, aMaterial, 1L), null, (int)Math.max(aMaterial.getMass() / 4L, 1L), 8); +/* 31: */ } +/* 32:26 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), aMaterial.contains(SubTag.SMELTING_TO_GEM) ? ItemList.Shape_Mold_Ball.get(0L, new Object[0]) : ItemList.Shape_Mold_Ingot.get(0L, new Object[0]), GT_OreDictUnificator.get(aMaterial.contains(SubTag.SMELTING_TO_GEM) ? OrePrefixes.gem : OrePrefixes.ingot, aMaterial.mSmeltInto, 1L), 200, 2); +/* 33:27 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 34:27 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Nugget.get(0L, new Object[0]), aMaterial.getMolten(16L), GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial, 1L), 16, 4); +/* 35: */ } +/* 36:28 */ GT_RecipeRegistrator.registerReverseFluidSmelting(aStack, aMaterial, aPrefix.mMaterialAmount, null); +/* 37:29 */ GT_RecipeRegistrator.registerReverseMacerating(aStack, aMaterial, aPrefix.mMaterialAmount, null, null, null, false); +/* 38: */ } +/* 39: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingNugget + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java b/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java new file mode 100644 index 0000000000..0f4fd7c39e --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingOre.java @@ -0,0 +1,151 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +/* 7: */ import gregtech.api.enums.*; +/* 10: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 11: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 12: */ import gregtech.api.util.GT_Config; +/* 13: */ import gregtech.api.util.GT_ModHandler; +/* 14: */ import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +/* 15: */ import gregtech.api.util.GT_Recipe.GT_Recipe_Map; +/* 16: */ import gregtech.api.util.GT_Utility; + +/* 17: */ import java.util.ArrayList; + +/* 18: */ import net.minecraft.init.Blocks; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingOre +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingOre() +/* 25: */ { +/* 26: 19 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 27: 19 */ if ((tPrefix.name().startsWith("ore")) && (tPrefix != OrePrefixes.orePoor) && (tPrefix != OrePrefixes.oreSmall) && (tPrefix != OrePrefixes.oreRich) && (tPrefix != OrePrefixes.oreNormal)) { +/* 28: 19 */ tPrefix.add(this); +/* 29: */ } +/* 30: */ } +/* 31: */ } +/* 32: */ +/* 33: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 34: */ { +/* 35: 24 */ boolean tIsRich = (aPrefix == OrePrefixes.oreNether) || (aPrefix == OrePrefixes.oreEnd) || (aPrefix == OrePrefixes.oreDense); +/* 36: 26 */ if (aMaterial == Materials.Oilsands) { +/* 37: 27 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, Materials.Oil.getFluid(tIsRich ? 1000L : 500L), new ItemStack(Blocks.sand, 1, 0), null, null, null, null, null, new int[] { tIsRich ? 10000 : 5000 }, tIsRich ? 2000 : 1000, 5); +/* 38: */ } else { +/* 39: 29 */ registerStandardOreRecipes(aPrefix, aMaterial, GT_Utility.copyAmount(1L, new Object[] { aStack }), Math.max(1, GregTech_API.sOPStuff.get(ConfigCategories.Materials.oreprocessingoutputmultiplier, aMaterial.toString(), 1)) * (tIsRich ? 2 : 1)); +/* 40: */ } +/* 41: */ } +/* 42: */ +/* 43: 33 */ private ArrayList mAlreadyListedOres = new ArrayList(1000); +/* 44: */ +/* 45: */ private boolean registerStandardOreRecipes(OrePrefixes aPrefix, Materials aMaterial, ItemStack aOreStack, int aMultiplier) +/* 46: */ { +/* 47: 36 */ if ((aOreStack == null) || (aMaterial == null)) { +/* 48: 36 */ return false; +/* 49: */ } +/* 50: 37 */ GT_ModHandler.addValuableOre(GT_Utility.getBlockFromStack(aOreStack), aOreStack.getItemDamage(), aMaterial.mOreValue); +/* 51: 38 */ Materials tMaterial = aMaterial.mOreReplacement;Materials tPrimaryByMaterial = null;Materials tSecondaryByMaterial = null; +/* 52: 39 */ aMultiplier = Math.max(1, aMultiplier); +/* 53: 40 */ aOreStack = GT_Utility.copyAmount(1L, new Object[] { aOreStack }); +/* 54: 41 */ aOreStack.stackSize = 1; +/* 55: */ +/* 56: */ +/* 57: 44 */ ItemStack tIngot = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); +/* 58: 45 */ ItemStack tGem = GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial, 1L); +/* 59: 46 */ ItemStack tSmeltInto = tIngot == null ? 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) : tIngot; +/* 60: */ +/* 61: 48 */ ItemStack tSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMaterial, 1L); +/* 62: 49 */ ItemStack tDust = GT_OreDictUnificator.get(OrePrefixes.dust, tMaterial, tGem, 1L); +/* 63: 50 */ ItemStack tCleaned = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, tMaterial, tDust, 1L); +/* 64: 51 */ ItemStack tCrushed = GT_OreDictUnificator.get(OrePrefixes.crushed, tMaterial, aMaterial.mOreMultiplier * aMultiplier); +/* 65: 52 */ ItemStack tPrimaryByProduct = null;ItemStack tPrimaryByProductSmall = null;ItemStack tSecondaryByProduct = null;ItemStack tSecondaryByProductSmall = null; +/* 66: 54 */ if (tCrushed == null) { +/* 67: 55 */ tCrushed = GT_OreDictUnificator.get(OrePrefixes.dustImpure, tMaterial, GT_Utility.copyAmount(aMaterial.mOreMultiplier * aMultiplier, new Object[] { tCleaned, tDust, tGem }), aMaterial.mOreMultiplier * aMultiplier); +/* 68: */ } +/* 69: 58 */ ArrayList tByProductStacks = new ArrayList(); +/* 70: 60 */ for (Materials tMat : aMaterial.mOreByProducts) +/* 71: */ { +/* 72: 61 */ ItemStack tByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); +/* 73: 62 */ if (tByProduct != null) { +/* 74: 62 */ tByProductStacks.add(tByProduct); +/* 75: */ } +/* 76: 63 */ if (tPrimaryByProduct == null) +/* 77: */ { +/* 78: 64 */ tPrimaryByMaterial = tMat; +/* 79: 65 */ tPrimaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); +/* 80: 66 */ tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L); +/* 81: 67 */ if (tPrimaryByProductSmall == null) { +/* 82: 67 */ tPrimaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); +/* 83: */ } +/* 84: */ } +/* 85: 69 */ if ((tSecondaryByProduct == null) || (tSecondaryByMaterial == tPrimaryByMaterial)) +/* 86: */ { +/* 87: 70 */ tSecondaryByMaterial = tMat; +/* 88: 71 */ tSecondaryByProduct = GT_OreDictUnificator.get(OrePrefixes.dust, tMat, 1L); +/* 89: 72 */ tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustSmall, tMat, 1L); +/* 90: 73 */ if (tSecondaryByProductSmall == null) { +/* 91: 73 */ tSecondaryByProductSmall = GT_OreDictUnificator.get(OrePrefixes.dustTiny, tMat, GT_OreDictUnificator.get(OrePrefixes.nugget, tMat, 2L), 2L); +/* 92: */ } +/* 93: */ } +/* 94: */ } +/* 95: 77 */ if ((!tByProductStacks.isEmpty()) && (!this.mAlreadyListedOres.contains(aMaterial))) +/* 96: */ { +/* 97: 78 */ this.mAlreadyListedOres.add(aMaterial); +/* 98: 79 */ GT_Recipe.GT_Recipe_Map.sByProductList.addFakeRecipe(false, new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.ore, aMaterial, aOreStack, 1L) }, (ItemStack[])tByProductStacks.toArray(new ItemStack[tByProductStacks.size()]), null, null, null, null, 0, 0, 0); +/* 99: */ } +/* 100: 82 */ if (tPrimaryByMaterial == null) { +/* 101: 82 */ tPrimaryByMaterial = tMaterial; +/* 102: */ } +/* 103: 83 */ if (tPrimaryByProduct == null) { +/* 104: 83 */ tPrimaryByProduct = tDust; +/* 105: */ } +/* 106: 84 */ if (tPrimaryByProductSmall == null) { +/* 107: 84 */ tPrimaryByProductSmall = tSmall; +/* 108: */ } +/* 109: 86 */ if (tSecondaryByMaterial == null) { +/* 110: 86 */ tSecondaryByMaterial = tPrimaryByMaterial; +/* 111: */ } +/* 112: 87 */ if (tSecondaryByProduct == null) { +/* 113: 87 */ tSecondaryByProduct = tPrimaryByProduct; +/* 114: */ } +/* 115: 88 */ if (tSecondaryByProductSmall == null) { +/* 116: 88 */ tSecondaryByProductSmall = tPrimaryByProductSmall; +/* 117: */ } +/* 118: 90 */ boolean tHasSmelting = false; +/* 119: 92 */ if (tSmeltInto != null) +/* 120: */ { +/* 121: 93 */ if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) +/* 122: */ { +/* 123: 94 */ GT_ModHandler.removeFurnaceSmelting(aOreStack); +/* 124: */ } +/* 125: */ else +/* 126: */ { +/* 127: 96 */ GT_ModHandler.addInductionSmelterRecipe(aOreStack, new ItemStack(Blocks.sand, 1), GT_Utility.mul(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 1 : 2) * aMaterial.mSmeltingMultiplier, new Object[] { tSmeltInto }), ItemList.TE_Slag_Rich.get(1L, new Object[0]), 300 * aMultiplier, 10 * aMultiplier); +/* 128: 97 */ GT_ModHandler.addInductionSmelterRecipe(aOreStack, ItemList.TE_Slag_Rich.get(aMultiplier, new Object[0]), GT_Utility.mul(aMultiplier * (aMaterial.contains(SubTag.INDUCTIONSMELTING_LOW_OUTPUT) ? 2 : 3) * aMaterial.mSmeltingMultiplier, new Object[] { tSmeltInto }), ItemList.TE_Slag.get(aMultiplier, new Object[0]), 300 * aMultiplier, 95); +/* 129: 98 */ tHasSmelting = GT_ModHandler.addSmeltingRecipe(aOreStack, GT_Utility.copyAmount(aMultiplier * aMaterial.mSmeltingMultiplier, new Object[] { tSmeltInto })); +/* 130: */ } +/* 131:101 */ if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_TRIPLE)) { +/* 132:102 */ GT_Values.RA.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier), null, null, GT_Utility.mul(aMultiplier * 3 * aMaterial.mSmeltingMultiplier, new Object[] { tSmeltInto }), ItemList.TE_Slag.get(1L, new Object[] { GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L) }), tSmeltInto.stackSize * 500, 120, 1500); +/* 133:103 */ } else if (aMaterial.contains(SubTag.BLASTFURNACE_CALCITE_DOUBLE)) { +/* 134:104 */ GT_Values.RA.addBlastRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Calcite, aMultiplier), null, null, GT_Utility.mul(aMultiplier * 2 * aMaterial.mSmeltingMultiplier, new Object[] { tSmeltInto }), ItemList.TE_Slag.get(1L, new Object[] { GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.DarkAsh, 1L) }), tSmeltInto.stackSize * 500, 120, 1500); +/* 135: */ } +/* 136: */ } +/* 137:108 */ if (!tHasSmelting) { +/* 138:109 */ tHasSmelting = GT_ModHandler.addSmeltingRecipe(aOreStack, GT_OreDictUnificator.get(OrePrefixes.gem, tMaterial.mDirectSmelting, Math.max(1, aMultiplier * aMaterial.mSmeltingMultiplier / 2))); +/* 139: */ } +/* 140:112 */ if (tCrushed != null) +/* 141: */ { +/* 142:113 */ GT_Values.RA.addForgeHammerRecipe(aOreStack, GT_Utility.copy(new Object[] { GT_Utility.copyAmount(tCrushed.stackSize, new Object[] { tGem }), tCrushed }), 16, 10); +/* 143:114 */ GT_ModHandler.addPulverisationRecipe(aOreStack, GT_Utility.mul(2L, new Object[] { tCrushed }), tMaterial.contains(SubTag.PULVERIZING_CINNABAR) ? GT_OreDictUnificator.get(OrePrefixes.crystal, Materials.Cinnabar, GT_OreDictUnificator.get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1L, new Object[] { tPrimaryByProduct }), 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.gem, tPrimaryByMaterial, GT_Utility.copyAmount(1L, new Object[] { tPrimaryByProduct }), 1L), tPrimaryByProduct == null ? 0 : tPrimaryByProduct.stackSize * 10 * aMultiplier * aMaterial.mByProductMultiplier, GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial), 50, true); +/* 144: */ } +/* 145:116 */ return true; +/* 146: */ } +/* 147: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingOre + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java b/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java new file mode 100644 index 0000000000..1775455a68 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingOrePoor.java @@ -0,0 +1,54 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingOrePoor +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17: */ public ProcessingOrePoor() +/* 18: */ { +/* 19:15 */ OrePrefixes.orePoor.add(this); +/* 20:16 */ OrePrefixes.oreSmall.add(this); +/* 21:17 */ OrePrefixes.oreNormal.add(this); +/* 22:18 */ OrePrefixes.oreRich.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:23 */ int aMultiplier = 1; +/* 28:24 */ switch (aPrefix.ordinal()) +/* 29: */ { +/* 30: */ case 1: +/* 31:25 */ aMultiplier = 1; break; +/* 32: */ case 2: +/* 33:26 */ aMultiplier = 2; break; +/* 34: */ case 3: +/* 35:27 */ aMultiplier = 3; break; +/* 36: */ case 4: +/* 37:28 */ aMultiplier = 4; +/* 38: */ } +/* 39:30 */ if (aMaterial != null) +/* 40: */ { +/* 41:31 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, aMultiplier), 16, 10); +/* 42:32 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 2 * aMultiplier), GT_OreDictUnificator.get(OrePrefixes.dustTiny, GT_Utility.selectItemInList(0, aMaterial, aMaterial.mOreByProducts), 1L), 5 * aMultiplier, GT_OreDictUnificator.getDust(aPrefix.mSecondaryMaterial), 100, true); +/* 43:33 */ if (aMaterial.contains(SubTag.NO_SMELTING)) { +/* 44:33 */ GT_ModHandler.addSmeltingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, aMultiplier)); +/* 45: */ } +/* 46: */ } +/* 47: */ } +/* 48: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingOrePoor + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java b/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java new file mode 100644 index 0000000000..9616191e1f --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingOreSmelting.java @@ -0,0 +1,65 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingOreSmelting +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17:15 */ private final OrePrefixes[] mSmeltingPrefixes = { OrePrefixes.crushed, OrePrefixes.crushedPurified, OrePrefixes.crushedCentrifuged, OrePrefixes.dustImpure, OrePrefixes.dustPure, OrePrefixes.dustRefined }; +/* 18: */ +/* 19: */ public ProcessingOreSmelting() +/* 20: */ { +/* 21:18 */ for (OrePrefixes tPrefix : this.mSmeltingPrefixes) { +/* 22:18 */ tPrefix.add(this); +/* 23: */ } +/* 24: */ } +/* 25: */ +/* 26: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 27: */ { +/* 28:23 */ GT_ModHandler.removeFurnaceSmelting(aStack); +/* 29:24 */ if (!aMaterial.contains(SubTag.NO_SMELTING)) { +/* 30:25 */ if ((aMaterial.mBlastFurnaceRequired) || (aMaterial.mDirectSmelting.mBlastFurnaceRequired)) +/* 31: */ { +/* 32:26 */ GT_Values.RA.addBlastRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, null, null, aMaterial.mBlastFurnaceTemp > 1750 ? GT_OreDictUnificator.get(OrePrefixes.ingotHot, aMaterial, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), 1L) : GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), null, (int)Math.max(aMaterial.getMass() / 4L, 1L) * aMaterial.mBlastFurnaceTemp, 120, aMaterial.mBlastFurnaceTemp); +/* 33:27 */ if (aMaterial.mBlastFurnaceTemp <= 1000) { +/* 34:27 */ GT_ModHandler.addRCBlastFurnaceRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L), aMaterial.mBlastFurnaceTemp * 2); +/* 35: */ } +/* 36: */ } +/* 37: */ else +/* 38: */ { +/* 39:29 */ switch (aPrefix.ordinal()) +/* 40: */ { +/* 41: */ case 1: +/* 42: */ case 2: +/* 43: */ case 3: +/* 44:31 */ ItemStack tStack = GT_OreDictUnificator.get(OrePrefixes.nugget, aMaterial.mDirectSmelting, aMaterial.mDirectSmelting == aMaterial ? 10L : 3L); +/* 45:32 */ if (tStack == null) { +/* 46:32 */ tStack = GT_OreDictUnificator.get(aMaterial.contains(SubTag.SMELTING_TO_GEM) ? OrePrefixes.gem : OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); +/* 47: */ } +/* 48:33 */ if ((tStack == null) && (!aMaterial.contains(SubTag.SMELTING_TO_GEM))) { +/* 49:33 */ tStack = GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L); +/* 50: */ } +/* 51:34 */ GT_ModHandler.addSmeltingRecipe(aStack, tStack); +/* 52:35 */ break; +/* 53: */ default: +/* 54:37 */ GT_ModHandler.addSmeltingRecipe(aStack, GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mDirectSmelting, 1L)); +/* 55: */ } +/* 56: */ } +/* 57: */ } +/* 58: */ } +/* 59: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingOreSmelting + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPipeLarge.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeLarge.java new file mode 100644 index 0000000000..fa216dcd48 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeLarge.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.enums.SubTag; +/* 6: */ import gregtech.api.enums.ToolDictNames; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingPipeLarge +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingPipeLarge() +/* 17: */ { +/* 18:16 */ OrePrefixes.pipeLarge.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:21 */ if ((!aMaterial.contains(SubTag.NO_WORKING)) && ((aMaterial.contains(SubTag.WOOD)) || (!aMaterial.contains(SubTag.NO_SMASHING)))) { +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PHP", "P P", "PWP", Character.valueOf('P'), aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) : OrePrefixes.plate.get(aMaterial), Character.valueOf('H'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer : ToolDictNames.craftingToolHardHammer, Character.valueOf('W'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw : ToolDictNames.craftingToolWrench }); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPipeLarge + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPipeMedium.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeMedium.java new file mode 100644 index 0000000000..1f3f3c4bd9 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeMedium.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.enums.SubTag; +/* 6: */ import gregtech.api.enums.ToolDictNames; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingPipeMedium +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingPipeMedium() +/* 17: */ { +/* 18:16 */ OrePrefixes.pipeMedium.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:21 */ if ((!aMaterial.contains(SubTag.NO_WORKING)) && ((aMaterial.contains(SubTag.WOOD)) || (!aMaterial.contains(SubTag.NO_SMASHING)))) { +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PPP", "W H", "PPP", Character.valueOf('P'), aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) : OrePrefixes.plate.get(aMaterial), Character.valueOf('H'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer : ToolDictNames.craftingToolHardHammer, Character.valueOf('W'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw : ToolDictNames.craftingToolWrench }); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPipeMedium + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPipeRestrictive.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeRestrictive.java new file mode 100644 index 0000000000..b2375c4b0d --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeRestrictive.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.objects.MaterialStack; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingPipeRestrictive +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingPipeRestrictive() +/* 17: */ { +/* 18:14 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 19:14 */ if (tPrefix.name().startsWith("pipeRestrictive")) { +/* 20:14 */ tPrefix.add(this); +/* 21: */ } +/* 22: */ } +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:19 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(aOreDictName.replaceFirst("Restrictive", ""), null, 1L, false, true), GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Steel, aPrefix.mSecondaryMaterial.mAmount / OrePrefixes.ring.mMaterialAmount), GT_Utility.copyAmount(1L, new Object[] { aStack }), (int)(aPrefix.mSecondaryMaterial.mAmount * 400L / OrePrefixes.ring.mMaterialAmount), 4); +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPipeRestrictive + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPipeSmall.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeSmall.java new file mode 100644 index 0000000000..fe3c7f3955 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPipeSmall.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.enums.SubTag; +/* 6: */ import gregtech.api.enums.ToolDictNames; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingPipeSmall +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingPipeSmall() +/* 17: */ { +/* 18:16 */ OrePrefixes.pipeSmall.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:21 */ if ((!aMaterial.contains(SubTag.NO_WORKING)) && ((aMaterial.contains(SubTag.WOOD)) || (!aMaterial.contains(SubTag.NO_SMASHING)))) { +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(6L, new Object[] { aStack }), GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PWP", "P P", "PHP", Character.valueOf('P'), aMaterial == Materials.Wood ? OrePrefixes.plank.get(aMaterial) : OrePrefixes.plate.get(aMaterial), Character.valueOf('H'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSoftHammer : ToolDictNames.craftingToolHardHammer, Character.valueOf('W'), aMaterial.contains(SubTag.WOOD) ? ToolDictNames.craftingToolSaw : ToolDictNames.craftingToolWrench }); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPipeSmall + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java new file mode 100644 index 0000000000..09269b714f --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlank.java @@ -0,0 +1,73 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.init.Blocks; +/* 13: */ import net.minecraft.init.Items; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ +/* 16: */ public class ProcessingPlank +/* 17: */ implements IOreRecipeRegistrator +/* 18: */ { +/* 19: */ public ProcessingPlank() +/* 20: */ { +/* 21:19 */ OrePrefixes.plank.add(this); +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:24 */ if (aOreDictName.startsWith("plankWood")) +/* 27: */ { +/* 28:25 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 2L), null, 10, 8); +/* 29:26 */ GT_Values.RA.addCNCRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.gearGt, Materials.Wood, 1L), 800, 1); +/* 30:27 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), new ItemStack(Blocks.noteblock, 1), 200, 4); +/* 31:28 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Diamond, 1L), new ItemStack(Blocks.jukebox, 1), 400, 4); +/* 32:29 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Iron, 1L), ItemList.Crate_Empty.get(1L, new Object[0]), 200, 1); +/* 33:30 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.screw, Materials.WroughtIron, 1L), ItemList.Crate_Empty.get(1L, new Object[0]), 200, 1); +/* 34:31 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Steel, 1L), ItemList.Crate_Empty.get(1L, new Object[0]), 200, 1); +/* 35:32 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 1L, new Object[0]), new ItemStack(Blocks.wooden_button, 1), 100, 4); +/* 36:33 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 2L, new Object[0]), new ItemStack(Blocks.wooden_pressure_plate, 1), 200, 4); +/* 37:34 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 3L, new Object[0]), new ItemStack(Blocks.trapdoor, 1), 300, 4); +/* 38:35 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 4L, new Object[0]), new ItemStack(Blocks.crafting_table, 1), 400, 4); +/* 39:36 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(6L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 6L, new Object[0]), new ItemStack(Items.wooden_door, 1), 600, 4); +/* 40:37 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]), new ItemStack(Blocks.chest, 1), 800, 4); +/* 41:38 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(6L, new Object[] { aStack }), new ItemStack(Items.book, 3), new ItemStack(Blocks.bookshelf, 1), 400, 4); +/* 42:40 */ if (aStack.getItemDamage() == 32767) +/* 43: */ { +/* 44:41 */ for (byte i = 0; i < 16; i = (byte)(i + 1)) +/* 45: */ { +/* 46:42 */ ItemStack tStack = GT_Utility.copyMetaData(i, new Object[] { aStack });ItemStack tOutput = GT_ModHandler.getRecipeOutput(new ItemStack[] { tStack, tStack, tStack }); +/* 47:43 */ if ((tOutput != null) && (tOutput.stackSize >= 3)) +/* 48: */ { +/* 49:44 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { tStack }), GT_Utility.copyAmount(tOutput.stackSize / 3, new Object[] { tOutput }), null, 25, 4); +/* 50:45 */ GT_ModHandler.removeRecipe(new ItemStack[] { tStack, tStack, tStack }); +/* 51:46 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(tOutput.stackSize / 3, new Object[] { tOutput }), new Object[] { "sP", Character.valueOf('P'), tStack }); +/* 52: */ } +/* 53: */ } +/* 54: */ } +/* 55: */ else +/* 56: */ { +/* 57:50 */ ItemStack tOutput = GT_ModHandler.getRecipeOutput(new ItemStack[] { aStack, aStack, aStack }); +/* 58:51 */ if ((tOutput != null) && (tOutput.stackSize >= 3)) +/* 59: */ { +/* 60:52 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.copyAmount(tOutput.stackSize / 3, new Object[] { tOutput }), null, 25, 4); +/* 61:53 */ GT_ModHandler.removeRecipe(new ItemStack[] { aStack, aStack, aStack }); +/* 62:54 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(tOutput.stackSize / 3, new Object[] { tOutput }), new Object[] { "sP", Character.valueOf('P'), aStack }); +/* 63: */ } +/* 64: */ } +/* 65: */ } +/* 66: */ } +/* 67: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlank + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate1.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate1.java new file mode 100644 index 0000000000..dda5ad924d --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate1.java @@ -0,0 +1,103 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Recipes; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +import gregtech.api.enums.Textures; +/* 10: */ import gregtech.api.enums.Textures.BlockIcons; +/* 11: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 12: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 13: */ import gregtech.api.objects.GT_CopiedBlockTexture; +/* 14: */ import gregtech.api.objects.GT_RenderedTexture; +/* 15: */ import gregtech.api.util.GT_Config; +/* 16: */ import gregtech.api.util.GT_ModHandler; +/* 17: */ import gregtech.api.util.GT_OreDictUnificator; +/* 18: */ import gregtech.api.util.GT_Utility; +/* 19: */ import net.minecraft.init.Blocks; +/* 20: */ import net.minecraft.init.Items; +/* 21: */ import net.minecraft.item.ItemStack; +/* 22: */ +/* 23: */ public class ProcessingPlate1 +/* 24: */ implements IOreRecipeRegistrator +/* 25: */ { +/* 26: */ public ProcessingPlate1() +/* 27: */ { +/* 28:21 */ OrePrefixes.plate.add(this); +/* 29: */ } +/* 30: */ +/* 31: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 32: */ { +/* 33:26 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 34:27 */ GT_ModHandler.removeRecipe(new ItemStack[] { aStack }); +/* 35: */ +/* 36:29 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), ItemList.Crate_Empty.get(1L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.crateGtPlate, aMaterial, 1L), 100, 8); +/* 37:30 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.crateGtPlate, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 16L), ItemList.Crate_Empty.get(1L, new Object[0]), 800, 1); +/* 38:32 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 39:32 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Plate.get(0L, new Object[0]), aMaterial.getMolten(144L), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), 32, 8); +/* 40: */ } +/* 41:34 */ switch (aMaterial.ordinal()) +/* 42: */ { +/* 43: */ case 1: +/* 44:35 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.iron_block, 1, 0), null); break; +/* 45: */ case 2: +/* 46:36 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.gold_block, 1, 0), null); break; +/* 47: */ case 3: +/* 48:37 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.diamond_block, 1, 0), null); break; +/* 49: */ case 4: +/* 50:38 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.emerald_block, 1, 0), null); break; +/* 51: */ case 5: +/* 52:39 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.lapis_block, 1, 0), null); break; +/* 53: */ case 6: +/* 54:40 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.coal_block, 1, 0), null); break; +/* 55: */ case 7: +/* 56:41 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.redstone_block, 1, 0), null); break; +/* 57: */ case 8: +/* 58:42 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.glowstone, 1, 0), null); break; +/* 59: */ case 9: +/* 60:43 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.quartz_block, 1, 0), null); break; +/* 61: */ case 10: +/* 62:44 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.obsidian, 1, 0), null); break; +/* 63: */ case 11: +/* 64:45 */ GregTech_API.registerCover(aStack, new GT_CopiedBlockTexture(Blocks.stone, 1, 0), null); break; +/* 65: */ case 12: +/* 66:46 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(Textures.BlockIcons.GRANITE_BLACK_SMOOTH), null); break; +/* 67: */ case 13: +/* 68:47 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(Textures.BlockIcons.GRANITE_RED_SMOOTH), null); break; +/* 69: */ case 14: +/* 70:48 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(Textures.BlockIcons.CONCRETE_LIGHT_SMOOTH), null); break; +/* 71: */ default: +/* 72:49 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[71], aMaterial.mRGBa, false), null); +/* 73: */ } +/* 74:52 */ if (aMaterial.mFuelPower > 0) { +/* 75:52 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, aMaterial.mFuelPower, aMaterial.mFuelType); +/* 76: */ } +/* 77:53 */ GT_Utility.removeSimpleIC2MachineRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_ModHandler.getCompressorRecipeList(), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L)); +/* 78:54 */ GT_ModHandler.addCompressionRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.compressed, aMaterial, 1L)); +/* 79:55 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 80:55 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.lens, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L), (int)Math.max(aMaterial.getMass() / 2L, 1L), 16); +/* 81: */ } +/* 82:57 */ if (aMaterial == Materials.Paper) { +/* 83:57 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(GregTech_API.sRecipeFile.get(ConfigCategories.Recipes.harderrecipes, aStack, true) ? 2L : 3L, new Object[] { aStack }), new Object[] { "XXX", Character.valueOf('X'), new ItemStack(Items.reeds, 1, 32767) }); +/* 84: */ } +/* 85:58 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 86: */ { +/* 87:59 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.foil, aMaterial, 4L), (int)Math.max(aMaterial.getMass() * 1L, 1L), 24); +/* 88:60 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 96); +/* 89:61 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L), 96); +/* 90:62 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 4L, 1L), 96); +/* 91:63 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(5L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 5L, 1L), 96); +/* 92:64 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 9L, 1L), 96); +/* 93: */ } +/* 94: */ } +/* 95: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate1 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate2.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate2.java new file mode 100644 index 0000000000..b9022d6e95 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate2.java @@ -0,0 +1,54 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Tools; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +/* 10: */ import gregtech.api.enums.ToolDictNames; +/* 11: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 12: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 13: */ import gregtech.api.objects.GT_RenderedTexture; +/* 14: */ import gregtech.api.util.GT_Config; +/* 15: */ import gregtech.api.util.GT_ModHandler; +/* 16: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 17: */ import gregtech.api.util.GT_OreDictUnificator; +/* 18: */ import gregtech.api.util.GT_Utility; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingPlate2 +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingPlate2() +/* 25: */ { +/* 26:17 */ OrePrefixes.plateDouble.add(this); +/* 27: */ } +/* 28: */ +/* 29: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 30: */ { +/* 31:22 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 32: */ +/* 33:24 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[72], aMaterial.mRGBa, false), null); +/* 34:26 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) { +/* 35:27 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 96); +/* 36: */ } +/* 37:29 */ if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerdoubleplate, OrePrefixes.plate.get(aMaterial).toString(), true))) +/* 38: */ { +/* 39:30 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "I", "B", "h", Character.valueOf('I'), OrePrefixes.plate.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial) }); +/* 40:31 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { ToolDictNames.craftingToolForgeHammer, OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial) }); +/* 41: */ } +/* 42: */ else +/* 43: */ { +/* 44:33 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 2L), ItemList.Circuit_Integrated.getWithDamage(0L, 2L, new Object[0]), Materials.Glue.getFluid(10L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 64, 8); +/* 45: */ } +/* 46: */ } +/* 47: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate2 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate3.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate3.java new file mode 100644 index 0000000000..d505851df7 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate3.java @@ -0,0 +1,54 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Tools; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +/* 10: */ import gregtech.api.enums.ToolDictNames; +/* 11: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 12: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 13: */ import gregtech.api.objects.GT_RenderedTexture; +/* 14: */ import gregtech.api.util.GT_Config; +/* 15: */ import gregtech.api.util.GT_ModHandler; +/* 16: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 17: */ import gregtech.api.util.GT_OreDictUnificator; +/* 18: */ import gregtech.api.util.GT_Utility; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingPlate3 +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingPlate3() +/* 25: */ { +/* 26:17 */ OrePrefixes.plateTriple.add(this); +/* 27: */ } +/* 28: */ +/* 29: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 30: */ { +/* 31:22 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 32: */ +/* 33:24 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[73], aMaterial.mRGBa, false), null); +/* 34:26 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) { +/* 35:27 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 3L, 1L), 96); +/* 36: */ } +/* 37:29 */ if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammertripleplate, OrePrefixes.plate.get(aMaterial).toString(), true))) +/* 38: */ { +/* 39:30 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "I", "B", "h", Character.valueOf('I'), OrePrefixes.plateDouble.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial) }); +/* 40:31 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { ToolDictNames.craftingToolForgeHammer, OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial) }); +/* 41: */ } +/* 42: */ else +/* 43: */ { +/* 44:33 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 3L), ItemList.Circuit_Integrated.getWithDamage(0L, 3L, new Object[0]), Materials.Glue.getFluid(20L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 96, 8); +/* 45: */ } +/* 46: */ } +/* 47: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate3 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate4.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate4.java new file mode 100644 index 0000000000..c95e32c011 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate4.java @@ -0,0 +1,53 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Tools; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +/* 10: */ import gregtech.api.enums.ToolDictNames; +/* 11: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 12: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 13: */ import gregtech.api.objects.GT_RenderedTexture; +/* 14: */ import gregtech.api.util.GT_Config; +/* 15: */ import gregtech.api.util.GT_ModHandler; +/* 16: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 17: */ import gregtech.api.util.GT_OreDictUnificator; +/* 18: */ import gregtech.api.util.GT_Utility; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingPlate4 +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingPlate4() +/* 25: */ { +/* 26:17 */ OrePrefixes.plateQuadruple.add(this); +/* 27: */ } +/* 28: */ +/* 29: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 30: */ { +/* 31:22 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 32:23 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[74], aMaterial.mRGBa, false), null); +/* 33:24 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 34:24 */ GT_Values.RA.addCNCRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial, 1L), (int)Math.max(aMaterial.getMass() * 2L, 1L), 32); +/* 35: */ } +/* 36:25 */ if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerquadrupleplate, OrePrefixes.plate.get(aMaterial).toString(), true))) +/* 37: */ { +/* 38:26 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "I", "B", "h", Character.valueOf('I'), OrePrefixes.plateTriple.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial) }); +/* 39:27 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { ToolDictNames.craftingToolForgeHammer, OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial) }); +/* 40: */ } +/* 41: */ else +/* 42: */ { +/* 43:29 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 4L), ItemList.Circuit_Integrated.getWithDamage(0L, 4L, new Object[0]), Materials.Glue.getFluid(30L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 128, 8); +/* 44: */ } +/* 45: */ } +/* 46: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate4 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate5.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate5.java new file mode 100644 index 0000000000..59c3227375 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate5.java @@ -0,0 +1,50 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ConfigCategories.Tools; +/* 5: */ import gregtech.api.enums.GT_Values; +/* 6: */ import gregtech.api.enums.ItemList; +/* 7: */ import gregtech.api.enums.Materials; +/* 8: */ import gregtech.api.enums.OrePrefixes; +/* 9: */ import gregtech.api.enums.SubTag; +/* 10: */ import gregtech.api.enums.ToolDictNames; +/* 11: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 12: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 13: */ import gregtech.api.objects.GT_RenderedTexture; +/* 14: */ import gregtech.api.util.GT_Config; +/* 15: */ import gregtech.api.util.GT_ModHandler; +/* 16: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 17: */ import gregtech.api.util.GT_OreDictUnificator; +/* 18: */ import gregtech.api.util.GT_Utility; +/* 19: */ import net.minecraft.item.ItemStack; +/* 20: */ +/* 21: */ public class ProcessingPlate5 +/* 22: */ implements IOreRecipeRegistrator +/* 23: */ { +/* 24: */ public ProcessingPlate5() +/* 25: */ { +/* 26:17 */ OrePrefixes.plateQuintuple.add(this); +/* 27: */ } +/* 28: */ +/* 29: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 30: */ { +/* 31:22 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 32:23 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[75], aMaterial.mRGBa, false), null); +/* 33:24 */ if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.hammerquintupleplate, OrePrefixes.plate.get(aMaterial).toString(), true))) +/* 34: */ { +/* 35:25 */ GT_ModHandler.addCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "I", "B", "h", Character.valueOf('I'), OrePrefixes.plateQuadruple.get(aMaterial), Character.valueOf('B'), OrePrefixes.plate.get(aMaterial) }); +/* 36:26 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { ToolDictNames.craftingToolForgeHammer, OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial), OrePrefixes.plate.get(aMaterial) }); +/* 37: */ } +/* 38: */ else +/* 39: */ { +/* 40:28 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 5L), ItemList.Circuit_Integrated.getWithDamage(0L, 5L, new Object[0]), Materials.Glue.getFluid(40L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 160, 8); +/* 41: */ } +/* 42: */ } +/* 43: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate5 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlate9.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate9.java new file mode 100644 index 0000000000..24f99d7160 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlate9.java @@ -0,0 +1,30 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.objects.GT_RenderedTexture; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import net.minecraft.item.ItemStack; +/* 10: */ +/* 11: */ public class ProcessingPlate9 +/* 12: */ implements IOreRecipeRegistrator +/* 13: */ { +/* 14: */ public ProcessingPlate9() +/* 15: */ { +/* 16:15 */ OrePrefixes.plateDense.add(this); +/* 17: */ } +/* 18: */ +/* 19: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 20: */ { +/* 21:20 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 22:21 */ GregTech_API.registerCover(aStack, new GT_RenderedTexture(aMaterial.mIconSet.mTextures[76], aMaterial.mRGBa, false), null); +/* 23: */ } +/* 24: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlate9 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPlateAlloy.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPlateAlloy.java new file mode 100644 index 0000000000..77ff13fa38 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPlateAlloy.java @@ -0,0 +1,44 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.init.Blocks; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingPlateAlloy +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17: */ public ProcessingPlateAlloy() +/* 18: */ { +/* 19:17 */ OrePrefixes.plateAlloy.add(this); +/* 20: */ } +/* 21: */ +/* 22: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 23: */ { +/* 24:22 */ if (aOreDictName.equals("plateAlloyCarbon")) +/* 25: */ { +/* 26:23 */ GT_Values.RA.addAssemblerRecipe(GT_ModHandler.getIC2Item("generator", 1L), GT_Utility.copyAmount(4L, new Object[] { aStack }), GT_ModHandler.getIC2Item("windMill", 1L), 6400, 8); +/* 27: */ } +/* 28:25 */ else if (aOreDictName.equals("plateAlloyAdvanced")) +/* 29: */ { +/* 30:26 */ GT_ModHandler.addAlloySmelterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack(Blocks.glass, 3, 32767), GT_ModHandler.getIC2Item("reinforcedGlass", 4L), 400, 4, false); +/* 31:27 */ GT_ModHandler.addAlloySmelterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Glass, 3L), GT_ModHandler.getIC2Item("reinforcedGlass", 4L), 400, 4, false); +/* 32: */ } +/* 33:29 */ else if (aOreDictName.equals("plateAlloyIridium")) +/* 34: */ { +/* 35:30 */ GT_ModHandler.removeRecipeByOutput(aStack); +/* 36: */ } +/* 37: */ } +/* 38: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPlateAlloy + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java b/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java new file mode 100644 index 0000000000..c44959b5b7 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingPure.java @@ -0,0 +1,34 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingPure +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingPure() +/* 17: */ { +/* 18:15 */ OrePrefixes.crushedPurified.add(this); +/* 19:16 */ OrePrefixes.cleanGravel.add(this); +/* 20:17 */ OrePrefixes.reduced.add(this); +/* 21: */ } +/* 22: */ +/* 23: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 24: */ { +/* 25:22 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustPure, aMaterial.mMacerateInto, 1L), 10, 16); +/* 26:23 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustPure, aMaterial.mMacerateInto, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial.mMacerateInto, 1L), 1L), GT_OreDictUnificator.get(OrePrefixes.dust, GT_Utility.selectItemInList(1, aMaterial.mMacerateInto, aMaterial.mOreByProducts), 1L), 10, false); +/* 27: */ } +/* 28: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingPure + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java b/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java new file mode 100644 index 0000000000..eafdc44847 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingRecycling.java @@ -0,0 +1,36 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_OreDictUnificator; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingRecycling +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingRecycling() +/* 16: */ { +/* 17:14 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 18:14 */ if ((tPrefix.mIsMaterialBased) && (tPrefix.mMaterialAmount > 0L) && (tPrefix.mIsContainer)) { +/* 19:14 */ tPrefix.add(this); +/* 20: */ } +/* 21: */ } +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:19 */ if ((aMaterial != Materials.Empty) && (GT_Utility.getFluidForFilledItem(aStack, true) == null)) { +/* 27:19 */ GT_Values.RA.addCannerRecipe(aStack, null, GT_Utility.getContainerItem(aStack, true), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, aPrefix.mMaterialAmount / 3628800L), (int)Math.max(aMaterial.getMass() / 2L, 1L), 2); +/* 28: */ } +/* 29: */ } +/* 30: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingRecycling + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java b/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java new file mode 100644 index 0000000000..0739d25b98 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingSand.java @@ -0,0 +1,36 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.init.Blocks; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingSand +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17: */ public ProcessingSand() +/* 18: */ { +/* 19:16 */ OrePrefixes.sand.add(this); +/* 20: */ } +/* 21: */ +/* 22: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 23: */ { +/* 24:21 */ if (aOreDictName.equals("sandCracked")) { +/* 25:22 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), -1, GT_ModHandler.getFuelCan(25000), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 8L), null, null, null, new ItemStack(Blocks.sand, 10), 2500); +/* 26:23 */ } else if (aOreDictName.equals("sandOil")) { +/* 27:24 */ GT_Values.RA.addCentrifugeRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), 1, GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, 1L), new ItemStack(Blocks.sand, 1, 0), null, null, null, null, 1000); +/* 28: */ } +/* 29: */ } +/* 30: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingSand + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java b/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java new file mode 100644 index 0000000000..324c269cf5 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingSaplings.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingSaplings +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingSaplings() +/* 17: */ { +/* 18:15 */ OrePrefixes.treeSapling.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L), null, 0, false); +/* 24:21 */ GT_Values.RA.addLatheRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Wood, 1L), 16, 8); +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingSaplings + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java b/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java new file mode 100644 index 0000000000..a406375a59 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingShaping.java @@ -0,0 +1,156 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.enums.SubTag; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.init.Blocks; +/* 14: */ import net.minecraft.init.Items; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class ProcessingShaping +/* 18: */ implements IOreRecipeRegistrator +/* 19: */ { +/* 20: */ public ProcessingShaping() +/* 21: */ { +/* 22: 20 */ OrePrefixes.ingot.add(this); +/* 23: 21 */ OrePrefixes.dust.add(this); +/* 24: */ } +/* 25: */ +/* 26: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 27: */ { +/* 28: 26 */ if (((aMaterial == Materials.Glass) || (GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial, 1L) != null)) && (!aMaterial.contains(SubTag.NO_SMELTING))) +/* 29: */ { +/* 30: 27 */ int tAmount = (int)(aPrefix.mMaterialAmount / 3628800L); +/* 31: 28 */ if ((tAmount > 0) && (tAmount <= 64) && (aPrefix.mMaterialAmount % 3628800L == 0L)) +/* 32: */ { +/* 33: 29 */ int tVoltageMultiplier = aMaterial.mBlastFurnaceTemp >= 2800 ? 64 : 16; +/* 34: 31 */ if (aMaterial.contains(SubTag.NO_SMASHING)) { +/* 35: 32 */ tVoltageMultiplier /= 4; +/* 36: 34 */ } else if (aPrefix.name().startsWith(OrePrefixes.dust.name())) { +/* 37: 34 */ return; +/* 38: */ } +/* 39: 37 */ if (!OrePrefixes.block.isIgnored(aMaterial.mSmeltInto)) +/* 40: */ { +/* 41: 38 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), ItemList.Shape_Extruder_Block.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, tAmount), 10 * tAmount, 8 * tVoltageMultiplier); +/* 42: 39 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(9L, new Object[] { aStack }), ItemList.Shape_Mold_Block.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.block, aMaterial.mSmeltInto, tAmount), 5 * tAmount, 4 * tVoltageMultiplier); +/* 43: */ } +/* 44: 41 */ if ((aPrefix != OrePrefixes.ingot) || (aMaterial != aMaterial.mSmeltInto)) { +/* 45: 42 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Ingot.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, tAmount), 10, 4 * tVoltageMultiplier); +/* 46: */ } +/* 47: 45 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Pipe_Tiny.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.pipeTiny, aMaterial.mSmeltInto, tAmount * 2), 4 * tAmount, 8 * tVoltageMultiplier); +/* 48: 46 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Pipe_Small.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.pipeSmall, aMaterial.mSmeltInto, tAmount), 8 * tAmount, 8 * tVoltageMultiplier); +/* 49: 47 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), ItemList.Shape_Extruder_Pipe_Medium.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.pipeMedium, aMaterial.mSmeltInto, tAmount), 24 * tAmount, 8 * tVoltageMultiplier); +/* 50: 48 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(6L, new Object[] { aStack }), ItemList.Shape_Extruder_Pipe_Large.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.pipeLarge, aMaterial.mSmeltInto, tAmount), 48 * tAmount, 8 * tVoltageMultiplier); +/* 51: 49 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(12L, new Object[] { aStack }), ItemList.Shape_Extruder_Pipe_Huge.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.pipeHuge, aMaterial.mSmeltInto, tAmount), 96 * tAmount, 8 * tVoltageMultiplier); +/* 52: 50 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Plate.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 1L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 53: 51 */ if (tAmount * 2 <= 64) { +/* 54: 51 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Rod.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial.mSmeltInto, tAmount * 2), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 6 * tVoltageMultiplier); +/* 55: */ } +/* 56: 52 */ if (tAmount * 2 <= 64) { +/* 57: 52 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Wire.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial.mSmeltInto, tAmount * 2), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 6 * tVoltageMultiplier); +/* 58: */ } +/* 59: 53 */ if (tAmount * 8 <= 64) { +/* 60: 53 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Bolt.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial.mSmeltInto, tAmount * 8), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 61: */ } +/* 62: 54 */ if (tAmount * 4 <= 64) { +/* 63: 54 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Ring.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.ring, aMaterial.mSmeltInto, tAmount * 4), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 6 * tVoltageMultiplier); +/* 64: */ } +/* 65: 55 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Extruder_Sword.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadSword, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 66: 56 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), ItemList.Shape_Extruder_Pickaxe.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadPickaxe, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 3L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 67: 57 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Shovel.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadShovel, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 1L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 68: 58 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), ItemList.Shape_Extruder_Axe.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadAxe, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 3L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 69: 59 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Extruder_Hoe.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadHoe, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 70: 60 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(6L, new Object[] { aStack }), ItemList.Shape_Extruder_Hammer.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadHammer, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 6L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 71: 61 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Extruder_File.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadFile, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 72: 62 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Extruder_Saw.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.toolHeadSaw, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 73: 63 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), ItemList.Shape_Extruder_Gear.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 5L * tAmount, tAmount), 8 * tVoltageMultiplier); +/* 74: */ +/* 75: 65 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Plate.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 2L * tAmount, tAmount), 2 * tVoltageMultiplier); +/* 76: 66 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.Shape_Mold_Gear.get(0L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.gearGt, aMaterial.mSmeltInto, tAmount), (int)Math.max(aMaterial.getMass() * 10L * tAmount, tAmount), 2 * tVoltageMultiplier); +/* 77: 67 */ switch (aMaterial.mSmeltInto.ordinal()) +/* 78: */ { +/* 79: */ case 1: +/* 80: 69 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Bottle.get(0L, new Object[0]), new ItemStack(Items.glass_bottle, 1), tAmount * 32, 16); +/* 81: 70 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Mold_Bottle.get(0L, new Object[0]), new ItemStack(Items.glass_bottle, 1), tAmount * 64, 4); +/* 82: 71 */ break; +/* 83: */ case 2: +/* 84: 73 */ if (tAmount * 2 <= 64) { +/* 85: 73 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingadviron", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 86: */ } +/* 87: 74 */ if (tAmount * 2 <= 64) { +/* 88: 74 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingadviron", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 89: */ } +/* 90: */ break; +/* 91: */ case 3: +/* 92: */ case 4: +/* 93: 77 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Cell.get(0L, new Object[0]), GT_ModHandler.getIC2Item("fuelRod", tAmount), tAmount * 128, 32); +/* 94: 78 */ if (tAmount * 2 <= 64) { +/* 95: 78 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingiron", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 96: */ } +/* 97: 79 */ if (tAmount * 2 <= 64) { +/* 98: 79 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingiron", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 99: */ } +/* 100: 80 */ if (tAmount * 31 <= 64) { +/* 101: 80 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(31L, new Object[] { aStack }), ItemList.Shape_Mold_Anvil.get(0L, new Object[0]), new ItemStack(Blocks.anvil, 1, 0), tAmount * 512, 4 * tVoltageMultiplier); +/* 102: */ } +/* 103: */ break; +/* 104: */ case 5: +/* 105: 83 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Extruder_Cell.get(0L, new Object[0]), ItemList.Cell_Empty.get(tAmount, new Object[0]), tAmount * 128, 32); +/* 106: 84 */ if (tAmount * 2 <= 64) { +/* 107: 84 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingtin", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 108: */ } +/* 109: 85 */ if (tAmount * 2 <= 64) { +/* 110: 85 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingtin", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 111: */ } +/* 112: */ break; +/* 113: */ case 6: +/* 114: 88 */ if (tAmount * 2 <= 64) { +/* 115: 88 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casinglead", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 116: */ } +/* 117: 89 */ if (tAmount * 2 <= 64) { +/* 118: 89 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casinglead", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 119: */ } +/* 120: */ break; +/* 121: */ case 7: +/* 122: */ case 8: +/* 123: 92 */ if (tAmount * 2 <= 64) { +/* 124: 92 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingcopper", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 125: */ } +/* 126: 93 */ if (tAmount * 2 <= 64) { +/* 127: 93 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingcopper", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 128: */ } +/* 129: */ break; +/* 130: */ case 9: +/* 131: 96 */ if (tAmount * 2 <= 64) { +/* 132: 96 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingbronze", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 133: */ } +/* 134: 97 */ if (tAmount * 2 <= 64) { +/* 135: 97 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casingbronze", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 136: */ } +/* 137: */ break; +/* 138: */ case 10: +/* 139:100 */ if (tAmount * 2 <= 64) { +/* 140:100 */ GT_Values.RA.addExtruderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Shape_Extruder_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casinggold", tAmount * 2), tAmount * 32, 3 * tVoltageMultiplier); +/* 141: */ } +/* 142:101 */ if (tAmount * 2 <= 64) { +/* 143:101 */ GT_Values.RA.addAlloySmelterRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Shape_Mold_Casing.get(0L, new Object[0]), GT_ModHandler.getIC2Item("casinggold", tAmount * 3), tAmount * 128, 1 * tVoltageMultiplier); +/* 144: */ } +/* 145: */ break; +/* 146: */ } +/* 147: */ } +/* 148: */ } +/* 149: */ } +/* 150: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingShaping + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java b/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java new file mode 100644 index 0000000000..cc49362094 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingSlab.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingSlab +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingSlab() +/* 16: */ { +/* 17:14 */ OrePrefixes.slab.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:19 */ if (aOreDictName.startsWith("slabWood")) { +/* 23:20 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), Materials.Creosote.getFluid(1000L), ItemList.RC_Tie_Wood.get(1L, new Object[0]), null, null, null, 200, 4); +/* 24: */ } +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingSlab + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java b/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java new file mode 100644 index 0000000000..b6977ca6cc --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingStick.java @@ -0,0 +1,38 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingStick +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingStick() +/* 17: */ { +/* 18:15 */ OrePrefixes.stick.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 24:20 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 4L), null, (int)Math.max(aMaterial.getMass() * 2L, 1L), 4); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 27: */ { +/* 28:22 */ GT_Values.RA.addForgeHammerRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L), (int)Math.max(aMaterial.getMass(), 1L), 16); +/* 29:23 */ GT_Values.RA.addWiremillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_Utility.copy(new Object[] { GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 4L) }), 50, 4); +/* 30: */ } +/* 31: */ } +/* 32: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingStick + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java b/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java new file mode 100644 index 0000000000..380fe99492 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingStickLong.java @@ -0,0 +1,36 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingStickLong +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingStickLong() +/* 17: */ { +/* 18:15 */ OrePrefixes.stickLong.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ if (!aMaterial.contains(SubTag.NO_WORKING)) { +/* 24:20 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 2L), null, (int)Math.max(aMaterial.getMass(), 1L), 4); +/* 25: */ } +/* 26:21 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) { +/* 27:22 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.spring, aMaterial, 1L), 200, 16); +/* 28: */ } +/* 29: */ } +/* 30: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingStickLong + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java b/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java new file mode 100644 index 0000000000..ac86be0d91 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingStone.java @@ -0,0 +1,84 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.api.util.GT_OreDictUnificator; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 12: */ import net.minecraft.block.Block; +/* 13: */ import net.minecraft.init.Blocks; +/* 14: */ import net.minecraft.init.Items; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class ProcessingStone +/* 18: */ implements IOreRecipeRegistrator +/* 19: */ { +/* 20: */ public ProcessingStone() +/* 21: */ { +/* 22:22 */ OrePrefixes.stone.add(this); +/* 23: */ } +/* 24: */ +/* 25: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 26: */ { +/* 27:27 */ Block aBlock = GT_Utility.getBlockFromStack(aStack); +/* 28:28 */ switch (aMaterial.ordinal()) +/* 29: */ { +/* 30: */ case 1: +/* 31:30 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(3L, new Object[] { aStack }), new ItemStack(Blocks.redstone_torch, 2), Materials.Redstone.getMolten(144L), new ItemStack(Items.repeater, 1), 100, 4); +/* 32:31 */ break; +/* 33: */ case 2: +/* 34:33 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new ItemStack(Blocks.sand, 1, 0), null, 10, false); +/* 35:34 */ break; +/* 36: */ case 3: +/* 37:36 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Endstone, 1L), GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Tungsten, 1L), 5, false); +/* 38:37 */ break; +/* 39: */ case 4: +/* 40:39 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, Materials.Netherrack, 1L), GT_OreDictUnificator.get(OrePrefixes.nugget, Materials.Gold, 1L), 5, false); +/* 41:40 */ break; +/* 42: */ case 5: +/* 43:42 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 1L, new Object[0]), new ItemStack(Blocks.nether_brick_fence, 1), 100, 4); +/* 44:43 */ break; +/* 45: */ case 6: +/* 46:45 */ if (aBlock != Blocks.air) { +/* 47:45 */ aBlock.setResistance(20.0F); +/* 48: */ } +/* 49:46 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 2L), GT_Utility.copyAmount(5L, new Object[] { aStack }), Materials.Glass.getMolten(72L), GT_ModHandler.getModItem("Forestry", "thermionicTubes", 4L, 6), 64, 32); +/* 50:47 */ GT_Values.RA.addAssemblerRecipe(GT_OreDictUnificator.get(OrePrefixes.gem, Materials.NetherStar, 1L), GT_Utility.copyAmount(3L, new Object[] { aStack }), Materials.Glass.getMolten(720L), new ItemStack(Blocks.beacon, 1, 0), 32, 16); +/* 51:48 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.IC2_Compressed_Coal_Ball.get(8L, new Object[0]), ItemList.IC2_Compressed_Coal_Chunk.get(1L, new Object[0]), 400, 4); +/* 52:49 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.gem, Materials.EnderEye, 1L), new ItemStack(Blocks.ender_chest, 1), 400, 4); +/* 53:50 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_ModHandler.getModItem("Railcraft", "cube.crushed.obsidian", 1L, GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), 10, true); +/* 54:51 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), null, 200, 32); +/* 55:52 */ break; +/* 56: */ case 7: +/* 57:54 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), null, 100, 32); +/* 58:55 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L)); +/* 59:56 */ break; +/* 60: */ case 8: +/* 61: */ case 9: +/* 62: */ case 10: +/* 63: */ case 11: +/* 64:58 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L), 10, false); +/* 65:59 */ break; +/* 66: */ case 12: +/* 67:61 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 2L), new ItemStack(Items.flint, 1), 50, false); +/* 68:62 */ break; +/* 69: */ case 13: +/* 70:64 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), null, 200, 32); +/* 71:65 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1L), 1, false); +/* 72:66 */ break; +/* 73: */ case 14: +/* 74:68 */ GT_Values.RA.addCutterRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L), null, 200, 32); +/* 75:69 */ GT_ModHandler.addPulverisationRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dustImpure, aMaterial, 1L), GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Uranium, 1L), 1, false); +/* 76: */ } +/* 77: */ } +/* 78: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingStone + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java b/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java new file mode 100644 index 0000000000..a7d2d25ecc --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingStoneCobble.java @@ -0,0 +1,36 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.init.Blocks; +/* 12: */ import net.minecraft.init.Items; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class ProcessingStoneCobble +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingStoneCobble() +/* 19: */ { +/* 20:18 */ OrePrefixes.stoneCobble.add(this); +/* 21: */ } +/* 22: */ +/* 23: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 24: */ { +/* 25:23 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.stick, Materials.Wood, 1L), new ItemStack(Blocks.lever, 1), 400, 1); +/* 26:24 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]), new ItemStack(Blocks.furnace, 1), 400, 4); +/* 27:25 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(7L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), new ItemStack(Blocks.dropper, 1), 400, 4); +/* 28:26 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(7L, new Object[] { aStack }), new ItemStack(Items.bow, 1, 0), Materials.Redstone.getMolten(144L), new ItemStack(Blocks.dispenser, 1), 400, 4); +/* 29: */ } +/* 30: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingStoneCobble + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java b/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java new file mode 100644 index 0000000000..65b8d01d20 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingStoneVarious.java @@ -0,0 +1,42 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.init.Blocks; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingStoneVarious +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingStoneVarious() +/* 17: */ { +/* 18:15 */ OrePrefixes.stone.add(this); +/* 19:16 */ OrePrefixes.stoneCobble.add(this); +/* 20:17 */ OrePrefixes.stoneBricks.add(this); +/* 21:18 */ OrePrefixes.stoneChiseled.add(this); +/* 22:19 */ OrePrefixes.stoneCracked.add(this); +/* 23:20 */ OrePrefixes.stoneMossy.add(this); +/* 24:21 */ OrePrefixes.stoneMossyBricks.add(this); +/* 25:22 */ OrePrefixes.stoneSmooth.add(this); +/* 26: */ } +/* 27: */ +/* 28: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 29: */ { +/* 30:27 */ if (aPrefix == OrePrefixes.stoneSmooth) +/* 31: */ { +/* 32:28 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 1L, new Object[0]), new ItemStack(Blocks.stone_button, 1), 100, 4); +/* 33:29 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 2L, new Object[0]), new ItemStack(Blocks.stone_pressure_plate, 1), 200, 4); +/* 34: */ } +/* 35: */ } +/* 36: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingStoneVarious + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadArrow.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadArrow.java new file mode 100644 index 0000000000..fb1809c34c --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadArrow.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadArrow +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadArrow() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadArrow.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ if (aMaterial.mStandardMoltenFluid != null) { +/* 23:20 */ GT_Values.RA.addFluidSolidifierRecipe(ItemList.Shape_Mold_Arrow.get(0L, new Object[0]), aMaterial.getMolten(36L), GT_Utility.copyAmount(1L, new Object[] { aStack }), 16, 4); +/* 24: */ } +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadArrow + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadAxe.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadAxe.java new file mode 100644 index 0000000000..472e47539c --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadAxe.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadAxe +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadAxe() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadAxe.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(6, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadAxe + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadBuzzSaw.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadBuzzSaw.java new file mode 100644 index 0000000000..4352f4b624 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadBuzzSaw.java @@ -0,0 +1,32 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.ItemList; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 9: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadBuzzSaw +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadBuzzSaw() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadBuzzSaw.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(140, 1, aMaterial, Materials.StainlessSteel, new long[] { 100000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PBM", "dXG", "SGP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Lithium.get(1L, new Object[0]) }); +/* 23:21 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(140, 1, aMaterial, Materials.StainlessSteel, new long[] { 75000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PBM", "dXG", "SGP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Cadmium.get(1L, new Object[0]) }); +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(140, 1, aMaterial, Materials.StainlessSteel, new long[] { 50000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PBM", "dXG", "SGP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Sodium.get(1L, new Object[0]) }); +/* 25: */ } +/* 26: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadBuzzSaw + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadChainsaw.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadChainsaw.java new file mode 100644 index 0000000000..0c914bdc9d --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadChainsaw.java @@ -0,0 +1,38 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.ItemList; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 9: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadChainsaw +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadChainsaw() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadChainsaw.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(110, 1, aMaterial, Materials.StainlessSteel, new long[] { 100000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Lithium.get(1L, new Object[0]) }); +/* 23:21 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(112, 1, aMaterial, Materials.Titanium, new long[] { 400000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Lithium.get(1L, new Object[0]) }); +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(114, 1, aMaterial, Materials.TungstenSteel, new long[] { 1600000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Lithium.get(1L, new Object[0]) }); +/* 25:23 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(110, 1, aMaterial, Materials.StainlessSteel, new long[] { 75000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Cadmium.get(1L, new Object[0]) }); +/* 26:24 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(112, 1, aMaterial, Materials.Titanium, new long[] { 300000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Cadmium.get(1L, new Object[0]) }); +/* 27:25 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(114, 1, aMaterial, Materials.TungstenSteel, new long[] { 1200000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Cadmium.get(1L, new Object[0]) }); +/* 28:26 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(110, 1, aMaterial, Materials.StainlessSteel, new long[] { 50000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Sodium.get(1L, new Object[0]) }); +/* 29:27 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(112, 1, aMaterial, Materials.Titanium, new long[] { 200000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Sodium.get(1L, new Object[0]) }); +/* 30:28 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(114, 1, aMaterial, Materials.TungstenSteel, new long[] { 800000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0]) }); +/* 31: */ } +/* 32: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadChainsaw + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadDrill.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadDrill.java new file mode 100644 index 0000000000..cf352e6a88 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadDrill.java @@ -0,0 +1,42 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.ItemList; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 9: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadDrill +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadDrill() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadDrill.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(100, 1, aMaterial, Materials.StainlessSteel, new long[] { 100000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Lithium.get(1L, new Object[0]) }); +/* 23:21 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(100, 1, aMaterial, Materials.StainlessSteel, new long[] { 75000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Cadmium.get(1L, new Object[0]) }); +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(100, 1, aMaterial, Materials.StainlessSteel, new long[] { 50000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Sodium.get(1L, new Object[0]) }); +/* 25:23 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(102, 1, aMaterial, Materials.Titanium, new long[] { 400000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Lithium.get(1L, new Object[0]) }); +/* 26:24 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(102, 1, aMaterial, Materials.Titanium, new long[] { 300000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Cadmium.get(1L, new Object[0]) }); +/* 27:25 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(102, 1, aMaterial, Materials.Titanium, new long[] { 200000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Sodium.get(1L, new Object[0]) }); +/* 28:26 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(104, 1, aMaterial, Materials.TungstenSteel, new long[] { 1600000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Lithium.get(1L, new Object[0]) }); +/* 29:27 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(104, 1, aMaterial, Materials.TungstenSteel, new long[] { 1200000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Cadmium.get(1L, new Object[0]) }); +/* 30:28 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(104, 1, aMaterial, Materials.TungstenSteel, new long[] { 800000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0]) }); +/* 31: */ +/* 32:30 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(130, 1, aMaterial, Materials.Titanium, new long[] { 1600000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "PRP", "MPB", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Piston_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('R'), OrePrefixes.spring.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_HV_Lithium.get(1L, new Object[0]) }); +/* 33:31 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(130, 1, aMaterial, Materials.Titanium, new long[] { 1200000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "PRP", "MPB", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Piston_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('R'), OrePrefixes.spring.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_HV_Cadmium.get(1L, new Object[0]) }); +/* 34:32 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(130, 1, aMaterial, Materials.Titanium, new long[] { 800000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "PRP", "MPB", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Piston_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('R'), OrePrefixes.spring.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0]) }); +/* 35: */ } +/* 36: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadDrill + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadFile.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadFile.java new file mode 100644 index 0000000000..d91e6f5c2a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadFile.java @@ -0,0 +1,33 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.enums.SubTag; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 9: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadFile +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadFile() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadFile.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(18, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 23:21 */ if ((!aMaterial.contains(SubTag.NO_SMASHING)) && (!aMaterial.contains(SubTag.BOUNCY))) { +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(18, 1, aMaterial, aMaterial.mHandleMaterial, null), GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "P", "P", "S", Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), Character.valueOf('S'), OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 25: */ } +/* 26: */ } +/* 27: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadFile + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHammer.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHammer.java new file mode 100644 index 0000000000..7f775efd54 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHammer.java @@ -0,0 +1,51 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.enums.SubTag; +/* 7: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 10: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 11: */ import net.minecraft.init.Blocks; +/* 12: */ import net.minecraft.item.ItemStack; +/* 13: */ +/* 14: */ public class ProcessingToolHeadHammer +/* 15: */ implements IOreRecipeRegistrator +/* 16: */ { +/* 17: */ public ProcessingToolHeadHammer() +/* 18: */ { +/* 19:18 */ OrePrefixes.toolHeadHammer.add(this); +/* 20: */ } +/* 21: */ +/* 22: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 23: */ { +/* 24:23 */ if ((aMaterial != Materials.Stone) && (aMaterial != Materials.Flint)) +/* 25: */ { +/* 26:24 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats((aMaterial.contains(SubTag.BOUNCY)) || (aMaterial.contains(SubTag.WOOD)) ? 14 : 12, 1, aMaterial, aMaterial.mHandleMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 27:25 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats((aMaterial.contains(SubTag.BOUNCY)) || (aMaterial.contains(SubTag.WOOD)) ? 14 : 12, 1, aMaterial, aMaterial.mHandleMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "XX ", "XXS", "XX ", Character.valueOf('X'), aMaterial == Materials.Wood ? OrePrefixes.plank.get(Materials.Wood) : OrePrefixes.ingot.get(aMaterial), Character.valueOf('S'), OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 28:26 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats((aMaterial.contains(SubTag.BOUNCY)) || (aMaterial.contains(SubTag.WOOD)) ? 14 : 12, 1, aMaterial, aMaterial.mHandleMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "XX ", "XXS", "XX ", Character.valueOf('X'), aMaterial == Materials.Wood ? OrePrefixes.plank.get(Materials.Wood) : OrePrefixes.gem.get(aMaterial), Character.valueOf('S'), OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 29:27 */ if (aMaterial != Materials.Rubber) { +/* 30:27 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(44, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "xRR", " SR", "S f", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('R'), OrePrefixes.plate.get(Materials.Rubber) }); +/* 31: */ } +/* 32:28 */ if ((!aMaterial.contains(SubTag.WOOD)) && (!aMaterial.contains(SubTag.BOUNCY)) && (!aMaterial.contains(SubTag.NO_SMASHING))) +/* 33: */ { +/* 34:29 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(16, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "IhI", "III", " I ", Character.valueOf('I'), OrePrefixes.ingot.get(aMaterial) }); +/* 35:30 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(20, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "hDS", "DSD", "SDf", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('D'), Dyes.dyeBlue }); +/* 36:31 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(22, 1, aMaterial, aMaterial.mHandleMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { " fS", " Sh", "W ", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('W'), OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 37:32 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(26, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PfP", "hPd", "STS", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), Character.valueOf('T'), OrePrefixes.screw.get(aMaterial) }); +/* 38:33 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(28, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SWS", "SSS", "xSh", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('W'), new ItemStack(Blocks.wool, 1, 32767) }); +/* 39:34 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(30, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PfP", "PdP", "STS", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('P'), OrePrefixes.plate.get(aMaterial), Character.valueOf('T'), OrePrefixes.screw.get(aMaterial) }); +/* 40:35 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(34, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "fPh", " S ", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('P'), OrePrefixes.plate.get(aMaterial) }); +/* 41:36 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(36, 1, aMaterial, aMaterial, null), GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PPf", "PP ", "Sh ", Character.valueOf('S'), OrePrefixes.stick.get(aMaterial), Character.valueOf('P'), OrePrefixes.plate.get(aMaterial) }); +/* 42: */ } +/* 43: */ } +/* 44: */ } +/* 45: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadHammer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHoe.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHoe.java new file mode 100644 index 0000000000..47d72e59a7 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadHoe.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadHoe +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadHoe() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadHoe.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(8, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadHoe + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPickaxe.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPickaxe.java new file mode 100644 index 0000000000..d687affa98 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPickaxe.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadPickaxe +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadPickaxe() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadPickaxe.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(2, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadPickaxe + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPlow.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPlow.java new file mode 100644 index 0000000000..ecbe5b5d6f --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadPlow.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadPlow +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadPlow() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadPlow.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(42, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadPlow + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSaw.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSaw.java new file mode 100644 index 0000000000..33860e4b1a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSaw.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadSaw +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadSaw() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadSaw.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(10, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadSaw + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSense.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSense.java new file mode 100644 index 0000000000..8f2f4baebb --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSense.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadSense +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadSense() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadSense.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(40, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadSense + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadShovel.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadShovel.java new file mode 100644 index 0000000000..4ccf048cae --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadShovel.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadShovel +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadShovel() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadShovel.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(4, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadShovel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSword.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSword.java new file mode 100644 index 0000000000..373e562df5 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadSword.java @@ -0,0 +1,28 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 8: */ import net.minecraft.item.ItemStack; +/* 9: */ +/* 10: */ public class ProcessingToolHeadSword +/* 11: */ implements IOreRecipeRegistrator +/* 12: */ { +/* 13: */ public ProcessingToolHeadSword() +/* 14: */ { +/* 15:13 */ OrePrefixes.toolHeadSword.add(this); +/* 16: */ } +/* 17: */ +/* 18: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 19: */ { +/* 20:18 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(0, 1, aMaterial, aMaterial.mHandleMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial.mHandleMaterial) }); +/* 21: */ } +/* 22: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadSword + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadUniversalSpade.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadUniversalSpade.java new file mode 100644 index 0000000000..acbc950165 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadUniversalSpade.java @@ -0,0 +1,29 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.enums.ToolDictNames; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 9: */ import net.minecraft.item.ItemStack; +/* 10: */ +/* 11: */ public class ProcessingToolHeadUniversalSpade +/* 12: */ implements IOreRecipeRegistrator +/* 13: */ { +/* 14: */ public ProcessingToolHeadUniversalSpade() +/* 15: */ { +/* 16:14 */ OrePrefixes.toolHeadUniversalSpade.add(this); +/* 17: */ } +/* 18: */ +/* 19: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 20: */ { +/* 21:19 */ GT_ModHandler.addShapelessCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(32, 1, aMaterial, aMaterial, null), new Object[] { aOreDictName, OrePrefixes.stick.get(aMaterial), OrePrefixes.screw.get(aMaterial), ToolDictNames.craftingToolScrewdriver }); +/* 22: */ } +/* 23: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadUniversalSpade + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadWrench.java b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadWrench.java new file mode 100644 index 0000000000..98d7ce317a --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingToolHeadWrench.java @@ -0,0 +1,42 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.ItemList; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.util.GT_ModHandler; +/* 8: */ import gregtech.api.util.GT_ModHandler.RecipeBits; +/* 9: */ import gregtech.common.items.GT_MetaGenerated_Tool_01; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingToolHeadWrench +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingToolHeadWrench() +/* 16: */ { +/* 17:15 */ OrePrefixes.toolHeadWrench.add(this); +/* 18: */ } +/* 19: */ +/* 20: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 21: */ { +/* 22:20 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(120, 1, aMaterial, Materials.StainlessSteel, new long[] { 100000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Lithium.get(1L, new Object[0]) }); +/* 23:21 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(122, 1, aMaterial, Materials.Titanium, new long[] { 400000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Lithium.get(1L, new Object[0]) }); +/* 24:22 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(124, 1, aMaterial, Materials.TungstenSteel, new long[] { 1600000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Lithium.get(1L, new Object[0]) }); +/* 25:23 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(120, 1, aMaterial, Materials.StainlessSteel, new long[] { 75000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Cadmium.get(1L, new Object[0]) }); +/* 26:24 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(122, 1, aMaterial, Materials.Titanium, new long[] { 300000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Cadmium.get(1L, new Object[0]) }); +/* 27:25 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(124, 1, aMaterial, Materials.TungstenSteel, new long[] { 1200000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Cadmium.get(1L, new Object[0]) }); +/* 28:26 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(120, 1, aMaterial, Materials.StainlessSteel, new long[] { 50000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Sodium.get(1L, new Object[0]) }); +/* 29:27 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(122, 1, aMaterial, Materials.Titanium, new long[] { 200000L, 128L, 2L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_MV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.Titanium), Character.valueOf('P'), OrePrefixes.plate.get(Materials.Titanium), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.Titanium), Character.valueOf('B'), ItemList.Battery_RE_MV_Sodium.get(1L, new Object[0]) }); +/* 30:28 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(124, 1, aMaterial, Materials.TungstenSteel, new long[] { 800000L, 512L, 3L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "SXd", "GMG", "PBP", Character.valueOf('X'), aOreDictName, Character.valueOf('M'), ItemList.Electric_Motor_HV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.TungstenSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.TungstenSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), Character.valueOf('B'), ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0]) }); +/* 31: */ +/* 32:30 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(150, 1, aMaterial, Materials.StainlessSteel, new long[] { 100000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PdX", "MGS", "GBP", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Lithium.get(1L, new Object[0]) }); +/* 33:31 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(150, 1, aMaterial, Materials.StainlessSteel, new long[] { 75000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PdX", "MGS", "GBP", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Cadmium.get(1L, new Object[0]) }); +/* 34:32 */ GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(150, 1, aMaterial, Materials.StainlessSteel, new long[] { 50000L, 32L, 1L, -1L }), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[] { "PdX", "MGS", "GBP", Character.valueOf('X'), OrePrefixes.stickLong.get(aMaterial), Character.valueOf('M'), ItemList.Electric_Motor_LV.get(1L, new Object[0]), Character.valueOf('S'), OrePrefixes.screw.get(Materials.StainlessSteel), Character.valueOf('P'), OrePrefixes.plate.get(Materials.StainlessSteel), Character.valueOf('G'), OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), Character.valueOf('B'), ItemList.Battery_RE_LV_Sodium.get(1L, new Object[0]) }); +/* 35: */ } +/* 36: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingToolHeadWrench + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java b/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java new file mode 100644 index 0000000000..1613fafbae --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingTransforming.java @@ -0,0 +1,58 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_OreDictUnificator; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import net.minecraft.item.ItemStack; +/* 11: */ +/* 12: */ public class ProcessingTransforming +/* 13: */ implements IOreRecipeRegistrator +/* 14: */ { +/* 15: */ public ProcessingTransforming() +/* 16: */ { +/* 17:17 */ for (OrePrefixes tPrefix : OrePrefixes.values()) { +/* 18:17 */ if (((tPrefix.mMaterialAmount > 0L) && (!tPrefix.mIsContainer) && (!tPrefix.mIsEnchantable)) || (tPrefix == OrePrefixes.plank)) { +/* 19:17 */ tPrefix.add(this); +/* 20: */ } +/* 21: */ } +/* 22: */ } +/* 23: */ +/* 24: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 25: */ { +/* 26:22 */ if (aPrefix == OrePrefixes.plank) { +/* 27:22 */ aPrefix = OrePrefixes.plate; +/* 28: */ } +/* 29:23 */ switch (aMaterial.ordinal()) +/* 30: */ { +/* 31: */ case 1: +/* 32:25 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.SeedOil.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 120L, true)), GT_OreDictUnificator.get(aPrefix, Materials.WoodSealed, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 33:26 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.SeedOilLin.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 80L, true)), GT_OreDictUnificator.get(aPrefix, Materials.WoodSealed, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 34:27 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.SeedOilHemp.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 80L, true)), GT_OreDictUnificator.get(aPrefix, Materials.WoodSealed, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 35:28 */ break; +/* 36: */ case 2: +/* 37:30 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.FierySteel.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 250L, true)), GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 38:31 */ GT_Values.RA.addPolarizerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L), (int)Math.max(16L, aPrefix.mMaterialAmount * 128L / 3628800L), 16); +/* 39:32 */ break; +/* 40: */ case 3: +/* 41:34 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.FierySteel.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 225L, true)), GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 42:35 */ GT_Values.RA.addPolarizerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(aPrefix, Materials.IronMagnetic, 1L), (int)Math.max(16L, aPrefix.mMaterialAmount * 128L / 3628800L), 16); +/* 43:36 */ break; +/* 44: */ case 4: +/* 45:38 */ GT_Values.RA.addChemicalBathRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), Materials.FierySteel.getFluid(GT_Utility.translateMaterialToAmount(aPrefix.mMaterialAmount, 200L, true)), GT_OreDictUnificator.get(aPrefix, Materials.FierySteel, 1L), GT_Values.NI, GT_Values.NI, null, 100, 8); +/* 46:39 */ GT_Values.RA.addPolarizerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(aPrefix, Materials.SteelMagnetic, 1L), (int)Math.max(16L, aPrefix.mMaterialAmount * 128L / 3628800L), 16); +/* 47:40 */ break; +/* 48: */ case 5: +/* 49:42 */ GT_Values.RA.addPolarizerRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(aPrefix, Materials.NeodymiumMagnetic, 1L), (int)Math.max(16L, aPrefix.mMaterialAmount * 128L / 3628800L), 256); +/* 50: */ } +/* 51: */ } +/* 52: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingTransforming + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java new file mode 100644 index 0000000000..a54269c5ec --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWax.java @@ -0,0 +1,31 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_Utility; +/* 9: */ import net.minecraft.item.ItemStack; +/* 10: */ +/* 11: */ public class ProcessingWax +/* 12: */ implements IOreRecipeRegistrator +/* 13: */ { +/* 14: */ public ProcessingWax() +/* 15: */ { +/* 16:13 */ OrePrefixes.wax.add(this); +/* 17: */ } +/* 18: */ +/* 19: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 20: */ { +/* 21:18 */ if (aOreDictName.equals("waxMagical")) { +/* 22:18 */ GT_Values.RA.addFuel(GT_Utility.copyAmount(1L, new Object[] { aStack }), null, 6, 5); +/* 23: */ } +/* 24: */ } +/* 25: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWax + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java new file mode 100644 index 0000000000..7a6ad5b44e --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire01.java @@ -0,0 +1,45 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.ItemList; +/* 5: */ import gregtech.api.enums.Materials; +/* 6: */ import gregtech.api.enums.OrePrefixes; +/* 7: */ import gregtech.api.enums.SubTag; +/* 8: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 9: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 10: */ import gregtech.api.util.GT_ModHandler; +/* 11: */ import gregtech.api.util.GT_OreDictUnificator; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class ProcessingWire01 +/* 16: */ implements IOreRecipeRegistrator +/* 17: */ { +/* 18: */ public ProcessingWire01() +/* 19: */ { +/* 20:17 */ OrePrefixes.wireGt01.add(this); +/* 21: */ } +/* 22: */ +/* 23: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 24: */ { +/* 25:22 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt01, aMaterial, 1L), new Object[] { aOreDictName, OrePrefixes.plate.get(Materials.Rubber) }); +/* 26:23 */ if (!aMaterial.contains(SubTag.NO_SMASHING)) +/* 27: */ { +/* 28:24 */ GT_Values.RA.addBenderRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.springSmall, aMaterial, 2L), 100, 8); +/* 29:25 */ GT_Values.RA.addWiremillRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.wireFine, aMaterial, 4L), 200, 8); +/* 30: */ } +/* 31:27 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 1L), GT_OreDictUnificator.get(OrePrefixes.cableGt01, aMaterial, 1L), 100, 8); +/* 32:28 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt01, aMaterial, 1L), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 1L), 100, 8); +/* 33:29 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(2L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 2L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt02, aMaterial, 1L), 150, 8); +/* 34:30 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(4L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 4L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt04, aMaterial, 1L), 200, 8); +/* 35:31 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(8L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 8L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt08, aMaterial, 1L), 300, 8); +/* 36:32 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(12L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 12L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt12, aMaterial, 1L), 400, 8); +/* 37:33 */ GT_Values.RA.addAssemblerRecipe(GT_Utility.copyAmount(16L, new Object[] { aStack }), ItemList.Circuit_Integrated.getWithDamage(0L, 16L, new Object[0]), GT_OreDictUnificator.get(OrePrefixes.wireGt16, aMaterial, 1L), 500, 8); +/* 38: */ } +/* 39: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire01 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java new file mode 100644 index 0000000000..abc95b22ab --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire02.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingWire02 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingWire02() +/* 17: */ { +/* 18:15 */ OrePrefixes.wireGt02.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 1L), GT_OreDictUnificator.get(OrePrefixes.cableGt02, aMaterial, 1L), 150, 8); +/* 24:21 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt02, aMaterial, 1L), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 1L), 150, 8); +/* 25:22 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt02, aMaterial, 1L), new Object[] { aOreDictName, OrePrefixes.plate.get(Materials.Rubber) }); +/* 26:23 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 2L), new Object[] { aOreDictName }); +/* 27:24 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt01.get(aMaterial), OrePrefixes.wireGt01.get(aMaterial) }); +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire02 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java new file mode 100644 index 0000000000..f0dcde6c20 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire04.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingWire04 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingWire04() +/* 17: */ { +/* 18:15 */ OrePrefixes.wireGt04.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 2L), GT_OreDictUnificator.get(OrePrefixes.cableGt04, aMaterial, 1L), 200, 8); +/* 24:21 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt04, aMaterial, 1L), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 2L), 200, 8); +/* 25:22 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt04, aMaterial, 1L), new Object[] { aOreDictName, OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber) }); +/* 26:23 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 4L), new Object[] { aOreDictName }); +/* 27:24 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt02.get(aMaterial), OrePrefixes.wireGt02.get(aMaterial) }); +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire04 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java new file mode 100644 index 0000000000..3b6ee57bc8 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire08.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingWire08 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingWire08() +/* 17: */ { +/* 18:15 */ OrePrefixes.wireGt08.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 3L), GT_OreDictUnificator.get(OrePrefixes.cableGt08, aMaterial, 1L), 300, 8); +/* 24:21 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt08, aMaterial, 1L), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 3L), 300, 8); +/* 25:22 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt08, aMaterial, 1L), new Object[] { aOreDictName, OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber) }); +/* 26:23 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 8L), new Object[] { aOreDictName }); +/* 27:24 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt04.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire08 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java new file mode 100644 index 0000000000..f1451ccdfa --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire12.java @@ -0,0 +1,35 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.GT_Values; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +/* 6: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 7: */ import gregtech.api.interfaces.internal.IGT_RecipeAdder; +/* 8: */ import gregtech.api.util.GT_ModHandler; +/* 9: */ import gregtech.api.util.GT_OreDictUnificator; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import net.minecraft.item.ItemStack; +/* 12: */ +/* 13: */ public class ProcessingWire12 +/* 14: */ implements IOreRecipeRegistrator +/* 15: */ { +/* 16: */ public ProcessingWire12() +/* 17: */ { +/* 18:15 */ OrePrefixes.wireGt12.add(this); +/* 19: */ } +/* 20: */ +/* 21: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 22: */ { +/* 23:20 */ GT_Values.RA.addBoxingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 4L), GT_OreDictUnificator.get(OrePrefixes.cableGt12, aMaterial, 1L), 400, 8); +/* 24:21 */ GT_Values.RA.addUnboxingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt12, aMaterial, 1L), GT_Utility.copyAmount(1L, new Object[] { aStack }), GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Rubber, 4L), 400, 8); +/* 25:22 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.cableGt12, aMaterial, 1L), new Object[] { aOreDictName, OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber), OrePrefixes.plate.get(Materials.Rubber) }); +/* 26:23 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 12L), new Object[] { aOreDictName }); +/* 27:24 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); +/* 28: */ } +/* 29: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire12 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/loaders/oreprocessing/ProcessingWire16.java b/main/java/gregtech/loaders/oreprocessing/ProcessingWire16.java new file mode 100644 index 0000000000..452b91c9a9 --- /dev/null +++ b/main/java/gregtech/loaders/oreprocessing/ProcessingWire16.java @@ -0,0 +1,31 @@ +/* 1: */ package gregtech.loaders.oreprocessing; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.enums.OrePrefixes; +/* 5: */ import gregtech.api.interfaces.IOreRecipeRegistrator; +/* 6: */ import gregtech.api.util.GT_ModHandler; +/* 7: */ import gregtech.api.util.GT_OreDictUnificator; +/* 8: */ import gregtech.api.util.GT_Utility; +/* 9: */ import net.minecraft.item.ItemStack; +/* 10: */ +/* 11: */ public class ProcessingWire16 +/* 12: */ implements IOreRecipeRegistrator +/* 13: */ { +/* 14: */ public ProcessingWire16() +/* 15: */ { +/* 16:14 */ OrePrefixes.wireGt16.add(this); +/* 17: */ } +/* 18: */ +/* 19: */ public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) +/* 20: */ { +/* 21:19 */ GT_ModHandler.addShapelessCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.wireGt01, aMaterial, 16L), new Object[] { aOreDictName }); +/* 22:20 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt08.get(aMaterial), OrePrefixes.wireGt08.get(aMaterial) }); +/* 23:21 */ GT_ModHandler.addShapelessCraftingRecipe(GT_Utility.copyAmount(1L, new Object[] { aStack }), new Object[] { OrePrefixes.wireGt12.get(aMaterial), OrePrefixes.wireGt04.get(aMaterial) }); +/* 24: */ } +/* 25: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.loaders.oreprocessing.ProcessingWire16 + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file -- cgit