diff options
Diffstat (limited to 'src/main/java/goodgenerator/util')
| -rw-r--r-- | src/main/java/goodgenerator/util/CharExchanger.java | 52 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/CrackRecipeAdder.java | 624 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/DescTextLocalization.java | 22 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/ItemRefer.java | 221 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/Log.java | 9 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/MaterialFix.java | 393 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/MyRecipeAdder.java | 72 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/StackUtils.java | 143 | ||||
| -rw-r--r-- | src/main/java/goodgenerator/util/StructureHelper.java | 117 |
9 files changed, 1653 insertions, 0 deletions
diff --git a/src/main/java/goodgenerator/util/CharExchanger.java b/src/main/java/goodgenerator/util/CharExchanger.java new file mode 100644 index 0000000000..96019eecd1 --- /dev/null +++ b/src/main/java/goodgenerator/util/CharExchanger.java @@ -0,0 +1,52 @@ +package goodgenerator.util; + +import net.minecraft.util.EnumChatFormatting; + +public class CharExchanger { + + public static final String[] tierName = new String[] { EnumChatFormatting.RED + "ULV" + EnumChatFormatting.RESET, + EnumChatFormatting.GRAY + "LV" + EnumChatFormatting.RESET, + EnumChatFormatting.AQUA + "MV" + EnumChatFormatting.RESET, + EnumChatFormatting.GOLD + "HV" + EnumChatFormatting.RESET, + EnumChatFormatting.DARK_PURPLE + "EV" + EnumChatFormatting.RESET, + EnumChatFormatting.DARK_BLUE + "IV" + EnumChatFormatting.RESET, + EnumChatFormatting.LIGHT_PURPLE + "LuV" + EnumChatFormatting.RESET, + EnumChatFormatting.WHITE + "ZPM" + EnumChatFormatting.RESET, + EnumChatFormatting.DARK_AQUA + "UV" + EnumChatFormatting.RESET, + EnumChatFormatting.DARK_RED + "UHV" + EnumChatFormatting.RESET, + EnumChatFormatting.GREEN + "UEV" + EnumChatFormatting.RESET, }; + + public static char shifter(int unicode) { + return (char) unicode; + } + + public static String formatNumber(String exp) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < exp.length(); ++i) { + if (Character.isDigit(exp.charAt(i))) { + int cnt = 0, prt = i; + while (i < exp.length() && Character.isDigit(exp.charAt(i))) { + i++; + cnt++; + } + while (prt < exp.length() && Character.isDigit(exp.charAt(prt))) { + sb.append(exp.charAt(prt)); + prt++; + cnt--; + if (cnt % 3 == 0 && cnt != 0) sb.append(","); + } + } + if (i < exp.length()) sb.append(exp.charAt(i)); + } + return sb.toString(); + } + + public static String[] genString(String content, int len) { + String[] ret = new String[len]; + while (len > 0) { + len--; + ret[len] = content; + } + return ret; + } +} diff --git a/src/main/java/goodgenerator/util/CrackRecipeAdder.java b/src/main/java/goodgenerator/util/CrackRecipeAdder.java new file mode 100644 index 0000000000..dddb7fe69d --- /dev/null +++ b/src/main/java/goodgenerator/util/CrackRecipeAdder.java @@ -0,0 +1,624 @@ +package goodgenerator.util; + +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.crackingRecipes; +import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes; +import static gregtech.api.recipe.RecipeMaps.distilleryRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.wiremillRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; + +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.TierEU; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Fluid; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_Utility; + +public class CrackRecipeAdder { + + static float[] coe1 = { 1.25f, 1.2f, 1.1f, 0.9f, 0.85f, 0.8f, 0.75f }; + static float[] coe2 = { 1.4f, 1.25f, 1.2f, 0.8f, 0.75f, 0.7f, 0.65f }; + static float[] coe3 = { 1.6f, 1.5f, 1.45f, 0.7f, 0.6f, 0.55f, 0.45f }; + + public static void crackerAdder(FluidStack inputFluid, FluidStack cracker, FluidStack[] outputFluids, + ItemStack outputItem, int num, int EUt, int Duration) { + + String name; + FluidStack[] actOutput = new FluidStack[num]; + name = inputFluid.getFluid() + .getName() + .replaceAll(" ", ""); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(inputFluid, cracker) + .fluidOutputs(FluidRegistry.getFluidStack("lightlycracked" + name, 1000)) + .duration(Math.max((long) (Duration * 0.8), 1L) * TICKS) + .eut(EUt) + .addTo(crackingRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(2)) + .fluidInputs(inputFluid, cracker) + .fluidOutputs(FluidRegistry.getFluidStack("moderatelycracked" + name, 1000)) + .duration(Math.max((long) (Duration), 1L) * TICKS) + .eut(EUt) + .addTo(crackingRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(3)) + .fluidInputs(inputFluid, cracker) + .fluidOutputs(FluidRegistry.getFluidStack("heavilycracked" + name, 1000)) + .duration(Math.max((long) (Duration * 1.2), 1L) * TICKS) + .eut(EUt) + .addTo(crackingRecipes); + + for (int i = num - 1, j = 0; i >= 0; i--, j++) { + Fluid tmp1 = outputFluids[i].getFluid(); + int tmp2 = (int) (outputFluids[i].amount * coe1[i]); + actOutput[j] = new FluidStack(tmp1, tmp2); + } + + addUniversalDistillationRecipe( + FluidRegistry.getFluidStack("lightlycracked" + name, 1000), + actOutput, + outputItem, + Duration / 2, + EUt / 3); + + for (int i = num - 1, j = 0; i >= 0; i--, j++) { + Fluid tmp1 = outputFluids[i].getFluid(); + int tmp2 = (int) (outputFluids[i].amount * coe2[i]); + actOutput[j] = new FluidStack(tmp1, tmp2); + } + + addUniversalDistillationRecipe( + FluidRegistry.getFluidStack("moderatelycracked" + name, 1000), + actOutput, + outputItem, + Duration / 2, + EUt / 3); + + for (int i = num - 1, j = 0; i >= 0; i--, j++) { + Fluid tmp1 = outputFluids[i].getFluid(); + int tmp2 = (int) (outputFluids[i].amount * coe3[i]); + actOutput[j] = new FluidStack(tmp1, tmp2); + } + + addUniversalDistillationRecipe( + FluidRegistry.getFluidStack("heavilycracked" + name, 1000), + actOutput, + outputItem, + Duration / 2, + EUt / 3); + } + + public static void reAddBlastRecipe(Werkstoff material, int duration, int EUt, int level, boolean gas) { + ItemStack input = material.get(OrePrefixes.dust, 1); + ItemStack output = level > 1750 ? material.get(OrePrefixes.ingotHot, 1) : material.get(OrePrefixes.ingot, 1); + if (gas) { + GT_Values.RA.stdBuilder() + .itemInputs(input, GT_Utility.getIntegratedCircuit(11)) + .fluidInputs(Materials.Helium.getGas(1000)) + .itemOutputs(output) + .duration(duration * TICKS) + .eut(EUt) + .metadata(COIL_HEAT, level) + .addTo(blastFurnaceRecipes); + } else { + GT_Values.RA.stdBuilder() + .itemInputs(input, GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(output) + .duration(duration * TICKS) + .eut(EUt) + .metadata(COIL_HEAT, level) + .addTo(blastFurnaceRecipes); + } + } + + public static void addUniversalDistillationRecipewithCircuit(FluidStack aInput, ItemStack[] aCircuit, + FluidStack[] aOutputs, ItemStack aOutput2, int aDuration, long aEUt) { + for (int i = 0; i < Math.min(aOutputs.length, 11); i++) { + GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(i + 1)); + if (aOutput2 != GT_Values.NI) { + buildDistillation.itemOutputs(aOutput2); + } + buildDistillation.fluidInputs(aInput) + .fluidOutputs(aOutputs[i]) + .duration(2 * aDuration) + .eut(aEUt / 4) + .addTo(distilleryRecipes); + } + GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder() + .itemInputs(aCircuit); + if (aOutput2 != GT_Values.NI) { + buildDT.itemOutputs(aOutput2); + } + buildDT.fluidInputs(aInput) + .fluidOutputs(aOutputs) + .duration(aDuration) + .eut(aEUt) + .addTo(distillationTowerRecipes); + } + + public static void addUniversalDistillationRecipe(FluidStack aInput, FluidStack[] aOutputs, ItemStack aOutput2, + int aDuration, long aEUt) { + for (int i = 0; i < Math.min(aOutputs.length, 11); i++) { + GT_RecipeBuilder buildDistillation = GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(i + 1)); + if (aOutput2 != GT_Values.NI) { + buildDistillation.itemOutputs(aOutput2); + } + buildDistillation.fluidInputs(aInput) + .fluidOutputs(aOutputs[i]) + .duration(2 * aDuration) + .eut(aEUt / 4) + .addTo(distilleryRecipes); + } + GT_RecipeBuilder buildDT = GT_Values.RA.stdBuilder(); + if (aOutput2 != GT_Values.NI) { + buildDT.itemOutputs(aOutput2); + } + buildDT.fluidInputs(aInput) + .fluidOutputs(aOutputs) + .duration(aDuration) + .eut(aEUt) + .addTo(distillationTowerRecipes); + } + + public static FluidStack copyFluidWithAmount(FluidStack fluid, int amount) { + if (fluid == null || amount <= 0) return null; + return new FluidStack(fluid.getFluid(), amount); + } + + public static void registerPipe(int ID, Werkstoff material, int flow, int temp, boolean gas) { + String unName = material.getDefaultName() + .replace(" ", "_"); + String Name = material.getDefaultName(); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeTiny.get(material.getBridgeMaterial()), + new GT_MetaPipeEntity_Fluid( + ID, + "GT_Pipe_" + unName + "_Tiny", + "Tiny " + Name + " Fluid Pipe", + 0.25F, + material.getBridgeMaterial(), + flow / 6, + temp, + gas).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeSmall.get(material.getBridgeMaterial()), + new GT_MetaPipeEntity_Fluid( + ID + 1, + "GT_Pipe_" + unName + "_Small", + "Small " + Name + " Fluid Pipe", + 0.375F, + material.getBridgeMaterial(), + flow / 3, + temp, + gas).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeMedium.get(material.getBridgeMaterial()), + new GT_MetaPipeEntity_Fluid( + ID + 2, + "GT_Pipe_" + unName, + Name + " Fluid Pipe", + 0.5F, + material.getBridgeMaterial(), + flow, + temp, + gas).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeLarge.get(material.getBridgeMaterial()), + new GT_MetaPipeEntity_Fluid( + ID + 3, + "GT_Pipe_" + unName + "_Large", + "Large " + Name + " Fluid Pipe", + 0.75F, + material.getBridgeMaterial(), + flow * 2, + temp, + gas).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeHuge.get(material.getBridgeMaterial()), + new GT_MetaPipeEntity_Fluid( + ID + 4, + "GT_Pipe_" + unName + "_Huge", + "Huge " + Name + " Fluid Pipe", + 0.875F, + material.getBridgeMaterial(), + flow * 4, + temp, + gas).getStackForm(1L)); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Tiny.get(0)) + .itemOutputs(material.get(OrePrefixes.pipeTiny, 2)) + .duration( + material.getStats() + .getMass() * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Pipe_Small.get(0)) + .itemOutputs(material.get(OrePrefixes.pipeSmall, 1)) + .duration( + material.getStats() + .getMass() * 2 + * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 3), ItemList.Shape_Extruder_Pipe_Medium.get(0)) + .itemOutputs(material.get(OrePrefixes.pipeMedium, 1)) + .duration( + material.getStats() + .getMass() * 6 + * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 6), ItemList.Shape_Extruder_Pipe_Large.get(0)) + .itemOutputs(material.get(OrePrefixes.pipeLarge, 1)) + .duration( + material.getStats() + .getMass() * 12 + * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 12), ItemList.Shape_Extruder_Pipe_Huge.get(0)) + .itemOutputs(material.get(OrePrefixes.pipeHuge, 1)) + .duration( + material.getStats() + .getMass() * 24 + * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(extruderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Tiny.get(0)) + .fluidInputs(material.getMolten(72)) + .itemOutputs(material.get(OrePrefixes.pipeTiny, 1)) + .duration( + material.getStats() + .getMass() * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Small.get(0)) + .fluidInputs(material.getMolten(144)) + .itemOutputs(material.get(OrePrefixes.pipeSmall, 1)) + .duration( + material.getStats() + .getMass() * 2 + * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Medium.get(0)) + .fluidInputs(material.getMolten(432)) + .itemOutputs(material.get(OrePrefixes.pipeMedium, 1)) + .duration( + material.getStats() + .getMass() * 6 + * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Large.get(0)) + .fluidInputs(material.getMolten(864)) + .itemOutputs(material.get(OrePrefixes.pipeLarge, 1)) + .duration( + material.getStats() + .getMass() * 12 + * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Pipe_Huge.get(0)) + .fluidInputs(material.getMolten(1728)) + .itemOutputs(material.get(OrePrefixes.pipeHuge, 1)) + .duration( + material.getStats() + .getMass() * 24 + * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidSolidifierRecipes); + } + + public static void registerWire(int ID, Werkstoff material, int aAmperage, int aVoltage, int aLoss, boolean cover) { + String unName = material.getDefaultName() + .replace(" ", "_") + .toLowerCase(); + String Name = material.getDefaultName(); + String aTextWire1 = "wire."; + String aTextCable1 = "cable."; + String aTextWire2 = " Wire"; + String aTextCable2 = " Cable"; + int aLossInsulated = aLoss / 4; + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt01, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 0, + aTextWire1 + unName + ".01", + "1x " + Name + aTextWire2, + 0.125F, + material.getBridgeMaterial(), + aLoss, + 1L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt02, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 1, + aTextWire1 + unName + ".02", + "2x " + Name + aTextWire2, + 0.25F, + material.getBridgeMaterial(), + aLoss, + 2L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt04, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 2, + aTextWire1 + unName + ".04", + "4x " + Name + aTextWire2, + 0.375F, + material.getBridgeMaterial(), + aLoss, + 4L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt08, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 3, + aTextWire1 + unName + ".08", + "8x " + Name + aTextWire2, + 0.5F, + material.getBridgeMaterial(), + aLoss, + 8L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt12, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 4, + aTextWire1 + unName + ".12", + "12x " + Name + aTextWire2, + 0.625F, + material.getBridgeMaterial(), + aLoss, + 12L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt16, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 5, + aTextWire1 + unName + ".16", + "16x " + Name + aTextWire2, + 0.75F, + material.getBridgeMaterial(), + aLoss, + 16L * aAmperage, + aVoltage, + false, + true).getStackForm(1L)); + if (cover) { + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt01, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 6, + aTextCable1 + unName + ".01", + "1x " + Name + aTextCable2, + 0.25F, + material.getBridgeMaterial(), + aLossInsulated, + 1L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt02, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 7, + aTextCable1 + unName + ".02", + "2x " + Name + aTextCable2, + 0.375F, + material.getBridgeMaterial(), + aLossInsulated, + 2L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt04, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 8, + aTextCable1 + unName + ".04", + "4x " + Name + aTextCable2, + 0.5F, + material.getBridgeMaterial(), + aLossInsulated, + 4L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt08, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 9, + aTextCable1 + unName + ".08", + "8x " + Name + aTextCable2, + 0.625F, + material.getBridgeMaterial(), + aLossInsulated, + 8L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt12, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 10, + aTextCable1 + unName + ".12", + "12x " + Name + aTextCable2, + 0.75F, + material.getBridgeMaterial(), + aLossInsulated, + 12L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt16, + material.getBridgeMaterial(), + new GT_MetaPipeEntity_Cable( + ID + 11, + aTextCable1 + unName + ".16", + "16x " + Name + aTextCable2, + 0.875F, + material.getBridgeMaterial(), + aLossInsulated, + 16L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + } + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(material.get(OrePrefixes.wireGt01, 2)) + .duration(5 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(material.get(OrePrefixes.wireGt02, 1)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 2), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(material.get(OrePrefixes.wireGt04, 1)) + .duration(10 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 4), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(material.get(OrePrefixes.wireGt08, 1)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 6), GT_Utility.getIntegratedCircuit(12)) + .itemOutputs(material.get(OrePrefixes.wireGt12, 1)) + .duration(15 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 8), GT_Utility.getIntegratedCircuit(16)) + .itemOutputs(material.get(OrePrefixes.wireGt16, 1)) + .duration(17 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(material.get(OrePrefixes.wireGt01, 1)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 2), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(material.get(OrePrefixes.wireGt02, 1)) + .duration(5 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 4), GT_Utility.getIntegratedCircuit(4)) + .itemOutputs(material.get(OrePrefixes.wireGt04, 1)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 8), GT_Utility.getIntegratedCircuit(8)) + .itemOutputs(material.get(OrePrefixes.wireGt08, 1)) + .duration(10 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 12), GT_Utility.getIntegratedCircuit(12)) + .itemOutputs(material.get(OrePrefixes.wireGt12, 1)) + .duration(12 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 16), GT_Utility.getIntegratedCircuit(16)) + .itemOutputs(material.get(OrePrefixes.wireGt16, 1)) + .duration(15 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(material.get(OrePrefixes.wireFine, 8)) + .duration(5 * SECONDS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(material.get(OrePrefixes.wireFine, 4)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(4) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.wireGt01, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(material.get(OrePrefixes.wireFine, 4)) + .duration(10 * SECONDS) + .eut(8) + .addTo(wiremillRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot, 1), ItemList.Shape_Extruder_Wire.get(0)) + .itemOutputs(material.get(OrePrefixes.wireGt01, 2)) + .duration( + material.getStats() + .getMass() * 8 + * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(extruderRecipes); + } +} diff --git a/src/main/java/goodgenerator/util/DescTextLocalization.java b/src/main/java/goodgenerator/util/DescTextLocalization.java new file mode 100644 index 0000000000..3470737d6b --- /dev/null +++ b/src/main/java/goodgenerator/util/DescTextLocalization.java @@ -0,0 +1,22 @@ +package goodgenerator.util; + +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +public class DescTextLocalization { + + public static final String BLUE_PRINT_INFO = "Follow the" + EnumChatFormatting.BLUE + + " Structure" + + EnumChatFormatting.DARK_BLUE + + "Lib" + + EnumChatFormatting.GRAY + + " hologram projector to build the main structure."; + + public static String[] addText(String preFix, int length) { + String[] text = new String[length]; + for (int i = 0; i < length; i++) { + text[i] = StatCollector.translateToLocal(preFix + "." + i); + } + return text; + } +} diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java new file mode 100644 index 0000000000..400199ef03 --- /dev/null +++ b/src/main/java/goodgenerator/util/ItemRefer.java @@ -0,0 +1,221 @@ +package goodgenerator.util; + +import static goodgenerator.loader.FuelRodLoader.*; +import static goodgenerator.loader.Loaders.*; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import gregtech.api.util.GT_Utility; +import ic2.core.Ic2Items; + +public final class ItemRefer { + + public static ItemRefer NULL = getItemStack(_null_); + + public static ItemRefer Radiation_Protection_Plate = getItemStack(radiationProtectionPlate); + public static ItemRefer Wrapped_Uranium_Ingot = getItemStack(wrappedUraniumIngot); + public static ItemRefer High_Density_Uranium_Nugget = getItemStack(highDensityUraniumNugget); + public static ItemRefer High_Density_Uranium = getItemStack(highDensityUranium); + public static ItemRefer Wrapped_Thorium_Ingot = getItemStack(wrappedThoriumIngot); + public static ItemRefer High_Density_Thorium_Nugget = getItemStack(highDensityThoriumNugget); + public static ItemRefer High_Density_Thorium = getItemStack(highDensityThorium); + public static ItemRefer Wrapped_Plutonium_Ingot = getItemStack(wrappedPlutoniumIngot); + public static ItemRefer High_Density_Plutonium_Nugget = getItemStack(highDensityPlutoniumNugget); + public static ItemRefer High_Density_Plutonium = getItemStack(highDensityPlutonium); + public static ItemRefer Raw_Atomic_Separation_Catalyst = getItemStack(rawAtomicSeparationCatalyst); + public static ItemRefer Advanced_Radiation_Protection_Plate = getItemStack(advancedRadiationProtectionPlate); + public static ItemRefer Aluminum_Nitride_Dust = getItemStack(aluminumNitride); + public static ItemRefer Special_Ceramics_Dust = getItemStack(specialCeramics); + public static ItemRefer Special_Ceramics_Plate = getItemStack(specialCeramicsPlate); + public static ItemRefer Radioactive_Waste = getItemStack(radioactiveWaste); + public static ItemRefer Plastic_Case = getItemStack(plasticCase); + public static ItemRefer Quartz_Wafer = getItemStack(quartzWafer); + public static ItemRefer Micro_Heater = getItemStack(microHeater); + public static ItemRefer Quartz_Crystal_Resonator = getItemStack(quartzCrystalResonator); + public static ItemRefer Inverter = getItemStack(inverter); + public static ItemRefer Neutron_Source = getItemStack(neutronSource); + public static ItemRefer Naquadah_Mass = getItemStack(naquadahMass); + public static ItemRefer Enriched_Naquadah_Mass = getItemStack(enrichedNaquadahMass); + public static ItemRefer Naquadria_Mass = getItemStack(naquadriaMass); + public static ItemRefer Advanced_Fuel_Rod = getItemStack(advancedFuelRod); + public static ItemRefer Fuel_Rod_U_Depleted_1 = getItemStack(rodCompressedUraniumDepleted); + public static ItemRefer Fuel_Rod_U_Depleted_2 = getItemStack(rodCompressedUraniumDepleted_2); + public static ItemRefer Fuel_Rod_U_Depleted_4 = getItemStack(rodCompressedUraniumDepleted_4); + public static ItemRefer Fuel_Rod_U_1 = getItemStack(rodCompressedUranium); + public static ItemRefer Fuel_Rod_U_2 = getItemStack(rodCompressedUranium_2); + public static ItemRefer Fuel_Rod_U_4 = getItemStack(rodCompressedUranium_4); + public static ItemRefer Fuel_Rod_Pu_Depleted_1 = getItemStack(rodCompressedPlutoniumDepleted); + public static ItemRefer Fuel_Rod_Pu_Depleted_2 = getItemStack(rodCompressedPlutoniumDepleted_2); + public static ItemRefer Fuel_Rod_Pu_Depleted_4 = getItemStack(rodCompressedPlutoniumDepleted_4); + public static ItemRefer Fuel_Rod_Pu_1 = getItemStack(rodCompressedPlutonium); + public static ItemRefer Fuel_Rod_Pu_2 = getItemStack(rodCompressedPlutonium_2); + public static ItemRefer Fuel_Rod_Pu_4 = getItemStack(rodCompressedPlutonium_4); + public static ItemRefer Fuel_Rod_LU_Depleted_1 = getItemStack(rodLiquidUraniumDepleted); + public static ItemRefer Fuel_Rod_LU_Depleted_2 = getItemStack(rodLiquidUraniumDepleted_2); + public static ItemRefer Fuel_Rod_LU_Depleted_4 = getItemStack(rodLiquidUraniumDepleted_4); + public static ItemRefer Fuel_Rod_LU_1 = getItemStack(rodLiquidUranium); + public static ItemRefer Fuel_Rod_LU_2 = getItemStack(rodLiquidUranium_2); + public static ItemRefer Fuel_Rod_LU_4 = getItemStack(rodLiquidUranium_4); + public static ItemRefer Fuel_Rod_LPu_Depleted_1 = getItemStack(rodLiquidPlutoniumDepleted); + public static ItemRefer Fuel_Rod_LPu_Depleted_2 = getItemStack(rodLiquidPlutoniumDepleted_2); + public static ItemRefer Fuel_Rod_LPu_Depleted_4 = getItemStack(rodLiquidPlutoniumDepleted_4); + public static ItemRefer Fuel_Rod_LPu_1 = getItemStack(rodLiquidPlutonium); + public static ItemRefer Fuel_Rod_LPu_2 = getItemStack(rodLiquidPlutonium_2); + public static ItemRefer Fuel_Rod_LPu_4 = getItemStack(rodLiquidPlutonium_4); + public static ItemRefer Fluid_Storage_Core_T1 = getItemStack(fluidCore, 0); + public static ItemRefer Fluid_Storage_Core_T2 = getItemStack(fluidCore, 1); + public static ItemRefer Fluid_Storage_Core_T3 = getItemStack(fluidCore, 2); + public static ItemRefer Fluid_Storage_Core_T4 = getItemStack(fluidCore, 3); + public static ItemRefer Fluid_Storage_Core_T5 = getItemStack(fluidCore, 4); + public static ItemRefer Fluid_Storage_Core_T6 = getItemStack(fluidCore, 5); + public static ItemRefer Fluid_Storage_Core_T7 = getItemStack(fluidCore, 6); + public static ItemRefer Fluid_Storage_Core_T8 = getItemStack(fluidCore, 7); + public static ItemRefer Fluid_Storage_Core_T9 = getItemStack(fluidCore, 8); + public static ItemRefer Fluid_Storage_Core_T10 = getItemStack(fluidCore, 9); + public static ItemRefer Essentia_Upgrade_Empty = getItemStack(upgradeEssentia, 0); + public static ItemRefer Essentia_Upgrade_Air = getItemStack(upgradeEssentia, 1); + public static ItemRefer Essentia_Upgrade_Thermal = getItemStack(upgradeEssentia, 2); + public static ItemRefer Essentia_Upgrade_Unstable = getItemStack(upgradeEssentia, 3); + public static ItemRefer Essentia_Upgrade_Victus = getItemStack(upgradeEssentia, 4); + public static ItemRefer Essentia_Upgrade_Tainted = getItemStack(upgradeEssentia, 5); + public static ItemRefer Essentia_Upgrade_Mechanics = getItemStack(upgradeEssentia, 6); + public static ItemRefer Essentia_Upgrade_Spirit = getItemStack(upgradeEssentia, 7); + public static ItemRefer Essentia_Upgrade_Radiation = getItemStack(upgradeEssentia, 8); + public static ItemRefer Essentia_Upgrade_Electric = getItemStack(upgradeEssentia, 9); + public static ItemRefer High_Energy_Mixture = getItemStack(highEnergyMixture); + public static ItemRefer Salty_Root = getItemStack(saltyRoot); + public static ItemRefer HiC_T1 = getItemStack(huiCircuit, 0); + public static ItemRefer HiC_T2 = getItemStack(huiCircuit, 1); + public static ItemRefer HiC_T3 = getItemStack(huiCircuit, 2); + public static ItemRefer HiC_T4 = getItemStack(huiCircuit, 3); + public static ItemRefer HiC_T5 = getItemStack(huiCircuit, 4); + public static ItemRefer IC2_Ir_Plate = getItemStack(Ic2Items.iridiumPlate); + public static ItemRefer IC2_Glass = getItemStack(Ic2Items.reinforcedGlass); + + public static ItemRefer Field_Restriction_Casing = getItemStack(MAR_Casing); + public static ItemRefer Naquadah_Fuel_Refinery_Casing = getItemStack(FRF_Casings); + public static ItemRefer Field_Restriction_Coil_T1 = getItemStack(FRF_Coil_1); + public static ItemRefer Field_Restriction_Coil_T2 = getItemStack(FRF_Coil_2); + public static ItemRefer Field_Restriction_Coil_T3 = getItemStack(FRF_Coil_3); + public static ItemRefer Field_Restriction_Coil_T4 = getItemStack(FRF_Coil_4); + public static ItemRefer Radiation_Proof_Steel_Frame_Box = getItemStack(radiationProtectionSteelFrame); + public static ItemRefer Field_Restriction_Glass = getItemStack(fieldRestrictingGlass); + public static ItemRefer Raw_Cylinder = getItemStack(rawCylinder); + public static ItemRefer Titanium_Plated_Cylinder = getItemStack(titaniumPlatedCylinder); + public static ItemRefer Magic_Casing = getItemStack(magicCasing); + public static ItemRefer Speeding_Pipe = getItemStack(speedingPipe); + public static ItemRefer Essentia_Cell_T1 = getItemStack(essentiaCell, 0); + public static ItemRefer Essentia_Cell_T2 = getItemStack(essentiaCell, 1); + public static ItemRefer Essentia_Cell_T3 = getItemStack(essentiaCell, 2); + public static ItemRefer Essentia_Cell_T4 = getItemStack(essentiaCell, 3); + public static ItemRefer Essentia_Hatch = getItemStack(essentiaHatch); + public static ItemRefer YOTTank_Casing = getItemStack(yottaFluidTankCasing); + public static ItemRefer YOTTank_Cell_T1 = getItemStack(yottaFluidTankCell, 0); + public static ItemRefer YOTTank_Cell_T2 = getItemStack(yottaFluidTankCell, 1); + public static ItemRefer YOTTank_Cell_T3 = getItemStack(yottaFluidTankCell, 2); + public static ItemRefer YOTTank_Cell_T4 = getItemStack(yottaFluidTankCell, 3); + public static ItemRefer YOTTank_Cell_T5 = getItemStack(yottaFluidTankCell, 4); + public static ItemRefer YOTTank_Cell_T6 = getItemStack(yottaFluidTankCell, 5); + public static ItemRefer YOTTank_Cell_T7 = getItemStack(yottaFluidTankCell, 6); + public static ItemRefer YOTTank_Cell_T8 = getItemStack(yottaFluidTankCell, 7); + public static ItemRefer YOTTank_Cell_T9 = getItemStack(yottaFluidTankCell, 8); + public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9); + public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing); + public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls); + public static ItemRefer Precise_Electronic_Unit_T1 = getItemStack(preciseUnitCasing, 0); + public static ItemRefer Precise_Electronic_Unit_T2 = getItemStack(preciseUnitCasing, 1); + public static ItemRefer Precise_Electronic_Unit_T3 = getItemStack(preciseUnitCasing, 2); + public static ItemRefer Compact_Fusion_Coil_T0 = getItemStack(compactFusionCoil, 0); + public static ItemRefer Compact_Fusion_Coil_T1 = getItemStack(compactFusionCoil, 1); + public static ItemRefer Compact_Fusion_Coil_T2 = getItemStack(compactFusionCoil, 2); + public static ItemRefer Compact_Fusion_Coil_T3 = getItemStack(compactFusionCoil, 3); + public static ItemRefer Compact_Fusion_Coil_T4 = getItemStack(compactFusionCoil, 4); + public static ItemRefer Essentia_Filter_Casing = getItemStack(essentiaFilterCasing); + public static ItemRefer Essentia_Output_Hatch = getItemStack(essentiaOutputHatch); + public static ItemRefer Essentia_Output_Hatch_ME = getItemStack(essentiaOutputHatch_ME); + + public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR); + public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF); + public static ItemRefer Universal_Chemical_Fuel_Engine = getItemStack(UCFE); + public static ItemRefer Large_Essentia_Generator = getItemStack(LEG); + public static ItemRefer YOTTank = getItemStack(YFT); + public static ItemRefer Combustion_Generator_EV = getItemStack(Generator_Diesel[0]); + public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]); + public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine); + public static ItemRefer Extreme_Heat_Exchanger = getItemStack(XHE); + public static ItemRefer Precise_Assembler = getItemStack(PA); + public static ItemRefer Compact_Fusion_MK1 = getItemStack(LFC[0]); + public static ItemRefer Compact_Fusion_MK2 = getItemStack(LFC[1]); + public static ItemRefer Compact_Fusion_MK3 = getItemStack(LFC[2]); + public static ItemRefer Compact_Fusion_MK4 = getItemStack(LFC[3]); + public static ItemRefer Compact_Fusion_MK5 = getItemStack(LFC[4]); + public static ItemRefer Large_Essentia_Smeltery = getItemStack(LES); + public static ItemRefer Coolant_Tower = getItemStack(CT); + public static ItemRefer Component_Assembly_Line = getItemStack(CompAssline); + + public static ItemRefer Compassline_Casing_LV = getItemStack(componentAssemblylineCasing, 0); + public static ItemRefer Compassline_Casing_MV = getItemStack(componentAssemblylineCasing, 1); + public static ItemRefer Compassline_Casing_HV = getItemStack(componentAssemblylineCasing, 2); + public static ItemRefer Compassline_Casing_EV = getItemStack(componentAssemblylineCasing, 3); + public static ItemRefer Compassline_Casing_IV = getItemStack(componentAssemblylineCasing, 4); + public static ItemRefer Compassline_Casing_LuV = getItemStack(componentAssemblylineCasing, 5); + public static ItemRefer Compassline_Casing_ZPM = getItemStack(componentAssemblylineCasing, 6); + public static ItemRefer Compassline_Casing_UV = getItemStack(componentAssemblylineCasing, 7); + public static ItemRefer Compassline_Casing_UHV = getItemStack(componentAssemblylineCasing, 8); + public static ItemRefer Compassline_Casing_UEV = getItemStack(componentAssemblylineCasing, 9); + public static ItemRefer Compassline_Casing_UIV = getItemStack(componentAssemblylineCasing, 10); + public static ItemRefer Compassline_Casing_UMV = getItemStack(componentAssemblylineCasing, 11); + public static ItemRefer Compassline_Casing_UXV = getItemStack(componentAssemblylineCasing, 12); + public static ItemRefer Compassline_Casing_MAX = getItemStack(componentAssemblylineCasing, 13); + + private Item mItem = null; + private Block mBlock = null; + private ItemStack mItemStack = null; + private int mMeta = 0; + + private static ItemRefer getItemStack(ItemStack itemStack) { + if (itemStack == null) return NULL; + return new ItemRefer(itemStack); + } + + private static ItemRefer getItemStack(Item item) { + return getItemStack(item, 0); + } + + private static ItemRefer getItemStack(Item item, int meta) { + if (item == null) return NULL; + return new ItemRefer(item, meta); + } + + private static ItemRefer getItemStack(Block block) { + return getItemStack(block, 0); + } + + private static ItemRefer getItemStack(Block block, int meta) { + if (block == null) return NULL; + return new ItemRefer(block, meta); + } + + private ItemRefer(Item item, int meta) { + mItem = item; + mMeta = meta; + } + + private ItemRefer(Block block, int meta) { + mBlock = block; + mMeta = meta; + } + + private ItemRefer(ItemStack itemStack) { + mItemStack = itemStack; + } + + public ItemStack get(int amount) { + if (mItem != null) return new ItemStack(mItem, amount, mMeta); + if (mBlock != null) return new ItemStack(mBlock, amount, mMeta); + if (mItemStack != null) return GT_Utility.copyAmount(amount, mItemStack); + return new ItemStack(_null_, amount, 0); + } +} diff --git a/src/main/java/goodgenerator/util/Log.java b/src/main/java/goodgenerator/util/Log.java new file mode 100644 index 0000000000..4cf9e40484 --- /dev/null +++ b/src/main/java/goodgenerator/util/Log.java @@ -0,0 +1,9 @@ +package goodgenerator.util; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class Log { + + public static final Logger LOGGER = LogManager.getLogger("GoodGenerator"); +} diff --git a/src/main/java/goodgenerator/util/MaterialFix.java b/src/main/java/goodgenerator/util/MaterialFix.java new file mode 100644 index 0000000000..32827b18b2 --- /dev/null +++ b/src/main/java/goodgenerator/util/MaterialFix.java @@ -0,0 +1,393 @@ +package goodgenerator.util; + +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidSolidifierRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; + +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.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class MaterialFix { + + public static void MaterialFluidExtractionFix(Werkstoff material) { + if (material.hasItemType(OrePrefixes.ingot)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ingot)) + .fluidOutputs(material.getMolten(144)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Ingot.get(0)) + .fluidInputs(material.getMolten(144)) + .itemOutputs(material.get(OrePrefixes.ingot)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(fluidSolidifierRecipes); + } + if (material.hasItemType(OrePrefixes.plate)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.plate)) + .fluidOutputs(material.getMolten(144)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Plate.get(0)) + .fluidInputs(material.getMolten(144)) + .itemOutputs(material.get(OrePrefixes.plate)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(fluidSolidifierRecipes); + } + if (material.hasItemType(OrePrefixes.gearGtSmall)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.gearGtSmall)) + .fluidOutputs(material.getMolten(144)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.stickLong)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stickLong)) + .fluidOutputs(material.getMolten(144)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.spring)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.spring)) + .fluidOutputs(material.getMolten(144)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.stick)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.stick)) + .fluidOutputs(material.getMolten(72)) + .duration(16 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.itemCasing)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.itemCasing)) + .fluidOutputs(material.getMolten(72)) + .duration(16 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.wireGt01)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.wireGt01)) + .fluidOutputs(material.getMolten(72)) + .duration(16 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.cableGt01)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.cableGt01)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Ash, 2)) + .fluidOutputs(material.getMolten(72)) + .duration(16 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.foil)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.foil)) + .fluidOutputs(material.getMolten(36)) + .duration(8 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.springSmall)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.springSmall)) + .fluidOutputs(material.getMolten(36)) + .duration(8 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.ring)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.ring)) + .fluidOutputs(material.getMolten(36)) + .duration(8 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.bolt)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.bolt)) + .fluidOutputs(material.getMolten(18)) + .duration(4 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.wireFine)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.wireFine)) + .fluidOutputs(material.getMolten(18)) + .duration(4 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.round)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.round)) + .fluidOutputs(material.getMolten(16)) + .duration(4 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.screw)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.screw)) + .fluidOutputs(material.getMolten(16)) + .duration(4 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.nugget)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.nugget)) + .fluidOutputs(material.getMolten(16)) + .duration(4 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.rotor)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.rotor)) + .fluidOutputs(material.getMolten(612)) + .duration(136 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + if (material.hasItemType(OrePrefixes.gearGt)) { + GT_Values.RA.stdBuilder() + .itemInputs(material.get(OrePrefixes.gearGt)) + .fluidOutputs(material.getMolten(576)) + .duration(128 * TICKS) + .eut(8) + .addTo(fluidExtractionRecipes); + } + } + + public static void addRecipeForMultiItems() { + for (Werkstoff tMaterial : Werkstoff.werkstoffHashSet) { + if (tMaterial == null) continue; + if (tMaterial.hasItemType(OrePrefixes.plateDouble) && tMaterial.hasItemType(OrePrefixes.ingotDouble)) { + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.plate, 2), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 2, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.ingotDouble, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDouble, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass(), + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.plateDouble, 1), + new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1) }); + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.ingotDouble, 1), + new Object[] { "P", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1) }); + } + if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) { + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.plate, 3), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 3, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.ingot, 3), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 3, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(tMaterial.get(OrePrefixes.plateTriple, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass(), + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.plateTriple, 1), + new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.plate, 1), 'B', + tMaterial.get(OrePrefixes.plateDouble, 1) }); + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.ingotTriple, 1), + new Object[] { "B", "P", "h", 'P', tMaterial.get(OrePrefixes.ingot, 1), 'B', + tMaterial.get(OrePrefixes.ingotDouble, 1) }); + } + if (tMaterial.hasItemType(OrePrefixes.plateDense)) { + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.plate, 9), GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 9, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.ingot, 9), GT_Utility.getIntegratedCircuit(9)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 9, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + + if (tMaterial.hasItemType(OrePrefixes.plateTriple) && tMaterial.hasItemType(OrePrefixes.ingotTriple)) { + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.plateTriple, 3), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 3, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.ingotTriple, 3), GT_Utility.getIntegratedCircuit(3)) + .itemOutputs(tMaterial.get(OrePrefixes.plateDense, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 3, + 1L) * TICKS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(benderRecipes); + } + } + if (tMaterial.hasItemType(OrePrefixes.stick)) { + if (tMaterial.hasItemType(OrePrefixes.cellMolten)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Rod.get(0)) + .fluidInputs(tMaterial.getMolten(72)) + .itemOutputs(tMaterial.get(OrePrefixes.stick, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() >> 1, + 1L) * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(fluidSolidifierRecipes); + } + } + if (tMaterial.hasItemType(OrePrefixes.stickLong)) { + if (tMaterial.hasItemType(OrePrefixes.cellMolten)) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Rod_Long.get(0)) + .fluidInputs(tMaterial.getMolten(144)) + .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass(), + 1L) * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(fluidSolidifierRecipes); + } + if (tMaterial.hasItemType(OrePrefixes.stick)) { + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.stickLong, 1), + new Object[] { "PhP", 'P', tMaterial.get(OrePrefixes.stick, 1) }); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.stick, 2)) + .itemOutputs(tMaterial.get(OrePrefixes.stickLong, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass(), + 1L) * TICKS) + .eut(TierEU.RECIPE_LV / 2) + .addTo(hammerRecipes); + } + } + if (tMaterial.hasItemType(OrePrefixes.spring)) { + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.spring, 1), + new Object[] { " s ", "fPx", " P ", 'P', tMaterial.get(OrePrefixes.stickLong, 1) }); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.stickLong, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(tMaterial.get(OrePrefixes.spring, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass() * 2, + 1L) * TICKS) + .eut(TierEU.RECIPE_LV / 2) + .addTo(benderRecipes); + } + if (tMaterial.hasItemType(OrePrefixes.springSmall)) { + GT_ModHandler.addCraftingRecipe( + tMaterial.get(OrePrefixes.springSmall, 1), + new Object[] { " s ", "fPx", 'P', tMaterial.get(OrePrefixes.stick, 1) }); + GT_Values.RA.stdBuilder() + .itemInputs(tMaterial.get(OrePrefixes.stick, 1), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(tMaterial.get(OrePrefixes.springSmall, 1)) + .duration( + Math.max( + tMaterial.getStats() + .getMass(), + 1L) * TICKS) + .eut(TierEU.RECIPE_LV / 2) + .addTo(benderRecipes); + } + } + Materials tUHV = Materials.Longasssuperconductornameforuhvwire; + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.stick, tUHV, 2)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.stickLong, tUHV, 1)) + .duration(Math.max(tUHV.getMass(), 1L) * TICKS) + .eut(TierEU.RECIPE_LV / 2) + .addTo(hammerRecipes); + } +} diff --git a/src/main/java/goodgenerator/util/MyRecipeAdder.java b/src/main/java/goodgenerator/util/MyRecipeAdder.java new file mode 100644 index 0000000000..6cc0eb585c --- /dev/null +++ b/src/main/java/goodgenerator/util/MyRecipeAdder.java @@ -0,0 +1,72 @@ +package goodgenerator.util; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import goodgenerator.api.recipe.ExtremeHeatExchangerRecipe; +import goodgenerator.api.recipe.GoodGeneratorRecipeMaps; + +public class MyRecipeAdder { + + public static final MyRecipeAdder instance = new MyRecipeAdder(); + + public void addLiquidMentalFuel(FluidStack input, FluidStack output, int EUt, int ticks) { + GoodGeneratorRecipeMaps.naquadahReactorFuels + .addRecipe(true, null, null, null, new FluidStack[] { input }, new FluidStack[] { output }, ticks, 0, EUt); + } + + public void addNaquadahFuelRefineRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack output, int EUt, + int ticks, int tier) { + GoodGeneratorRecipeMaps.naquadahFuelRefineFactoryRecipes + .addRecipe(false, input2, null, null, input1, new FluidStack[] { output }, ticks, EUt, tier); + } + + public void addNeutronActivatorRecipe(FluidStack[] input1, ItemStack[] input2, FluidStack[] output1, + ItemStack[] output2, int ticks, int maxNKE, int minNKE) { + if (maxNKE <= 0) maxNKE = 1; + if (maxNKE >= 1100) maxNKE = 1100; + if (minNKE < 0) minNKE = 0; + if (minNKE >= maxNKE) minNKE = maxNKE - 1; + GoodGeneratorRecipeMaps.neutronActivatorRecipes + .addRecipe(false, input2, output2, null, input1, output1, ticks, 0, maxNKE * 10000 + minNKE); + } + + public void addExtremeHeatExchangerRecipe(FluidStack HotFluid, FluidStack ColdFluid, FluidStack WorkFluid, + FluidStack HeatedWorkFluid, FluidStack OverHeatedWorkFluid, int Threshold) { + GoodGeneratorRecipeMaps.extremeHeatExchangerFuels.addRecipe( + new ExtremeHeatExchangerRecipe( + new FluidStack[] { HotFluid, WorkFluid }, + new FluidStack[] { HeatedWorkFluid, OverHeatedWorkFluid, ColdFluid }, + Threshold)); + } + + public void addPreciseAssemblerRecipe(ItemStack[] aItemInputs, FluidStack[] aFluidInputs, ItemStack aOutput, + int aEUt, int aDuration, int aTier) { + if (aOutput == null) return; + GoodGeneratorRecipeMaps.preciseAssemblerRecipes.addRecipe( + false, + aItemInputs, + new ItemStack[] { aOutput }, + null, + null, + aFluidInputs, + null, + aDuration, + aEUt, + aTier); + } + + public void addComponentAssemblyLineRecipe(ItemStack[] ItemInputArray, FluidStack[] FluidInputArray, + ItemStack OutputItem, int aDuration, int aEUt, int casingLevel) { + GoodGeneratorRecipeMaps.componentAssemblyLineRecipes.addRecipe( + false, + ItemInputArray, + new ItemStack[] { OutputItem }, + null, + FluidInputArray, + null, + aDuration, + aEUt, + casingLevel); + } +} diff --git a/src/main/java/goodgenerator/util/StackUtils.java b/src/main/java/goodgenerator/util/StackUtils.java new file mode 100644 index 0000000000..2784828117 --- /dev/null +++ b/src/main/java/goodgenerator/util/StackUtils.java @@ -0,0 +1,143 @@ +package goodgenerator.util; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import appeng.api.AEApi; +import appeng.api.storage.data.IAEFluidStack; +import goodgenerator.items.MyMaterial; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.util.GT_Utility; + +public class StackUtils { + + /** + * Multiplies one ItemStack by a multiplier, and splits it into as many full stacks as it needs to. + * + * @param stack The ItemStack you want to multiply + * @param multiplier The number the stack is multiplied by + * @return A List of stacks that, in total, are the same as the input ItemStack after it has been multiplied. + */ + public static List<ItemStack> multiplyAndSplitIntoStacks(ItemStack stack, int multiplier) { + int totalItems = stack.stackSize * multiplier; + ArrayList<ItemStack> stacks = new ArrayList<>(); + if (totalItems >= 64) { + for (int i = 0; i < totalItems / 64; i++) { + stacks.add(GT_Utility.copyAmount(64, stack)); + } + } + if (totalItems % 64 > 0) { + stacks.add(GT_Utility.copyAmount(totalItems % 64, stack)); + } + return stacks; + } + + /** + * Merges the ItemStacks in the array into full stacks. + */ + public static ArrayList<ItemStack> mergeStacks(List<ItemStack> stacks) { + ArrayList<ItemStack> output = new ArrayList<>(); + for (int index = 0; index < stacks.size(); index++) { + ItemStack i = stacks.get(index); + int newSize = i.stackSize; + for (int j = index + 1; j < stacks.size(); j++) { + ItemStack is2 = stacks.get(j); + if (GT_Utility.areStacksEqual(i, is2)) { + newSize += is2.stackSize; + stacks.remove(j); + j--; + } + } + output.add(GT_Utility.copyAmountUnsafe(newSize, i)); + } + return output; + } + + /** + * Turns the {@code items} List into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a + * value representing the total amount of the respective {@code ItemStack} in the List. + */ + public static HashMap<ItemStack, Integer> getTotalItems(List<ItemStack> items) { + HashMap<ItemStack, Integer> totals = new HashMap<>(); + itemLoop: for (ItemStack item : items) { + int t = items.stream() + .filter(i2 -> GT_Utility.areStacksEqual(item, i2)) + .mapToInt(i -> i.stackSize) + .sum(); + for (ItemStack i2 : totals.keySet()) if (GT_Utility.areStacksEqual(item, i2)) continue itemLoop; + totals.put(GT_Utility.copyAmount(1, item), t); + } + return totals; + } + + /** + * Turns the {@code items} Array into a {@code HashMap} containing each unique {@code ItemStack} as the key, and a + * value representing the total amount of the respective {@code ItemStack} in the Array. + */ + public static HashMap<ItemStack, Integer> getTotalItems(ItemStack[] items) { + return getTotalItems(Arrays.asList(items)); + } + + public static FluidStack getTieredFluid(int aTier, int aAmount) { + switch (aTier) { + case 0: // ULV + return Materials.RedAlloy.getMolten(aAmount); + case 1: // LV + return Materials.TinAlloy.getMolten(aAmount); + case 2: // MV + return Materials.RoseGold.getMolten(aAmount); + case 3: // HV + return MyMaterial.zircaloy4.getMolten(aAmount); + case 4: // EV + return MyMaterial.incoloy903.getMolten(aAmount); + case 5: // IV + return MyMaterial.titaniumBetaC.getMolten(aAmount); + case 6: // LuV + return MyMaterial.artheriumSn.getMolten(aAmount); + case 7: // ZPM + return MyMaterial.dalisenite.getMolten(aAmount); + case 8: // UV + return MyMaterial.tairitsu.getMolten(aAmount); + case 9: // UHV + return MyMaterial.preciousMetalAlloy.getMolten(aAmount); + case 10: // UEV + return MyMaterial.enrichedNaquadahAlloy.getMolten(aAmount); + case 11: // UIV + return MyMaterial.metastableOganesson.getMolten(aAmount); + case 12: // UMV + return MaterialsUEVplus.SpaceTime.getMolten(aAmount); + default: + return MyMaterial.shirabon.getMolten(aAmount); + } + } + + // === Copied from AE2FC to avoid hard dep === + + public static IAEFluidStack createAEFluidStack(Fluid fluid) { + return createAEFluidStack(new FluidStack(fluid, FluidContainerRegistry.BUCKET_VOLUME)); + } + + public static IAEFluidStack createAEFluidStack(Fluid fluid, long amount) { + return createAEFluidStack(fluid.getID(), amount); + } + + public static IAEFluidStack createAEFluidStack(FluidStack fluid) { + return AEApi.instance() + .storage() + .createFluidStack(fluid); + } + + public static IAEFluidStack createAEFluidStack(int fluidId, long amount) { + return createAEFluidStack(new FluidStack(FluidRegistry.getFluid(fluidId), 1)).setStackSize(amount); + } + +} diff --git a/src/main/java/goodgenerator/util/StructureHelper.java b/src/main/java/goodgenerator/util/StructureHelper.java new file mode 100644 index 0000000000..e66ac9f9ee --- /dev/null +++ b/src/main/java/goodgenerator/util/StructureHelper.java @@ -0,0 +1,117 @@ +package goodgenerator.util; + +import java.util.Arrays; +import java.util.function.BiConsumer; +import java.util.function.BiPredicate; +import java.util.function.Function; + +import net.minecraft.block.Block; +import net.minecraft.init.Items; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +import com.gtnewhorizon.structurelib.StructureLibAPI; +import com.gtnewhorizon.structurelib.structure.IStructureElement; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.metatileentity.BaseMetaPipeEntity; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Frame; +import gregtech.api.util.GT_OreDictUnificator; + +public class StructureHelper { + + public static <T> IStructureElement<T> addFrame(Materials aMaterials) { + return new IStructureElement<T>() { + + private IIcon[] mIcons; + + @Override + public boolean check(T t, World world, int x, int y, int z) { + TileEntity tBlock = world.getTileEntity(x, y, z); + if (tBlock instanceof BaseMetaPipeEntity) { + BaseMetaPipeEntity tFrame = (BaseMetaPipeEntity) tBlock; + if (tFrame.isInvalidTileEntity()) return false; + if (tFrame.getMetaTileEntity() instanceof GT_MetaPipeEntity_Frame) { + return ((GT_MetaPipeEntity_Frame) tFrame.getMetaTileEntity()).mMaterial == aMaterials; + } + } + return false; + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + if (mIcons == null) { + mIcons = new IIcon[6]; + Arrays.fill(mIcons, aMaterials.mIconSet.mTextures[OrePrefixes.frameGt.mTextureIndex].getIcon()); + } + StructureLibAPI.hintParticleTinted(world, x, y, z, mIcons, aMaterials.mRGBa); + return true; + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + ItemStack tFrame = GT_OreDictUnificator.get(OrePrefixes.frameGt, aMaterials, 1); + if (tFrame.getItem() instanceof ItemBlock) { + ItemBlock tFrameStackItem = (ItemBlock) tFrame.getItem(); + return tFrameStackItem + .placeBlockAt(tFrame, null, world, x, y, z, 6, 0, 0, 0, Items.feather.getDamage(tFrame)); + } + return false; + } + }; + } + + // Only support to use meta to tier + public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiConsumer<T, Integer> aSetTheFuckingMeta, + Function<T, Integer> aGetTheFuckingMeta, int maxMeta) { + return addTieredBlock(aBlock, (t, i) -> { + aSetTheFuckingMeta.accept(t, i); + return true; + }, aGetTheFuckingMeta, maxMeta); + } + + public static <T> IStructureElement<T> addTieredBlock(Block aBlock, BiPredicate<T, Integer> aSetTheFuckingMeta, + Function<T, Integer> aGetTheFuckingMeta, int maxMeta) { + + return new IStructureElement<T>() { + + @Override + public boolean check(T t, World world, int x, int y, int z) { + Block tBlock = world.getBlock(x, y, z); + if (aBlock == tBlock) { + Integer currentMeta = aGetTheFuckingMeta.apply(t); + int newMeta = tBlock.getDamageValue(world, x, y, z) + 1; + if (newMeta > maxMeta) return false; + if (currentMeta == 0) { + return aSetTheFuckingMeta.test(t, newMeta); + } else { + return currentMeta == newMeta; + } + } + return false; + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, aBlock, getMeta(trigger)); + return true; + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + return world.setBlock(x, y, z, aBlock, getMeta(trigger), 3); + } + + private int getMeta(ItemStack trigger) { + int meta = trigger.stackSize - 1; + if (meta <= 0) meta = 0; + if (meta >= maxMeta) meta = maxMeta - 1; + return meta; + } + }; + } +} |