feat: More Condition stuff

src/main/java/net/zepalesque/zenith/Zenith.java

@@ -14,14 +14,16 @@
 import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
 import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
 import net.neoforged.fml.loading.FMLPaths;
-import net.neoforged.neoforge.data.event.GatherDataEvent;
 import net.neoforged.neoforge.registries.DataPackRegistryEvent;
 import net.zepalesque.zenith.api.condition.Condition;
 import net.zepalesque.zenith.api.condition.ConditionElements;
 import net.zepalesque.zenith.api.condition.ConfigCondition;
 import net.zepalesque.zenith.api.condition.config.ConfigSerializer;
 import net.zepalesque.zenith.config.ZConfig;
+import net.zepalesque.zenith.loot.condition.ZenithLootConditions;
 import net.zepalesque.zenith.recipe.condition.ZenithRecipeConditions;
+import net.zepalesque.zenith.world.placement.ZenithPlacementModifiers;
+import net.zepalesque.zenith.world.state.ZenithStateProviders;
 import org.slf4j.Logger;
 
 import java.nio.file.Path;
@@ -42,6 +44,9 @@ public Zenith(IEventBus bus, Dist dist) {
 
         ConditionElements.ELEMENTS.register(bus);
         ZenithRecipeConditions.CODECS.register(bus);
+        ZenithPlacementModifiers.FILTERS.register(bus);
+        ZenithLootConditions.LOOT_CONDITIONS.register(bus);
+        ZenithStateProviders.PROVIDERS.register(bus);
 
         // Register example config serializer
         ConfigCondition.registerSerializer("zenith", new ConfigSerializer(ZConfig.Serializer::serialize, ZConfig.Serializer::deserialize));

src/main/java/net/zepalesque/zenith/loot/condition/ConditionLootModule.java

@@ -0,0 +1,36 @@
+package net.zepalesque.zenith.loot.condition;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.core.Holder;
+import net.minecraft.world.level.storage.loot.LootContext;
+import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
+import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType;
+import net.zepalesque.zenith.api.condition.Condition;
+
+import java.util.Optional;
+
+public class ConditionLootModule implements LootItemCondition {
+
+    public static Codec<ConditionLootModule> CODEC = RecordCodecBuilder.create(
+            builder -> builder
+                    .group(Condition.CODEC.fieldOf("condition").forGetter(module -> module.condition))
+                    .apply(builder, ConditionLootModule::new));
+
+    private final Holder<Condition<?>> condition;
+
+    public ConditionLootModule(Holder<Condition<?>> condition)
+    {
+        this.condition = condition;
+    }
+
+    public LootItemConditionType getType() {
+        return ZenithLootConditions.LOOT_MODULE.get();
+    }
+
+    public boolean test(LootContext lootContext) {
+        Optional<Condition<?>> optional = this.condition.unwrap().right();
+        return optional.isEmpty() || optional.get().test();
+    }
+
+}

src/main/java/net/zepalesque/zenith/loot/condition/ZenithLootConditions.java

@@ -0,0 +1,15 @@
+package net.zepalesque.zenith.loot.condition;
+
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.level.storage.loot.predicates.LootItemConditionType;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.zepalesque.zenith.Zenith;
+
+public class ZenithLootConditions {
+
+    public static final DeferredRegister<LootItemConditionType> LOOT_CONDITIONS = DeferredRegister.create(BuiltInRegistries.LOOT_CONDITION_TYPE, Zenith.MODID);
+
+    public static final DeferredHolder<LootItemConditionType, LootItemConditionType> LOOT_MODULE =
+            LOOT_CONDITIONS.register("when", () -> new LootItemConditionType(ConditionLootModule.CODEC));
+}

src/main/java/net/zepalesque/zenith/recipe/condition/ConditionCondition.java → src/main/java/net/zepalesque/zenith/recipe/condition/ConditionRecipeModule.java

@@ -9,16 +9,16 @@
 import java.util.Objects;
 import java.util.Optional;
 
-public  class ConditionCondition implements ICondition {
+public  class ConditionRecipeModule implements ICondition {
 
-    public static Codec<ConditionCondition> CODEC = RecordCodecBuilder.create(
+    public static Codec<ConditionRecipeModule> CODEC = RecordCodecBuilder.create(
             builder -> builder
-                    .group(Condition.CODEC.fieldOf("condition").forGetter(cc -> cc.condition))
-                    .apply(builder, ConditionCondition::new));
+                    .group(Condition.CODEC.fieldOf("condition").forGetter(module -> module.condition))
+                    .apply(builder, ConditionRecipeModule::new));
 
     public final Holder<Condition<?>> condition;
 
-    public ConditionCondition(Holder<Condition<?>> pCondition)
+    public ConditionRecipeModule(Holder<Condition<?>> pCondition)
     {
         this.condition = pCondition;
     }
@@ -29,7 +29,6 @@ public boolean test(IContext context) {
         return optional.isEmpty() || optional.get().test();
     }
 
-
     @Override
     public Codec<? extends ICondition> codec() {
         return CODEC;

src/main/java/net/zepalesque/zenith/recipe/condition/ZenithRecipeConditions.java

@@ -11,6 +11,6 @@ public class ZenithRecipeConditions {
 
     public static final DeferredRegister<Codec<? extends ICondition>> CODECS = DeferredRegister.create(NeoForgeRegistries.Keys.CONDITION_CODECS, Zenith.MODID);
 
-    public static final DeferredHolder<Codec<? extends ICondition>, Codec<ConditionCondition>> ZCOND_PREDICATE = CODECS.register("when", () -> ConditionCondition.CODEC);
-
+    public static final DeferredHolder<Codec<? extends ICondition>, Codec<ConditionRecipeModule>> RECIPE_MODULE =
+            CODECS.register("when", () -> ConditionRecipeModule.CODEC);
 }

src/main/java/net/zepalesque/zenith/world/placement/ConditionPlacementModule.java

@@ -0,0 +1,44 @@
+package net.zepalesque.zenith.world.placement;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.levelgen.placement.PlacementContext;
+import net.minecraft.world.level.levelgen.placement.PlacementFilter;
+import net.minecraft.world.level.levelgen.placement.PlacementModifierType;
+import net.zepalesque.zenith.api.condition.Condition;
+
+import javax.annotation.Nonnull;
+import java.util.Optional;
+
+public class ConditionPlacementModule extends PlacementFilter {
+
+    public static Codec<ConditionPlacementModule> CODEC = RecordCodecBuilder.create(
+            builder -> builder
+                    .group(Condition.CODEC.fieldOf("condition").forGetter(module -> module.condition))
+                    .apply(builder, ConditionPlacementModule::new));
+
+    public final Holder<Condition<?>> condition;
+
+    private ConditionPlacementModule(Holder<Condition<?>> pCondition) {
+        this.condition = pCondition;
+    }
+
+    public static ConditionPlacementModule of(Holder<Condition<?>> condition) {
+        return new ConditionPlacementModule(condition);
+    }
+
+    protected boolean shouldPlace(@Nonnull PlacementContext context, @Nonnull RandomSource random, @Nonnull BlockPos pos) {
+        Optional<Condition<?>> optional = this.condition.unwrap().right();
+        return optional.isEmpty() || optional.get().test();
+    }
+
+    @Nonnull
+    public PlacementModifierType<?> type() {
+        return ZenithPlacementModifiers.PLACEMENT_MODULE.get();
+    }
+}
+
+

src/main/java/net/zepalesque/zenith/world/placement/ZenithPlacementModifiers.java

@@ -0,0 +1,15 @@
+package net.zepalesque.zenith.world.placement;
+
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.level.levelgen.placement.PlacementModifierType;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.zepalesque.zenith.Zenith;
+
+public class ZenithPlacementModifiers {
+
+    public static final DeferredRegister<PlacementModifierType<?>> FILTERS = DeferredRegister.create(BuiltInRegistries.PLACEMENT_MODIFIER_TYPE, Zenith.MODID);
+
+    public static final DeferredHolder<PlacementModifierType<?>, PlacementModifierType<ConditionPlacementModule>> PLACEMENT_MODULE =
+            FILTERS.register("when", () -> () -> ConditionPlacementModule.CODEC);
+}

src/main/java/net/zepalesque/zenith/world/state/ConditionalStateProvider.java

@@ -0,0 +1,43 @@
+package net.zepalesque.zenith.world.state;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvider;
+import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProviderType;
+import net.zepalesque.zenith.api.condition.Condition;
+
+import java.util.Optional;
+
+public class ConditionalStateProvider extends BlockStateProvider {
+    private final BlockStateProvider base;
+    private final Holder<Condition<?>> condition;
+    private final BlockStateProvider alternative;
+
+    public static final Codec<ConditionalStateProvider> CODEC = RecordCodecBuilder.create((condition) ->
+            condition.group(
+                    BlockStateProvider.CODEC.fieldOf("base").forGetter((alt) -> alt.base),
+                    Condition.CODEC.fieldOf("condition").forGetter((alt) -> alt.condition),
+                    BlockStateProvider.CODEC.fieldOf("alternative").forGetter((alt) -> alt.alternative))
+                    .apply(condition, ConditionalStateProvider::new));
+
+    public ConditionalStateProvider(BlockStateProvider base, Holder<Condition<?>> condition, BlockStateProvider alternative) {
+        this.base = base;
+        this.condition = condition;
+        this.alternative = alternative;
+    }
+
+    @Override
+    public BlockState getState(RandomSource random, BlockPos pos) {
+        Optional<Condition<?>> optional = this.condition.unwrap().right();
+        boolean test = optional.isEmpty() || optional.get().test();
+        return (test ? this.base : this.alternative).getState(random, pos);
+    }
+    protected BlockStateProviderType<?> type() {
+        return ZenithStateProviders.CONDITIONAL_STATE.get();
+    }
+
+}

src/main/java/net/zepalesque/zenith/world/state/ZenithStateProviders.java

@@ -0,0 +1,15 @@
+package net.zepalesque.zenith.world.state;
+
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProviderType;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+import net.zepalesque.zenith.Zenith;
+
+public class ZenithStateProviders {
+
+    public static final DeferredRegister<BlockStateProviderType<?>> PROVIDERS = DeferredRegister.create(Registries.BLOCK_STATE_PROVIDER_TYPE, Zenith.MODID);
+
+    public static DeferredHolder<BlockStateProviderType<?>, BlockStateProviderType<ConditionalStateProvider>> CONDITIONAL_STATE =
+            PROVIDERS.register("conditional_state", () -> new BlockStateProviderType<>(ConditionalStateProvider.CODEC));
+}