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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
package gtneioreplugin.util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import com.google.common.collect.BiMap;
import gregtech.GTMod;
import gregtech.api.objects.GTUODimension;
import gregtech.api.objects.GTUODimensionList;
import gregtech.api.objects.GTUOFluid;
import gtneioreplugin.GTNEIOrePlugin;
public class GT5UndergroundFluidHelper {
/**
* Need to store fluid name instead of fluid because fluid instance might be different between gas and liquid
*/
private static final Map<String, List<UndergroundFluidWrapper>> fluidMap = new HashMap<>();
@SuppressWarnings("unchecked")
public static void init() {
try {
Field fieldDimensionList = GTUODimensionList.class.getDeclaredField("fDimensionList");
fieldDimensionList.setAccessible(true);
BiMap<String, GTUODimension> dimensionList = (BiMap<String, GTUODimension>) fieldDimensionList
.get(GTMod.gregtechproxy.mUndergroundOil);
for (Map.Entry<String, GTUODimension> dimensionEntry : dimensionList.entrySet()) {
String rawDimension = dimensionEntry.getKey();
String dimension;
try {
dimension = getDimensionFromID(Integer.parseInt(rawDimension));
} catch (NumberFormatException ignored) {
dimension = getDimensionForEdgeCase(rawDimension);
if (dimension == null) {
for (int i = 0; i < DimensionHelper.DimNameTrimmed.length; i++) {
if (DimensionHelper.DimNameTrimmed[i].equalsIgnoreCase(rawDimension)) {
dimension = DimensionHelper.DimNameDisplayed[i];
break;
}
}
}
}
if (dimension == null) {
GTNEIOrePlugin.LOG.warn("Unknown dimension found in GT5 config: " + rawDimension);
continue;
}
Field fieldFluids = GTUODimension.class.getDeclaredField("fFluids");
fieldFluids.setAccessible(true);
BiMap<String, GTUOFluid> fluids = (BiMap<String, GTUOFluid>) fieldFluids.get(dimensionEntry.getValue());
int maxChance = 0;
for (Map.Entry<String, GTUOFluid> fluidEntry : fluids.entrySet()) {
maxChance += fluidEntry.getValue().Chance;
}
for (Map.Entry<String, GTUOFluid> fluidEntry : fluids.entrySet()) {
Fluid fluid = FluidRegistry.getFluid(fluidEntry.getKey());
if (fluid != null) {
UndergroundFluidWrapper wrapper = new UndergroundFluidWrapper(
dimension,
fluidEntry.getValue().Chance * 10000 / maxChance,
fluidEntry.getValue().MaxAmount,
fluidEntry.getValue().MinAmount);
if (fluidMap.containsKey(fluid.getName())) {
fluidMap.get(fluid.getName())
.add(wrapper);
} else {
fluidMap.put(fluid.getName(), new ArrayList<>(Collections.singletonList(wrapper)));
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
for (List<UndergroundFluidWrapper> wrappers : fluidMap.values()) {
wrappers.sort(
Comparator.comparingInt(
w -> Arrays.asList(DimensionHelper.DimNameDisplayed)
.indexOf(w.dimension)));
}
}
public static List<UndergroundFluidWrapper> getEntry(String fluidName) {
return fluidMap.get(fluidName);
}
public static Map<String, List<UndergroundFluidWrapper>> getAllEntries() {
return fluidMap;
}
@SuppressWarnings("SwitchStatementWithTooFewBranches")
private static String getDimensionFromID(int id) {
return switch (id) {
case 0 -> "Ow";
default -> null;
};
}
private static String getDimensionForEdgeCase(String rawDimension) {
return switch (rawDimension) {
case "aCentauriBb" -> "CB";
case "BarnardaC" -> "BC";
case "BarnardaE" -> "BE";
case "BarnardaF" -> "BF";
case "TCetiE" -> "TE";
default -> {
GTNEIOrePlugin.LOG.warn("Unknown dimension name while parsing: " + rawDimension);
yield null;
}
};
}
public static class UndergroundFluidWrapper {
/**
* Using {@link DimensionHelper#DimNameDisplayed}
*/
public final String dimension;
/**
* Chance of this fluid field being generated. 10000 means 100% of the dimension
*/
public final int chance;
public final int maxAmount;
public final int minAmount;
public UndergroundFluidWrapper(String dimension, int chance, int maxAmount, int minAmount) {
this.dimension = dimension;
this.chance = chance;
this.maxAmount = maxAmount;
this.minAmount = minAmount;
}
}
}
|
