aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/gregtech/loaders/oreprocessing/ProcessingCell.java
blob: bbb54d142e45b9e0a97ec3ab9f76f1e50f63bbfc (plain)
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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
package gregtech.loaders.oreprocessing;

import static gregtech.api.enums.GTValues.RA;
import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes;
import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes;
import static gregtech.api.recipe.RecipeMaps.extractorRecipes;
import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes;
import static gregtech.api.util.GTRecipeBuilder.SECONDS;
import static gregtech.api.util.GTRecipeBuilder.TICKS;
import static gregtech.api.util.GTRecipeConstants.FUEL_TYPE;
import static gregtech.api.util.GTRecipeConstants.FUEL_VALUE;

import java.util.ArrayList;

import net.minecraft.item.ItemStack;

import gregtech.api.enums.ItemList;
import gregtech.api.enums.Materials;
import gregtech.api.enums.OrePrefixes;
import gregtech.api.enums.TierEU;
import gregtech.api.interfaces.IOreRecipeRegistrator;
import gregtech.api.objects.MaterialStack;
import gregtech.api.util.GTModHandler;
import gregtech.api.util.GTOreDictUnificator;
import gregtech.api.util.GTRecipeBuilder;
import gregtech.api.util.GTRecipeConstants;
import gregtech.api.util.GTUtility;

public class ProcessingCell implements IOreRecipeRegistrator {

    public ProcessingCell() {
        OrePrefixes.cell.add(this);
        OrePrefixes.cellPlasma.add(this);
    }

