Add replacer / printing support. Close #14

src/main/java/com/blamejared/createtweaker/CreateTweaker.java

@@ -1,6 +1,10 @@
 package com.blamejared.createtweaker;
 
 import com.blamejared.crafttweaker.api.fluid.CTFluidIngredient;
+import com.blamejared.crafttweaker.impl.item.MCItemStack;
+import com.blamejared.crafttweaker.impl.item.MCItemStackMutable;
+import com.blamejared.crafttweaker.impl.item.MCWeightedItemStack;
+import com.simibubi.create.content.contraptions.processing.ProcessingOutput;
 import com.simibubi.create.foundation.fluid.FluidIngredient;
 import net.minecraft.fluid.Fluid;
 import net.minecraft.tags.ITag;
@@ -14,12 +18,18 @@ public CreateTweaker() {
     }
 
     public static FluidIngredient mapFluidIngredients(CTFluidIngredient ingredient) {
-
+        
         return ingredient
                 .mapTo(FluidIngredient::fromFluidStack, (fluidITag, integer) -> FluidIngredient
                         .fromTag((ITag.INamedTag<Fluid>) fluidITag, integer), stream -> {
                     throw new IllegalArgumentException("Unable to use a compound ingredient for Create!");
                 });
     }
 
+
+    public static MCWeightedItemStack mapMutableProcessingResult(ProcessingOutput result) {
+
+        return new MCWeightedItemStack(new MCItemStackMutable(result.getStack()), result.getChance());
+    }
+
 }

src/main/java/com/blamejared/createtweaker/handlers/CompactingRecipeHandler.java

@@ -0,0 +1,80 @@
+package com.blamejared.createtweaker.handlers;
+
+import com.blamejared.crafttweaker.api.item.IIngredient;
+import com.blamejared.crafttweaker.api.managers.IRecipeManager;
+import com.blamejared.crafttweaker.api.recipes.IRecipeHandler;
+import com.blamejared.crafttweaker.api.recipes.IReplacementRule;
+import com.blamejared.crafttweaker.api.recipes.ReplacementHandlerHelper;
+import com.blamejared.crafttweaker.impl.fluid.MCFluidStackMutable;
+import com.blamejared.crafttweaker.impl.item.MCItemStackMutable;
+import com.mojang.datafixers.util.Either;
+import com.simibubi.create.AllRecipeTypes;
+import com.simibubi.create.content.contraptions.components.mixer.CompactingRecipe;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeBuilder;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeSerializer;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@IRecipeHandler.For(CompactingRecipe.class)
+public class CompactingRecipeHandler implements IRecipeHandler<CompactingRecipe> {
+
+    @Override
+    public String dumpToCommandString(IRecipeManager iRecipeManager, CompactingRecipe recipe) {
+
+        Either<MCItemStackMutable, MCFluidStackMutable> result;
+
+        if(!recipe.getFluidResults().isEmpty()) {
+            result = Either.right(new MCFluidStackMutable(recipe.getFluidResults().get(0)));
+        } else {
+            result = Either.left(new MCItemStackMutable(recipe.getResultItem()));
+        }
+
+        String output = String.format("<recipetype:create:compacting>.addRecipe(\"%s\", \"%s\", %s, [%s]",
+                recipe.getId(),
+                recipe.getRequiredHeat().name(),
+                result.map(MCItemStackMutable::getCommandString, MCFluidStackMutable::getCommandString),
+                recipe.getIngredients()
+                        .stream()
+                        .map(IIngredient::fromIngredient)
+                        .map(IIngredient::getCommandString)
+                        .collect(Collectors.joining(", "))
+        );
+
+        if(!recipe.getFluidResults().isEmpty()) {
+            output += String.format(", [%s]", recipe.getFluidResults()
+                    .stream()
+                    .map(MCFluidStackMutable::new)
+                    .map(MCFluidStackMutable::getCommandString)
+                    .collect(Collectors.joining(", ")));
+        }
+
+        return output + ");";
+
+    }
+
+    @Override
+    public Optional<Function<ResourceLocation, CompactingRecipe>> replaceIngredients(IRecipeManager manager, CompactingRecipe recipe, List<IReplacementRule> rules) {
+
+        return ReplacementHandlerHelper.replaceNonNullIngredientList(
+                recipe.getIngredients(),
+                Ingredient.class,
+                recipe,
+                rules,
+                newIngredients -> id -> {
+                    ProcessingRecipeBuilder<CompactingRecipe> builder = new ProcessingRecipeBuilder<>(((ProcessingRecipeSerializer<CompactingRecipe>) AllRecipeTypes.COMPACTING.getSerializer()).getFactory(), id);
+                    builder.withItemOutputs(recipe.getRollableResults());
+                    builder.withItemIngredients(newIngredients);
+                    builder.withFluidIngredients(recipe.getFluidIngredients());
+                    builder.requiresHeat(recipe.getRequiredHeat());
+                    builder.duration(recipe.getProcessingDuration());
+                    return builder.build();
+                });
+
+    }
+
+}

