Tinker's Construct manuals, Dreamcraft edition (#797)

* Loading TiCo manuals in postinitialization to fix the font not being registered.

* Decouple ShapedUniversalRecipe from boot loader

* Added Recipe interface to represent any set of recipe arguments for use with recipe registries.

* Added recipe resolving and flattening to Recipe

* Added MantleManualRecipeRegistry

* Added TiCo manuals to lang files unmodified

* Added GT items required for seared bricks to Materials and You: Volume 1

* Updated oreberry description in Materials and You: Volume 1

* Removed unused content from manuals

* Adjusted TiCo manual recipes

* Adjusted TiCo manual text

* Updated cast description

* Replace Paper Stack recipe in TiCo manuals

* Redirected certain TiCo manual recipes to the Thauminomicon

* Updated Materials and You: Volume 2 intro

* Override Stencil Table recipe definition to not have lava fences

* Ingredients flattener doesn't need to be public at this time

* Reusing a safe missing item constant

* Lock down member visibility in the recipes package

* Documented usage of package private classes

* Made GameRegistryProxy partially public

Author: YannickMG

src/main/java/com/dreammaster/gthandler/GT_CraftingRecipeLoader.java

@@ -1,14 +1,37 @@
 package com.dreammaster.gthandler;
 
-import static gregtech.api.enums.Mods.*;
+import static gregtech.api.enums.Mods.AdventureBackpack;
+import static gregtech.api.enums.Mods.BartWorks;
+import static gregtech.api.enums.Mods.BuildCraftFactory;
+import static gregtech.api.enums.Mods.Chisel;
+import static gregtech.api.enums.Mods.Computronics;
+import static gregtech.api.enums.Mods.ExtraUtilities;
+import static gregtech.api.enums.Mods.Forestry;
+import static gregtech.api.enums.Mods.GalacticraftCore;
+import static gregtech.api.enums.Mods.GalacticraftMars;
+import static gregtech.api.enums.Mods.GalaxySpace;
+import static gregtech.api.enums.Mods.GoodGenerator;
+import static gregtech.api.enums.Mods.IguanaTweaksTinkerConstruct;
+import static gregtech.api.enums.Mods.IndustrialCraft2;
+import static gregtech.api.enums.Mods.NewHorizonsCoreMod;
+import static gregtech.api.enums.Mods.OpenComputers;
+import static gregtech.api.enums.Mods.OpenPrinters;
+import static gregtech.api.enums.Mods.ProjectRedIllumination;
+import static gregtech.api.enums.Mods.Railcraft;
+import static gregtech.api.enums.Mods.TinkerConstruct;
+import static gregtech.api.enums.Mods.ZTones;
 import static gregtech.api.enums.OrePrefixes.screw;
 import static gregtech.api.util.GT_ModHandler.RecipeBits.DELETE_ALL_OTHER_RECIPES;
 
+import java.util.function.Consumer;
+
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
 import net.minecraft.item.ItemStack;
 
 import com.dreammaster.main.NHItems;
+import com.dreammaster.mantle.MantleManualRecipeRegistry;
+import com.dreammaster.recipes.Recipe;
 import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry;
 import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
 
