-
Notifications
You must be signed in to change notification settings - Fork 150
/
RecyclingRecipes.java
112 lines (101 loc) · 5.42 KB
/
RecyclingRecipes.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package gregtech.loaders.recipe;
import gregtech.api.recipes.RecipeBuilder;
import gregtech.api.recipes.RecipeMaps;
import gregtech.api.unification.OreDictUnifier;
import gregtech.api.unification.material.Materials;
import gregtech.api.unification.material.type.DustMaterial;
import gregtech.api.unification.material.type.GemMaterial;
import gregtech.api.unification.material.type.IngotMaterial;
import gregtech.api.unification.material.type.Material.MatFlags;
import gregtech.api.unification.stack.ItemMaterialInfo;
import gregtech.api.unification.stack.MaterialStack;
import net.minecraft.item.ItemStack;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import static gregtech.api.GTValues.L;
import static gregtech.api.GTValues.M;
public class RecyclingRecipes {
public static void init() {
initializeArcRecyclingRecipes();
}
private static void initializeArcRecyclingRecipes() {
for (Entry<ItemStack, ItemMaterialInfo> entry : OreDictUnifier.getAllItemInfos()) {
ItemStack itemStack = entry.getKey();
ItemMaterialInfo materialInfo = entry.getValue();
ArrayList<MaterialStack> materialStacks = new ArrayList<>();
materialStacks.add(materialInfo.material);
materialStacks.addAll(materialInfo.additionalComponents);
registerArcRecyclingRecipe(b -> b.inputs(itemStack), materialStacks, false);
}
}
public static void registerArcRecyclingRecipe(Consumer<RecipeBuilder<?>> inputSupplier, List<MaterialStack> components, boolean ignoreArcSmelting) {
List<MaterialStack> dustMaterials = components.stream()
.filter(stack -> stack.material instanceof DustMaterial)
.filter(stack -> stack.amount >= M / 9) //do only materials which have at least one nugget
.collect(Collectors.toList());
if (dustMaterials.isEmpty()) return;
MaterialStack firstStack = dustMaterials.get(0);
DustMaterial dustMaterial = (DustMaterial) firstStack.material;
int voltageMultiplier = 1;
if (dustMaterial instanceof IngotMaterial) {
int blastFurnaceTemperature = ((IngotMaterial) dustMaterial).blastFurnaceTemperature;
voltageMultiplier = blastFurnaceTemperature == 0 ? 1 : blastFurnaceTemperature > 2000 ? 16 : 4;
} else {
//do not apply arc smelting for gems, solid materials and dust materials
//only generate recipes for ingot materials
ignoreArcSmelting = true;
}
RecipeBuilder<?> maceratorRecipeBuilder = RecipeMaps.MACERATOR_RECIPES.recipeBuilder()
.outputs(dustMaterials.stream().map(OreDictUnifier::getDust).collect(Collectors.toList()))
.duration((int) Math.max(1L, firstStack.amount * 30 / M))
.EUt(8 * voltageMultiplier);
inputSupplier.accept(maceratorRecipeBuilder);
maceratorRecipeBuilder.buildAndRegister();
if (dustMaterial.shouldGenerateFluid()) {
RecipeBuilder<?> fluidExtractorRecipeBuilder = RecipeMaps.FLUID_EXTRACTION_RECIPES.recipeBuilder()
.fluidOutputs(dustMaterial.getFluid((int) (firstStack.amount * L / M)))
.duration((int) Math.max(1L, firstStack.amount * 80 / M))
.EUt(32 * voltageMultiplier);
inputSupplier.accept(fluidExtractorRecipeBuilder);
fluidExtractorRecipeBuilder.buildAndRegister();
}
if (!ignoreArcSmelting) {
List<ItemStack> resultList = dustMaterials.stream().map(RecyclingRecipes::getArcSmeltingResult).collect(Collectors.toList());
resultList.removeIf(ItemStack::isEmpty);
if (resultList.isEmpty()) return;
RecipeBuilder<?> arcFurnaceRecipeBuilder = RecipeMaps.ARC_FURNACE_RECIPES.recipeBuilder()
.outputs(resultList)
.duration((int) Math.max(1L, firstStack.amount * 60 / M))
.EUt(30 * voltageMultiplier);
inputSupplier.accept(arcFurnaceRecipeBuilder);
arcFurnaceRecipeBuilder.buildAndRegister();
}
}
private static ItemStack getArcSmeltingResult(MaterialStack materialStack) {
DustMaterial material = (DustMaterial) materialStack.material;
long materialAmount = materialStack.amount;
if (material.hasFlag(MatFlags.FLAMMABLE)) {
return OreDictUnifier.getDust(Materials.Ash, materialAmount);
} else if (material instanceof GemMaterial) {
if (materialStack.material.materialComponents.stream()
.anyMatch(stack -> stack.material == Materials.Oxygen)) {
return OreDictUnifier.getDust(Materials.Ash, materialAmount);
}
if (materialStack.material.materialComponents.stream()
.anyMatch(stack -> stack.material == Materials.Carbon)) {
return OreDictUnifier.getDust(Materials.Carbon, materialAmount);
}
return OreDictUnifier.getDust(Materials.DarkAsh, materialAmount);
} else if (material instanceof IngotMaterial) {
IngotMaterial ingotMaterial = (IngotMaterial) material;
if (ingotMaterial.arcSmeltInto != null)
ingotMaterial = ingotMaterial.arcSmeltInto;
return OreDictUnifier.getIngot(ingotMaterial, materialAmount);
} else {
return OreDictUnifier.getDust(material, materialAmount);
}
}
}