src/main/java/com/blamejared/createtweaker/handlers/CrushingRecipeHandler.java

@@ -0,0 +1,61 @@
+package com.blamejared.createtweaker.handlers;
+
+import com.blamejared.crafttweaker.api.item.IIngredient;
+import com.blamejared.crafttweaker.api.managers.IRecipeManager;
+import com.blamejared.crafttweaker.api.recipes.IRecipeHandler;
+import com.blamejared.crafttweaker.api.recipes.IReplacementRule;
+import com.blamejared.crafttweaker.api.recipes.ReplacementHandlerHelper;
+import com.blamejared.crafttweaker.impl.item.MCWeightedItemStack;
+import com.blamejared.createtweaker.CreateTweaker;
+import com.simibubi.create.AllRecipeTypes;
+import com.simibubi.create.content.contraptions.components.crusher.CrushingRecipe;
+import com.simibubi.create.content.contraptions.components.mixer.MixingRecipe;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeBuilder;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeSerializer;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@IRecipeHandler.For(CrushingRecipe.class)
+public class CrushingRecipeHandler implements IRecipeHandler<CrushingRecipe> {
+
+    @Override
+    public String dumpToCommandString(IRecipeManager iRecipeManager, CrushingRecipe recipe) {
+
+        return String.format("<recipetype:create:crushing>.addRecipe(\"%s\", [%s], %s, %s);",
+                recipe.getId(),
+                recipe.getRollableResults()
+                        .stream()
+                        .map(CreateTweaker::mapMutableProcessingResult)
+                        .map(MCWeightedItemStack::getCommandString)
+                        .collect(Collectors.joining(", ")),
+                IIngredient.fromIngredient(recipe.getIngredients().get(0)).getCommandString(),
+                recipe.getProcessingDuration()
+        );
+
+    }
+
+    @Override
+    public Optional<Function<ResourceLocation, CrushingRecipe>> replaceIngredients(IRecipeManager manager, CrushingRecipe recipe, List<IReplacementRule> rules) {
+
+        return ReplacementHandlerHelper.replaceNonNullIngredientList(
+                recipe.getIngredients(),
+                Ingredient.class,
+                recipe,
+                rules,
+                newIngredients -> id -> {
+                    ProcessingRecipeBuilder<CrushingRecipe> builder = new ProcessingRecipeBuilder<>(((ProcessingRecipeSerializer<CrushingRecipe>) AllRecipeTypes.CRUSHING.getSerializer()).getFactory(), id);
+                    builder.withItemOutputs(recipe.getRollableResults());
+                    builder.withItemIngredients(newIngredients);
+                    builder.withFluidIngredients(recipe.getFluidIngredients());
+                    builder.requiresHeat(recipe.getRequiredHeat());
+                    builder.duration(recipe.getProcessingDuration());
+                    return builder.build();
+                });
+    }
+
+}

src/main/java/com/blamejared/createtweaker/handlers/CuttingRecipeHandler.java

