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
114
115
116
|
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.FluidStack;
import goodgenerator.items.MyMaterial;
import gregtech.api.enums.Materials;
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);
boolean hasDupe = false;
int newSize = i.stackSize;
for (int j = index + 1; j < stacks.size(); j++) {
ItemStack is2 = stacks.get(j);
if (GT_Utility.areStacksEqual(i, is2)) {
hasDupe = true;
newSize += is2.stackSize;
stacks.remove(j);
j--;
}
}
if (hasDupe) {
if (newSize >= 64) {
for (int k = 0; k < newSize / 64; k++) {
output.add(GT_Utility.copyAmount(64, i));
}
}
if (newSize % 64 > 0) {
output.add(GT_Utility.copyAmount(newSize > 64 ? newSize % 64 : newSize, i));
}
} else output.add(i);
}
return output;
}
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;
}
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 Materials.SpaceTime.getMolten(aAmount);
default:
return MyMaterial.shirabon.getMolten(aAmount);
}
}
}
|