@@ -29,6 +52,7 @@
 
 public class GT_CraftingRecipeLoader extends gregtech.loaders.postload.GT_CraftingRecipeLoader implements Runnable {
 
+    private static final MantleManualRecipeRegistry MANTLE = MantleManualRecipeRegistry.getInstance();
     private static final String aTextMachineBeta = "machine.beta";
     private static final String aTextMachineAlpha = "machine.alpha";
     private static final String aTextIron1 = "X X";
@@ -746,22 +770,24 @@ public void run() {
                 new Object[] { new ItemStack(Items.clay_ball, 1, 0),
                         new ItemStack(NHItems.WOODEN_BRICK_FORM.get(), 1, GT_Values.W) });
         if (TinkerConstruct.isModLoaded()) {
-            GT_ModHandler.addShapelessCraftingRecipe(
+            Recipe.of(
                     new ItemStack(NHItems.WOODEN_BRICK_FORM.get(), 1, GT_Values.W),
-                    GT_ModHandler.RecipeBits.NOT_REMOVABLE,
-                    new Object[] { ToolDictNames.craftingToolKnife,
-                            GT_ModHandler.getModItem(aTextTConstruct, "blankPattern", 1L, 0) });
+                    ToolDictNames.craftingToolKnife,
+                    GT_ModHandler.getModItem(aTextTConstruct, "blankPattern", 1L, 0))
+                    .provideTo(shapelessUnremovableGtRecipes())
+                    .provideTo(MANTLE.manualShapedCraftingRecipeNamed("woodenformbrick"));
             GT_ModHandler.addCraftingRecipe(
                     CustomItemList.UnfiredSearedBrick.get(8L),
                     GT_ModHandler.RecipeBits.NOT_REMOVABLE,
                     new Object[] { "GGG", "GFG", "GGG", 'G',
                             GT_ModHandler.getModItem(aTextTConstruct, "CraftedSoil", 1L, 1), 'F',
                             new ItemStack(NHItems.WOODEN_BRICK_FORM.get(), 1, GT_Values.W) });
-            GT_ModHandler.addShapelessCraftingRecipe(
+            Recipe.of(
                     CustomItemList.UnfiredSearedBrick.get(1L),
-                    GT_ModHandler.RecipeBits.NOT_REMOVABLE,
-                    new Object[] { GT_ModHandler.getModItem(aTextTConstruct, "CraftedSoil", 1L, 1),
-                            new ItemStack(NHItems.WOODEN_BRICK_FORM.get(), 1, GT_Values.W) });
+                    GT_ModHandler.getModItem(aTextTConstruct, "CraftedSoil", 1L, 1),
+                    new ItemStack(NHItems.WOODEN_BRICK_FORM.get(), 1, GT_Values.W))
+                    .provideTo(shapelessUnremovableGtRecipes())
+                    .provideTo(MANTLE.manualShapedCraftingRecipeNamed("unfiredsearedbrick"));
             GT_ModHandler.addCraftingRecipe(
                     CustomItemList.UnfiredSlimeSoulBrick.get(8L),
                     GT_ModHandler.RecipeBits.NOT_REMOVABLE,
@@ -1822,4 +1848,11 @@ public void run() {
                     new Object[] { "  C", "W  ", "   ", 'W', ToolDictNames.craftingToolKnife, 'C', aBlankClayCast });
         }
     }
+
+    private Consumer<Recipe> shapelessUnremovableGtRecipes() {
+        return craft -> GT_ModHandler.addShapelessCraftingRecipe(
+                craft.getResult(),
+                GT_ModHandler.RecipeBits.NOT_REMOVABLE,
+                craft.getIngredients());
+    }
 }

src/main/java/com/dreammaster/main/MainRegistry.java

@@ -72,6 +72,7 @@
 import com.dreammaster.recipes.RecipeRemover;
 import com.dreammaster.scripts.ScriptLoader;
 import com.dreammaster.thaumcraft.TCLoader;
+import com.dreammaster.tinkersConstruct.TiCoLoader;
 import com.dreammaster.witchery.WitcheryPlugin;
 import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
 
@@ -485,6 +486,8 @@ public void PostLoad(FMLPostInitializationEvent PostEvent) {
         }
 
         if (Thaumcraft.isModLoaded()) TCLoader.run();
+
+        if (TinkerConstruct.isModLoaded()) TiCoLoader.doPostInitialization();
     }
 
     @Mod.EventHandler

src/main/java/com/dreammaster/mantle/BookDataReader.java