@@ -0,0 +1,61 @@
+package com.blamejared.createtweaker.handlers;
+
+import com.blamejared.crafttweaker.api.item.IIngredient;
+import com.blamejared.crafttweaker.api.managers.IRecipeManager;
+import com.blamejared.crafttweaker.api.recipes.IRecipeHandler;
+import com.blamejared.crafttweaker.api.recipes.IReplacementRule;
+import com.blamejared.crafttweaker.api.recipes.ReplacementHandlerHelper;
+import com.blamejared.crafttweaker.impl.item.MCWeightedItemStack;
+import com.blamejared.createtweaker.CreateTweaker;
+import com.simibubi.create.AllRecipeTypes;
+import com.simibubi.create.content.contraptions.components.crusher.CrushingRecipe;
+import com.simibubi.create.content.contraptions.components.saw.CuttingRecipe;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeBuilder;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeSerializer;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@IRecipeHandler.For(CuttingRecipe.class)
+public class CuttingRecipeHandler implements IRecipeHandler<CuttingRecipe> {
+
+    @Override
+    public String dumpToCommandString(IRecipeManager iRecipeManager, CuttingRecipe recipe) {
+
+        return String.format("<recipetype:create:cutting>.addRecipe(\"%s\", %s, %s, %s);",
+                recipe.getId(),
+                recipe.getRollableResults()
+                        .stream()
+                        .map(CreateTweaker::mapMutableProcessingResult)
+                        .map(MCWeightedItemStack::getCommandString)
+                        .collect(Collectors.joining(", ")),
+                IIngredient.fromIngredient(recipe.getIngredients().get(0)).getCommandString(),
+                recipe.getProcessingDuration()
+        );
+
+    }
+
+    @Override
+    public Optional<Function<ResourceLocation, CuttingRecipe>> replaceIngredients(IRecipeManager manager, CuttingRecipe recipe, List<IReplacementRule> rules) {
+
+        return ReplacementHandlerHelper.replaceNonNullIngredientList(
+                recipe.getIngredients(),
+                Ingredient.class,
+                recipe,
+                rules,
+                newIngredients -> id -> {
+                    ProcessingRecipeBuilder<CuttingRecipe> builder = new ProcessingRecipeBuilder<>(((ProcessingRecipeSerializer<CuttingRecipe>) AllRecipeTypes.CUTTING.getSerializer()).getFactory(), id);
+                    builder.withItemOutputs(recipe.getRollableResults());
+                    builder.withItemIngredients(newIngredients);
+                    builder.withFluidIngredients(recipe.getFluidIngredients());
+                    builder.requiresHeat(recipe.getRequiredHeat());
+                    builder.duration(recipe.getProcessingDuration());
+                    return builder.build();
+                });
+    }
+
+}

src/main/java/com/blamejared/createtweaker/handlers/DeployerApplicationRecipeHandler.java

@@ -0,0 +1,60 @@
+package com.blamejared.createtweaker.handlers;
+
+import com.blamejared.crafttweaker.api.item.IIngredient;
+import com.blamejared.crafttweaker.api.managers.IRecipeManager;
+import com.blamejared.crafttweaker.api.recipes.IRecipeHandler;
+import com.blamejared.crafttweaker.api.recipes.IReplacementRule;
+import com.blamejared.crafttweaker.api.recipes.ReplacementHandlerHelper;
+import com.blamejared.crafttweaker.impl.item.MCWeightedItemStack;
+import com.blamejared.createtweaker.CreateTweaker;
+import com.simibubi.create.AllRecipeTypes;
+import com.simibubi.create.content.contraptions.components.deployer.DeployerApplicationRecipe;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeBuilder;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeSerializer;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@IRecipeHandler.For(DeployerApplicationRecipe.class)
+public class DeployerApplicationRecipeHandler implements IRecipeHandler<DeployerApplicationRecipe> {
+
+    @Override
+    public String dumpToCommandString(IRecipeManager iRecipeManager, DeployerApplicationRecipe recipe) {
+
+        return String.format("<recipetype:create:deploying>.addRecipe(\"%s\", %s, %s, [%s]);",
+                recipe.getId(),
+                IIngredient.fromIngredient(recipe.getProcessedItem()).getCommandString(),
+                IIngredient.fromIngredient(recipe.getRequiredHeldItem()).getCommandString(),
+                recipe.getRollableResults()
+                        .stream()
+                        .map(CreateTweaker::mapMutableProcessingResult)
+                        .map(MCWeightedItemStack::getCommandString)
+                        .collect(Collectors.joining(", "))
+        );
+
+    }
+
+    @Override
+    public Optional<Function<ResourceLocation, DeployerApplicationRecipe>> replaceIngredients(IRecipeManager manager, DeployerApplicationRecipe recipe, List<IReplacementRule> rules) {
+
+        return ReplacementHandlerHelper.replaceNonNullIngredientList(
+                recipe.getIngredients(),
+                Ingredient.class,
+                recipe,
+                rules,
+                newIngredients -> id -> {
+                    ProcessingRecipeBuilder<DeployerApplicationRecipe> builder = new ProcessingRecipeBuilder<>(((ProcessingRecipeSerializer<DeployerApplicationRecipe>) AllRecipeTypes.DEPLOYING.getSerializer()).getFactory(), id);
+                    builder.withItemOutputs(recipe.getRollableResults());
+                    builder.withItemIngredients(newIngredients);
+                    builder.withFluidIngredients(recipe.getFluidIngredients());
+                    builder.requiresHeat(recipe.getRequiredHeat());
+                    builder.duration(recipe.getProcessingDuration());
+                    return builder.build();
+                });
+    }
+
+}

