Add recipes for clearing facades

src/main/java/org/cyclops/integrateddynamics/blockentity/BlockEntityMechanicalSqueezer.java

@@ -142,7 +142,7 @@ public int getRecipeDuration(RecipeMechanicalSqueezer recipe) {
     protected boolean finalizeRecipe(RecipeMechanicalSqueezer recipe, boolean simulate) {
         // Output items
         NonNullList<ItemStack> outputStacks = NonNullList.create();
-        for (RecipeSqueezer.IngredientChance itemStackChance : recipe.getOutputItems()) {
+        for (RecipeSqueezer.IngredientChance itemStackChance : recipe.assemble(getInventory().getItem(SLOT_INPUT))) {
             ItemStack outputStack = itemStackChance.getIngredientFirst().copy();
             if (!outputStack.isEmpty() && (simulate || itemStackChance.getChance() == 1.0F
                     || itemStackChance.getChance() >= getLevel().random.nextFloat())) {

src/main/java/org/cyclops/integrateddynamics/blockentity/BlockEntitySqueezer.java

@@ -161,9 +161,10 @@ protected void update(Level level, BlockPos pos, BlockState blockState, BlockEnt
                     Optional<RecipeSqueezer> recipeOptional = blockEntity.getCurrentRecipe();
                     if (recipeOptional.isPresent()) {
                         RecipeSqueezer recipe = recipeOptional.get();
+                        ItemStack oldItem = blockEntity.getInventory().getItem(0);
                         blockEntity.getInventory().setItem(0, ItemStack.EMPTY);
-                        for (RecipeSqueezer.IngredientChance itemStackChance : recipe.getOutputItems()) {
-                            if (itemStackChance.getChance() == 1.0F || itemStackChance.getChance() >= level.random.nextFloat()) {
+                        for (RecipeSqueezer.IngredientChance itemStackChance : recipe.assemble(oldItem)) {
+                        if (itemStackChance.getChance() == 1.0F || itemStackChance.getChance() >= level.random.nextFloat()) {
                                 ItemStack resultStack = itemStackChance.getIngredientFirst().copy();
                                 for (Direction side : Direction.values()) {
                                     if (!resultStack.isEmpty() && side != Direction.UP) {

src/main/java/org/cyclops/integrateddynamics/core/recipe/type/FacadeSqueezeCalculator.java

@@ -0,0 +1,36 @@
+package org.cyclops.integrateddynamics.core.recipe.type;
+
+import org.cyclops.cyclopscore.recipe.ItemStackFromIngredient;
+import org.cyclops.integrateddynamics.RegistryEntries;
+import org.cyclops.integrateddynamics.core.recipe.type.RecipeSqueezer.IngredientChance;
+
+import com.mojang.datafixers.util.Either;
+
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.registries.ForgeRegistries;
+
+public class FacadeSqueezeCalculator {
+
+    public static NonNullList<IngredientChance> getOutputItems(ItemStack inputItem) {
+        ItemStack facadeItemStack = new ItemStack(RegistryEntries.ITEM_FACADE);
+
+        facadeItemStack.setTag(null);
+        Either<ItemStack, ItemStackFromIngredient> facadeEither = Either.left(facadeItemStack);
+        IngredientChance facade = new IngredientChance(facadeEither, 1.0F);
+
+        CompoundTag nbt = inputItem.getOrCreateTag();
+        ResourceLocation resourceLocation = new ResourceLocation(nbt.getCompound("block").getString("Name"));
+        Item item = ForgeRegistries.ITEMS.getValue(resourceLocation);
+
+        if (resourceLocation.toString().equals("minecraft:")) return NonNullList.of(facade, facade); // NBT is either malformed or non-existent
+
+        Either<ItemStack, ItemStackFromIngredient> itemStack = Either.left(new ItemStack(item));
+        IngredientChance combinedBlock = new IngredientChance(itemStack, 1.0F);
+
+        return NonNullList.of(facade, facade, combinedBlock);
+    }
+}

src/main/java/org/cyclops/integrateddynamics/core/recipe/type/RecipeSqueezer.java

@@ -61,6 +61,11 @@ public ItemStack assemble(Container inv) {
         return this.outputItems.get(0).getIngredientFirst().copy();
     }
 
+    public NonNullList<IngredientChance> assemble(ItemStack inputItem) {
+        if (!inputItem.is(RegistryEntries.ITEM_FACADE.asItem())) return getOutputItems();
+        return FacadeSqueezeCalculator.getOutputItems(inputItem);
+    }
+
     @Override
     public boolean canCraftInDimensions(int width, int height) {
         return width * height <= 1;

src/main/resources/data/integrateddynamics/recipes/mechanical_squeezer/convenience/mechanical_facade_squeeze.json

@@ -0,0 +1,19 @@
+{
+  "type": "integrateddynamics:mechanical_squeezer",
+  "item": "integrateddynamics:facade",
+  "result": {
+	"items": [
+	      {
+	        "item": "integrateddynamics:facade",
+			"chance": 1,
+			"count": 1
+	      },
+		  {
+		    "item": "integrateddynamics:facade",
+		    "chance": 1,
+		    "count": 1
+		  }
+	    ]
+  },
+  "duration": 20
+}

src/main/resources/data/integrateddynamics/recipes/special/facade_clear.json

@@ -0,0 +1,4 @@
+{
+  "type": "integrateddynamics:crafting_special_nbt_clear",
+  "item": "integrateddynamics:facade"
+}

src/main/resources/data/integrateddynamics/recipes/squeezer/convenience/facade_squeeze.json

@@ -0,0 +1,18 @@
+{
+  "type": "integrateddynamics:squeezer",
+  "item": "integrateddynamics:facade",
+  "result": {
+    "items": [
+      {
+        "item": "integrateddynamics:facade",
+		"chance": 1,
+		"count": 1
+      },
+	  {
+	    "item": "integrateddynamics:facade",
+	    "chance": 1,
+	    "count": 1
+	  }
+    ]
+  }
+}