From 6d57804fe1fd9cb5b9b9d6c752eea9e18ee41109 Mon Sep 17 00:00:00 2001 From: mmyddd Date: Tue, 2 Jun 2026 22:35:26 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E6=96=B0=E5=A2=9Ecreatevintage=E9=85=8D?= =?UTF-8?q?=E6=96=B9=E7=B1=BB=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../MechanicalCraftingRecipeBuilder.java | 19 +- .../SequencedAssemblyRecipeBuilder.java | 25 ++- .../vintage/AbstractVintageRecipeBuilder.java | 210 ++++++++++++++++++ .../vintage/CentrifugationRecipeBuilder.java | 24 ++ .../create/vintage/CoilingRecipeBuilder.java | 37 +++ .../create/vintage/CurvingRecipeBuilder.java | 44 ++++ .../vintage/HammeringRecipeBuilder.java | 37 +++ .../vintage/PressurizingRecipeBuilder.java | 44 ++++ .../create/vintage/TurningRecipeBuilder.java | 24 ++ .../vintage/VibratingRecipeBuilder.java | 24 ++ .../create/vintage/VintageRecipeResult.java | 38 ++++ 11 files changed, 523 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/AbstractVintageRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CentrifugationRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CoilingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CurvingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/HammeringRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/PressurizingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/TurningRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VibratingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VintageRecipeResult.java diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MechanicalCraftingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MechanicalCraftingRecipeBuilder.java index 08d57c3..89a1012 100644 --- a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MechanicalCraftingRecipeBuilder.java +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MechanicalCraftingRecipeBuilder.java @@ -28,6 +28,7 @@ public class MechanicalCraftingRecipeBuilder { private final ResourceLocation id; + private final boolean exactId; private final List ingredients = new ArrayList<>(); private final List results = new ArrayList<>(); // optional pattern support (Create's mechanical_crafting supports a pattern + key mapping) @@ -35,13 +36,26 @@ public class MechanicalCraftingRecipeBuilder { private final Map key = new HashMap<>(); public MechanicalCraftingRecipeBuilder(String name) { - this.id = CTPP.id(name); + this(CTPP.id(name), false); + } + + public MechanicalCraftingRecipeBuilder(ResourceLocation id) { + this(id, true); + } + + private MechanicalCraftingRecipeBuilder(ResourceLocation id, boolean exactId) { + this.id = id; + this.exactId = exactId; } public static MechanicalCraftingRecipeBuilder builder(String name) { return new MechanicalCraftingRecipeBuilder(name); } + public static MechanicalCraftingRecipeBuilder builder(ResourceLocation id) { + return new MechanicalCraftingRecipeBuilder(id); + } + public MechanicalCraftingRecipeBuilder input(ItemStack stack) { return input(Ingredient.of(stack)); } @@ -187,6 +201,7 @@ public void serializeRecipeData(@Nonnull JsonObject pJson) { @Nonnull @Override public ResourceLocation getId() { + if (exactId) return id; return ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "mechanical_crafting/" + id.getPath()); } @@ -194,7 +209,7 @@ public ResourceLocation getId() { @Override public RecipeSerializer getType() { return Objects.requireNonNull(ForgeRegistries.RECIPE_SERIALIZERS.getValue( - ResourceLocation.tryParse("create:mechanical_crafting")), + ResourceLocation.tryParse("create:mechanical_crafting")), "Create mechanical_crafting serializer not found"); } diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/SequencedAssemblyRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/SequencedAssemblyRecipeBuilder.java index ef2d91e..c3f4793 100644 --- a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/SequencedAssemblyRecipeBuilder.java +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/SequencedAssemblyRecipeBuilder.java @@ -32,16 +32,30 @@ public class SequencedAssemblyRecipeBuilder { private final List results = new ArrayList<>(); private final List sequence = new ArrayList<>(); private final ResourceLocation id; + private final boolean exactId; private int loops = 1; public SequencedAssemblyRecipeBuilder(String name) { - this.id = CTPP.id(name); + this(CTPP.id(name), false); + } + + public SequencedAssemblyRecipeBuilder(ResourceLocation id) { + this(id, true); + } + + private SequencedAssemblyRecipeBuilder(ResourceLocation id, boolean exactId) { + this.id = id; + this.exactId = exactId; } public static SequencedAssemblyRecipeBuilder builder(String name) { return new SequencedAssemblyRecipeBuilder(name); } + public static SequencedAssemblyRecipeBuilder builder(ResourceLocation id) { + return new SequencedAssemblyRecipeBuilder(id); + } + public SequencedAssemblyRecipeBuilder input(ItemStack itemStack) { return ingredient(Ingredient.of(itemStack)); } @@ -175,6 +189,14 @@ public SequencedAssemblyRecipeBuilder cutting() { }); } + public SequencedAssemblyRecipeBuilder vintageCurving(ItemStack head) { + return step("vintageimprovements:curving", json -> { + json.add("ingredients", ingredients(itemIngredient(transitionalItem))); + json.add("results", ingredients(itemIngredient(transitionalItem))); + json.addProperty("head", Objects.requireNonNull(ForgeRegistries.ITEMS.getKey(head.getItem())).toString()); + }); + } + public SequencedAssemblyRecipeBuilder step(ResourceLocation type, java.util.function.Consumer config) { JsonObject json = new JsonObject(); json.addProperty("type", type.toString()); @@ -224,6 +246,7 @@ public void serializeRecipeData(@Nonnull JsonObject pJson) { @Nonnull @Override public ResourceLocation getId() { + if (exactId) return id; return ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "sequenced_assembly/" + id.getPath()); } diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/AbstractVintageRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/AbstractVintageRecipeBuilder.java new file mode 100644 index 0000000..9964ec1 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/AbstractVintageRecipeBuilder.java @@ -0,0 +1,210 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.item.crafting.RecipeSerializer; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.registries.ForgeRegistries; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import com.mo_guang.ctpp.CTPP; +import com.negodya1.vintageimprovements.VintageRecipes; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Consumer; + +import javax.annotation.Nonnull; + +public abstract class AbstractVintageRecipeBuilder> { + + private final ResourceLocation id; + private final VintageRecipes recipe; + private final boolean exactId; + private final List ingredients = new ArrayList<>(); + private final List results = new ArrayList<>(); + private String heatRequirement; + private Integer processingTime; + private Integer minimalRpm; + + protected AbstractVintageRecipeBuilder(String name, VintageRecipes recipe) { + this(CTPP.id(name), recipe, false); + } + + protected AbstractVintageRecipeBuilder(ResourceLocation id, VintageRecipes recipe) { + this(id, recipe, true); + } + + private AbstractVintageRecipeBuilder(ResourceLocation id, VintageRecipes recipe, boolean exactId) { + this.id = id; + this.recipe = recipe; + this.exactId = exactId; + } + + public T input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public T input(Item item) { + return input(Ingredient.of(new ItemStack(item, 1))); + } + + public T input(TagKey tag) { + return input(Ingredient.of(tag)); + } + + public T input(Ingredient ingredient) { + this.ingredients.add(ingredient.toJson().getAsJsonObject()); + return self(); + } + + public T inputFluid(Fluid fluid, int amount) { + return inputFluid(new FluidStack(fluid, amount)); + } + + public T inputFluid(FluidStack stack) { + this.ingredients.add(serializeFluidStack(stack)); + return self(); + } + + public T inputFluid(String fluidId, int amount) { + JsonObject json = new JsonObject(); + json.addProperty("fluid", fluidId); + json.addProperty("amount", amount); + this.ingredients.add(json); + return self(); + } + + public T result(ItemStack stack) { + this.results.add(VintageRecipeResult.item(stack.copy(), null)); + return self(); + } + + public T result(ItemStack stack, double chance) { + this.results.add(VintageRecipeResult.item(stack.copy(), chance)); + return self(); + } + + public T resultFluid(Fluid fluid, int amount) { + return resultFluid(new FluidStack(fluid, amount)); + } + + public T resultFluid(FluidStack stack) { + this.results.add(VintageRecipeResult.fluid(stack.copy())); + return self(); + } + + public T resultFluid(String fluidId, int amount) { + JsonObject json = new JsonObject(); + json.addProperty("fluid", fluidId); + json.addProperty("amount", amount); + this.results.add(new VintageRecipeResult(json)); + return self(); + } + + public T output(ItemStack stack) { + return result(stack); + } + + public T heatRequirement(String heatRequirement) { + this.heatRequirement = heatRequirement; + return self(); + } + + public T processingTime(int processingTime) { + this.processingTime = processingTime; + return self(); + } + + public T minimalRpm(int minimalRpm) { + this.minimalRpm = minimalRpm; + return self(); + } + + public T minimalRPM(int minimalRpm) { + return minimalRpm(minimalRpm); + } + + public void toJson(JsonObject json) { + if (ingredients.isEmpty() || results.isEmpty()) { + throw new IllegalStateException("Vintage recipe missing required fields"); + } + + json.addProperty("type", recipe.getId().toString()); + + JsonArray ingredientsJson = new JsonArray(); + ingredients.forEach(ingredientsJson::add); + json.add("ingredients", ingredientsJson); + + JsonArray resultsJson = new JsonArray(); + results.forEach(result -> resultsJson.add(result.toJson())); + json.add("results", resultsJson); + + if (heatRequirement != null) json.addProperty("heatRequirement", heatRequirement); + if (processingTime != null) json.addProperty("processingTime", processingTime); + if (minimalRpm != null) json.addProperty("minimalRPM", minimalRpm); + addExtraJson(json); + } + + public FinishedRecipe build() { + return new FinishedRecipe() { + + @Override + public void serializeRecipeData(@Nonnull JsonObject pJson) { + AbstractVintageRecipeBuilder.this.toJson(pJson); + } + + @Nonnull + @Override + public ResourceLocation getId() { + if (exactId) return id; + return ResourceLocation.fromNamespaceAndPath(id.getNamespace(), recipe.getId().getPath() + "/" + id.getPath()); + } + + @Nonnull + @Override + public RecipeSerializer getType() { + return recipe.getSerializer(); + } + + @Nullable + @Override + public JsonObject serializeAdvancement() { + return null; + } + + @Nullable + @Override + public ResourceLocation getAdvancementId() { + return null; + } + }; + } + + public void save(Consumer consumer) { + consumer.accept(build()); + } + + protected void addExtraJson(JsonObject json) { + } + + @SuppressWarnings("unchecked") + private T self() { + return (T) this; + } + + private static JsonObject serializeFluidStack(FluidStack stack) { + JsonObject json = new JsonObject(); + json.addProperty("fluid", Objects.requireNonNull(ForgeRegistries.FLUIDS.getKey(stack.getFluid())).toString()); + json.addProperty("amount", stack.getAmount()); + return json; + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CentrifugationRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CentrifugationRecipeBuilder.java new file mode 100644 index 0000000..360f9a7 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CentrifugationRecipeBuilder.java @@ -0,0 +1,24 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.negodya1.vintageimprovements.VintageRecipes; + +public class CentrifugationRecipeBuilder extends AbstractVintageRecipeBuilder { + + public CentrifugationRecipeBuilder(String name) { + super(name, VintageRecipes.CENTRIFUGATION); + } + + public CentrifugationRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.CENTRIFUGATION); + } + + public static CentrifugationRecipeBuilder builder(String name) { + return new CentrifugationRecipeBuilder(name); + } + + public static CentrifugationRecipeBuilder builder(ResourceLocation id) { + return new CentrifugationRecipeBuilder(id); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CoilingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CoilingRecipeBuilder.java new file mode 100644 index 0000000..eb5ab54 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CoilingRecipeBuilder.java @@ -0,0 +1,37 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.google.gson.JsonObject; +import com.negodya1.vintageimprovements.VintageRecipes; + +public class CoilingRecipeBuilder extends AbstractVintageRecipeBuilder { + + private String springColor; + + public CoilingRecipeBuilder(String name) { + super(name, VintageRecipes.COILING); + } + + public CoilingRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.COILING); + } + + public static CoilingRecipeBuilder builder(String name) { + return new CoilingRecipeBuilder(name); + } + + public static CoilingRecipeBuilder builder(ResourceLocation id) { + return new CoilingRecipeBuilder(id); + } + + public CoilingRecipeBuilder springColor(String springColor) { + this.springColor = springColor; + return this; + } + + @Override + protected void addExtraJson(JsonObject json) { + if (springColor != null) json.addProperty("springColor", springColor); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CurvingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CurvingRecipeBuilder.java new file mode 100644 index 0000000..94791a1 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/CurvingRecipeBuilder.java @@ -0,0 +1,44 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.google.gson.JsonObject; +import com.negodya1.vintageimprovements.VintageRecipes; + +public class CurvingRecipeBuilder extends AbstractVintageRecipeBuilder { + + private Integer mode; + private String head; + + public CurvingRecipeBuilder(String name) { + super(name, VintageRecipes.CURVING); + } + + public CurvingRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.CURVING); + } + + public static CurvingRecipeBuilder builder(String name) { + return new CurvingRecipeBuilder(name); + } + + public static CurvingRecipeBuilder builder(ResourceLocation id) { + return new CurvingRecipeBuilder(id); + } + + public CurvingRecipeBuilder mode(int mode) { + this.mode = mode; + return this; + } + + public CurvingRecipeBuilder head(String head) { + this.head = head; + return this; + } + + @Override + protected void addExtraJson(JsonObject json) { + if (mode != null) json.addProperty("mode", mode); + if (head != null) json.addProperty("head", head); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/HammeringRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/HammeringRecipeBuilder.java new file mode 100644 index 0000000..871e8aa --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/HammeringRecipeBuilder.java @@ -0,0 +1,37 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.google.gson.JsonObject; +import com.negodya1.vintageimprovements.VintageRecipes; + +public class HammeringRecipeBuilder extends AbstractVintageRecipeBuilder { + + private Integer hammerBlows; + + public HammeringRecipeBuilder(String name) { + super(name, VintageRecipes.HAMMERING); + } + + public HammeringRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.HAMMERING); + } + + public static HammeringRecipeBuilder builder(String name) { + return new HammeringRecipeBuilder(name); + } + + public static HammeringRecipeBuilder builder(ResourceLocation id) { + return new HammeringRecipeBuilder(id); + } + + public HammeringRecipeBuilder hammerBlows(int hammerBlows) { + this.hammerBlows = hammerBlows; + return this; + } + + @Override + protected void addExtraJson(JsonObject json) { + if (hammerBlows != null) json.addProperty("hammerBlows", hammerBlows); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/PressurizingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/PressurizingRecipeBuilder.java new file mode 100644 index 0000000..506aa35 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/PressurizingRecipeBuilder.java @@ -0,0 +1,44 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.google.gson.JsonObject; +import com.negodya1.vintageimprovements.VintageRecipes; + +public class PressurizingRecipeBuilder extends AbstractVintageRecipeBuilder { + + private Integer secondaryFluidInput; + private Integer secondaryFluidOutput; + + public PressurizingRecipeBuilder(String name) { + super(name, VintageRecipes.PRESSURIZING); + } + + public PressurizingRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.PRESSURIZING); + } + + public static PressurizingRecipeBuilder builder(String name) { + return new PressurizingRecipeBuilder(name); + } + + public static PressurizingRecipeBuilder builder(ResourceLocation id) { + return new PressurizingRecipeBuilder(id); + } + + public PressurizingRecipeBuilder secondaryFluidInput(int secondaryFluidInput) { + this.secondaryFluidInput = secondaryFluidInput; + return this; + } + + public PressurizingRecipeBuilder secondaryFluidOutput(int secondaryFluidOutput) { + this.secondaryFluidOutput = secondaryFluidOutput; + return this; + } + + @Override + protected void addExtraJson(JsonObject json) { + if (secondaryFluidInput != null) json.addProperty("secondaryFluidInput", secondaryFluidInput); + if (secondaryFluidOutput != null) json.addProperty("secondaryFluidOutput", secondaryFluidOutput); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/TurningRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/TurningRecipeBuilder.java new file mode 100644 index 0000000..81ca0f0 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/TurningRecipeBuilder.java @@ -0,0 +1,24 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.negodya1.vintageimprovements.VintageRecipes; + +public class TurningRecipeBuilder extends AbstractVintageRecipeBuilder { + + public TurningRecipeBuilder(String name) { + super(name, VintageRecipes.TURNING); + } + + public TurningRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.TURNING); + } + + public static TurningRecipeBuilder builder(String name) { + return new TurningRecipeBuilder(name); + } + + public static TurningRecipeBuilder builder(ResourceLocation id) { + return new TurningRecipeBuilder(id); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VibratingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VibratingRecipeBuilder.java new file mode 100644 index 0000000..a3401c7 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VibratingRecipeBuilder.java @@ -0,0 +1,24 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.resources.ResourceLocation; + +import com.negodya1.vintageimprovements.VintageRecipes; + +public class VibratingRecipeBuilder extends AbstractVintageRecipeBuilder { + + public VibratingRecipeBuilder(String name) { + super(name, VintageRecipes.VIBRATING); + } + + public VibratingRecipeBuilder(ResourceLocation id) { + super(id, VintageRecipes.VIBRATING); + } + + public static VibratingRecipeBuilder builder(String name) { + return new VibratingRecipeBuilder(name); + } + + public static VibratingRecipeBuilder builder(ResourceLocation id) { + return new VibratingRecipeBuilder(id); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VintageRecipeResult.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VintageRecipeResult.java new file mode 100644 index 0000000..de7ea62 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/vintage/VintageRecipeResult.java @@ -0,0 +1,38 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.vintage; + +import net.minecraft.world.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.registries.ForgeRegistries; + +import com.google.gson.JsonObject; + +import java.util.Objects; + +final class VintageRecipeResult { + + private final JsonObject json; + + VintageRecipeResult(JsonObject json) { + this.json = json; + } + + static VintageRecipeResult item(ItemStack stack, Double chance) { + JsonObject json = new JsonObject(); + json.addProperty("item", Objects.requireNonNull(ForgeRegistries.ITEMS.getKey(stack.getItem())).toString()); + if (stack.getCount() != 1) json.addProperty("count", stack.getCount()); + if (stack.hasTag()) json.addProperty("nbt", String.valueOf(stack.getTag())); + if (chance != null) json.addProperty("chance", chance); + return new VintageRecipeResult(json); + } + + static VintageRecipeResult fluid(FluidStack stack) { + JsonObject json = new JsonObject(); + json.addProperty("fluid", Objects.requireNonNull(ForgeRegistries.FLUIDS.getKey(stack.getFluid())).toString()); + json.addProperty("amount", stack.getAmount()); + return new VintageRecipeResult(json); + } + + JsonObject toJson() { + return json.deepCopy(); + } +} From 6311427cc3180b9ab9542523c9ceb302c550314d Mon Sep 17 00:00:00 2001 From: mmyddd Date: Wed, 3 Jun 2026 01:19:47 +0800 Subject: [PATCH 2/2] =?UTF-8?q?=E6=96=B0=E5=A2=9Emetallurguy=E3=80=81diese?= =?UTF-8?q?l=E9=85=8D=E6=96=B9=E7=B1=BB=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dependencies.gradle | 1 + .../create/CompactingRecipeBuilder.java | 63 +++++- .../builder/create/MixingRecipeBuilder.java | 31 ++- .../diesel/BasinFermentingRecipeBuilder.java | 200 ++++++++++++++++++ .../diesel/DistillationRecipeBuilder.java | 172 +++++++++++++++ .../metallurgy/AlloyingRecipeBuilder.java | 108 ++++++++++ .../metallurgy/BulkMeltingRecipeBuilder.java | 93 ++++++++ .../CastingInBasinRecipeBuilder.java | 78 +++++++ .../CastingInTableRecipeBuilder.java | 109 ++++++++++ .../metallurgy/MeltingRecipeBuilder.java | 94 ++++++++ .../MetallurgyRecipeBuilderSupport.java | 39 ++++ 11 files changed, 983 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/BasinFermentingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/DistillationRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/AlloyingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/BulkMeltingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInBasinRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInTableRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MeltingRecipeBuilder.java create mode 100644 src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MetallurgyRecipeBuilderSupport.java diff --git a/dependencies.gradle b/dependencies.gradle index 780d064..bd9acba 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -5,6 +5,7 @@ dependencies { modImplementation(ctnh.botarium) modImplementation(ctnh.createnewage) modImplementation(ctnh.creatediesel) + modImplementation(ctnh.createmetallurgy) modImplementation(ctnh.createvintage) modCompileOnly(variantOf(ctnh.curios) { classifier("api") }) diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/CompactingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/CompactingRecipeBuilder.java index f04b5aa..eb17fbd 100644 --- a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/CompactingRecipeBuilder.java +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/CompactingRecipeBuilder.java @@ -7,6 +7,8 @@ import net.minecraft.world.item.ItemStack; import net.minecraft.world.item.crafting.Ingredient; import net.minecraft.world.item.crafting.RecipeSerializer; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.registries.ForgeRegistries; import com.google.gson.JsonArray; @@ -24,17 +26,33 @@ public class CompactingRecipeBuilder { private final ResourceLocation id; + private final boolean exactId; private final List ingredients = new ArrayList<>(); + private final List fluidIngredients = new ArrayList<>(); private final List results = new ArrayList<>(); + private final List fluidResults = new ArrayList<>(); public CompactingRecipeBuilder(String name) { - this.id = CTPP.id(name); + this(CTPP.id(name), false); + } + + public CompactingRecipeBuilder(ResourceLocation id) { + this(id, true); + } + + private CompactingRecipeBuilder(ResourceLocation id, boolean exactId) { + this.id = id; + this.exactId = exactId; } public static CompactingRecipeBuilder builder(String name) { return new CompactingRecipeBuilder(name); } + public static CompactingRecipeBuilder builder(ResourceLocation id) { + return new CompactingRecipeBuilder(id); + } + public CompactingRecipeBuilder input(ItemStack stack) { return input(Ingredient.of(stack)); } @@ -52,17 +70,47 @@ public CompactingRecipeBuilder input(Ingredient ingredient) { return this; } + public CompactingRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.fluidIngredients.add(serializeFluidStack(new FluidStack(fluid, amount))); + return this; + } + + public CompactingRecipeBuilder inputFluid(FluidStack fluidStack) { + this.fluidIngredients.add(serializeFluidStack(fluidStack)); + return this; + } + + public CompactingRecipeBuilder inputFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return inputFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + public CompactingRecipeBuilder result(ItemStack stack) { this.results.add(stack.copy()); return this; } + public CompactingRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.fluidResults.add(serializeFluidStack(new FluidStack(fluid, amount))); + return this; + } + + public CompactingRecipeBuilder resultFluid(FluidStack fluidStack) { + this.fluidResults.add(serializeFluidStack(fluidStack)); + return this; + } + + public CompactingRecipeBuilder resultFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return resultFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + public CompactingRecipeBuilder output(ItemStack stack) { return result(stack); } public void toJson(JsonObject json) { - if (ingredients.isEmpty() || results.isEmpty()) { + if ((ingredients.isEmpty() && fluidIngredients.isEmpty()) || (results.isEmpty() && fluidResults.isEmpty())) { throw new IllegalStateException("Compacting recipe missing required fields"); } @@ -70,10 +118,12 @@ public void toJson(JsonObject json) { JsonArray ingredientsJson = new JsonArray(); ingredients.forEach(ing -> ingredientsJson.add(ing.toJson())); + fluidIngredients.forEach(ingredientsJson::add); json.add("ingredients", ingredientsJson); JsonArray resultsJson = new JsonArray(); results.forEach(stack -> resultsJson.add(serializeItemStack(stack))); + fluidResults.forEach(resultsJson::add); json.add("results", resultsJson); } @@ -88,7 +138,7 @@ public void serializeRecipeData(@Nonnull JsonObject pJson) { @Nonnull @Override public ResourceLocation getId() { - return ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "compacting/" + id.getPath()); + return exactId ? id : ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "compacting/" + id.getPath()); } @Nonnull @@ -123,4 +173,11 @@ private static JsonObject serializeItemStack(ItemStack stack) { if (stack.hasTag()) json.addProperty("nbt", String.valueOf(stack.getTag())); return json; } + + private static JsonObject serializeFluidStack(FluidStack stack) { + JsonObject json = new JsonObject(); + json.addProperty("fluid", Objects.requireNonNull(ForgeRegistries.FLUIDS.getKey(stack.getFluid())).toString()); + json.addProperty("amount", stack.getAmount()); + return json; + } } diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MixingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MixingRecipeBuilder.java index 9759f41..4069f1f 100644 --- a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MixingRecipeBuilder.java +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/MixingRecipeBuilder.java @@ -14,6 +14,7 @@ import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.mo_guang.ctpp.CTPP; +import com.simibubi.create.content.processing.recipe.HeatCondition; import org.jetbrains.annotations.Nullable; import java.util.ArrayList; @@ -26,21 +27,36 @@ public class MixingRecipeBuilder { private final ResourceLocation id; + private final boolean exactId; private final List ingredients = new ArrayList<>(); private final List results = new ArrayList<>(); private final List resultObjects = new ArrayList<>(); // optional fluid result support private JsonObject fluidResult = null; private final List fluidIngredients = new ArrayList<>(); + private HeatCondition heatRequirement = HeatCondition.NONE; public MixingRecipeBuilder(String name) { - this.id = CTPP.id(name); + this(CTPP.id(name), false); + } + + public MixingRecipeBuilder(ResourceLocation id) { + this(id, true); + } + + private MixingRecipeBuilder(ResourceLocation id, boolean exactId) { + this.id = id; + this.exactId = exactId; } public static MixingRecipeBuilder builder(String name) { return new MixingRecipeBuilder(name); } + public static MixingRecipeBuilder builder(ResourceLocation id) { + return new MixingRecipeBuilder(id); + } + public MixingRecipeBuilder input(ItemStack stack) { return input(Ingredient.of(stack)); } @@ -116,6 +132,15 @@ public MixingRecipeBuilder output(ItemStack stack) { return result(stack); } + public MixingRecipeBuilder heatRequirement(HeatCondition heatCondition) { + this.heatRequirement = heatCondition; + return this; + } + + public MixingRecipeBuilder heatRequirement(String heatRequirement) { + return heatRequirement(HeatCondition.deserialize(heatRequirement)); + } + public void toJson(JsonObject json) { if (ingredients.isEmpty() || (results.isEmpty() && fluidResult == null)) { throw new IllegalStateException("Mixing recipe missing required fields"); @@ -134,6 +159,7 @@ public void toJson(JsonObject json) { resultObjects.forEach(resultsJson::add); if (fluidResult != null) resultsJson.add(fluidResult); json.add("results", resultsJson); + if (heatRequirement != HeatCondition.NONE) json.addProperty("heatRequirement", heatRequirement.serialize()); } public FinishedRecipe build() { @@ -147,7 +173,8 @@ public void serializeRecipeData(@Nonnull JsonObject pJson) { @Nonnull @Override public ResourceLocation getId() { - return ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "mixing/" + id.getPath()); + return exactId ? id : + ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "mixing/" + id.getPath()); } @Nonnull diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/BasinFermentingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/BasinFermentingRecipeBuilder.java new file mode 100644 index 0000000..5c73cff --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/BasinFermentingRecipeBuilder.java @@ -0,0 +1,200 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.diesel; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.item.crafting.RecipeSerializer; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.registries.ForgeRegistries; + +import com.google.gson.JsonObject; +import com.jesz.createdieselgenerators.content.basin_lid.BasinFermentingRecipe; +import com.mo_guang.ctpp.CTPP; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeBuilder; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeSerializer; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Consumer; + +import javax.annotation.Nonnull; + +public class BasinFermentingRecipeBuilder { + + private final ResourceLocation id; + private final boolean exactId; + private final List>> steps = new ArrayList<>(); + private boolean hasIngredient; + private boolean hasResult; + + public BasinFermentingRecipeBuilder(String name) { + this.exactId = name.contains(":"); + this.id = exactId ? ResourceLocation.parse(name) : CTPP.id(name); + } + + public BasinFermentingRecipeBuilder(ResourceLocation id) { + this.exactId = true; + this.id = id; + } + + public static BasinFermentingRecipeBuilder builder(String name) { + return new BasinFermentingRecipeBuilder(name); + } + + public static BasinFermentingRecipeBuilder builder(ResourceLocation id) { + return new BasinFermentingRecipeBuilder(id); + } + + public BasinFermentingRecipeBuilder input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public BasinFermentingRecipeBuilder input(ItemLike item) { + return input(Ingredient.of(item)); + } + + public BasinFermentingRecipeBuilder input(TagKey tag) { + return input(Ingredient.of(tag)); + } + + public BasinFermentingRecipeBuilder input(Ingredient ingredient) { + this.steps.add(builder -> builder.require(ingredient)); + this.hasIngredient = true; + return this; + } + + public BasinFermentingRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.steps.add(builder -> builder.require(fluid, amount)); + this.hasIngredient = true; + return this; + } + + public BasinFermentingRecipeBuilder inputFluid(FluidStack fluidStack) { + return inputFluid(fluidStack.getFluid(), fluidStack.getAmount()); + } + + public BasinFermentingRecipeBuilder inputFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return inputFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + + public BasinFermentingRecipeBuilder result(ItemStack stack) { + this.steps.add(builder -> builder.output(stack)); + this.hasResult = true; + return this; + } + + public BasinFermentingRecipeBuilder result(ItemStack stack, double chance) { + this.steps.add(builder -> builder.output((float) chance, stack)); + this.hasResult = true; + return this; + } + + public BasinFermentingRecipeBuilder result(String itemId, int count, double chance) { + this.steps.add(builder -> builder.output((float) chance, ResourceLocation.parse(itemId), count)); + this.hasResult = true; + return this; + } + + public BasinFermentingRecipeBuilder output(ItemStack stack) { + return result(stack); + } + + public BasinFermentingRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.steps.add(builder -> builder.output(fluid, amount)); + this.hasResult = true; + return this; + } + + public BasinFermentingRecipeBuilder resultFluid(FluidStack fluidStack) { + this.steps.add(builder -> builder.output(fluidStack)); + this.hasResult = true; + return this; + } + + public BasinFermentingRecipeBuilder resultFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return resultFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + + public BasinFermentingRecipeBuilder duration(int ticks) { + this.steps.add(builder -> builder.duration(ticks)); + return this; + } + + public BasinFermentingRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void toJson(JsonObject json) { + if (!hasIngredient || !hasResult) { + throw new IllegalStateException("Basin fermenting recipe missing required fields"); + } + serializer().write(json, recipe()); + } + + public FinishedRecipe build() { + return new FinishedRecipe() { + + @Override + public void serializeRecipeData(@Nonnull JsonObject pJson) { + BasinFermentingRecipeBuilder.this.toJson(pJson); + } + + @Nonnull + @Override + public ResourceLocation getId() { + return recipeId(); + } + + @Nonnull + @Override + public RecipeSerializer getType() { + return recipe().getSerializer(); + } + + @Nullable + @Override + public JsonObject serializeAdvancement() { + return null; + } + + @Nullable + @Override + public ResourceLocation getAdvancementId() { + return null; + } + }; + } + + public void save(Consumer consumer) { + consumer.accept(build()); + } + + @SuppressWarnings("unchecked") + private ProcessingRecipeSerializer serializer() { + RecipeSerializer serializer = recipe().getSerializer(); + if (!(serializer instanceof ProcessingRecipeSerializer processingSerializer)) { + throw new IllegalStateException("Basin fermenting serializer not found"); + } + return (ProcessingRecipeSerializer) processingSerializer; + } + + private BasinFermentingRecipe recipe() { + ProcessingRecipeBuilder builder = + new ProcessingRecipeBuilder<>(BasinFermentingRecipe::new, recipeId()); + steps.forEach(step -> step.accept(builder)); + return builder.build(); + } + + private ResourceLocation recipeId() { + return exactId ? id : ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "basin_fermenting/" + id.getPath()); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/DistillationRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/DistillationRecipeBuilder.java new file mode 100644 index 0000000..e6df6f6 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/diesel/DistillationRecipeBuilder.java @@ -0,0 +1,172 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.diesel; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.crafting.RecipeSerializer; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.registries.ForgeRegistries; + +import com.google.gson.JsonObject; +import com.jesz.createdieselgenerators.content.distillation.DistillationRecipe; +import com.mo_guang.ctpp.CTPP; +import com.simibubi.create.content.processing.recipe.HeatCondition; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeBuilder; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeSerializer; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Consumer; + +import javax.annotation.Nonnull; + +public class DistillationRecipeBuilder { + + private final ResourceLocation id; + private final boolean exactId; + private final List>> steps = new ArrayList<>(); + private boolean hasIngredient; + private boolean hasResult; + + public DistillationRecipeBuilder(String name) { + this.exactId = name.contains(":"); + this.id = exactId ? ResourceLocation.parse(name) : CTPP.id(name); + } + + public DistillationRecipeBuilder(ResourceLocation id) { + this.exactId = true; + this.id = id; + } + + public static DistillationRecipeBuilder builder(String name) { + return new DistillationRecipeBuilder(name); + } + + public static DistillationRecipeBuilder builder(ResourceLocation id) { + return new DistillationRecipeBuilder(id); + } + + public DistillationRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.steps.add(builder -> builder.require(fluid, amount)); + this.hasIngredient = true; + return this; + } + + public DistillationRecipeBuilder inputFluid(FluidStack fluidStack) { + return inputFluid(fluidStack.getFluid(), fluidStack.getAmount()); + } + + public DistillationRecipeBuilder inputFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return inputFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + + public DistillationRecipeBuilder inputFluid(TagKey tag, int amount) { + this.steps.add(builder -> builder.require(tag, amount)); + this.hasIngredient = true; + return this; + } + + public DistillationRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.steps.add(builder -> builder.output(fluid, amount)); + this.hasResult = true; + return this; + } + + public DistillationRecipeBuilder resultFluid(FluidStack fluidStack) { + this.steps.add(builder -> builder.output(fluidStack)); + this.hasResult = true; + return this; + } + + public DistillationRecipeBuilder resultFluid(String fluidId, int amount) { + ResourceLocation fluid = ResourceLocation.parse(fluidId); + return resultFluid(Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(fluid), fluidId), amount); + } + + public DistillationRecipeBuilder heatRequirement(HeatCondition heatCondition) { + this.steps.add(builder -> builder.requiresHeat(heatCondition)); + return this; + } + + public DistillationRecipeBuilder heatRequirement(String heatRequirement) { + return heatRequirement(HeatCondition.deserialize(heatRequirement)); + } + + public DistillationRecipeBuilder duration(int ticks) { + this.steps.add(builder -> builder.duration(ticks)); + return this; + } + + public DistillationRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void toJson(JsonObject json) { + if (!hasIngredient || !hasResult) { + throw new IllegalStateException("Distillation recipe missing required fields"); + } + serializer().write(json, recipe()); + } + + public FinishedRecipe build() { + return new FinishedRecipe() { + + @Override + public void serializeRecipeData(@Nonnull JsonObject pJson) { + DistillationRecipeBuilder.this.toJson(pJson); + } + + @Nonnull + @Override + public ResourceLocation getId() { + return recipeId(); + } + + @Nonnull + @Override + public RecipeSerializer getType() { + return recipe().getSerializer(); + } + + @Nullable + @Override + public JsonObject serializeAdvancement() { + return null; + } + + @Nullable + @Override + public ResourceLocation getAdvancementId() { + return null; + } + }; + } + + public void save(Consumer consumer) { + consumer.accept(build()); + } + + @SuppressWarnings("unchecked") + private ProcessingRecipeSerializer serializer() { + RecipeSerializer serializer = recipe().getSerializer(); + if (!(serializer instanceof ProcessingRecipeSerializer processingSerializer)) { + throw new IllegalStateException("Distillation serializer not found"); + } + return (ProcessingRecipeSerializer) processingSerializer; + } + + private DistillationRecipe recipe() { + ProcessingRecipeBuilder builder = + new ProcessingRecipeBuilder<>(DistillationRecipe::new, recipeId()); + steps.forEach(step -> step.accept(builder)); + return builder.build(); + } + + private ResourceLocation recipeId() { + return exactId ? id : ResourceLocation.fromNamespaceAndPath(id.getNamespace(), "distillation/" + id.getPath()); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/AlloyingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/AlloyingRecipeBuilder.java new file mode 100644 index 0000000..024f144 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/AlloyingRecipeBuilder.java @@ -0,0 +1,108 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import com.simibubi.create.content.processing.recipe.HeatCondition; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeBuilder; + +import fr.lucreeper74.createmetallurgy.content.blocks.foundry_mixer.AlloyingRecipe; + +import java.util.function.Consumer; + +public class AlloyingRecipeBuilder { + + private final ProcessingRecipeBuilder builder; + + private AlloyingRecipeBuilder(ResourceLocation id) { + this.builder = new ProcessingRecipeBuilder<>(AlloyingRecipe::new, id); + } + + public static AlloyingRecipeBuilder builder(String name) { + return new AlloyingRecipeBuilder(MetallurgyRecipeBuilderSupport.id(name)); + } + + public static AlloyingRecipeBuilder builder(ResourceLocation id) { + return new AlloyingRecipeBuilder(id); + } + + public AlloyingRecipeBuilder input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public AlloyingRecipeBuilder input(ItemLike item) { + this.builder.require(item); + return this; + } + + public AlloyingRecipeBuilder input(String itemId) { + return input(MetallurgyRecipeBuilderSupport.item(itemId)); + } + + public AlloyingRecipeBuilder input(TagKey tag) { + this.builder.require(tag); + return this; + } + + public AlloyingRecipeBuilder input(Ingredient ingredient) { + this.builder.require(ingredient); + return this; + } + + public AlloyingRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.builder.require(fluid, amount); + return this; + } + + public AlloyingRecipeBuilder inputFluid(FluidStack fluidStack) { + this.builder.require(fluidStack.getFluid(), fluidStack.getAmount()); + return this; + } + + public AlloyingRecipeBuilder inputFluid(String fluidId, int amount) { + return inputFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public AlloyingRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.builder.output(fluid, amount); + return this; + } + + public AlloyingRecipeBuilder resultFluid(FluidStack fluidStack) { + this.builder.output(fluidStack); + return this; + } + + public AlloyingRecipeBuilder resultFluid(String fluidId, int amount) { + return resultFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public AlloyingRecipeBuilder heatRequirement(HeatCondition heatCondition) { + this.builder.requiresHeat(heatCondition); + return this; + } + + public AlloyingRecipeBuilder heatRequirement(String heatRequirement) { + return heatRequirement(HeatCondition.deserialize(heatRequirement)); + } + + public AlloyingRecipeBuilder duration(int ticks) { + this.builder.duration(ticks); + return this; + } + + public AlloyingRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void save(Consumer consumer) { + this.builder.build(consumer); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/BulkMeltingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/BulkMeltingRecipeBuilder.java new file mode 100644 index 0000000..173228f --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/BulkMeltingRecipeBuilder.java @@ -0,0 +1,93 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import fr.lucreeper74.createmetallurgy.content.blocks.industrial_crucible.foundry.recipes.BulkMeltingRecipe; +import fr.lucreeper74.createmetallurgy.content.blocks.industrial_crucible.foundry.recipes.FoundryRecipeBuilder; + +import java.util.function.Consumer; + +public class BulkMeltingRecipeBuilder { + + private final FoundryRecipeBuilder builder; + + private BulkMeltingRecipeBuilder(ResourceLocation id) { + this.builder = new FoundryRecipeBuilder<>(BulkMeltingRecipe::new, id); + } + + public static BulkMeltingRecipeBuilder builder(String name) { + return new BulkMeltingRecipeBuilder(MetallurgyRecipeBuilderSupport.id(name)); + } + + public static BulkMeltingRecipeBuilder builder(ResourceLocation id) { + return new BulkMeltingRecipeBuilder(id); + } + + public BulkMeltingRecipeBuilder input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public BulkMeltingRecipeBuilder input(ItemLike item) { + this.builder.require(item); + return this; + } + + public BulkMeltingRecipeBuilder input(String itemId) { + return input(MetallurgyRecipeBuilderSupport.item(itemId)); + } + + public BulkMeltingRecipeBuilder input(TagKey tag) { + this.builder.require(tag); + return this; + } + + public BulkMeltingRecipeBuilder input(Ingredient ingredient) { + this.builder.require(ingredient); + return this; + } + + public BulkMeltingRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.builder.output(fluid, amount); + return this; + } + + public BulkMeltingRecipeBuilder resultFluid(FluidStack fluidStack) { + this.builder.output(fluidStack); + return this; + } + + public BulkMeltingRecipeBuilder resultFluid(String fluidId, int amount) { + return resultFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public BulkMeltingRecipeBuilder minHeat(int heat) { + this.builder.requiresMinHeat(heat); + return this; + } + + public BulkMeltingRecipeBuilder maxHeat(int heat) { + this.builder.requiresMaxHeat(heat); + return this; + } + + public BulkMeltingRecipeBuilder duration(int ticks) { + this.builder.duration(ticks); + return this; + } + + public BulkMeltingRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void save(Consumer consumer) { + this.builder.build(consumer); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInBasinRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInBasinRecipeBuilder.java new file mode 100644 index 0000000..371bc46 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInBasinRecipeBuilder.java @@ -0,0 +1,78 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import fr.lucreeper74.createmetallurgy.content.blocks.casting.recipe.CastingRecipeBuilder; +import fr.lucreeper74.createmetallurgy.registries.CMRecipeTypes; + +import java.util.function.Consumer; + +public class CastingInBasinRecipeBuilder { + + private final CastingRecipeBuilder builder; + + private CastingInBasinRecipeBuilder(ResourceLocation id) { + this.builder = new CastingRecipeBuilder(CMRecipeTypes.CASTING_IN_BASIN, id); + } + + public static CastingInBasinRecipeBuilder builder(String name) { + return new CastingInBasinRecipeBuilder(MetallurgyRecipeBuilderSupport.id(name)); + } + + public static CastingInBasinRecipeBuilder builder(ResourceLocation id) { + return new CastingInBasinRecipeBuilder(id); + } + + public CastingInBasinRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.builder.require(fluid, amount); + return this; + } + + public CastingInBasinRecipeBuilder inputFluid(FluidStack fluidStack) { + return inputFluid(fluidStack.getFluid(), fluidStack.getAmount()); + } + + public CastingInBasinRecipeBuilder inputFluid(String fluidId, int amount) { + return inputFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public CastingInBasinRecipeBuilder result(ItemStack stack) { + this.builder.output(stack); + return this; + } + + public CastingInBasinRecipeBuilder result(ItemLike item) { + this.builder.output(item); + return this; + } + + public CastingInBasinRecipeBuilder result(String itemId) { + return result(MetallurgyRecipeBuilderSupport.itemStack(itemId, 1)); + } + + public CastingInBasinRecipeBuilder result(String itemId, int count) { + return result(MetallurgyRecipeBuilderSupport.itemStack(itemId, count)); + } + + public CastingInBasinRecipeBuilder output(ItemStack stack) { + return result(stack); + } + + public CastingInBasinRecipeBuilder duration(int ticks) { + this.builder.duration(ticks); + return this; + } + + public CastingInBasinRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void save(Consumer consumer) { + this.builder.build(consumer); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInTableRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInTableRecipeBuilder.java new file mode 100644 index 0000000..86f90c2 --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/CastingInTableRecipeBuilder.java @@ -0,0 +1,109 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import fr.lucreeper74.createmetallurgy.content.blocks.casting.recipe.CastingRecipeBuilder; +import fr.lucreeper74.createmetallurgy.registries.CMRecipeTypes; + +import java.util.function.Consumer; + +public class CastingInTableRecipeBuilder { + + private final CastingRecipeBuilder builder; + + private CastingInTableRecipeBuilder(ResourceLocation id) { + this.builder = new CastingRecipeBuilder(CMRecipeTypes.CASTING_IN_TABLE, id); + } + + public static CastingInTableRecipeBuilder builder(String name) { + return new CastingInTableRecipeBuilder(MetallurgyRecipeBuilderSupport.id(name)); + } + + public static CastingInTableRecipeBuilder builder(ResourceLocation id) { + return new CastingInTableRecipeBuilder(id); + } + + public CastingInTableRecipeBuilder input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public CastingInTableRecipeBuilder input(ItemLike item) { + this.builder.require(item); + return this; + } + + public CastingInTableRecipeBuilder input(String itemId) { + return input(MetallurgyRecipeBuilderSupport.item(itemId)); + } + + public CastingInTableRecipeBuilder input(TagKey tag) { + this.builder.require(tag); + return this; + } + + public CastingInTableRecipeBuilder input(Ingredient ingredient) { + this.builder.require(ingredient); + return this; + } + + public CastingInTableRecipeBuilder inputFluid(Fluid fluid, int amount) { + this.builder.require(fluid, amount); + return this; + } + + public CastingInTableRecipeBuilder inputFluid(FluidStack fluidStack) { + return inputFluid(fluidStack.getFluid(), fluidStack.getAmount()); + } + + public CastingInTableRecipeBuilder inputFluid(String fluidId, int amount) { + return inputFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public CastingInTableRecipeBuilder result(ItemStack stack) { + this.builder.output(stack); + return this; + } + + public CastingInTableRecipeBuilder result(ItemLike item) { + this.builder.output(item); + return this; + } + + public CastingInTableRecipeBuilder result(String itemId) { + return result(MetallurgyRecipeBuilderSupport.itemStack(itemId, 1)); + } + + public CastingInTableRecipeBuilder result(String itemId, int count) { + return result(MetallurgyRecipeBuilderSupport.itemStack(itemId, count)); + } + + public CastingInTableRecipeBuilder output(ItemStack stack) { + return result(stack); + } + + public CastingInTableRecipeBuilder duration(int ticks) { + this.builder.duration(ticks); + return this; + } + + public CastingInTableRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public CastingInTableRecipeBuilder moldConsumed(boolean consumed) { + this.builder.withMoldConsumed(consumed); + return this; + } + + public void save(Consumer consumer) { + this.builder.build(consumer); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MeltingRecipeBuilder.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MeltingRecipeBuilder.java new file mode 100644 index 0000000..59ebeef --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MeltingRecipeBuilder.java @@ -0,0 +1,94 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.data.recipes.FinishedRecipe; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.level.ItemLike; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import com.simibubi.create.content.processing.recipe.HeatCondition; +import com.simibubi.create.content.processing.recipe.ProcessingRecipeBuilder; + +import fr.lucreeper74.createmetallurgy.content.blocks.foundry_lid.MeltingRecipe; + +import java.util.function.Consumer; + +public class MeltingRecipeBuilder { + + private final ProcessingRecipeBuilder builder; + + private MeltingRecipeBuilder(ResourceLocation id) { + this.builder = new ProcessingRecipeBuilder<>(MeltingRecipe::new, id); + } + + public static MeltingRecipeBuilder builder(String name) { + return new MeltingRecipeBuilder(MetallurgyRecipeBuilderSupport.id(name)); + } + + public static MeltingRecipeBuilder builder(ResourceLocation id) { + return new MeltingRecipeBuilder(id); + } + + public MeltingRecipeBuilder input(ItemStack stack) { + return input(Ingredient.of(stack)); + } + + public MeltingRecipeBuilder input(ItemLike item) { + this.builder.require(item); + return this; + } + + public MeltingRecipeBuilder input(String itemId) { + return input(MetallurgyRecipeBuilderSupport.item(itemId)); + } + + public MeltingRecipeBuilder input(TagKey tag) { + this.builder.require(tag); + return this; + } + + public MeltingRecipeBuilder input(Ingredient ingredient) { + this.builder.require(ingredient); + return this; + } + + public MeltingRecipeBuilder resultFluid(Fluid fluid, int amount) { + this.builder.output(fluid, amount); + return this; + } + + public MeltingRecipeBuilder resultFluid(FluidStack fluidStack) { + this.builder.output(fluidStack); + return this; + } + + public MeltingRecipeBuilder resultFluid(String fluidId, int amount) { + return resultFluid(MetallurgyRecipeBuilderSupport.fluid(fluidId), amount); + } + + public MeltingRecipeBuilder heatRequirement(HeatCondition heatCondition) { + this.builder.requiresHeat(heatCondition); + return this; + } + + public MeltingRecipeBuilder heatRequirement(String heatRequirement) { + return heatRequirement(HeatCondition.deserialize(heatRequirement)); + } + + public MeltingRecipeBuilder duration(int ticks) { + this.builder.duration(ticks); + return this; + } + + public MeltingRecipeBuilder processingTime(int ticks) { + return duration(ticks); + } + + public void save(Consumer consumer) { + this.builder.build(consumer); + } +} diff --git a/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MetallurgyRecipeBuilderSupport.java b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MetallurgyRecipeBuilderSupport.java new file mode 100644 index 0000000..e1981cf --- /dev/null +++ b/src/main/java/com/mo_guang/ctpp/common/recipe/builder/create/metallurgy/MetallurgyRecipeBuilderSupport.java @@ -0,0 +1,39 @@ +package com.mo_guang.ctpp.common.recipe.builder.create.metallurgy; + +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.level.material.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.registries.ForgeRegistries; + +import com.mo_guang.ctpp.CTPP; + +import java.util.Objects; + +final class MetallurgyRecipeBuilderSupport { + + private MetallurgyRecipeBuilderSupport() {} + + static ResourceLocation id(String name) { + return name.contains(":") ? ResourceLocation.parse(name) : CTPP.id(name); + } + + static ItemStack itemStack(String itemId, int count) { + return new ItemStack(item(itemId), count); + } + + static Item item(String itemId) { + ResourceLocation id = ResourceLocation.parse(itemId); + return Objects.requireNonNull(ForgeRegistries.ITEMS.getValue(id), itemId); + } + + static Fluid fluid(String fluidId) { + ResourceLocation id = ResourceLocation.parse(fluidId); + return Objects.requireNonNull(ForgeRegistries.FLUIDS.getValue(id), fluidId); + } + + static FluidStack fluidStack(String fluidId, int amount) { + return new FluidStack(fluid(fluidId), amount); + } +}