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
113
|
package gtPlusPlus.core.util.recipe;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import gnu.trove.strategy.HashingStrategy;
import gregtech.api.util.GTRecipe;
public class RecipeHashStrat {
public static final HashingStrategy<GTRecipe> RecipeHashingStrategy = new HashingStrategy<>() {
@Override
public int computeHashCode(GTRecipe recipe) {
return com.google.common.base.Objects.hashCode(recipe.mDuration, recipe.mEUt);
}
@Override
public boolean equals(GTRecipe recipe1, GTRecipe recipe2) {
return areRecipesEqual(recipe1, recipe2);
}
};
public static boolean areRecipesEqual(GTRecipe recipe1, GTRecipe recipe2) {
// both item outputs use a copy to prevent interfering with chance based output orders
// sort all the arrays for recipe1
RecipeHashStrat.sortItemStackArray(recipe1.mInputs);
ItemStack[] recipe1OutputCopy = recipe1.mOutputs.clone();
RecipeHashStrat.sortItemStackArray(recipe1OutputCopy);
RecipeHashStrat.sortFluidStackArray(recipe1.mFluidInputs);
RecipeHashStrat.sortFluidStackArray(recipe1.mFluidOutputs);
// sort all the arrays for recipe2
RecipeHashStrat.sortItemStackArray(recipe2.mInputs);
ItemStack[] recipe2OutputCopy = recipe2.mOutputs.clone();
RecipeHashStrat.sortItemStackArray(recipe2OutputCopy);
RecipeHashStrat.sortFluidStackArray(recipe2.mFluidInputs);
RecipeHashStrat.sortFluidStackArray(recipe2.mFluidOutputs);
// checks if the recipe EUt, Duration, inputs and outputs for both items and fluids are equal
if (recipe1.mEUt != recipe2.mEUt) {
return false;
}
if (recipe1.mDuration != recipe2.mDuration) {
return false;
}
if (!areItemsStackArraysEqual(recipe1.mInputs, recipe2.mInputs)) {
return false;
}
if (!areItemsStackArraysEqual(recipe1OutputCopy, recipe2OutputCopy)) {
return false;
}
if (!areFluidStackArraysEqual(recipe1.mFluidInputs, recipe2.mFluidInputs)) {
return false;
}
return areFluidStackArraysEqual(recipe1.mFluidOutputs, recipe2.mFluidOutputs);
}
public static void sortItemStackArray(ItemStack[] itemStackArray) {
Arrays.sort(
itemStackArray,
Comparator.<ItemStack, Integer>comparing(itemStack -> Item.getIdFromItem(itemStack.getItem()))
.thenComparing(ItemStack::getItemDamage)
.thenComparing(itemStack -> itemStack.stackSize));
}
public static void sortFluidStackArray(FluidStack[] fluidStackArray) {
Arrays.sort(
fluidStackArray,
Comparator.comparing(FluidStack::getFluidID)
.thenComparing(fluidStack -> fluidStack.amount));
}
public static boolean areItemsStackArraysEqual(ItemStack[] array1, ItemStack[] array2) {
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; i++) {
if (!Objects.equals(array1[i].getItem(), array2[i].getItem())) {
return false;
}
if (!Objects.equals(array1[i].getItemDamage(), array2[i].getItemDamage())) {
return false;
}
if (!Objects.equals(array1[i].stackSize, array2[i].stackSize)) {
return false;
}
}
return true;
}
public static boolean areFluidStackArraysEqual(FluidStack[] array1, FluidStack[] array2) {
if (array1.length != array2.length) {
return false;
}
for (int i = 0; i < array1.length; i++) {
// check if the string representation of both FluidStacks are not equal
if (!Objects.equals(array1[i].getFluid(), array2[i].getFluid())) {
return false;
}
if (!Objects.equals(array1[i].amount, array2[i].amount)) {
return false;
}
}
return true;
}
}
|