src/main/java/com/blamejared/createtweaker/handlers/EmptyingRecipeHandler.java

@@ -0,0 +1,57 @@
+package com.blamejared.createtweaker.handlers;
+
+import com.blamejared.crafttweaker.api.item.IIngredient;
+import com.blamejared.crafttweaker.api.managers.IRecipeManager;
+import com.blamejared.crafttweaker.api.recipes.IRecipeHandler;
+import com.blamejared.crafttweaker.api.recipes.IReplacementRule;
+import com.blamejared.crafttweaker.api.recipes.ReplacementHandlerHelper;
+import com.blamejared.crafttweaker.impl.fluid.MCFluidStackMutable;
+import com.blamejared.crafttweaker.impl.item.MCItemStackMutable;
+import com.simibubi.create.AllRecipeTypes;
+import com.simibubi.create.content.contraptions.processing.EmptyingRecipe;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeBuilder;
+import com.simibubi.create.content.contraptions.processing.ProcessingRecipeSerializer;
+import net.minecraft.item.crafting.Ingredient;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fluids.FluidStack;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+@IRecipeHandler.For(EmptyingRecipe.class)
+public class EmptyingRecipeHandler implements IRecipeHandler<EmptyingRecipe> {
+
+    @Override
+    public String dumpToCommandString(IRecipeManager iRecipeManager, EmptyingRecipe recipe) {
+
+        return String.format("<recipetype:create:emptying>.addRecipe(\"%s\", %s, %s, %s);",
+                recipe.getId(),
+                new MCItemStackMutable(recipe.getResultItem()).getCommandString(),
+                new MCFluidStackMutable(recipe.getFluidResults()
+                        .isEmpty() ? FluidStack.EMPTY : recipe.getResultingFluid()).getCommandString(),
+                IIngredient.fromIngredient(recipe.getIngredients().get(0)).getCommandString()
+        );
+
+    }
+
+    @Override
+    public Optional<Function<ResourceLocation, EmptyingRecipe>> replaceIngredients(IRecipeManager manager, EmptyingRecipe recipe, List<IReplacementRule> rules) {
+
+        return ReplacementHandlerHelper.replaceNonNullIngredientList(
+                recipe.getIngredients(),
+                Ingredient.class,
+                recipe,
+                rules,
+                newIngredients -> id -> {
+                    ProcessingRecipeBuilder<EmptyingRecipe> builder = new ProcessingRecipeBuilder<>(((ProcessingRecipeSerializer<EmptyingRecipe>) AllRecipeTypes.EMPTYING.getSerializer()).getFactory(), id);
+                    builder.withItemOutputs(recipe.getRollableResults());
+                    builder.withItemIngredients(newIngredients);
+                    builder.withFluidIngredients(recipe.getFluidIngredients());
+                    builder.requiresHeat(recipe.getRequiredHeat());
+                    builder.duration(recipe.getProcessingDuration());
+                    return builder.build();
+                });
+    }
+
+}