@@ -14,6 +14,8 @@
 /**
  * This class doesn't support loading different XML documents based on Minecraft's currently configured language. Books
  * are instead intended to be translated through lang files.
+ * <p>
+ * This is an implementation class. Use it through BookLoader::of
  */
 class BookDataReader {
 

src/main/java/com/dreammaster/mantle/BookDataStoreProxy.java

@@ -10,6 +10,8 @@
 
 /**
  * This class helps us avoid issues with books already loaded by another mod.
+ * <p>
+ * Implementation class. Use it through BookLoader::of
  */
 class BookDataStoreProxy {
 

src/main/java/com/dreammaster/mantle/MantleBookLoader.java

@@ -13,6 +13,9 @@
 import gregtech.api.interfaces.internal.IGT_Mod;
 import mantle.books.BookData;
 
+/**
+ * Implementation class. Use it through BookLoader::of
+ */
 final class MantleBookLoader implements BookLoader {
 
     private static final BookDataReader BOOK_DATA_READER = new BookDataReader();

src/main/java/com/dreammaster/mantle/MantleClientRegistryProxy.java

@@ -0,0 +1,64 @@
+package com.dreammaster.mantle;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+
+import com.dreammaster.recipes.Recipe;
+import com.dreammaster.recipes.ShapedIngredientsResolver;
+import com.dreammaster.recipes.ShapelessIngredientsResolver;
+
+import mantle.lib.client.MantleClientRegistry;
+
+/**
+ * Implementation class. Access it through MantleManualRecipeRegistry::getInstance
+ */
+class MantleClientRegistryProxy implements MantleManualRecipeRegistry {
+
+    private static final UnaryOperator<Object[]> SHAPED_INGREDIENTS_RESOLVER = new ShapedIngredientsResolver();
+    private static final UnaryOperator<Object[]> SHAPELESS_INGREDIENTS_RESOLVER = new ShapelessIngredientsResolver();
+
+    @Override
+    @Nonnull
+    public Consumer<Recipe> manualShapedCraftingRecipeNamed(String manualRecipeName) {
+        Objects.requireNonNull(manualRecipeName);
+        return (recipe) -> setTicoManualRecipe(
+                manualRecipeName,
+                recipe.getResult(),
+                recipe.flattenWith(SHAPED_INGREDIENTS_RESOLVER));
+    }
+
+    @Nonnull
+    @Override
+    public Consumer<Recipe> manualShapelessCraftingRecipeNamed(String manualRecipeName) {
+        Objects.requireNonNull(manualRecipeName);
+        return (recipe) -> setTicoManualRecipe(
+                manualRecipeName,
+                recipe.getResult(),
+                recipe.flattenWith(SHAPELESS_INGREDIENTS_RESOLVER));
+    }
+
+    private void setTicoManualRecipe(String name, ItemStack result, ItemStack[] recipe) {
+        if (recipe.length <= 4) {
+            MantleClientRegistry.registerManualSmallRecipe(name, result, Arrays.copyOf(recipe, 4));
+        } else if (recipe.length <= 9) {
+            MantleClientRegistry.registerManualLargeRecipe(name, result, Arrays.copyOf(recipe, 9));
+        } else {
+            throw new IllegalArgumentException("Recipe has too many ingredients: " + Arrays.toString(recipe));
+        }
+    }
+
+    @Override
+    @Nonnull
+    public Consumer<Recipe> manualSmeltingRecipeNamed(String manualRecipeName) {
+        Objects.requireNonNull(manualRecipeName);
+        return (recipe) -> MantleClientRegistry
+                .registerManualFurnaceRecipe(manualRecipeName, recipe.getResult(), recipe.flatten()[0]);
+    }
+
+}

src/main/java/com/dreammaster/mantle/MantleManualRecipeRegistry.java

@@ -0,0 +1,24 @@
+package com.dreammaster.mantle;
+
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+
+import com.dreammaster.recipes.Recipe;
+
+public interface MantleManualRecipeRegistry {
+
+    @Nonnull
+    static MantleManualRecipeRegistry getInstance() {
+        return new MantleClientRegistryProxy();
+    }
+
+    @Nonnull
+    Consumer<Recipe> manualShapedCraftingRecipeNamed(String manualRecipeName);
+
+    @Nonnull
+    Consumer<Recipe> manualShapelessCraftingRecipeNamed(String manualRecipeName);
+
+    @Nonnull
+    Consumer<Recipe> manualSmeltingRecipeNamed(String manualRecipeName);
+}

src/main/java/com/dreammaster/recipes/IngredientsFlattener.java

@@ -0,0 +1,8 @@
+package com.dreammaster.recipes;
+
+import net.minecraft.item.ItemStack;
+
+interface IngredientsFlattener {
+
+    ItemStack[] flatten(Object[] ingredients);
+}

src/main/java/com/dreammaster/recipes/Recipe.java

@@ -0,0 +1,32 @@
+package com.dreammaster.recipes;
+
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+
+public interface Recipe {
+
+    @Nonnull
+    static Recipe of(@Nonnull ItemStack result, @Nonnull Object... ingredients) {
+        return new RecipeArgs(result, ingredients);
+    }
+
+    @Nonnull
+    ItemStack getResult();
+
+    @Nonnull
+    Object[] getIngredients();
+
+    @Nonnull
+    Recipe provideTo(@Nonnull Consumer<Recipe> recipeUser);
+
+    @Nonnull
+    ItemStack[] flatten();
+
+    @Nonnull
+    ItemStack[] flattenWith(UnaryOperator<Object[]> ingredientsResolver);
+
+}

src/main/java/com/dreammaster/recipes/RecipeArgs.java

@@ -0,0 +1,101 @@
+package com.dreammaster.recipes;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+
+/**
+ * Implementation class. Access it through Recipe::of
+ */
+class RecipeArgs implements Recipe {
+
+    // Hardcoded dependency for now
+    private final UnaryOperator<Object[]> defaultIngredientsResolver = new ShapedIngredientsResolver();
+    // Hardcoded dependency for now
+    private final IngredientsFlattener ingredientsFlattener = new ResolvedIngredientsFlattener();
+
+    protected final ItemStack result;
+    protected final Object[] ingredients;
+    private Object[] resolvedIngredients;
+
+    RecipeArgs(ItemStack result, Object... ingredients) {
+        if (Objects.isNull(result)) throw new NullPointerException("Craft created with null result!");
+        if (Objects.isNull(ingredients)) throw new NullPointerException("Craft created with null ingredients!");
+        if (ingredients.length == 0) throw new IllegalArgumentException("Craft created with no ingredients!");
+        this.result = result.copy();
+        this.ingredients = Arrays.copyOf(ingredients, ingredients.length);
+    }
+
+    /**
+     * Flattens the recipe to only have up to one ItemStack per slot.
+     *
+     * @return A non-empty array of ItemStack or null values.
+     */
+    @Nonnull
+    @Override
+    public ItemStack[] flatten() {
+        return ingredientsFlattener.flatten(getResolvedIngredients());
+    }
+
+    /**
+     * Flattens the recipe to only have up to one ItemStack per slot.
+     * 
+     * @param ingredientsResolver Transforms the ingredients to only contain null, ItemStack or List&lt;ItemStack&gt;
+     * @return A non-empty array of ItemStack or null values.
+     */
+    @Nonnull
+    @Override
+    public ItemStack[] flattenWith(@Nonnull UnaryOperator<Object[]> ingredientsResolver) {
+        return ingredientsFlattener.flatten(ingredientsResolver.apply(ingredients));
+    }
+
+    private Object[] getResolvedIngredients() {
+        if (resolvedIngredients == null) {
+            resolvedIngredients = defaultIngredientsResolver.apply(ingredients);
+        }
+        return resolvedIngredients;
+    }
+
+    @Nonnull
+    @Override
+    public ItemStack getResult() {
+        return result;
+    }
+
+    @Nonnull
+    @Override
+    public Object[] getIngredients() {
+        return ingredients;
+    }
+
+    @Override
+    public @Nonnull Recipe provideTo(@Nonnull Consumer<Recipe> recipeUser) {
+        recipeUser.accept(this);
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return "Recipe{result=" + result + ", ingredients=" + Arrays.toString(ingredients) + '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RecipeArgs that = (RecipeArgs) o;
+        return result.isItemEqual(that.result) && Arrays.equals(ingredients, that.ingredients);
+    }
+
+    @Override
+    public int hashCode() {
+        int result1 = Objects.hash(result);
+        result1 = 31 * result1 + Arrays.hashCode(ingredients);
+        return result1;
+    }
+}