aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/gregtech/loaders/oreprocessing/ProcessingGem.java
blob: 7a6a3ec0043bc5a629b559e3d06cf18ab1b3f26c (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
package gregtech.loaders.oreprocessing;

import static gregtech.api.enums.Mods.AppliedEnergistics2;
import static gregtech.api.util.GT_Utility.calculateRecipeEU;

import net.minecraft.item.ItemStack;
import net.minecraftforge.oredict.OreDictionary;

import gregtech.api.GregTech_API;
import gregtech.api.enums.*;
import gregtech.api.util.GT_ModHandler;
import gregtech.api.util.GT_OreDictUnificator;
import gregtech.api.util.GT_Utility;
import gregtech.common.GT_Proxy;

public class ProcessingGem implements gregtech.api.interfaces.IOreRecipeRegistrator { // TODO COMPARE WITH GEM???
                                                                                      // generators

    public ProcessingGem() {
        OrePrefixes.gem.add(this);
        OrePrefixes.gemChipped.add(this);
        OrePrefixes.gemExquisite.add(this);
        OrePrefixes.gemFlawed.add(this);
        OrePrefixes.gemFlawless.add(this);
    }

    @Override
    public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName,
            ItemStack aStack) {
        long aMaterialMass = aMaterial.getMass();
        boolean aNoSmashing = aMaterial.contains(SubTag.NO_SMASHING);
        boolean aNoWorking = aMaterial.contains(SubTag.NO_WORKING);
        boolean aNoSmelting = aMaterial.contains(SubTag.NO_SMELTING);
        boolean aSpecialRecipeReq = (aMaterial.contains(SubTag.MORTAR_GRINDABLE))
                && (GregTech_API.sRecipeFile.get(ConfigCategories.Tools.mortar, aMaterial.mName, true));
        boolean aFuelPower = aMaterial.mFuelPower > 0;

        switch (aPrefix) {
            case gem -> {
                if (aFuelPower) {
                    GT_Values.RA.addFuel(
                            GT_Utility.copyAmount(1L, aStack),
                            null,
                            aMaterial.mFuelPower * 2,
                            aMaterial.mFuelType);
                }
                if (!OrePrefixes.block.isIgnored(aMaterial)) {
                    GT_ModHandler.addCompressionRecipe(
                            GT_Utility.copyAmount(9L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.block, aMaterial, 1L));
                }
                if (!aNoSmelting) {
                    GT_ModHandler.addSmeltingRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.ingot, aMaterial.mSmeltInto, 1L));
                }
                if (aNoSmashing) {
                    GT_Values.RA.addForgeHammerRecipe(
                            aStack,
                            GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 2L),
                            64,
                            16);
                } else {
                    GT_Values.RA.addForgeHammerRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
                            (int) Math.max(aMaterialMass, 1L),
                            calculateRecipeEU(aMaterial, 16));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plate, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 2L, 1L),
                            calculateRecipeEU(aMaterial, 24));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(2L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plateDouble, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 2L, 1L),
                            calculateRecipeEU(aMaterial, 96));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(3L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plateTriple, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 3L, 1L),
                            calculateRecipeEU(aMaterial, 96));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(4L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 4L, 1L),
                            calculateRecipeEU(aMaterial, 96));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(5L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plateQuintuple, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 5L, 1L),
                            calculateRecipeEU(aMaterial, 96));
                    GT_Values.RA.addBenderRecipe(
                            GT_Utility.copyAmount(9L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.plateDense, aMaterial, 1L),
                            (int) Math.max(aMaterialMass * 9L, 1L),
                            calculateRecipeEU(aMaterial, 96));
                }
                if (aNoWorking) {
                    if (aMaterial.getProcessingMaterialTierEU() < TierEU.IV) {
                        GT_Values.RA.addLatheRecipe(
                                GT_Utility.copyAmount(1L, aStack),
                                GT_OreDictUnificator.get(OrePrefixes.stick, aMaterial, 1L),
                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L),
                                (int) Math.max(aMaterialMass, 1L),
                                calculateRecipeEU(aMaterial, 16));
                    }
                } else {
                    if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
                        GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "h", "X", 'X', OrePrefixes.gemFlawless.get(aMaterial) });
                        GT_Values.RA.addImplosionRecipe(
                                GT_Utility.copyAmount(3L, aStack),
                                8,
                                GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1),
                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2));
                        if (aMaterial.contains(SubTag.SMELTING_TO_GEM)) GT_ModHandler.addCraftingRecipe(
                                GT_Utility.copyAmount(1L, aStack),
                                GT_Proxy.tBits,
                                new Object[] { "XXX", "XXX", "XXX", 'X', OrePrefixes.nugget.get(aMaterial) });
                        if (aSpecialRecipeReq) GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 1L),
                                GT_Proxy.tBits,
                                new Object[] { "X", "m", 'X', OrePrefixes.gem.get(aMaterial) });
                    }
                }
                // GT_RecipeRegistrator.registerUsagesForMaterials(OrePrefixes.plate.get(aMaterial).toString(),
                // !aNoSmashing, GT_Utility.copyAmount(1L, aStack));

                switch (aMaterial.mName) {
                    case "NULL":
                        break;
                    case "Coal":
                    case "Charcoal":
                        if (GregTech_API.sRecipeFile.get(
                                ConfigCategories.Recipes.disabledrecipes,
                                "torchesFromCoal",
                                false)) {
                            GT_ModHandler.removeRecipeDelayed(
                                    GT_Utility.copyAmount(1L, aStack),
                                    null,
                                    null,
                                    new ItemStack(net.minecraft.init.Items.stick, 1, 0));
                        }
                        break;
                    case "CertusQuartz":
                        GT_Values.RA.addElectrolyzerRecipe(
                                aStack,
                                0,
                                GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 1),
                                null,
                                null,
                                null,
                                null,
                                null,
                                2000,
                                30);
                }
                for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver
                    // Recipe
                    // adder
                    is.stackSize = 0;
                    GT_Values.RA.addLaserEngraverRecipe(
                            GT_Utility.copyAmount(3L, aStack),
                            is,
                            GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 1L),
                            1200,
                            480);
                }
            }
            case gemChipped -> {
                if (aFuelPower) GT_Values.RA.addFuel(
                        GT_Utility.copyAmount(1L, aStack),
                        null,
                        aMaterial.mFuelPower / 2,
                        aMaterial.mFuelType);
                if (!aNoWorking) {
                    GT_Values.RA.addLatheRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 1L),
                            GT_OreDictUnificator.get(OrePrefixes.dustTiny, aMaterial, 1L),
                            (int) Math.max(aMaterialMass, 1L),
                            8);
                    if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
                        GT_Values.RA.addImplosionRecipe(
                                GT_Utility.copyAmount(3L, aStack),
                                8,
                                GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1),
                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2));
                        GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "h", "X", 'X', OrePrefixes.gemFlawed.get(aMaterial) });
                        if (aSpecialRecipeReq) GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L),
                                GT_Proxy.tBits,
                                new Object[] { "X", "m", 'X', OrePrefixes.gemChipped.get(aMaterial) });
                    }
                }
                for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver
                    // Recipe
                    // adder
                    is.stackSize = 0;
                    GT_Values.RA.addLaserEngraverRecipe(
                            GT_Utility.copyAmount(3L, aStack),
                            is,
                            GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 1L),
                            600,
                            30);
                }
            }
            case gemExquisite -> {
                if (aFuelPower) GT_Values.RA.addFuel(
                        GT_Utility.copyAmount(1L, aStack),
                        null,
                        aMaterial.mFuelPower * 8,
                        aMaterial.mFuelType);
                if (!aNoWorking) {
                    if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial))
                        if (aSpecialRecipeReq) GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 4L),
                                GT_Proxy.tBits,
                                new Object[] { "X", "m", 'X', OrePrefixes.gemExquisite.get(aMaterial) });
                }
                GT_Values.RA.addForgeHammerRecipe(
                        aStack,
                        GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 2L),
                        64,
                        16);
            }
            case gemFlawed -> {
                if (aFuelPower) GT_Values.RA.addFuel(
                        GT_Utility.copyAmount(1L, aStack),
                        null,
                        aMaterial.mFuelPower,
                        aMaterial.mFuelType);
                if (!aNoWorking) {
                    GT_Values.RA.addLatheRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.bolt, aMaterial, 2L),
                            GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 1L),
                            (int) Math.max(aMaterialMass, 1L),
                            12);
                    if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
                        GT_Values.RA.addImplosionRecipe(
                                GT_Utility.copyAmount(3L, aStack),
                                8,
                                GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1),
                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2));
                        GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.gemFlawed, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "h", "X", 'X', OrePrefixes.gem.get(aMaterial) });
                        if (aSpecialRecipeReq) GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.dustSmall, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "X", "m", 'X', OrePrefixes.gemFlawed.get(aMaterial) });
                    }
                }
                GT_Values.RA.addForgeHammerRecipe(
                        aStack,
                        GT_OreDictUnificator.get(OrePrefixes.gemChipped, aMaterial, 2L),
                        64,
                        16);
                for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver
                    // Recipe
                    // adder
                    is.stackSize = 0;
                    GT_Values.RA.addLaserEngraverRecipe(
                            GT_Utility.copyAmount(3L, aStack),
                            is,
                            GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 1L),
                            600,
                            120);
                }
            }
            case gemFlawless -> {
                if (aFuelPower) GT_Values.RA.addFuel(
                        GT_Utility.copyAmount(1L, aStack),
                        null,
                        aMaterial.mFuelPower * 4,
                        aMaterial.mFuelType);
                if (!aNoWorking) {
                    GT_Values.RA.addLatheRecipe(
                            GT_Utility.copyAmount(1L, aStack),
                            GT_OreDictUnificator.get(OrePrefixes.stickLong, aMaterial, 1L),
                            GT_OreDictUnificator.getDust(
                                    aMaterial,
                                    aPrefix.mMaterialAmount - OrePrefixes.stickLong.mMaterialAmount),
                            (int) Math.max(aMaterialMass * 5L, 1L),
                            16);
                    if (aMaterial.mUnificatable && (aMaterial.mMaterialInto == aMaterial)) {
                        GT_Values.RA.addImplosionRecipe(
                                GT_Utility.copyAmount(3L, aStack),
                                8,
                                GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1),
                                GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 2));
                        GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.gemFlawless, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "h", "X", 'X', OrePrefixes.gemExquisite.get(aMaterial) });
                        if (aSpecialRecipeReq) GT_ModHandler.addCraftingRecipe(
                                GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial, 2L),
                                GT_Proxy.tBits,
                                new Object[] { "X", "m", 'X', OrePrefixes.gemFlawless.get(aMaterial) });
                    }
                }
                GT_Values.RA.addForgeHammerRecipe(
                        aStack,
                        GT_OreDictUnificator.get(OrePrefixes.gem, aMaterial, 2L),
                        64,
                        16);
                for (ItemStack is : OreDictionary.getOres("craftingLens" + aMaterial.mColor.mName.replace(" ", ""))) { // Engraver
                    // Recipe
                    // adder
                    is.stackSize = 0;
                    GT_Values.RA.addLaserEngraverRecipe(
                            GT_Utility.copyAmount(3L, aStack),
                            is,
                            GT_OreDictUnificator.get(OrePrefixes.gemExquisite, aMaterial, 1L),
                            2400,
                            2000);
                }
            }
            default -> {}
        }
    }
}