diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java')
| -rw-r--r-- | src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java | 321 |
1 files changed, 321 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java new file mode 100644 index 0000000000..2d573c9fb7 --- /dev/null +++ b/src/main/java/gtPlusPlus/xmod/gregtech/loaders/RecipeGen_BlastSmelter.java @@ -0,0 +1,321 @@ +package gtPlusPlus.xmod.gregtech.loaders; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gtPlusPlus.api.interfaces.RunnableWithInfo; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.recipe.GTPPRecipeCategories; +import gtPlusPlus.api.recipe.GTPPRecipeMaps; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.MaterialGenerator; +import gtPlusPlus.core.material.MaterialStack; +import gtPlusPlus.core.material.nuclear.FLUORIDES; +import gtPlusPlus.core.material.nuclear.NUCLIDE; +import gtPlusPlus.core.material.state.MaterialState; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; + +public class RecipeGen_BlastSmelter extends RecipeGen_Base { + + public static final Set<RunnableWithInfo<Material>> mRecipeGenMap = new HashSet<>(); + + static { + MaterialGenerator.mRecipeMapsToGenerate.put(mRecipeGenMap); + } + + public RecipeGen_BlastSmelter(final Material M) { + this.toGenerate = M; + mRecipeGenMap.add(this); + } + + @Override + public void run() { + generateARecipe(this.toGenerate); + } + + private void generateARecipe(final Material M) { + + // Add a Blast Smelting Recipe, Let's go! + ItemStack tStack; + if (null != (tStack = M.getDust(1))) { + + final Material[] badMaterials = { FLUORIDES.THORIUM_HEXAFLUORIDE, FLUORIDES.THORIUM_TETRAFLUORIDE, + ALLOY.BLOODSTEEL, NUCLIDE.LiFBeF2ThF4UF4, NUCLIDE.LiFBeF2ZrF4UF4, NUCLIDE.LiFBeF2ZrF4U235 }; + for (final Material R : badMaterials) { + if (M == R) { + return; + } + } + + // Prepare some Variables + ItemStack[] components; + ArrayList<MaterialStack> tMaterial = new ArrayList<>(); + int inputStackCount = 0; + int fluidAmount = 0; + final boolean doTest = true; + tMaterial = M.getComposites(); + + // This Bad boy here is what dictates unique recipes. + ItemStack circuitGT; + + // Set a duration - OLD + /* + * int duration = 0; if (M.getMeltingPointK() > 150){ duration = (int) Math.max(M.getMass() / 50L, 1L) * + * M.getMeltingPointK(); } else { duration = (int) Math.max(M.getMass() / 50L, 1L) * 150; } + */ + + long aVoltage = MaterialUtils.getVoltageForTier(M.vTier); + + // Set a duration - NEW + int duration = 120 * M.vTier * 10; + + if (M.vTier <= 4) { + duration = 20 * M.vTier * 10; + } + + int mMaterialListSize = 0; + + int mTotalPartsCounter = M.smallestStackSizeWhenProcessing; + + if (M.getComposites() != null) { + for (final gtPlusPlus.core.material.MaterialStack ternkfsdf : M.getComposites()) { + if (ternkfsdf != null) { + mMaterialListSize++; + // mTotalPartsCounter += ternkfsdf.getSmallestStackSizes()[0]; + } + } + } else { + mMaterialListSize = 1; + } + + if (duration <= 0) { + final int second = 20; + duration = 14 * second * mMaterialListSize * 8; + } + + Logger.WARNING("[BAS] Size: " + mMaterialListSize); + + // Make a simple one Material MaterialStack[] and log it for validity. + circuitGT = ItemUtils.getGregtechCircuit(1); + final ItemStack[] tItemStackTest = new ItemStack[] { circuitGT, tStack }; + inputStackCount = 1; + fluidAmount = 144 * inputStackCount; + Logger.WARNING( + "[BAS] Adding an Alloy Blast Smelter Recipe for " + M.getLocalizedName() + + ". Gives " + + fluidAmount + + "L of molten metal."); + for (int das = 0; das < tItemStackTest.length; das++) { + if (tItemStackTest[das] != null) { + Logger.WARNING( + "[BAS] tMaterial[" + das + + "]: " + + tItemStackTest[das].getDisplayName() + + " Meta: " + + tItemStackTest[das].getItemDamage() + + ", Amount: " + + tItemStackTest[das].stackSize); + } + } + + final boolean hasMoreInputThanACircuit = (tItemStackTest.length > 1); + + // Generate Recipes for all singular materials that can be made molten. + if (hasMoreInputThanACircuit) { + if (M.requiresBlastFurnace()) { + GT_Values.RA.stdBuilder() + .itemInputs(tItemStackTest) + .fluidOutputs(M.getFluidStack(fluidAmount)) + .duration(duration / (mTotalPartsCounter > 0 ? mTotalPartsCounter : 1)) + .eut(aVoltage) + .recipeCategory(GTPPRecipeCategories.absNonAlloyRecipes) + .addTo(GTPPRecipeMaps.alloyBlastSmelterRecipes); + } else { + Logger.WARNING("[BAS] Failed."); + } + } else { + if (CORE.RA.addBlastSmelterRecipe( + tItemStackTest, + M.getFluidStack(fluidAmount), + 100, + duration / (mTotalPartsCounter > 0 ? mTotalPartsCounter : 1) / 2, + (int) aVoltage)) { + Logger.WARNING("[BAS] Success."); + if (GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ingot.get(0), + M.getFluidStack(144), + M.getIngot(1), + duration / 2, + 60)) { + Logger.WARNING("[BAS] Success, Also added a Fluid solidifier recipe."); + /* + * if (GT_Values.RA.addFluidExtractionRecipe(M.getIngot(1), null, M.getFluidStack(144), 100, + * duration/2, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } if + * (GT_Values.RA.addFluidExtractionRecipe(M.getNugget(1), null, M.getFluidStack(16), 100, + * duration/2/9, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + */ + /* + * if (GT_Values.RA.addFluidExtractionRecipe(M.getSmallDust(1), null, M.getFluid(36), 100, + * duration/2/4, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + * if (GT_Values.RA.addFluidExtractionRecipe(M.getTinyDust(1), null, M.getFluid(16), 100, + * duration/2/9, 60)){ Logger.WARNING("[BAS] Success, Also added a Fluid Extractor recipe."); } + */ + } + } else { + Logger.WARNING("[BAS] Failed."); + } + } + + if (tMaterial != null) { + // Reset the Variables for compounds if last recipe was a success. + inputStackCount = 0; + + // If this Material has some kind of compound list, proceed + if (mMaterialListSize > 1) { + final gtPlusPlus.core.material.MaterialStack[] tempStack = new gtPlusPlus.core.material.MaterialStack[mMaterialListSize]; + circuitGT = ItemUtils.getGregtechCircuit(mMaterialListSize); + // Just double checking + if (tempStack.length > 1) { + + // Builds me a MaterialStack[] from the MaterialList of M. + int ooo = 0; + for (final gtPlusPlus.core.material.MaterialStack xMaterial : M.getComposites()) { + if (xMaterial != null) { + if (xMaterial.getStackMaterial() != null) { + Logger.WARNING( + "[BAS] FOUND: " + xMaterial.getStackMaterial() + .getLocalizedName()); + Logger.WARNING( + "[BAS] ADDING: " + xMaterial.getStackMaterial() + .getLocalizedName()); + } + tempStack[ooo] = xMaterial; + } + ooo++; + } + + // Builds me an ItemStack[] of the materials. - Without a circuit - this gets a good count for + // the 144L fluid multiplier + components = new ItemStack[9]; + inputStackCount = 0; + FluidStack componentsFluid = null; + for (int irc = 0; irc < M.getComposites() + .size(); irc++) { + if (M.getComposites() + .get(irc) != null) { + final int r = (int) M.vSmallestRatio[irc]; + inputStackCount = inputStackCount + r; + if ((M.getComposites() + .get(irc) + .getStackMaterial() + .getState() != MaterialState.SOLID) + || !ItemUtils.checkForInvalidItems( + M.getComposites() + .get(irc) + .getDustStack(r))) { + final int xr = r; + if ((xr > 0) && (xr <= 100)) { + final int mathmatics = (r * 1000); + componentsFluid = FluidUtils.getFluidStack( + M.getComposites() + .get(irc) + .getStackMaterial() + .getFluidStack(mathmatics), + mathmatics); + } + } else { + components[irc] = M.getComposites() + .get(irc) + .getUnificatedDustStack(r); + } + } + } + + // Adds a circuit + if ((mMaterialListSize < 9) && (mMaterialListSize != 0)) { + final ItemStack[] components_NoCircuit = components; + // Builds me an ItemStack[] of the materials. - With a circuit + components = new ItemStack[components_NoCircuit.length + 1]; + for (int fr = 0; fr < components.length; fr++) { + if (fr == 0) { + components[0] = circuitGT; + } else { + components[fr] = components_NoCircuit[fr - 1]; + } + } + Logger.WARNING( + "[BAS] Should have added a circuit. mMaterialListSize: " + mMaterialListSize + + " | circuit: " + + components[0].getDisplayName()); + } else { + Logger.WARNING("[BAS] Did not add a circuit. mMaterialListSize: " + mMaterialListSize); + } + + // Set Fluid output + fluidAmount = 144 * inputStackCount; + + Logger.WARNING( + "[BAS] Adding an Alloy Blast Smelter Recipe for " + M.getLocalizedName() + + " using it's compound dusts. This material has " + + inputStackCount + + " parts. Gives " + + fluidAmount + + "L of molten metal."); + Logger.WARNING("[BAS] tMaterial.length: " + components.length + "."); + for (int das = 0; das < components.length; das++) { + if (components[das] != null) { + Logger.WARNING( + "[BAS] tMaterial[" + das + + "]: " + + components[das].getDisplayName() + + " Meta: " + + components[das].getItemDamage() + + ", Amount: " + + components[das].stackSize); + } + } + + // Adds Recipe + if (M.requiresBlastFurnace()) { + if (CORE.RA.addBlastSmelterRecipe( + components, + componentsFluid, + M.getFluidStack(fluidAmount), + 100, + duration, + (int) aVoltage)) { + Logger.WARNING("[BAS] Success."); + } else { + Logger.WARNING("[BAS] Failed."); + } + } else { + if (CORE.RA.addBlastSmelterRecipe( + components, + componentsFluid, + M.getFluidStack(fluidAmount), + 100, + duration, + (int) aVoltage / 2)) { + Logger.WARNING("[BAS] Success."); + } else { + Logger.WARNING("[BAS] Failed."); + } + } + } + } + } else { + Logger.WARNING("[BAS] doTest: " + doTest + " | tMaterial != null: " + (tMaterial != null)); + } + } + } +} |