add Inspirations compat

build.gradle

@@ -114,6 +114,11 @@ dependencies {
         runtimeOnly rfg.deobf('curse.maven:chisel-235279:2915375')
     }
 
+    compileOnly 'slimeknights.mantle:Mantle:1.12-1.3.3.55'
+    if (project.debug_inspirations.toBoolean() || project.debug_tinkers.toBoolean()) {
+        runtimeOnly 'slimeknights.mantle:Mantle:1.12-1.3.3.55'
+    }
+
     compileOnly rfg.deobf('curse.maven:mekanism-268560:2835175')
     if (project.debug_mekanism.toBoolean()) {
         runtimeOnly rfg.deobf('curse.maven:mekanism-268560:2835175')
@@ -153,6 +158,11 @@ dependencies {
         runtimeOnly rfg.deobf('curse.maven:actually-additions-228404:3117927')
     }
 
+    compileOnly rfg.deobf('curse.maven:inspirations-284007:2843007')
+    if (project.debug_inspirations.toBoolean()) {
+        runtimeOnly rfg.deobf('curse.maven:inspirations-284007:2843007')
+    }
+
     compileOnly rfg.deobf('curse.maven:cucumber-272335:2645867')
     compileOnly rfg.deobf('curse.maven:extended-crafting-nomifactory-edition-398267:3613140')
     if (project.debug_extended_crafting.toBoolean()) {
@@ -241,12 +251,10 @@ dependencies {
         runtimeOnly rfg.deobf('curse.maven:immersive_engineering-231951:2974106')
     }
 
-    compileOnly 'slimeknights.mantle:Mantle:1.12-1.3.3.55'
     compileOnly 'slimeknights:TConstruct:1.12.2-2.13.0.190'
     compileOnly rfg.deobf('curse.maven:constructs-armory-287683:3174535')
     compileOnly rfg.deobf('curse.maven:tinkers-complement-272671:2843439')
     if (project.debug_tinkers.toBoolean()) {
-        runtimeOnly 'slimeknights.mantle:Mantle:1.12-1.3.3.55'
         runtimeOnly 'slimeknights:TConstruct:1.12.2-2.13.0.190'
         runtimeOnly rfg.deobf('curse.maven:constructs-armory-287683:3174535')
         runtimeOnly rfg.deobf('curse.maven:tinkers-complement-272671:2843439')

examples/postInit/inspirations.groovy

@@ -0,0 +1,91 @@
+
+if (!isLoaded('inspirations')) return
+println 'mod \'inspirations\' detected, running script'
+
+// Cauldron:
+// Converts up to 1 itemstack and up to 1 fluid into up to 1 itemstack or up to 1 fluid, with a boiling boolean and variable amount of fluid consumed or produced.
+// Cauldrons have a cap of either 3 or 4 levels, depending on the config.
+mods.inspirations.cauldron.recipeBuilder()
+    .standard() // Optional, one type is required, it can either be done in a normal recipeBuilder or preset via a recipeBuilder variant.
+    .input(item('minecraft:gold_ingot'))
+    .fluidInput(fluid('lava'))
+    .output(item('minecraft:clay'))
+    .boiling()
+    .sound(sound('block.anvil.destroy'))
+    .levels(3)
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderStandard() // Requires 1 input, 1 output, 1 fluid input, 0 < levels < 3/4, and a sound
+    .input(item('minecraft:diamond'))
+    .output(item('minecraft:clay'))
+    .fluidInput(fluid('lava'))
+    .levels(3)
+    .sound(sound('block.anvil.destroy'))
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderTransform() // Requires 1 input, 1 fluid input, 1 fluid output, 0 < levels < 3/4
+    .input(item('minecraft:stone:3'))
+    .fluidInput(fluid('water'))
+    .fluidOutput(fluid('milk'))
+    .levels(2)
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderMix() // Requires 1 output and 2 fluid inputs
+    .output(item('minecraft:clay'))
+    .fluidInput(fluid('milk'), fluid('lava'))
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderFill() // Requires 1 input, 1 output, 1 fluid input, and a sound
+    .input(item('minecraft:gold_ingot'))
+    .output(item('minecraft:clay'))
+    .fluidInput(fluid('milk'))
+    .sound(sound('block.anvil.destroy'))
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderBrewing() // Requires 1 input, 1 input potion, and 1 output potion
+    .input(item('minecraft:diamond_block'))
+    .inputPotion(potionType('fire_resistance'))
+    .outputPotion(potionType('strength'))
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderPotion() // Requires 1 input, 1 output, 1 input potion, and 0 < levels < 3/4
+    .input(item('minecraft:gold_block'))
+    .output(item('minecraft:diamond_block'))
+    .inputPotion(potionType('fire_resistance'))
+    .levels(2)
+    .register()
+
+mods.inspirations.cauldron.recipeBuilderDye() // Requires 1 input, 1 output, 1 dye, and 0 < levels < 3/4
+    .input(item('minecraft:gold_block'))
+    .output(item('minecraft:diamond_block'))
+    .dye('blue')
+    .levels(2)
+    .register()
+
+
+// Note: some recipes (banners, potions) cannot be removed.
+mods.inspirations.cauldron.removeByInput(item('minecraft:ghast_tear'))
+mods.inspirations.cauldron.removeByOutput(item('minecraft:piston'))
+mods.inspirations.cauldron.removeByFluidOutput(fluid('beetroot_soup'))
+mods.inspirations.cauldron.removeByFluidInput(fluid('mushroom_stew'))
+
+//mods.inspirations.cauldron.removeAll()
+
+
+// Anvil Smashing:
+// Converts a Block or IBlockState into an IBlockState when an anvil falls on top of it (from any height).
+mods.inspirations.anvilsmashing.recipeBuilder()
+    .input(blockstate('minecraft:diamond_block'))
+    .output(blockstate('minecraft:clay'))
+    .register()
+
+mods.inspirations.anvilsmashing.recipeBuilder()
+    .input(blockstate('minecraft:clay'))
+    .output(blockstate('minecraft:air'))
+    .register()
+
+mods.inspirations.anvilsmashing.removeByInput(blockstate('minecraft:packed_ice'))
+mods.inspirations.anvilsmashing.removeByOutput(blockstate('minecraft:cobblestone'))
+
+//mods.inspirations.anvilsmashing.removeAll()
+

gradle.properties

@@ -35,4 +35,5 @@ debug_tinkers = false
 debug_extended_crafting = false
 debug_botania = false
 debug_forestry = false
-debug_compact_machines = false
+debug_inspirations = false
+debug_compact_machines = false

src/main/java/com/cleanroommc/groovyscript/brackets/BracketHandlerManager.java

@@ -66,6 +66,7 @@ public static void init() {
         registerBracketHandler("blockstate", BlockStateBracketHandler.INSTANCE);
         registerBracketHandler("enchantment", Enchantment::getEnchantmentByLocation);
         registerBracketHandler("potion", Potion::getPotionFromResourceLocation);
+        registerBracketHandler("potionType", s -> ForgeRegistries.POTION_TYPES.getValue(new ResourceLocation(s)));
         registerBracketHandler("sound", s -> ForgeRegistries.SOUND_EVENTS.getValue(new ResourceLocation(s)));
         registerBracketHandler("entity", s -> ForgeRegistries.ENTITIES.getValue(new ResourceLocation(s)));
         registerBracketHandler("creativeTab", s -> {

src/main/java/com/cleanroommc/groovyscript/compat/mods/ModSupport.java

@@ -15,6 +15,7 @@
 import com.cleanroommc.groovyscript.compat.mods.forestry.Forestry;
 import com.cleanroommc.groovyscript.compat.mods.ic2.IC2;
 import com.cleanroommc.groovyscript.compat.mods.immersiveengineering.ImmersiveEngineering;
+import com.cleanroommc.groovyscript.compat.mods.inspirations.Inspirations;
 import com.cleanroommc.groovyscript.compat.mods.jei.JustEnoughItems;
 import com.cleanroommc.groovyscript.compat.mods.mekanism.Mekanism;
 import com.cleanroommc.groovyscript.compat.mods.roots.Roots;
@@ -60,6 +61,7 @@ public class ModSupport implements IDynamicGroovyProperty {
     public static final Container<IC2> INDUSTRIALCRAFT = new Container<>("ic2", "Industrial Craft 2", IC2::new, "industrialcraft");
     public static final Container<ExtendedCrafting> EXTENDED_CRAFTING = new Container<>("extendedcrafting", "Extended Crafting", ExtendedCrafting::new);
     public static final Container<Forestry> FORESTRY = new Container<>("forestry", "Forestry", Forestry::new);
+    public static final Container<Inspirations> INSPIRATIONS = new Container<>("inspirations", "Inspirations", Inspirations::new);
     public static final Container<CompactMachines> COMPACT_MACHINES = new Container<>("compactmachines3", "Compact Machines 3", CompactMachines::new, "compactmachines");
 
     public static Collection<Container<? extends ModPropertyContainer>> getAllContainers() {

src/main/java/com/cleanroommc/groovyscript/compat/mods/inspirations/AnvilSmashing.java

@@ -0,0 +1,183 @@
+package com.cleanroommc.groovyscript.compat.mods.inspirations;
+
+import com.cleanroommc.groovyscript.api.GroovyLog;
+import com.cleanroommc.groovyscript.compat.mods.ModSupport;
+import com.cleanroommc.groovyscript.core.mixin.inspirations.InspirationsRegistryAccessor;
+import com.cleanroommc.groovyscript.helper.SimpleObjectStream;
+import com.cleanroommc.groovyscript.helper.recipe.AbstractRecipeBuilder;
+import com.cleanroommc.groovyscript.registry.VirtualizedRegistry;
+import knightminer.inspirations.library.InspirationsRegistry;
+import net.minecraft.block.Block;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.state.IBlockState;
+import org.apache.commons.lang3.tuple.Pair;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class AnvilSmashing extends VirtualizedRegistry<Pair<IBlockState, IBlockState>> {
+
+    private Collection<Pair<Block, IBlockState>> blockBackup;
+    private Collection<Pair<Block, IBlockState>> blockScripted;
+    private Collection<Material> materialBackup;
+
+    private void addBlockBackup(Pair<Block, IBlockState> recipe) {
+        if (blockScripted.stream().anyMatch(r -> r == recipe)) return;
+        blockBackup.add(recipe);
+    }
+
+    public void addBlockScripted(Pair<Block, IBlockState> recipe) {
+        blockScripted.add(recipe);
+    }
+
+    public AnvilSmashing() {
+        super();
+        blockBackup = new ArrayList<>();
+        blockScripted = new ArrayList<>();
+        materialBackup = new ArrayList<>();
+    }
+
+
+    public RecipeBuilder recipeBuilder() {
+        return new RecipeBuilder();
+    }
+
+    @Override
+    public void onReload() {
+        removeScripted().forEach(pair -> InspirationsRegistryAccessor.getAnvilSmashing().remove(pair.getKey(), pair.getValue()));
+        restoreFromBackup().forEach(pair -> InspirationsRegistryAccessor.getAnvilSmashing().put(pair.getKey(), pair.getValue()));
+        blockBackup.forEach(pair -> InspirationsRegistryAccessor.getAnvilSmashingBlocks().remove(pair.getKey(), pair.getValue()));
+        blockScripted.forEach(pair -> InspirationsRegistryAccessor.getAnvilSmashingBlocks().put(pair.getKey(), pair.getValue()));
+        materialBackup.forEach(mat -> InspirationsRegistryAccessor.getAnvilBreaking().add(mat));
+        blockBackup = new ArrayList<>();
+        blockScripted = new ArrayList<>();
+        materialBackup = new ArrayList<>();
+    }
+
+    public void add(IBlockState input, IBlockState output) {
+        addScripted(Pair.of(input, output));
+        InspirationsRegistry.registerAnvilSmashing(input, output);
+    }
+
+    public void add(Block input, IBlockState output) {
+        addBlockScripted(Pair.of(input, output));
+        InspirationsRegistry.registerAnvilSmashing(input, output);
+    }
+
+    public boolean remove(IBlockState input, IBlockState output) {
+        if (!InspirationsRegistryAccessor.getAnvilSmashing().get(input).equals(output)) return false;
+        addBackup(Pair.of(input, output));
+        InspirationsRegistryAccessor.getAnvilSmashing().remove(input, output);
+        return true;
+    }
+
+    public boolean remove(Block input, IBlockState output) {
+        if (!InspirationsRegistryAccessor.getAnvilSmashingBlocks().get(input).equals(output)) return false;
+        addBlockBackup(Pair.of(input, output));
+        InspirationsRegistryAccessor.getAnvilSmashingBlocks().remove(input, output);
+        return true;
+    }
+
+    public boolean remove(Material material) {
+        if (!InspirationsRegistryAccessor.getAnvilBreaking().contains(material)) return false;
+        materialBackup.add(material);
+        InspirationsRegistryAccessor.getAnvilBreaking().remove(material);
+        return true;
+    }
+
+    public void removeByInput(IBlockState input) {
+        for (Map.Entry<IBlockState, IBlockState> recipe : InspirationsRegistryAccessor.getAnvilSmashing().entrySet().stream()
+                .filter(r -> r.getKey().equals(input))
+                .collect(Collectors.toList())) {
+            addBackup(Pair.of(recipe.getKey(), recipe.getValue()));
+            InspirationsRegistryAccessor.getAnvilSmashing().remove(recipe.getKey(), recipe.getValue());
+        }
+    }
+
+    public void removeByInput(Block input) {
+        for (Map.Entry<Block, IBlockState> recipe : InspirationsRegistryAccessor.getAnvilSmashingBlocks().entrySet().stream()
+                .filter(r -> r.getKey().equals(input))
+                .collect(Collectors.toList())) {
+            addBlockBackup(Pair.of(recipe.getKey(), recipe.getValue()));
+            InspirationsRegistryAccessor.getAnvilSmashingBlocks().remove(recipe.getKey(), recipe.getValue());
+        }
+    }
+
+    public void removeByOutput(IBlockState output) {
+        for (Map.Entry<IBlockState, IBlockState> recipe : InspirationsRegistryAccessor.getAnvilSmashing().entrySet().stream()
+                .filter(r -> r.getValue().equals(output))
+                .collect(Collectors.toList())) {
+            addBackup(Pair.of(recipe.getKey(), recipe.getValue()));
+            InspirationsRegistryAccessor.getAnvilSmashing().remove(recipe.getKey(), recipe.getValue());
+        }
+        for (Map.Entry<Block, IBlockState> recipe : InspirationsRegistryAccessor.getAnvilSmashingBlocks().entrySet().stream()
+                .filter(r -> r.getValue().equals(output))
+                .collect(Collectors.toList())) {
+            addBlockBackup(Pair.of(recipe.getKey(), recipe.getValue()));
+            InspirationsRegistryAccessor.getAnvilSmashingBlocks().remove(recipe.getKey(), recipe.getValue());
+        }
+    }
+
+    public void removeAll() {
+        InspirationsRegistryAccessor.getAnvilSmashing().forEach((a, b) -> addBackup(Pair.of(a, b)));
+        InspirationsRegistryAccessor.getAnvilSmashing().clear();
+        InspirationsRegistryAccessor.getAnvilSmashingBlocks().forEach((a, b) -> addBlockBackup(Pair.of(a, b)));
+        InspirationsRegistryAccessor.getAnvilSmashingBlocks().clear();
+        materialBackup.addAll(InspirationsRegistryAccessor.getAnvilBreaking());
+        InspirationsRegistryAccessor.getAnvilBreaking().clear();
+    }
+
+    public SimpleObjectStream<Map.Entry<IBlockState, IBlockState>> streamRecipes() {
+        return new SimpleObjectStream<>(InspirationsRegistryAccessor.getAnvilSmashing().entrySet())
+                .setRemover(r -> remove(r.getKey(), r.getValue()));
+    }
+
+    public static class RecipeBuilder extends AbstractRecipeBuilder<Object> {
+
+        private IBlockState inputBlockState;
+        private Block inputBlock;
+        private IBlockState output;
+
+
+        public RecipeBuilder input(Block input) {
+            this.inputBlock = input;
+            return this;
+        }
+
+        public RecipeBuilder input(IBlockState input) {
+            this.inputBlockState = input;
+            return this;
+        }
+
+        public RecipeBuilder output(IBlockState output) {
+            this.output = output;
+            return this;
+        }
+
+        @Override
+        public String getErrorMsg() {
+            return "Error adding Inspirations Anvil Smashing recipe";
+        }
+
+        @Override
+        public void validate(GroovyLog.Msg msg) {
+            msg.add(inputBlockState == null && inputBlock == null, "either inputBlockState or inputBlock must be defined");
+            msg.add(output == null, "output must be defined");
+        }
+
+        @Override
+        public @Nullable Object register() {
+            if (!validate()) return null;
+            if (inputBlock == null) {
+                ModSupport.INSPIRATIONS.get().anvilSmashing.add(inputBlockState, output);
+                return Pair.of(inputBlockState, output);
+            }
+            ModSupport.INSPIRATIONS.get().anvilSmashing.add(inputBlock, output);
+            return Pair.of(inputBlock, output);
+        }
+    }
+
+}