Recipe requirements registry & codecs

gradle.properties

@@ -14,7 +14,7 @@ parchment_version = 2024.11.17
 mod_id=mechanical_lemon_lib
 mod_name=MechanicalLemonLib
 mod_license=LGPL3
-mod_version=0.1.12
+mod_version=0.1.32
 mod_group_id=com.oierbravo
 mod_author=oierbravo
 mod_description=Mod Utility Library

src/main/java/com/oierbravo/mechanical_lemon_lib/MechanicalLemonLib.java

@@ -2,12 +2,13 @@ package com.oierbravo.mechanical_lemon_lib;
 
 import com.mojang.logging.LogUtils;
 import com.oierbravo.mechanical_lemon_lib.register.LemonCreativeModeTabs;
+import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRecipeRequirementTypes;
 import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRegistries;
 import net.minecraft.resources.ResourceLocation;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.fml.ModContainer;
 import net.neoforged.fml.common.Mod;
-import net.neoforged.neoforge.registries.NewRegistryEvent;
+import net.neoforged.neoforge.registries.*;
 import org.slf4j.Logger;
 
 @Mod(MechanicalLemonLib.MODID)
@@ -19,12 +20,19 @@ public class MechanicalLemonLib {
     public MechanicalLemonLib(IEventBus modEventBus, ModContainer modContainer) {
 
         LemonCreativeModeTabs.register(modEventBus);
-        MechanicalLemonRegistries.init();
-        //modEventBus.addListener(MechanicalLemonRegistries::init);
 
+        modEventBus.addListener(this::newRegistries);
+        MechanicalLemonRecipeRequirementTypes.init(modEventBus);
+    }
+
+    private void newRegistries(NewRegistryEvent event) {
+        MechanicalLemonRegistries.register(event);
     }
 
     public static ResourceLocation asResource(String path) {
         return ResourceLocation.fromNamespaceAndPath(MODID, path);
     }
+    public static Logger getLogger(){
+        return LOGGER;
+    }
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/blockEntity/behaviour/CycleBehavior.java

@@ -10,8 +10,8 @@ import net.minecraft.world.level.Level;
 
 public class CycleBehavior extends BlockEntityBehaviour {
 
-	private final int CYCLE;
+	private final int cycleTime;
-	private boolean ACTUATE_HALFCYCLE;
+	private boolean actuateHalfcycle;
 	public static final BehaviourType<CycleBehavior> TYPE = new BehaviourType<>();
 	public CycleBehaviourSpecifics specifics;
 	private int prevRunningTicks;
@@ -19,22 +19,26 @@ public class CycleBehavior extends BlockEntityBehaviour {
 	private boolean running;
 	private boolean finished;
 	private int cycleDivider;
-
+	private int numCycles;
+	private int currentCycle;
 
 	public interface CycleBehaviourSpecifics {
 
 		public void onCycleCompleted();
+		public void onOperationCompletd();
 		public float getKineticSpeed();
 		public boolean tryProcess(boolean simulate);
 		public void playSound();
 	}
 
-	public <T extends SmartBlockEntity & CycleBehaviourSpecifics> CycleBehavior(T te, int pCycle, boolean pActuateHalfCycle) {
+	public <T extends SmartBlockEntity & CycleBehaviourSpecifics> CycleBehavior(T te, int pCycle, boolean pActuateHalfCycle, int pNumCycles) {
 		super(te);
 		this.specifics = te;
-		CYCLE = pCycle;
+		cycleTime = pCycle;
-		ACTUATE_HALFCYCLE = pActuateHalfCycle;
+		actuateHalfcycle = pActuateHalfCycle;
-		cycleDivider = (ACTUATE_HALFCYCLE) ? 2 : 1;
+		numCycles = pNumCycles;
+		cycleDivider = (actuateHalfcycle) ? 2 : 1;
+		currentCycle = 0;
 	}
 
 	@Override
@@ -42,6 +46,7 @@ public class CycleBehavior extends BlockEntityBehaviour {
 		running = compound.getBoolean("Running");
 		finished = compound.getBoolean("Finished");
 		prevRunningTicks = runningTicks = compound.getInt("Ticks");
+		currentCycle = compound.getInt("CurrentCycle");
 		super.read(compound,registries, clientPacket);
 	}
 
@@ -50,6 +55,7 @@ public class CycleBehavior extends BlockEntityBehaviour {
 		compound.putBoolean("Running", running);
 		compound.putBoolean("Finished", finished);
 		compound.putInt("Ticks", runningTicks);
+		compound.putInt("CurrentCycle", currentCycle);
 		super.write(compound, registries, clientPacket);
 	}
 
@@ -57,6 +63,7 @@ public class CycleBehavior extends BlockEntityBehaviour {
 		running = true;
 		prevRunningTicks = 0;
 		runningTicks = 0;
+		currentCycle = 0;
 		blockEntity.sendData();
 	}
 
@@ -83,33 +90,37 @@ public class CycleBehavior extends BlockEntityBehaviour {
 		}
 
 
-		if (level.isClientSide && runningTicks == -CYCLE / cycleDivider) {
+		if (level.isClientSide && runningTicks == -cycleTime / cycleDivider) {
-			prevRunningTicks = CYCLE / cycleDivider;
+			prevRunningTicks = cycleTime / cycleDivider;
 			return;
 		}
 
-		if (runningTicks == CYCLE / 2 && specifics.getKineticSpeed() != 0) {
+		if (runningTicks == cycleTime / cycleDivider && specifics.getKineticSpeed() != 0) {
 			apply();
 			specifics.playSound();
 			if (!level.isClientSide)
 				blockEntity.sendData();
 		}
 
-		if (!level.isClientSide && runningTicks > CYCLE / cycleDivider) {
+		if (!level.isClientSide && runningTicks > cycleTime / cycleDivider) {
+			specifics.onCycleCompleted();
+			currentCycle++;
+			if(currentCycle == numCycles){
 				finished = true;
 				running = false;
+				specifics.onOperationCompletd();
+			}
 			blockEntity.sendData();
-			specifics.onCycleCompleted();
 			return;
 		}
 
 		prevRunningTicks = runningTicks;
 		runningTicks += getRunningTickSpeed();
-		if (prevRunningTicks < CYCLE / 2 && runningTicks >= CYCLE / cycleDivider) {
+		if (prevRunningTicks < cycleTime / 2 && runningTicks >= cycleTime / cycleDivider) {
-			runningTicks = CYCLE / 2;
+			runningTicks = cycleTime / 2;
 			// Pause the ticks until a packet is received
 			if (level.isClientSide && !blockEntity.isVirtual())
-				runningTicks = -(CYCLE / 2);
+				runningTicks = -(cycleTime / 2);
 		}
 	}
 
@@ -118,7 +129,7 @@ public class CycleBehavior extends BlockEntityBehaviour {
 			return 0;
 		int runningTicks = Math.abs(this.runningTicks);
 		float ticks = Mth.lerp(partialTicks, prevRunningTicks, runningTicks);
-		return ticks/ CYCLE * 100;
+		return ticks/ cycleTime * 100;
 	}
 
 
@@ -142,6 +153,6 @@ public class CycleBehavior extends BlockEntityBehaviour {
 		return running;
 	}
 	public int getProgressPercent() {
-		return Mth.clamp(runningTicks * 100 / (CYCLE/cycleDivider), 0,100);
+		return Mth.clamp(runningTicks * 100 / (cycleTime /cycleDivider), 0,100);
 	}
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/blockEntity/behaviour/RecipeRequirementsBehaviour.java

@@ -1,7 +1,7 @@
 package com.oierbravo.mechanical_lemon_lib.foundation.blockEntity.behaviour;
 
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirement;
 import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeWithRequirements;
-import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirement;
 import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirementType;
 import com.oierbravo.mechanical_lemon_lib.utility.LibLang;
 import com.simibubi.create.foundation.blockEntity.SmartBlockEntity;
@@ -76,19 +76,23 @@ public class RecipeRequirementsBehaviour<R extends IRecipeWithRequirements> exte
     }
     private boolean checkRequirements(R pRecipe, Level pLevel, RecipeRequirementsSpecifics<R> pSpecifics){
         boolean result = true;
-        for (Map.Entry<RecipeRequirementType, RecipeRequirement<?>> entry : pRecipe.getRecipeRequirements().entrySet()) {
+        for( IRecipeRequirement requirement : pRecipe.getRecipeRequirements()){
+            if(!checkRequirement(requirement, pLevel, (BlockEntity) pSpecifics)){
+                missingRequirements.add(requirement.getType().toString());
+                result = false;
+            }
+        }
+        /*for (Map.Entry<RecipeRequirementType<?>, IRecipeRequirement> entry : pRecipe.getRecipeRequirements().entrySet()) {
             if(!checkRequirement(entry.getValue(), pLevel, (BlockEntity) pSpecifics)){
-                missingRequirements.add(entry.getKey().getId());
+                missingRequirements.add(entry.toString());
                 result = false;
             }
 
-        }
+        }*/
         return result;
     }
-    private boolean checkRequirement(RecipeRequirement value, Level pLevel, BlockEntity pSpecifics){
+    private boolean checkRequirement(IRecipeRequirement value, Level pLevel, BlockEntity pSpecifics){
-        if(value.test(pLevel, pSpecifics))
+        return value.test(pLevel, pSpecifics);
-            return true;
-        return false;
     }
     public boolean addToGoggleTooltip(List<Component> tooltip, boolean isPlayerSneaking, boolean added) {
         if(missingRequirements.isEmpty())

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/BaseRecipe.java

@@ -7,6 +7,7 @@ import net.minecraft.world.item.crafting.RecipeInput;
 import net.neoforged.neoforge.common.conditions.ICondition;
 
 import javax.annotation.ParametersAreNonnullByDefault;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
@@ -16,18 +17,16 @@ public abstract class BaseRecipe<T extends RecipeInput, P extends BaseRecipePara
 
     protected ResourceLocation id;
 
-    protected HashMap<RecipeRequirementType<?>, RecipeRequirement<?>> recipeRequirements = new HashMap<>();
+    protected ArrayList<IRecipeRequirement> recipeRequirements;
 
-    protected List<ICondition> conditions;
+    protected ArrayList<ICondition> conditions;
 
-    abstract public List<RecipeRequirementType<?>> getEnabledRequirements();
+    abstract public List<String> getEnabledRequirements();
 
     public BaseRecipe(P params){
         this.id = params.id;
-
+        recipeRequirements = params.recipeRequirements;
-        params.recipeRequirements.forEach(
+        //recipeRequirements.putAll(params.recipeRequirements);
-                recipeRequirement -> recipeRequirements.put(recipeRequirement.getType(), recipeRequirement)
-        );
         this.conditions = params.conditions;
     }
 

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/BaseRecipeBuilder.java

@@ -2,7 +2,11 @@ package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
 
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
+import net.minecraft.advancements.Advancement;
+import net.minecraft.advancements.AdvancementRequirements;
+import net.minecraft.advancements.AdvancementRewards;
 import net.minecraft.advancements.Criterion;
+import net.minecraft.advancements.critereon.RecipeUnlockedTrigger;
 import net.minecraft.data.recipes.RecipeBuilder;
 import net.minecraft.data.recipes.RecipeOutput;
 import net.minecraft.resources.ResourceLocation;
@@ -20,10 +24,11 @@ import java.util.Map;
 import java.util.function.Consumer;
 
 public abstract class BaseRecipeBuilder<R extends BaseRecipe<?,P>, P extends BaseRecipeParams> {
+    protected final Map<String, Criterion<?>> criteria = new LinkedHashMap<>();
 
     protected P params;
-    protected List<RecipeRequirement> recipeRequirements;
+    protected ArrayList<IRecipeRequirement> recipeRequirements;
-    protected List<ICondition> recipeConditions;
+    protected ArrayList<ICondition> recipeConditions;
 
     public BaseRecipeBuilder( ResourceLocation id){
         recipeRequirements = new ArrayList<>();
@@ -36,13 +41,15 @@ public abstract class BaseRecipeBuilder<R extends BaseRecipe<?,P>, P extends Bas
         consumer.accept(new DataGenResult<>(build(), recipeConditions));
     }
 
-    public BaseRecipeBuilder<R,P> withRequirement(RecipeRequirement requirement){
+    public <BRP extends BaseRecipeBuilder<?,?>> BRP withRequirement(IRecipeRequirement requirement){
+    //public <BRP extends BaseRecipeSerializer<?,?> BaseRecipeBuilder<R,P> withRequirement(IRecipeRequirement requirement){
         params.recipeRequirements.add(requirement);
-        return this;
+        return (BRP) this;
     }
-    public BaseRecipeBuilder<R,P> withRequirements(List<RecipeRequirement> recipeRequirements) {
+    public <BRP extends BaseRecipeBuilder<?,?>> BRP withRequirements(List<IRecipeRequirement> pRecipeRequirements) {
-        recipeRequirements.forEach(this::withRequirement);
+    //public BaseRecipeBuilder<R,P> withRequirements(List<IRecipeRequirement> pRecipeRequirements) {
-        return this;
+        params.recipeRequirements.addAll(pRecipeRequirements);
+        return (BRP) this;
     }
 
     public BaseRecipeBuilder<R,P> whenModLoaded(String modid) {
@@ -57,6 +64,19 @@ public abstract class BaseRecipeBuilder<R extends BaseRecipe<?,P>, P extends Bas
         recipeConditions.add(condition);
         return  this;
     }
+    public void save(RecipeOutput recipeOutput, ResourceLocation resourceLocation) {
+        Advancement.Builder advancement = recipeOutput.advancement()
+                .addCriterion("has_the_recipe", RecipeUnlockedTrigger.unlocked(resourceLocation))
+                .rewards(AdvancementRewards.Builder.recipe(resourceLocation))
+                .requirements(AdvancementRequirements.Strategy.OR);
+        this.criteria.forEach(advancement::addCriterion);
+
+        recipeOutput.accept(resourceLocation, build(), advancement.build(params.id.withPrefix("recipes/")));
+    }
+
+    public void save(RecipeOutput recipeOutput) {
+        save(recipeOutput, params.id);
+    }
 
     public static class DataGenResult<S extends BaseRecipe<?,?>> implements RecipeBuilder {
 

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/BaseRecipeParams.java

@@ -4,16 +4,18 @@ import net.minecraft.resources.ResourceLocation;
 import net.neoforged.neoforge.common.conditions.ICondition;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public abstract class BaseRecipeParams implements IBaseRecipeParams {
     public ResourceLocation id;
-    public ArrayList<RecipeRequirement<?>> recipeRequirements;
+    public ArrayList<IRecipeRequirement> recipeRequirements;
-    protected List<ICondition> conditions;
+    protected ArrayList<ICondition> conditions;
 
     protected BaseRecipeParams(ResourceLocation id) {
         this.id = id;
         recipeRequirements = new ArrayList<>();
-        conditions = List.of();
+        conditions = new ArrayList<>();
     }
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/BaseRecipeSerializer.java

@@ -12,9 +12,9 @@ import org.jetbrains.annotations.NotNull;
 import java.util.List;
 
 public abstract class BaseRecipeSerializer<R extends BaseRecipe<?,?>, B extends BaseRecipeBuilder<R,?>> implements RecipeSerializer<R> {
-    protected final List<RecipeRequirementType<?>> enabledRecipeRequirements;
+    protected final List<String> enabledRecipeRequirements;
 
-    public BaseRecipeSerializer(List<RecipeRequirementType<?>> pEnabledRecipeRequirements) {
+    public BaseRecipeSerializer(List<String> pEnabledRecipeRequirements) {
         this.enabledRecipeRequirements = pEnabledRecipeRequirements;
     }
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/IRecipeRequirement.java

@@ -0,0 +1,48 @@
+package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRegistries;
+import com.oierbravo.mechanical_lemon_lib.utility.LibLang;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public interface IRecipeRequirement {
+    Codec<IRecipeRequirement> CODEC = MechanicalLemonRegistries.RECIPE_REQUIREMENT_TYPE.byNameCodec().dispatch(IRecipeRequirement::getType, RecipeRequirementType::codec);
+    Codec<List<IRecipeRequirement>> LIST_CODEC = CODEC.listOf();
+
+    StreamCodec<RegistryFriendlyByteBuf,IRecipeRequirement> STREAM_CODEC
+            = ByteBufCodecs.registry(MechanicalLemonRegistries.Keys.RECIPE_REQUIREMENT)
+            .dispatch(IRecipeRequirement::getType, RecipeRequirementType::streamCodec);
+
+    StreamCodec<RegistryFriendlyByteBuf, List<IRecipeRequirement>> LIST_STREAM_CODEC =
+    //StreamCodec<RegistryFriendlyByteBuf, Map<RecipeRequirementType<?>, IRecipeRequirement>> LIST_STREAM_CODEC =
+           /* ByteBufCodecs.map(
+                    HashMap::new, // Constructs a map with the specified capacity
+                    RecipeRequirementType::streamCodec,
+                    IRecipeRequirement
+            );*/
+        STREAM_CODEC.apply(ByteBufCodecs.list(256));
+
+    boolean test(Level pLevel, BlockEntity pBlockEntity);
+    boolean isPresent();
+    String toString();
+    RecipeRequirementType<?> getType();
+
+    default Component toTooltipComponent(){
+        return LibLang.translate("ui.recipe_requirement." + getType().toString() + ".tooltip", toString()).component();
+    };
+    default Component toMissingComponent(){
+        return LibLang.translate("ui.recipe_requirement." + getType().toString() + ".missing", toString()).component();
+    }
+
+}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/IRecipeRequirement.java.old

@@ -1,62 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
-
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import com.mojang.serialization.*;
-import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRegistries;
-import net.minecraft.core.HolderLookup;
-import net.minecraft.resources.RegistryOps;
-import net.minecraft.util.Unit;
-import net.neoforged.neoforge.common.conditions.ConditionalOps;
-import net.neoforged.neoforge.common.conditions.WithConditions;
-import net.neoforged.neoforge.registries.NeoForgeRegistries;
-
-import java.util.*;
-import java.util.function.Function;
-
-public interface IRecipeRequirement<R extends IRecipeRequirement<?>> {
-    Codec<RecipeRequirement> CODEC = MechanicalLemonRegistries.RECIPE_REQUIREMENT_SERIALIZERS.byNameCodec().dispatch(RecipeRequirement::codec, Function.identity());
-    Codec<? extends List<?>> LIST_CODEC = CODEC.listOf();
-
-
-    static <V, T> Optional<T> getConditionally(Codec<T> codec, DynamicOps<V> ops, V element) {
-        return getWithConditionalCodec(ConditionalOps.createConditionalCodec(codec), ops, element);
-    }
-
-    static <V, T> Optional<T> getWithConditionalCodec(Codec<Optional<T>> codec, DynamicOps<V> ops, V element) {
-        return (Optional)codec.parse(ops, element).getOrThrow(JsonParseException::new);
-    }
-
-    /*static <V, T> Optional<T> getWithWithConditionsCodec(Codec<Optional<WithRecipeRequirements<T>>> codec, DynamicOps<V> ops, V elements) {
-        return ((Optional)codec.parse(ops, elements).promotePartial((m) -> {
-        }).getOrThrow(JsonParseException::new)).map(WithRecipeRequirements::carrier);
-    }
-*/
-    static <V> boolean conditionsMatched(DynamicOps<V> ops, V element) {
-        Codec<Unit> codec = Codec.unit(Unit.INSTANCE);
-        return getConditionally(codec, ops, element).isPresent();
-    }
-
-    static void writeRecipeRequirements(HolderLookup.Provider registries, JsonObject jsonObject, IRecipeRequirement... recipeRequirements) {
-        writeRecipeRequirements(registries, jsonObject, List.of(recipeRequirements));
-    }
-
-    static void writeRecipeRequirements(HolderLookup.Provider registries, JsonObject jsonObject, List<IRecipeRequirement> recipeRequirements) {
-        writeRecipeRequirements((DynamicOps) RegistryOps.create(JsonOps.INSTANCE, registries), jsonObject, (List)recipeRequirements);
-    }
-
-    static void writeRecipeRequirements(DynamicOps<JsonElement> jsonOps, JsonObject jsonObject, List<IRecipeRequirement> recipeRequirements) {
-        if (!recipeRequirements.isEmpty()) {
-            DataResult<JsonElement> result = LIST_CODEC.encodeStart(jsonOps, recipeRequirements);
-            JsonElement serializedConditions = (JsonElement)result.result().orElseThrow(() -> new RuntimeException("Failed to serialize conditions"));
-            jsonObject.add("neoforge:recipeRequirements", serializedConditions);
-        }
-
-    }
-
-    //boolean test(net.neoforged.neoforge.common.conditions.ICondition.IContext var1);
-
-    MapCodec<R> codec();
-
-}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/IRecipeRequirementCodec.java

@@ -1,7 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
-
-import com.mojang.serialization.MapCodec;
-
-public interface IRecipeRequirementCodec<RR extends RecipeRequirement<?>> {
-    public MapCodec<RR> codec();
-}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/IRecipeRequirementType.java

@@ -1,4 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
-
-public interface IRecipeRequirementType {
-}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/IRecipeWithRequirements.java

@@ -1,24 +1,21 @@
 package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
 
-import com.mojang.serialization.Codec;
-import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRegistries;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 
+import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.Optional;
-import java.util.function.Function;
 
 public interface IRecipeWithRequirements {
-    Codec<IRecipeRequirementType> CODEC = MechanicalLemonRegistries.RECIPE_REQUIREMENT_TYPES.byNameCodec().dispatch(t -> RecipeRequirementType.codec(t), Function.identity());
-    Codec<? extends List<?>> LIST_CODEC = CODEC.listOf();
-
-    Map<RecipeRequirementType<?>, RecipeRequirement<?>> getRecipeRequirements();
-    List<RecipeRequirementType<?>> getEnabledRequirements();
 
 
-    default <RRT extends RecipeRequirementType<?>> RecipeRequirement<?> getRequirement(RRT type) {
+    ArrayList<IRecipeRequirement> getRecipeRequirements();
-        return getRecipeRequirements().get(type);
+    //List<String> getEnabledRequirements();
+
+
+    default Optional<IRecipeRequirement> getRequirement(RecipeRequirementType<?> type) {
+        return getRecipeRequirements().stream().filter(iRecipeRequirement -> iRecipeRequirement == type).findFirst();
     }
 
     boolean checkRequirements(Level pLevel, BlockEntity pBlockEntity);

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/RecipeRequirement.java

@@ -1,40 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
-
-import com.mojang.serialization.MapCodec;
-import com.oierbravo.mechanical_lemon_lib.utility.LibLang;
-import net.minecraft.network.RegistryFriendlyByteBuf;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.codec.StreamCodec;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.entity.BlockEntity;
-
-import java.util.Optional;
-
-public abstract class RecipeRequirement<V>{
-
-    public abstract RecipeRequirementType<?> getType();
-
-    public abstract boolean test(Level pLevel, BlockEntity pBlockEntity);
-    public abstract Optional<V> getValue();
-    public abstract boolean isPresent();
-    public abstract String toString();
-
-    public boolean isProcessBlocker(){
-        return this instanceof IProcessBlockingRequirement;
-    }
-
-    public Component toTooltipComponent(){
-        return LibLang.translate("ui.recipe_requirement." + getType().getId() + ".tooltip", toString()).component();
-    };
-    public Component toMissingComponent(){
-        return LibLang.translate("ui.recipe_requirement." + getType().getId() + ".missing", toString()).component();
-    }
-
-
-    /*public static MapCodec<? extends RecipeRequirement<?>> typeCodec() {
-    }*/
-
-    public static MapCodec<? extends RecipeRequirementType<?>> typeCodec(RecipeRequirementType<?> recipeRequirementType) {
-
-    }
-}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/RecipeRequirementType.java

@@ -1,32 +1,23 @@
 package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
 
 import com.mojang.serialization.MapCodec;
-import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
 
-public abstract class RecipeRequirementType<RR extends RecipeRequirement<?>> {
+public class RecipeRequirementType<RR extends IRecipeRequirement> {
+    private final MapCodec<RR> codec;
+    private final StreamCodec<RegistryFriendlyByteBuf,RR> streamCodec;
 
-    private final String id;
+    public RecipeRequirementType(MapCodec<RR> codec, StreamCodec<RegistryFriendlyByteBuf, RR> streamCodec) {
-    public RecipeRequirementType(String id) {
+        this.codec = codec;
-        this.id = id;
+        this.streamCodec = streamCodec;
-    }
-    public String getId() {
-        return id;
     }
 
-    public abstract void toNetwork(FriendlyByteBuf buffer, RecipeRequirement<?> recipeRequirement);
+    public MapCodec<RR> codec() {
-    public abstract RR fromNetwork(FriendlyByteBuf buffer);
+        return codec;
-
-    public MapCodec<RR> codec(IRecipeRequirementType t) {
-        return RR.typeCodec(this);
     }
 
     public StreamCodec<RegistryFriendlyByteBuf, RR> streamCodec() {
-        return StreamCodec.of(this::toNetwork, this::fromNetwork);
+        return streamCodec;
-    };
-
-    public String toString() {
-        return getId();
     }
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/RecipeRequirementsUtils.java

@@ -10,44 +10,11 @@ import java.util.List;
 import java.util.Map;
 
 public class RecipeRequirementsUtils {
-    /*public static ArrayList<RecipeRequirement<?>>  fromJson(JsonObject json, List<RecipeRequirementType<?>> enabledRecipeRequirements){
+    public static ArrayList<RecipeRequirementType<?>> checkRequirements(Map<String, IRecipeRequirement> pRecipeRequirements, BlockEntity pBlockEntity){
-        ArrayList<RecipeRequirement> recipeRequirements = new ArrayList<>();
+        ArrayList<RecipeRequirementType<?>> missingRequirements = new ArrayList<>();
-
-        enabledRecipeRequirements.forEach(recipeRequirementType -> {
-            if (GsonHelper.isValidNode(json, recipeRequirementType.getId())) {
-                recipeRequirements.add(recipeRequirementType.fromJson(json));
-            }
-        });
-        return recipeRequirements;
-    }*/
-    public static ArrayList<RecipeRequirement<?>> fromBuffer(FriendlyByteBuf buffer,  List<RecipeRequirementType<?>> enabledRecipeRequirements){
-        ArrayList<RecipeRequirement<?>> recipeRequirements = new ArrayList<>();
-        enabledRecipeRequirements.forEach(recipeRequirementType -> {
-            recipeRequirements.add(recipeRequirementType.fromNetwork(buffer));
-        });
-
-        return recipeRequirements;
-    }
-
-    /*public static JsonObject toJson(JsonObject pJson, Map<RecipeRequirementType<?>, RecipeRequirement> pRecipeRequirements){
-        for (Map.Entry<RecipeRequirementType<?>, RecipeRequirement> entry : pRecipeRequirements.entrySet()) {
-            pJson = entry.getKey().toJson(pJson, entry.getValue());
-        }
-        return pJson;
-    }
-*/
-
-    public static <RRT extends RecipeRequirementType<?>> void toBuffer(FriendlyByteBuf buffer, IRecipeWithRequirements pRecipe){
-        pRecipe.getEnabledRequirements().forEach(recipeRequirementType -> {
-            recipeRequirementType.toNetwork(buffer,pRecipe.getRequirement(recipeRequirementType));
-        });
-    }
-
-    public static ArrayList<String> checkRequirements(Map<RecipeRequirementType<?>, RecipeRequirement<?>> pRecipeRequirements, BlockEntity pBlockEntity){
-        ArrayList<String> missingRequirements = new ArrayList<>();
         pRecipeRequirements.forEach((recipeRequirementType, recipeRequirement) -> {
             if(!recipeRequirement.test(pBlockEntity.getLevel(),pBlockEntity))
-                missingRequirements.add(recipeRequirement.getType().getId());
+                missingRequirements.add(recipeRequirement.getType());
         });
         return missingRequirements;
     }

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/WithRecipeRequirements.java.old

@@ -1,64 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.foundation.recipe;
-
-import net.neoforged.neoforge.common.conditions.ICondition;
-import net.neoforged.neoforge.common.conditions.WithConditions;
-import org.apache.commons.lang3.Validate;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-public record WithRecipeRequirements<A>(List<IRecipeRequirement> recipeRequirements, A carrier) {
-    public WithRecipeRequirements(A carrier, IRecipeRequirement... recipeRequirements) {
-        this(List.of(recipeRequirements), carrier);
-    }
-
-    public WithRecipeRequirements(A carrier) {
-        this(List.of(), carrier);
-    }
-
-    public WithRecipeRequirements(List<IRecipeRequirement> recipeRequirements, A carrier) {
-        this.recipeRequirements = recipeRequirements;
-        this.carrier = carrier;
-    }
-    public static <A> Builder<A> builder(A carrier) {
-        return (new Builder<A>()).withCarrier(carrier);
-    }
-
-    public List<IRecipeRequirement> recipeRequirements() {
-        return this.recipeRequirements;
-    }
-
-    public A carrier() {
-        return this.carrier;
-    }
-
-    public static class Builder<T> {
-        private final List<IRecipeRequirement> recipeRequirements = new ArrayList<>();
-        private T carrier;
-
-        public Builder() {
-        }
-
-        public WithRecipeRequirements.Builder<T> addRequirement(IRecipeRequirement... recipeRequirement) {
-            this.recipeRequirements.addAll(List.of(recipeRequirement));
-            return this;
-        }
-
-        public WithRecipeRequirements.Builder<T> addRequirement(Collection<IRecipeRequirement> recipeRequirement) {
-            this.recipeRequirements.addAll(recipeRequirement);
-            return this;
-        }
-
-        public WithRecipeRequirements.Builder<T> withCarrier(T carrier) {
-            this.carrier = carrier;
-            return this;
-        }
-
-        public WithRecipeRequirements<T> build() {
-            Validate.notNull(this.carrier, "You need to supply a carrier to create a WithRecipeRequirements", new Object[0]);
-            Validate.notEmpty(this.recipeRequirements, "You need to supply at least one condition to create a WithRecipeRequirements", new Object[0]);
-            return new WithRecipeRequirements<T>(this.recipeRequirements, this.carrier);
-        }
-    }
-}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/requirements/MinYRequirement.java

@@ -0,0 +1,51 @@
+package com.oierbravo.mechanical_lemon_lib.foundation.recipe.requirements;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirement;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirementType;
+import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRecipeRequirementTypes;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+
+public record MinYRequirement(Integer minY) implements IRecipeRequirement{
+    public static String ID = "min_y";
+
+    public static MapCodec<MinYRequirement> CODEC = RecordCodecBuilder
+            .mapCodec((builder)
+                    -> builder
+                    .group(Codec.INT.optionalFieldOf("value", null)
+                    .forGetter(MinYRequirement::minY)).apply(builder,MinYRequirement::new));
+
+    public static final StreamCodec<RegistryFriendlyByteBuf, MinYRequirement> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.INT, MinYRequirement::minY,
+            MinYRequirement::new
+    );
+    public static MinYRequirement of(Integer minY){
+        return new MinYRequirement(minY);
+    }
+
+    @Override
+    public boolean test(Level pLevel, BlockEntity pBlockEntity) {
+        return false;
+    }
+
+    @Override
+    public boolean isPresent() {
+        return false;
+    }
+
+    @Override
+    public RecipeRequirementType<?> getType() {
+        return MechanicalLemonRecipeRequirementTypes.MIN_Y.get();
+    }
+
+    @Override
+    public String toString() {
+        return ID;
+    }
+}

src/main/java/com/oierbravo/mechanical_lemon_lib/foundation/recipe/requirements/SpeedRequirement.java

@@ -3,106 +3,44 @@ package com.oierbravo.mechanical_lemon_lib.foundation.recipe.requirements;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
-import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirement;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirement;
 import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirementType;
-import com.simibubi.create.content.kinetics.base.KineticBlockEntity;
+import com.oierbravo.mechanical_lemon_lib.register.MechanicalLemonRecipeRequirementTypes;
-import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 
-import java.util.Optional;
+public record SpeedRequirement(Float speed) implements IRecipeRequirement {
-
+    public static String ID = "min_speed";
-public class SpeedRequirement extends RecipeRequirement<Float> {
+    public static MapCodec<SpeedRequirement> CODEC = RecordCodecBuilder.mapCodec((builder) -> builder.group(Codec.FLOAT.optionalFieldOf("value", null).forGetter(SpeedRequirement::speed)).apply(builder,SpeedRequirement::new));
-    public static final RecipeRequirementType TYPE = new SpeedRequirementType();
-    public static final SpeedRequirement EMPTY = new SpeedRequirement();
-
-
-    private Float value;
-
-    public SpeedRequirement() {
 
+    public static final StreamCodec<RegistryFriendlyByteBuf, SpeedRequirement> STREAM_CODEC = StreamCodec.composite(
+            ByteBufCodecs.FLOAT, SpeedRequirement::speed,
+            SpeedRequirement::new
+    );
+    public static SpeedRequirement of(Float speed){
+        return new SpeedRequirement(speed);
     }
-    public SpeedRequirement(Float value) {
-        this.value = value;
-    }
-
-    public SpeedRequirement(Optional<Float> value) {
-        this(value.get());
-    }
-
 
     @Override
     public boolean test(Level pLevel, BlockEntity pBlockEntity) {
-        if(pBlockEntity instanceof KineticBlockEntity){
+        return false;
-            return Math.abs(((KineticBlockEntity) pBlockEntity).getSpeed()) >= value;
-        }
-        return true;
     }
 
     @Override
     public boolean isPresent() {
-        return value != null;
+        return false;
+    }
+
+    @Override
+    public RecipeRequirementType<?> getType() {
+        return MechanicalLemonRecipeRequirementTypes.SPEED.get();
     }
 
     @Override
     public String toString() {
-        if(value == null)
+        return ID;
-            return null;
-        return value.toString();
-    }
-
-
-    public Optional<Float> getValue() {
-        if(value == null)
-            return Optional.empty();
-        return Optional.of(value);
-    }
-
-    public static SpeedRequirement of(float pValue) {
-        return new SpeedRequirement(pValue);
-    }
-
-
-    @Override
-    public RecipeRequirementType<?> getType() {
-        return TYPE;
-    }
-
-    private static class SpeedRequirementType extends RecipeRequirementType<SpeedRequirement> {
-        public static MapCodec<SpeedRequirement> CODEC = RecordCodecBuilder.mapCodec((builder) -> builder.group(Codec.FLOAT.optionalFieldOf("min_speed").forGetter(SpeedRequirement::getValue)).apply(builder,SpeedRequirement::new));
-
-
-        public SpeedRequirementType(String id) {
-            super(id);
-        }
-
-        @Override
-        public void toNetwork(FriendlyByteBuf buffer, RecipeRequirement<?> recipeRequirement) {
-
-        }
-
-        @Override
-        public SpeedRequirement fromNetwork(FriendlyByteBuf buffer) {
-            return null;
-        }
-
-        public SpeedRequirementType() {
-            super("min_speed");
-        }
-
-        @Override
-        public MapCodec<SpeedRequirement> codec() {
-            return CODEC;
-        }
-
-        @Override
-        public StreamCodec<RegistryFriendlyByteBuf, SpeedRequirement> streamCodec() {
-            return null;
-        }
-
-
-
     }
 }

src/main/java/com/oierbravo/mechanical_lemon_lib/register/LemonRecipeRequirementTypes.java

@@ -1,12 +0,0 @@
-package com.oierbravo.mechanical_lemon_lib.register;
-
-import com.oierbravo.mechanical_lemon_lib.foundation.recipe.requirements.SpeedRequirement;
-
-public class LemonRecipeRequirementTypes {
-
-    public static void register() {
-        IRecipeRequirement.REGISTRY.register(SpeedRequirement.TYPE,SpeedRequirement.);
-
-    }
-}
-

src/main/java/com/oierbravo/mechanical_lemon_lib/register/MechanicalLemonRecipeRequirementTypes.java

@@ -0,0 +1,36 @@
+package com.oierbravo.mechanical_lemon_lib.register;
+
+import com.mojang.serialization.MapCodec;
+import com.oierbravo.mechanical_lemon_lib.MechanicalLemonLib;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirement;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirementType;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.requirements.MinYRequirement;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.requirements.SpeedRequirement;
+import net.minecraft.network.codec.StreamCodec;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+
+
+import java.util.function.Supplier;
+
+public class MechanicalLemonRecipeRequirementTypes {
+    public static final DeferredRegister<RecipeRequirementType<?>> RECIPE_REQUIREMENT_TYPES =
+            DeferredRegister.create(MechanicalLemonRegistries.Keys.RECIPE_REQUIREMENT, MechanicalLemonLib.MODID);
+
+    public static final Supplier<RecipeRequirementType<SpeedRequirement>> SPEED =
+            register(SpeedRequirement.ID, SpeedRequirement.CODEC, SpeedRequirement.STREAM_CODEC);
+
+    public static final Supplier<RecipeRequirementType<MinYRequirement>> MIN_Y =
+            register(MinYRequirement.ID, MinYRequirement.CODEC, MinYRequirement.STREAM_CODEC);
+
+    public static void init(IEventBus modEventBus) {
+        RECIPE_REQUIREMENT_TYPES.register(modEventBus);
+    }
+
+    private static <RR extends IRecipeRequirement, RRT extends RecipeRequirementType<RR>> Supplier<RRT> register(String name, MapCodec<RR> codec, StreamCodec<RegistryFriendlyByteBuf, RR> streamCodec) {
+        //noinspection unchecked
+        return RECIPE_REQUIREMENT_TYPES.register(name, () -> (RRT) new RecipeRequirementType<>(codec, streamCodec));
+    }
+}
+

src/main/java/com/oierbravo/mechanical_lemon_lib/register/MechanicalLemonRegistries.java

@@ -1,56 +1,27 @@
 package com.oierbravo.mechanical_lemon_lib.register;
 
-import com.mojang.serialization.MapCodec;
 import com.oierbravo.mechanical_lemon_lib.MechanicalLemonLib;
-import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirementType;
+import com.oierbravo.mechanical_lemon_lib.foundation.recipe.IRecipeRequirement;
 import com.oierbravo.mechanical_lemon_lib.foundation.recipe.RecipeRequirementType;
 import net.minecraft.core.Registry;
 import net.minecraft.resources.ResourceKey;
+import net.neoforged.neoforge.registries.NewRegistryEvent;
 import net.neoforged.neoforge.registries.RegistryBuilder;
 
 public class MechanicalLemonRegistries {
-    //public static final Registry<MapCodec<? extends RecipeRequirementType<?>>> RECIPE_REQUIREMENT_TYPES = simple(key("requirements")) ;
+    public static Registry<RecipeRequirementType<?>> RECIPE_REQUIREMENT_TYPE;// = (new RegistryBuilder(Keys.RECIPE_REQUIREMENT_TYPES)).create();
-    public static final Registry<MapCodec<? extends IRecipeRequirementType>> RECIPE_REQUIREMENT_TYPES = (new RegistryBuilder(Keys.RECIPE_REQUIREMENT_TYPES)).create();
-
-    /*private static <T> Registry<T> simple(ResourceKey<Registry<T>> key) {
-        return register(key);
-    }*/
-
-    /*private static <T> Registry<T> withIntrusiveHolders(ResourceKey<Registry<T>> key) {
-        return register(key, true);
-    }*/
-
-    @SuppressWarnings({"deprecation", "unchecked", "rawtypes"})
-    /*private static <T> Registry<T> register(ResourceKey<Registry<T>> key) {
-        RegistryBuilder<T> builder = new RegistryBuilder<>(key)
-                .sync(true);
-
-
-        Registry<T> registry = builder.create();
-        ((WritableRegistry) BuiltInRegistries.REGISTRY)
-                .register(key, registry, RegistrationInfo.BUILT_IN);
-        return registry;
-    }
-    private static <T> ResourceKey<Registry<T>> key(String name) {
-        return ResourceKey.createRegistryKey(MechanicalLemonLib.asResource(name));
-    }*/
     public MechanicalLemonRegistries() {
     }
 
     static {
-        RECIPE_REQUIREMENT_TYPES = (new RegistryBuilder(MechanicalLemonRegistries.Keys.RECIPE_REQUIREMENT_TYPES)).create();
+        RECIPE_REQUIREMENT_TYPE = new RegistryBuilder<>(MechanicalLemonRegistries.Keys.RECIPE_REQUIREMENT).sync(true).create();
     }
     public static final class Keys {
-        public static final ResourceKey<Registry<MapCodec<? extends RecipeRequirementType<?>>>> RECIPE_REQUIREMENT_TYPES = key("requirements");
+        public static final ResourceKey<Registry<RecipeRequirementType<?>>> RECIPE_REQUIREMENT = ResourceKey.createRegistryKey(MechanicalLemonLib.asResource("requirement"));
 
-        public Keys() {
     }
-
+    public static void register(NewRegistryEvent event) {
-        private static <T> ResourceKey<Registry<T>> key(String name) {
+        event.register(RECIPE_REQUIREMENT_TYPE);
-            return ResourceKey.createRegistryKey(MechanicalLemonLib.asResource(name));
-        }
-    }
-    public static void init() {
     }
 
 }