Skip to content

Commit 92c40f9

Browse files
DilithiumThorideDilithiumThoride
authored
Implement creating Chanced and Ranged NBTPredicateIngredients (#4202)
1 parent 271df89 commit 92c40f9

File tree

2 files changed

+226
-15
lines changed

2 files changed

+226
-15
lines changed

‎src/main/java/com/gregtechceu/gtceu/data/recipe/builder/GTRecipeBuilder.java‎

Lines changed: 45 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -464,8 +464,12 @@ public GTRecipeBuilder inputItems(MachineDefinition machine, int count) {
464464
return inputItems(machine.asStack(count));
465465
}
466466

467+
public GTRecipeBuilder inputItemRanged(IntProviderIngredient provider) {
468+
return inputItems(provider);
469+
}
470+
467471
public GTRecipeBuilder inputItemsRanged(ItemStack input, IntProvider intProvider) {
468-
return inputItems(IntProviderIngredient.of(input, intProvider));
472+
return inputItemRanged(IntProviderIngredient.of(input, intProvider));
469473
}
470474

471475
public GTRecipeBuilder inputItemsRanged(Item input, IntProvider intProvider) {
@@ -490,7 +494,7 @@ public GTRecipeBuilder inputItemsRanged(MachineDefinition machine, IntProvider i
490494
}
491495

492496
public GTRecipeBuilder inputItemNbtPredicate(ItemStack stack, NBTPredicate predicate) {
493-
if (missingIngredientError(0, true, ItemRecipeCapability.CAP, input::isEmpty)) {
497+
if (missingIngredientError(0, true, ItemRecipeCapability.CAP, stack::isEmpty)) {
494498
return this;
495499
}
496500
gatherMaterialInfoFromStack(stack);
@@ -614,8 +618,12 @@ protected GTRecipeBuilder outputItems(Ingredient ingredient) {
614618
return output(ItemRecipeCapability.CAP, ingredient);
615619
}
616620

621+
public GTRecipeBuilder outputItemRanged(IntProviderIngredient provider) {
622+
return outputItems(provider);
623+
}
624+
617625
public GTRecipeBuilder outputItemsRanged(ItemStack output, IntProvider intProvider) {
618-
return outputItems(IntProviderIngredient.of(output, intProvider));
626+
return outputItemRanged(IntProviderIngredient.of(output, intProvider));
619627
}
620628

621629
public GTRecipeBuilder outputItemsRanged(Item input, IntProvider intProvider) {
@@ -707,7 +715,7 @@ public GTRecipeBuilder circuitMeta(int configuration) {
707715
return notConsumable(IntCircuitIngredient.of(configuration));
708716
}
709717

710-
public GTRecipeBuilder chancedInput(ItemStack stack, int chance, int tierChanceBoost) {
718+
public GTRecipeBuilder chancedInput(Ingredient stack, int chance, int tierChanceBoost) {
711719
if (checkChanceAndPrintError(chance)) {
712720
return this;
713721
}
@@ -721,7 +729,7 @@ public GTRecipeBuilder chancedInput(ItemStack stack, int chance, int tierChanceB
721729
return this;
722730
}
723731

724-
public GTRecipeBuilder chancedInput(FluidStack stack, int chance, int tierChanceBoost) {
732+
public GTRecipeBuilder chancedInput(FluidIngredient stack, int chance, int tierChanceBoost) {
725733
if (checkChanceAndPrintError(chance)) {
726734
return this;
727735
}
@@ -735,7 +743,7 @@ public GTRecipeBuilder chancedInput(FluidStack stack, int chance, int tierChance
735743
return this;
736744
}
737745

738-
public GTRecipeBuilder chancedOutput(ItemStack stack, int chance, int tierChanceBoost) {
746+
public GTRecipeBuilder chancedOutput(Ingredient stack, int chance, int tierChanceBoost) {
739747
if (checkChanceAndPrintError(chance)) {
740748
return this;
741749
}
@@ -749,7 +757,7 @@ public GTRecipeBuilder chancedOutput(ItemStack stack, int chance, int tierChance
749757
return this;
750758
}
751759

752-
public GTRecipeBuilder chancedOutput(FluidStack stack, int chance, int tierChanceBoost) {
760+
public GTRecipeBuilder chancedOutput(FluidIngredient stack, int chance, int tierChanceBoost) {
753761
if (checkChanceAndPrintError(chance)) {
754762
return this;
755763
}
@@ -763,6 +771,22 @@ public GTRecipeBuilder chancedOutput(FluidStack stack, int chance, int tierChanc
763771
return this;
764772
}
765773

774+
public GTRecipeBuilder chancedInput(ItemStack stack, int chance, int tierChanceBoost) {
775+
return chancedInput(Ingredient.of(stack), chance, tierChanceBoost);
776+
}
777+
778+
public GTRecipeBuilder chancedInput(FluidStack stack, int chance, int tierChanceBoost) {
779+
return chancedInput(FluidIngredient.of(stack), chance, tierChanceBoost);
780+
}
781+
782+
public GTRecipeBuilder chancedOutput(ItemStack stack, int chance, int tierChanceBoost) {
783+
return chancedOutput(Ingredient.of(stack), chance, tierChanceBoost);
784+
}
785+
786+
public GTRecipeBuilder chancedOutput(FluidStack stack, int chance, int tierChanceBoost) {
787+
return chancedOutput(FluidIngredient.of(stack), chance, tierChanceBoost);
788+
}
789+
766790
public GTRecipeBuilder chancedOutput(TagPrefix tag, Material mat, int chance, int tierChanceBoost) {
767791
return chancedOutput(ChemicalHelper.get(tag, mat), chance, tierChanceBoost);
768792
}
@@ -974,12 +998,16 @@ public GTRecipeBuilder inputFluids(FluidStack... inputs) {
974998
return input(FluidRecipeCapability.CAP, ingredients.toArray(FluidIngredient[]::new));
975999
}
9761000

977-
public GTRecipeBuilder inputFluidsRanged(FluidStack input, IntProvider intProvider) {
978-
return inputFluidsRanged(FluidIngredient.of(input), intProvider);
1001+
public GTRecipeBuilder inputFluidsRanged(IntProviderFluidIngredient provider) {
1002+
return inputFluids(provider);
9791003
}
9801004

9811005
protected GTRecipeBuilder inputFluidsRanged(FluidIngredient input, IntProvider intProvider) {
982-
return inputFluids(IntProviderFluidIngredient.of(input, intProvider));
1006+
return inputFluidsRanged(IntProviderFluidIngredient.of(input, intProvider));
1007+
}
1008+
1009+
public GTRecipeBuilder inputFluidsRanged(FluidStack input, IntProvider intProvider) {
1010+
return inputFluidsRanged(FluidIngredient.of(input), intProvider);
9831011
}
9841012

9851013
public GTRecipeBuilder inputFluids(FluidIngredient... inputs) {
@@ -999,12 +1027,16 @@ public GTRecipeBuilder outputFluids(FluidIngredient... outputs) {
9991027
return output(FluidRecipeCapability.CAP, outputs);
10001028
}
10011029

1002-
public GTRecipeBuilder outputFluidsRanged(FluidStack output, IntProvider intProvider) {
1003-
return outputFluidsRanged(FluidIngredient.of(output), intProvider);
1030+
public GTRecipeBuilder outputFluidsRanged(IntProviderFluidIngredient provider) {
1031+
return outputFluids(provider);
10041032
}
10051033

10061034
protected GTRecipeBuilder outputFluidsRanged(FluidIngredient output, IntProvider intProvider) {
1007-
return outputFluids(IntProviderFluidIngredient.of(output, intProvider));
1035+
return outputFluidsRanged(IntProviderFluidIngredient.of(output, intProvider));
1036+
}
1037+
1038+
public GTRecipeBuilder outputFluidsRanged(FluidStack output, IntProvider intProvider) {
1039+
return outputFluidsRanged(FluidIngredient.of(output), intProvider);
10081040
}
10091041

10101042
//////////////////////////////////////

‎src/test/java/com/gregtechceu/gtceu/api/recipe/ingredient/NBTPredicateTest.java‎

Lines changed: 181 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,78 @@
11
package com.gregtechceu.gtceu.api.recipe.ingredient;
22

33
import com.gregtechceu.gtceu.GTCEu;
4+
import com.gregtechceu.gtceu.api.GTValues;
5+
import com.gregtechceu.gtceu.api.capability.recipe.IO;
6+
import com.gregtechceu.gtceu.api.capability.recipe.ItemRecipeCapability;
7+
import com.gregtechceu.gtceu.api.machine.SimpleTieredMachine;
8+
import com.gregtechceu.gtceu.api.machine.trait.NotifiableItemStackHandler;
9+
import com.gregtechceu.gtceu.api.recipe.GTRecipeType;
410
import com.gregtechceu.gtceu.api.recipe.ingredient.nbtpredicate.NBTPredicate;
11+
import com.gregtechceu.gtceu.gametest.util.TestUtils;
512

13+
import net.minecraft.core.BlockPos;
614
import net.minecraft.gametest.framework.BeforeBatch;
715
import net.minecraft.gametest.framework.GameTest;
816
import net.minecraft.gametest.framework.GameTestHelper;
917
import net.minecraft.nbt.CompoundTag;
1018
import net.minecraft.server.level.ServerLevel;
19+
import net.minecraft.util.valueproviders.UniformInt;
20+
import net.minecraft.world.item.ItemStack;
21+
import net.minecraft.world.item.Items;
1122
import net.minecraftforge.gametest.GameTestHolder;
1223
import net.minecraftforge.gametest.PrefixGameTestTemplate;
1324

1425
import static com.gregtechceu.gtceu.api.recipe.ingredient.nbtpredicate.NBTPredicates.*;
15-
import static com.gregtechceu.gtceu.api.recipe.ingredient.nbtpredicate.NBTPredicates.eq;
26+
import static com.gregtechceu.gtceu.common.data.GTRecipeTypes.CHEMICAL_RECIPES;
27+
import static com.gregtechceu.gtceu.gametest.util.TestUtils.getMetaMachine;
1628

1729
@PrefixGameTestTemplate(false)
1830
@GameTestHolder(GTCEu.MOD_ID)
1931
public class NBTPredicateTest {
2032

33+
private static GTRecipeType CR_RECIPE_TYPE;
34+
2135
@BeforeBatch(batch = "NBTPredicateTest")
22-
public static void prepare(ServerLevel level) {}
36+
public static void prepare(ServerLevel level) {
37+
CR_RECIPE_TYPE = TestUtils.createRecipeType("nbt_predicate_ingredient_cr_tests", CHEMICAL_RECIPES);
38+
CR_RECIPE_TYPE.getLookup().addRecipe(
39+
CR_RECIPE_TYPE.recipeBuilder("nbt_predicate_test")
40+
.inputItemNbtPredicate(new ItemStack(Items.FEATHER), eq("foo", "bar"))
41+
.outputItems(new ItemStack(Items.COAL))
42+
.EUt(GTValues.V[GTValues.HV])
43+
.duration(5)
44+
.buildRawRecipe());
45+
46+
CR_RECIPE_TYPE.getLookup().addRecipe(
47+
CR_RECIPE_TYPE.recipeBuilder("nbt_predicate_test_chanced")
48+
.chance(4000)
49+
.inputItemNbtPredicate(new ItemStack(Items.FEATHER), eq("bin", "bar"))
50+
.chance(10000)
51+
.outputItems(new ItemStack(Items.CHARCOAL))
52+
.EUt(GTValues.V[GTValues.HV])
53+
.duration(4)
54+
.buildRawRecipe());
55+
56+
CR_RECIPE_TYPE.getLookup().addRecipe(
57+
CR_RECIPE_TYPE.recipeBuilder("nbt_predicate_test_ranged")
58+
.inputItemRanged(new IntProviderIngredient(new NBTPredicateIngredient(
59+
new ItemStack(Items.FEATHER), eq("bash", "bar")), UniformInt.of(0, 4)))
60+
.outputItems(new ItemStack(Items.COBBLESTONE))
61+
.EUt(GTValues.V[GTValues.HV])
62+
.duration(4)
63+
.buildRawRecipe());
64+
65+
CR_RECIPE_TYPE.getLookup().addRecipe(
66+
CR_RECIPE_TYPE.recipeBuilder("nbt_predicate_test_chanced_ranged")
67+
.chance(4000)
68+
.inputItemRanged(new IntProviderIngredient(new NBTPredicateIngredient(
69+
new ItemStack(Items.FEATHER), eq("bash", "botch")), UniformInt.of(0, 4)))
70+
.chance(10000)
71+
.outputItems(new ItemStack(Items.DEEPSLATE))
72+
.EUt(GTValues.V[GTValues.HV])
73+
.duration(4)
74+
.buildRawRecipe());
75+
}
2376

2477
@GameTest(template = "empty", batch = "NBTPredicateTest")
2578
public static void NBTPredicateEqualsTest(GameTestHelper helper) {
@@ -176,4 +229,130 @@ public static void NBTPredicateEmptyTest(GameTestHelper helper) {
176229
"Less-or-equal NBTPredicate succeeded with empty tag");
177230
helper.succeed();
178231
}
232+
233+
@GameTest(template = "singleblock_chem_reactor", batch = "NBTPredicateTest")
234+
public static void NBTPredicateMachineCRTestSucceeds(GameTestHelper helper) {
235+
SimpleTieredMachine machine = (SimpleTieredMachine) getMetaMachine(
236+
helper.getBlockEntity(new BlockPos(0, 1, 0)));
237+
238+
machine.setRecipeType(CR_RECIPE_TYPE);
239+
NotifiableItemStackHandler itemIn = (NotifiableItemStackHandler) machine
240+
.getCapabilitiesFlat(IO.IN, ItemRecipeCapability.CAP).get(0);
241+
NotifiableItemStackHandler itemOut = (NotifiableItemStackHandler) machine
242+
.getCapabilitiesFlat(IO.OUT, ItemRecipeCapability.CAP).get(0);
243+
244+
var inputStack = new ItemStack(Items.FEATHER);
245+
inputStack.getOrCreateTag().putString("foo", "bar");
246+
itemIn.setStackInSlot(0, inputStack);
247+
helper.runAfterDelay(10, () -> {
248+
helper.assertTrue(ItemStack.isSameItemSameTags(itemOut.getStackInSlot(0), new ItemStack(Items.COAL)),
249+
"NBT Predicate test didn't run when it should have.");
250+
helper.succeed();
251+
});
252+
}
253+
254+
@GameTest(template = "singleblock_chem_reactor", batch = "NBTPredicateTest")
255+
public static void NBTPredicateMachineCRTestDoesntSucceed(GameTestHelper helper) {
256+
SimpleTieredMachine machine = (SimpleTieredMachine) getMetaMachine(
257+
helper.getBlockEntity(new BlockPos(0, 1, 0)));
258+
259+
machine.setRecipeType(CR_RECIPE_TYPE);
260+
NotifiableItemStackHandler itemIn = (NotifiableItemStackHandler) machine
261+
.getCapabilitiesFlat(IO.IN, ItemRecipeCapability.CAP).get(0);
262+
NotifiableItemStackHandler itemOut = (NotifiableItemStackHandler) machine
263+
.getCapabilitiesFlat(IO.OUT, ItemRecipeCapability.CAP).get(0);
264+
265+
var inputStack = new ItemStack(Items.FEATHER);
266+
inputStack.getOrCreateTag().putString("foo", "baz");
267+
itemIn.setStackInSlot(0, inputStack);
268+
helper.runAfterDelay(10, () -> {
269+
helper.assertFalse(ItemStack.isSameItemSameTags(itemOut.getStackInSlot(0), new ItemStack(Items.COAL)),
270+
"NBT Predicate test ran when it shouldn't have.");
271+
helper.succeed();
272+
});
273+
}
274+
275+
@GameTest(template = "singleblock_chem_reactor", batch = "NBTPredicateTest")
276+
public static void NBTPredicateMachineCRTestChanced(GameTestHelper helper) {
277+
SimpleTieredMachine machine = (SimpleTieredMachine) getMetaMachine(
278+
helper.getBlockEntity(new BlockPos(0, 1, 0)));
279+
280+
machine.setRecipeType(CR_RECIPE_TYPE);
281+
NotifiableItemStackHandler itemIn = (NotifiableItemStackHandler) machine
282+
.getCapabilitiesFlat(IO.IN, ItemRecipeCapability.CAP).get(0);
283+
NotifiableItemStackHandler itemOut = (NotifiableItemStackHandler) machine
284+
.getCapabilitiesFlat(IO.OUT, ItemRecipeCapability.CAP).get(0);
285+
286+
var inputStack = new ItemStack(Items.FEATHER, 15); // one short, a chance roll needs to fail
287+
inputStack.getOrCreateTag().putString("bin", "bar");
288+
itemIn.setStackInSlot(0, inputStack);
289+
helper.runAfterDelay(4 * 16 + 1, () -> {
290+
helper.assertTrue(ItemStack.isSameItemSameTags(itemOut.getStackInSlot(0), new ItemStack(Items.CHARCOAL)),
291+
"NBT Predicate Chanced test ran the wrong recipe!");
292+
helper.assertTrue(itemOut.getStackInSlot(0).getCount() == 16,
293+
"NBT Predicate Chanced test didn't complete enough recipe runs, completed [" +
294+
itemOut.getStackInSlot(0).getCount() + "], not [16]");
295+
helper.assertFalse(itemIn.getStackInSlot(0).getCount() == 15,
296+
"NBT Predicate Chanced test didn't consume items");
297+
helper.assertFalse(itemIn.getStackInSlot(0).isEmpty(),
298+
"NBT Predicate Chanced test consumed too many items");
299+
helper.succeed();
300+
});
301+
}
302+
303+
@GameTest(template = "singleblock_chem_reactor", batch = "NBTPredicateTest")
304+
public static void NBTPredicateMachineCRTestRanged(GameTestHelper helper) {
305+
SimpleTieredMachine machine = (SimpleTieredMachine) getMetaMachine(
306+
helper.getBlockEntity(new BlockPos(0, 1, 0)));
307+
308+
machine.setRecipeType(CR_RECIPE_TYPE);
309+
NotifiableItemStackHandler itemIn = (NotifiableItemStackHandler) machine
310+
.getCapabilitiesFlat(IO.IN, ItemRecipeCapability.CAP).get(0);
311+
NotifiableItemStackHandler itemOut = (NotifiableItemStackHandler) machine
312+
.getCapabilitiesFlat(IO.OUT, ItemRecipeCapability.CAP).get(0);
313+
314+
var inputStack = new ItemStack(Items.FEATHER, 63); // one short, a range needs to roll not max
315+
inputStack.getOrCreateTag().putString("bash", "bar");
316+
itemIn.setStackInSlot(0, inputStack);
317+
helper.runAfterDelay(4 * 16 + 1, () -> {
318+
helper.assertTrue(ItemStack.isSameItemSameTags(itemOut.getStackInSlot(0), new ItemStack(Items.COBBLESTONE)),
319+
"NBT Predicate Ranged test ran the wrong recipe!");
320+
helper.assertTrue(itemOut.getStackInSlot(0).getCount() == 16,
321+
"NBT Predicate Ranged test didn't complete enough recipe runs, completed [" +
322+
itemOut.getStackInSlot(0).getCount() + "], not [16]");
323+
helper.assertFalse(itemIn.getStackInSlot(0).getCount() == 15,
324+
"NBT Predicate Ranged test didn't consume items");
325+
helper.assertFalse(itemIn.getStackInSlot(0).isEmpty(),
326+
"NBT Predicate Ranged test consumed too many items");
327+
helper.succeed();
328+
});
329+
}
330+
331+
@GameTest(template = "singleblock_chem_reactor", batch = "NBTPredicateTest")
332+
public static void NBTPredicateMachineCRTestChancedRanged(GameTestHelper helper) {
333+
SimpleTieredMachine machine = (SimpleTieredMachine) getMetaMachine(
334+
helper.getBlockEntity(new BlockPos(0, 1, 0)));
335+
336+
machine.setRecipeType(CR_RECIPE_TYPE);
337+
NotifiableItemStackHandler itemIn = (NotifiableItemStackHandler) machine
338+
.getCapabilitiesFlat(IO.IN, ItemRecipeCapability.CAP).get(0);
339+
NotifiableItemStackHandler itemOut = (NotifiableItemStackHandler) machine
340+
.getCapabilitiesFlat(IO.OUT, ItemRecipeCapability.CAP).get(0);
341+
342+
var inputStack = new ItemStack(Items.FEATHER, 63); // one short, a chance or range needs to not max
343+
inputStack.getOrCreateTag().putString("bash", "botch");
344+
itemIn.setStackInSlot(0, inputStack);
345+
helper.runAfterDelay(4 * 16 + 1, () -> {
346+
helper.assertTrue(ItemStack.isSameItemSameTags(itemOut.getStackInSlot(0), new ItemStack(Items.DEEPSLATE)),
347+
"NBT Predicate Chanced Ranged test ran the wrong recipe!");
348+
helper.assertTrue(itemOut.getStackInSlot(0).getCount() == 16,
349+
"NBT Predicate Chanced Ranged test didn't complete enough recipe runs, completed [" +
350+
itemOut.getStackInSlot(0).getCount() + "], not [16]");
351+
helper.assertFalse(itemIn.getStackInSlot(0).getCount() == 15,
352+
"NBT Predicate Chanced Ranged test didn't consume items");
353+
helper.assertFalse(itemIn.getStackInSlot(0).isEmpty(),
354+
"NBT Predicate Chanced Ranged test consumed too many items");
355+
helper.succeed();
356+
});
357+
}
179358
}

0 commit comments

Comments
 (0)