    @Override
    public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName,
        ItemStack aStack) {
        switch (aPrefix) {
            case cell -> {
                if (aMaterial == Materials.Empty) {
                    GTModHandler.removeRecipeByOutputDelayed(aStack);
                    if (aModName.equalsIgnoreCase("AtomicScience")) {
                        RA.stdBuilder()
                            .itemInputs(ItemList.Cell_Empty.get(1L))
                            .itemOutputs(aStack)
                            .duration(15 * SECONDS)
                            .eut(2)
                            .addTo(extractorRecipes);
                    }
                } else {
                    if (aMaterial.mFuelPower > 0) {
                        GTRecipeBuilder recipeBuilder = RA.stdBuilder();
                        recipeBuilder.itemInputs(GTUtility.copyAmount(1, aStack));
                        if (GTUtility.getFluidForFilledItem(aStack, true) == null
                            && GTUtility.getContainerItem(aStack, true) != null) {
                            recipeBuilder.itemOutputs(GTUtility.getContainerItem(aStack, true));
                        }
                        recipeBuilder.metadata(FUEL_VALUE, aMaterial.mFuelPower)
                            .metadata(FUEL_TYPE, aMaterial.mFuelType)
                            .addTo(GTRecipeConstants.Fuel);
                    }
                    if (!((!aMaterial.mMaterialList.isEmpty()) && ((aMaterial.mExtraData & 0x3) != 0))) {
                        break;
                    }

                    int tAllAmount = 0;
                    for (MaterialStack tMat2 : aMaterial.mMaterialList) {
                        tAllAmount = (int) (tAllAmount + tMat2.mAmount);
                    }
                    long tItemAmount = 0L;
                    long tCapsuleCount = (long) GTModHandler.getCapsuleCellContainerCountMultipliedWithStackSize(aStack)
                        * -tAllAmount;
                    long tDensityMultiplier = aMaterial.getDensity() > 3628800L ? aMaterial.getDensity() / 3628800L
                        : 1L;
                    ArrayList<ItemStack> tList = new ArrayList<>();
                    for (MaterialStack tMat : aMaterial.mMaterialList) {
                        if (tMat.mAmount <= 0) {
                            continue;
                        }

                        ItemStack tStack;
                        if (tMat.mMaterial == Materials.Air) {
                            tStack = ItemList.Cell_Air.get(tMat.mAmount * tDensityMultiplier / 2L);
                        } else {
                            tStack = GTOreDictUnificator.get(OrePrefixes.dust, tMat.mMaterial, tMat.mAmount);
                            if (tStack == null) {
                                tStack = GTOreDictUnificator.get(OrePrefixes.cell, tMat.mMaterial, tMat.mAmount);
                            }
                        }
                        if (tItemAmount + tMat.mAmount * 3628800L > aStack.getMaxStackSize() * aMaterial.getDensity()) {
                            continue;
                        }

                        tItemAmount += tMat.mAmount * 3628800L;

                        if (tStack == null) {
                            continue;
                        }

                        tStack.stackSize = ((int) (tStack.stackSize * tDensityMultiplier));
                        while ((tStack.stackSize > 64)
                            && (tCapsuleCount + GTModHandler.getCapsuleCellContainerCount(tStack) * 64L < 0L
                                ? tList.size() < 5
                                : tList.size() < 6)
                            && (tCapsuleCount + GTModHandler.getCapsuleCellContainerCount(tStack) * 64L <= 64L)) {
                            tCapsuleCount += GTModHandler.getCapsuleCellContainerCount(tStack) * 64L;
                            tList.add(GTUtility.copyAmount(64, tStack));
                            tStack.stackSize -= 64;
                        }
                        int tThisCapsuleCount = GTModHandler
                            .getCapsuleCellContainerCountMultipliedWithStackSize(tStack);
                        if (tStack.stackSize > 0 && tCapsuleCount + tThisCapsuleCount <= 64L) {
                            if (tCapsuleCount + tThisCapsuleCount < 0L ? tList.size() < 5 : tList.size() < 6) {
                                tCapsuleCount += tThisCapsuleCount;
                                tList.add(tStack);
                            }
                        }
                    }

                    tItemAmount = GTUtility.ceilDiv(tItemAmount * tDensityMultiplier, aMaterial.getDensity());

                    if (tList.size() <= 0) {
                        break;
                    }

                    if ((aMaterial.mExtraData & 0x1) != 0) {

                        // Electrolyzer recipe
                        if (GTUtility.getFluidForFilledItem(aStack, true) == null) {
                            // dust stuffed cell e.g. Phosphate, Phosphorous Pentoxide
                            GTRecipeBuilder recipeBuilder = RA.stdBuilder();
                            if (tCapsuleCount > 0L) {
                                recipeBuilder.itemInputs(
                                    GTUtility.copyAmount(tItemAmount, aStack),
                                    ItemList.Cell_Empty.get(tCapsuleCount));
                            } else {
                                recipeBuilder.itemInputs(GTUtility.copyAmount(tItemAmount, aStack));
                            }
                            if (tCapsuleCount < 0L) {
                                tList.add(ItemList.Cell_Empty.get(-tCapsuleCount));
                            }
                            ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]);
                            recipeBuilder.itemOutputs(outputsArray)
                                .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 2L * tItemAmount)))
                                .eut(Math.min(4, tList.size()) * 30)
                                .addTo(electrolyzerRecipes);
                        } else {
                            long tCellBalance = tCapsuleCount + tItemAmount - 1;
                            GTRecipeBuilder recipeBuilder = RA.stdBuilder();
                            if (tCellBalance > 0L) {
                                recipeBuilder.itemInputs(aStack, ItemList.Cell_Empty.get(tCellBalance));
                            } else {
                                recipeBuilder.itemInputs(aStack);
                            }
                            if (tCellBalance < 0L) {
                                tList.add(ItemList.Cell_Empty.get(-tCellBalance));
                            }
                            ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]);
                            recipeBuilder.itemOutputs(outputsArray)
                                .duration(Math.max(1L, Math.abs(aMaterial.getProtons() * 8L * tItemAmount)))
                                .eut(Math.min(4, tList.size()) * 30)
                                .addTo(electrolyzerRecipes);
                        }
                    }
                    if ((aMaterial.mExtraData & 0x2) != 0) {
                        GTRecipeBuilder recipeBuilder = RA.stdBuilder();
                        if (tCapsuleCount > 0L) {
                            recipeBuilder.itemInputs(
                                GTUtility.copyAmount(tItemAmount, aStack),
                                ItemList.Cell_Empty.get(tCapsuleCount));
                        } else {
                            recipeBuilder.itemInputs(GTUtility.copyAmount(tItemAmount, aStack));
                        }
                        if (tCapsuleCount < 0L) {
                            tList.add(ItemList.Cell_Empty.get(-tCapsuleCount));
                        }
                        ItemStack[] outputsArray = tList.toArray(new ItemStack[Math.min(tList.size(), 6)]);
                        recipeBuilder.itemOutputs(outputsArray)
                            .duration(Math.max(1L, Math.abs(aMaterial.getMass() * 2L * tItemAmount)))
                            .eut(5)
                            .addTo(centrifugeRecipes);
                    }
                }
            }
            case cellPlasma -> {
                if (aMaterial == Materials.Empty) {
                    GTModHandler.removeRecipeByOutputDelayed(aStack);
                } else {
                    GTRecipeBuilder recipeBuilder = RA.stdBuilder();
                    recipeBuilder.itemInputs(GTUtility.copyAmount(1, aStack));
                    if (GTUtility.getFluidForFilledItem(aStack, true) == null
                        && GTUtility.getContainerItem(aStack, true) != null) {
                        recipeBuilder.itemOutputs(GTUtility.getContainerItem(aStack, true));
                    }
                    // Switch case to set manual values for specific plasmas and escape the formula based on mass
                    // when it doesn't make sense for powergen balance.
                    switch (aMaterial.mName) {
                        case "Aluminium" -> recipeBuilder.metadata(FUEL_VALUE, 159_744)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Americium" -> recipeBuilder.metadata(FUEL_VALUE, 501_760)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Antimony" -> recipeBuilder.metadata(FUEL_VALUE, 309_760)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Argon" -> recipeBuilder.metadata(FUEL_VALUE, 188_416)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Arsenic" -> recipeBuilder.metadata(FUEL_VALUE, 230_400)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Barium" -> recipeBuilder.metadata(FUEL_VALUE, 342_302)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Beryllium" -> recipeBuilder.metadata(FUEL_VALUE, 110_592)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Bismuth" -> recipeBuilder.metadata(FUEL_VALUE, 425_984)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Boron" -> recipeBuilder.metadata(FUEL_VALUE, 112_640)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Cadmium" -> recipeBuilder.metadata(FUEL_VALUE, 293_601)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Caesium" -> recipeBuilder.metadata(FUEL_VALUE, 332_513)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Calcium" -> recipeBuilder.metadata(FUEL_VALUE, 188_416)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Cerium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Chlorine" -> recipeBuilder.metadata(FUEL_VALUE, 172_032)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Chrome" -> recipeBuilder.metadata(FUEL_VALUE, 202_342)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Cobalt" -> recipeBuilder.metadata(FUEL_VALUE, 217_497)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Copper" -> recipeBuilder.metadata(FUEL_VALUE, 219_340)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Deuterium" -> recipeBuilder.metadata(FUEL_VALUE, 40_960)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Erbium" -> recipeBuilder.metadata(FUEL_VALUE, 376_217)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Europium" -> recipeBuilder.metadata(FUEL_VALUE, 355_635)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Fluorine" -> recipeBuilder.metadata(FUEL_VALUE, 147_456)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Force" -> recipeBuilder.metadata(FUEL_VALUE, 180_000)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Gadolinium" -> recipeBuilder.metadata(FUEL_VALUE, 366_551)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Gallium" -> recipeBuilder.metadata(FUEL_VALUE, 229_376)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Gold" -> recipeBuilder.metadata(FUEL_VALUE, 401_408)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Helium_3" -> recipeBuilder.metadata(FUEL_VALUE, 61_440)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Helium" -> recipeBuilder.metadata(FUEL_VALUE, 81_920)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Holmium" -> recipeBuilder.metadata(FUEL_VALUE, 376_176)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Hydrogen" -> recipeBuilder.metadata(FUEL_VALUE, 20_480)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Indium" -> recipeBuilder.metadata(FUEL_VALUE, 296_509)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Iridium" -> recipeBuilder.metadata(FUEL_VALUE, 397_148)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Iron" -> recipeBuilder.metadata(FUEL_VALUE, 206_438)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Lanthanum" -> recipeBuilder.metadata(FUEL_VALUE, 344_801)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Lead" -> recipeBuilder.metadata(FUEL_VALUE, 423_936)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Lithium" -> recipeBuilder.metadata(FUEL_VALUE, 100_352)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Lutetium" -> recipeBuilder.metadata(FUEL_VALUE, 381_296)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Magnesium" -> recipeBuilder.metadata(FUEL_VALUE, 152_371)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Manganese" -> recipeBuilder.metadata(FUEL_VALUE, 202_752)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Mercury" -> recipeBuilder.metadata(FUEL_VALUE, 409_600)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Molybdenum" -> recipeBuilder.metadata(FUEL_VALUE, 272_384)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Neodymium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Nickel" -> recipeBuilder.metadata(FUEL_VALUE, 213_811)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Niobium" -> recipeBuilder.metadata(FUEL_VALUE, 269_516)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Nitrogen" -> recipeBuilder.metadata(FUEL_VALUE, 129_024)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Osmium" -> recipeBuilder.metadata(FUEL_VALUE, 393_659)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Oxygen" -> recipeBuilder.metadata(FUEL_VALUE, 131_072)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Palladium" -> recipeBuilder.metadata(FUEL_VALUE, 282_214)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Phosphor" -> recipeBuilder.metadata(FUEL_VALUE, 165_888)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Platinum" -> recipeBuilder.metadata(FUEL_VALUE, 399_360)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Plutonium241" -> recipeBuilder.metadata(FUEL_VALUE, 497_664)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Plutonium" -> recipeBuilder.metadata(FUEL_VALUE, 503_808)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Potassium" -> recipeBuilder.metadata(FUEL_VALUE, 183_705)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Praseodymium" -> recipeBuilder.metadata(FUEL_VALUE, 346_931)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Promethium" -> recipeBuilder.metadata(FUEL_VALUE, 347_996)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Radon" -> recipeBuilder.metadata(FUEL_VALUE, 450_560)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Rubidium" -> recipeBuilder.metadata(FUEL_VALUE, 243_712)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Samarium" -> recipeBuilder.metadata(FUEL_VALUE, 353_280)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Scandium" -> recipeBuilder.metadata(FUEL_VALUE, 193_536)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Silicon" -> recipeBuilder.metadata(FUEL_VALUE, 160_563)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Silver" -> recipeBuilder.metadata(FUEL_VALUE, 282_685)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Sodium" -> recipeBuilder.metadata(FUEL_VALUE, 148_684)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Strontium" -> recipeBuilder.metadata(FUEL_VALUE, 249_446)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Sulfur" -> recipeBuilder.metadata(FUEL_VALUE, 170_393)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Tantalum" -> recipeBuilder.metadata(FUEL_VALUE, 384_000)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Terbium" -> recipeBuilder.metadata(FUEL_VALUE, 368_885)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Thorium" -> recipeBuilder.metadata(FUEL_VALUE, 471_040)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Thulium" -> recipeBuilder.metadata(FUEL_VALUE, 378_470)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Tin" -> recipeBuilder.metadata(FUEL_VALUE, 150_000)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Titanium" -> recipeBuilder.metadata(FUEL_VALUE, 196_608)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Tritium" -> recipeBuilder.metadata(FUEL_VALUE, 61_440)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Tungsten" -> recipeBuilder.metadata(FUEL_VALUE, 384_778)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Uranium235" -> recipeBuilder.metadata(FUEL_VALUE, 481_280)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Uranium" -> recipeBuilder.metadata(FUEL_VALUE, 487_424)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Vanadium" -> recipeBuilder.metadata(FUEL_VALUE, 198_451)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Ytterbium" -> recipeBuilder.metadata(FUEL_VALUE, 379_695)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Yttrium" -> recipeBuilder.metadata(FUEL_VALUE, 255_180)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        case "Zinc" -> recipeBuilder.metadata(FUEL_VALUE, 226_304)
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                        default -> recipeBuilder
                            .metadata(FUEL_VALUE, (int) Math.max(1024L, 1024L * aMaterial.getMass()))
                            .metadata(FUEL_TYPE, 4)
                            .addTo(GTRecipeConstants.Fuel);
                    }
                    if (GTOreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L) != null) {
                        RA.stdBuilder()
                            .itemInputs(GTUtility.copyAmount(1, aStack))
                            .itemOutputs(GTOreDictUnificator.get(OrePrefixes.cell, aMaterial, 1L))
                            .duration(((int) Math.max(aMaterial.getMass() * 2L, 1L)) * TICKS)
                            .eut(TierEU.RECIPE_MV)
                            .addTo(vacuumFreezerRecipes);
                    }
                }
            }
            default -> {}
        }
    }
}