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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
package gregtech.api.logic;
import java.util.List;
import java.util.stream.Stream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidStack;
import gregtech.api.interfaces.tileentity.IRecipeLockable;
import gregtech.api.recipe.RecipeMap;
import gregtech.api.recipe.check.CheckRecipeResult;
import gregtech.api.recipe.check.CheckRecipeResultRegistry;
import gregtech.api.recipe.check.SingleRecipeCheck;
import gregtech.api.util.GTRecipe;
import gregtech.api.util.OverclockCalculator;
import gregtech.api.util.ParallelHelper;
/**
* Logic class to calculate result of recipe check from inputs, based on recipemap.
*/
@SuppressWarnings({ "unused", "UnusedReturnValue" })
public class ProcessingLogic extends AbstractProcessingLogic<ProcessingLogic> {
protected IRecipeLockable recipeLockableMachine;
protected ItemStack specialSlotItem;
protected ItemStack[] inputItems;
protected FluidStack[] inputFluids;
protected boolean isRecipeLocked;
public ProcessingLogic() {}
// #region Setters
@Nonnull
public ProcessingLogic setInputItems(ItemStack... itemInputs) {
this.inputItems = itemInputs;
return getThis();
}
@Nonnull
public ProcessingLogic setInputItems(List<ItemStack> itemOutputs) {
this.inputItems = itemOutputs.toArray(new ItemStack[0]);
return getThis();
}
@Nonnull
public ProcessingLogic setInputFluids(FluidStack... fluidInputs) {
this.inputFluids = fluidInputs;
return getThis();
}
@Nonnull
public ProcessingLogic setInputFluids(List<FluidStack> fluidInputs) {
this.inputFluids = fluidInputs.toArray(new FluidStack[0]);
return getThis();
}
public ProcessingLogic setSpecialSlotItem(ItemStack specialSlotItem) {
this.specialSlotItem = specialSlotItem;
return getThis();
}
/**
* Enables single recipe locking mode.
*/
public ProcessingLogic setRecipeLocking(IRecipeLockable recipeLockableMachine, boolean isRecipeLocked) {
this.recipeLockableMachine = recipeLockableMachine;
this.isRecipeLocked = isRecipeLocked;
return getThis();
}
/**
* Clears calculated results and provided machine inputs to prepare for the next machine operation.
*/
public ProcessingLogic clear() {
this.inputItems = null;
this.inputFluids = null;
this.specialSlotItem = null;
this.outputItems = null;
this.outputFluids = null;
this.calculatedEut = 0;
this.duration = 0;
this.calculatedParallels = 0;
return getThis();
}
// #endregion
// #region Logic
/**
* Executes the recipe check: Find recipe from recipemap, Calculate parallel, overclock and outputs.
*/
@Nonnull
public CheckRecipeResult process() {
RecipeMap<?> recipeMap = preProcess();
if (inputItems == null) {
inputItems = new ItemStack[0];
}
if (inputFluids == null) {
inputFluids = new FluidStack[0];
}
if (isRecipeLocked && recipeLockableMachine != null && recipeLockableMachine.getSingleRecipeCheck() != null) {
// Recipe checker is already built, we'll use it
SingleRecipeCheck singleRecipeCheck = recipeLockableMachine.getSingleRecipeCheck();
// Validate recipe here, otherwise machine will show "not enough output space"
// even if recipe cannot be found
if (singleRecipeCheck.checkRecipeInputs(false, 1, inputItems, inputFluids) == 0) {
return CheckRecipeResultRegistry.NO_RECIPE;
}
return validateAndCalculateRecipe(
recipeLockableMachine.getSingleRecipeCheck()
.getRecipe()).checkRecipeResult;
}
Stream<GTRecipe> matchedRecipes = findRecipeMatches(recipeMap);
Iterable<GTRecipe> recipeIterable = matchedRecipes::iterator;
CheckRecipeResult checkRecipeResult = CheckRecipeResultRegistry.NO_RECIPE;
for (GTRecipe matchedRecipe : recipeIterable) {
CalculationResult foundResult = validateAndCalculateRecipe(matchedRecipe);
if (foundResult.successfullyConsumedInputs) {
// Successfully found and set recipe, so return it
return foundResult.checkRecipeResult;
}
if (foundResult.checkRecipeResult != CheckRecipeResultRegistry.NO_RECIPE) {
// Recipe failed in interesting way, so remember that and continue searching
checkRecipeResult = foundResult.checkRecipeResult;
}
}
return checkRecipeResult;
}
/**
* Checks if supplied recipe is valid for process. This involves voltage check, output full check. If successful,
* additionally performs input consumption, output calculation with parallel, and overclock calculation.
*
* @param recipe The recipe which will be checked and processed
*/
@Nonnull
private CalculationResult validateAndCalculateRecipe(@Nonnull GTRecipe recipe) {
CheckRecipeResult result = validateRecipe(recipe);
if (!result.wasSuccessful()) {
return CalculationResult.ofFailure(result);
}
ParallelHelper helper = createParallelHelper(recipe);
OverclockCalculator calculator = createOverclockCalculator(recipe);
helper.setCalculator(calculator);
helper.build();
if (!helper.getResult()
.wasSuccessful()) {
return CalculationResult.ofFailure(helper.getResult());
}
return CalculationResult.ofSuccess(applyRecipe(recipe, helper, calculator, result));
}
/**
* Finds a list of matched recipes. At this point no additional check to the matched recipe has been done.
* <p>
* Override {@link #validateRecipe} to have custom check.
* <p>
* Override this method if it doesn't work with normal recipemaps.
*/
@Nonnull
protected Stream<GTRecipe> findRecipeMatches(@Nullable RecipeMap<?> map) {
if (map == null) {
return Stream.empty();
}
return map.findRecipeQuery()
.items(inputItems)
.fluids(inputFluids)
.specialSlot(specialSlotItem)
.cachedRecipe(lastRecipe)
.findAll();
}
/**
* Override to tweak parallel logic if needed.
*/
@Nonnull
protected ParallelHelper createParallelHelper(@Nonnull GTRecipe recipe) {
return new ParallelHelper().setRecipe(recipe)
.setItemInputs(inputItems)
.setFluidInputs(inputFluids)
.setAvailableEUt(availableVoltage * availableAmperage)
.setMachine(machine, protectItems, protectFluids)
.setRecipeLocked(recipeLockableMachine, isRecipeLocked)
.setMaxParallel(maxParallel)
.setEUtModifier(euModifier)
.enableBatchMode(batchSize)
.setConsumption(true)
.setOutputCalculation(true);
}
// #endregion
/**
* Represents the status of check recipe calculation. {@link #successfullyConsumedInputs} does not necessarily mean
* {@link #checkRecipeResult} being successful, when duration or power is overflowed. Being failure means
* recipe cannot meet requirements and recipe search should be continued if possible.
*/
protected final static class CalculationResult {
public final boolean successfullyConsumedInputs;
public final CheckRecipeResult checkRecipeResult;
public static CalculationResult ofSuccess(CheckRecipeResult checkRecipeResult) {
return new CalculationResult(true, checkRecipeResult);
}
public static CalculationResult ofFailure(CheckRecipeResult checkRecipeResult) {
return new CalculationResult(false, checkRecipeResult);
}
private CalculationResult(boolean successfullyConsumedInputs, CheckRecipeResult checkRecipeResult) {
this.successfullyConsumedInputs = successfullyConsumedInputs;
this.checkRecipeResult = checkRecipeResult;
}
}
}
|
