Shiny new JEI compatibility.

robotgryphon · robotgryphon · commit 8f94aeba76cd · 2020-12-05T21:24:56.000-05:00
diff --git a/src/main/java/com/robotgryphon/compactcrafting/blocks/FieldProjectorTile.java b/src/main/java/com/robotgryphon/compactcrafting/blocks/FieldProjectorTile.java
@@ -264,7 +264,7 @@ private void tickCrafting() {
                 return;
 
             // We grow the bounds check here a little to support patterns that are exactly the size of the field
-            List<ItemEntity> catalystEntities = getCatalystsInField(fieldBounds.grow(0.25), currentRecipe.catalyst.getItem());
+            List<ItemEntity> catalystEntities = getCatalystsInField(fieldBounds.grow(0.25), currentRecipe.getCatalyst().getItem());
             if (catalystEntities.size() > 0) {
                 // We dropped a catalyst item in
                 // At this point, we had a valid recipe and a valid catalyst entity
diff --git a/src/main/java/com/robotgryphon/compactcrafting/compat/jei/JeiMiniaturizationCraftingCategory.java b/src/main/java/com/robotgryphon/compactcrafting/compat/jei/JeiMiniaturizationCraftingCategory.java
@@ -0,0 +1,178 @@
+package com.robotgryphon.compactcrafting.compat.jei;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.robotgryphon.compactcrafting.CompactCrafting;
+import com.robotgryphon.compactcrafting.core.Registration;
+import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
+import mezz.jei.api.constants.VanillaTypes;
+import mezz.jei.api.gui.IRecipeLayout;
+import mezz.jei.api.gui.drawable.IDrawable;
+import mezz.jei.api.gui.drawable.IDrawableStatic;
+import mezz.jei.api.gui.ingredient.IGuiItemStackGroup;
+import mezz.jei.api.helpers.IGuiHelper;
+import mezz.jei.api.ingredients.IIngredients;
+import mezz.jei.api.recipe.category.IRecipeCategory;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.IFormattableTextComponent;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TranslationTextComponent;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class JeiMiniaturizationCraftingCategory implements IRecipeCategory<MiniaturizationRecipe> {
+
+    public static final ResourceLocation UID = new ResourceLocation(CompactCrafting.MOD_ID, "miniaturization");
+    private final IDrawable icon;
+    private IGuiHelper guiHelper;
+    private final IDrawableStatic background;
+    private final IDrawableStatic slotDrawable;
+
+
+    public JeiMiniaturizationCraftingCategory(IGuiHelper guiHelper) {
+        int width = (9 * 18) + 10;
+        int height = 10 + (18 * 3) + 5;
+
+        this.guiHelper = guiHelper;
+        this.background = guiHelper.createBlankDrawable(width, height);
+        this.slotDrawable = guiHelper.getSlotDrawable();
+        this.icon = guiHelper.createDrawableIngredient(new ItemStack(Registration.FIELD_PROJECTOR_BLOCK.get()));
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return UID;
+    }
+
+    @Override
+    public Class<? extends MiniaturizationRecipe> getRecipeClass() {
+        return MiniaturizationRecipe.class;
+    }
+
+    @Override
+    public String getTitle() {
+        return I18n.format(CompactCrafting.MOD_ID + ".jei.miniaturization.title");
+    }
+
+    @Override
+    public IDrawable getBackground() {
+        return background;
+    }
+
+    @Override
+    public IDrawable getIcon() {
+        return this.icon;
+    }
+
+    @Override
+    public void setIngredients(MiniaturizationRecipe recipe, IIngredients ing) {
+        List<ItemStack> inputs = new ArrayList<>();
+
+        for (String compKey : recipe.getComponentKeys()) {
+            Optional<BlockState> requiredBlock = recipe.getRecipeComponent(compKey);
+            requiredBlock.ifPresent(bs -> {
+                Item bi = Item.getItemFromBlock(bs.getBlock());
+                inputs.add(new ItemStack(bi));
+            });
+        }
+
+        inputs.add(recipe.getCatalyst());
+
+        ing.setInputs(VanillaTypes.ITEM, inputs);
+        ing.setOutputs(VanillaTypes.ITEM, Arrays.asList(recipe.getOutputs()));
+    }
+
+    @Override
+    public void setRecipe(IRecipeLayout recipeLayout, MiniaturizationRecipe recipe, IIngredients iIngredients) {
+
+        int GUTTER_X = 5;
+        int OFFSET_Y = 10;
+
+        IGuiItemStackGroup guiItemStacks = recipeLayout.getItemStacks();
+        int numComponentSlots = 18;
+
+        addMaterialSlots(recipe, GUTTER_X, OFFSET_Y, guiItemStacks, numComponentSlots);
+
+        int catalystSlot = addCatalystSlots(recipe, GUTTER_X, OFFSET_Y, guiItemStacks, numComponentSlots);
+
+        addOutputSlots(recipe, GUTTER_X, OFFSET_Y, guiItemStacks, numComponentSlots);
+
+        guiItemStacks.addTooltipCallback((slot, b, itemStack, tooltip) -> {
+            if (slot >= 0 && slot < recipe.getComponentKeys().size()) {
+                IFormattableTextComponent text =
+                        new TranslationTextComponent(CompactCrafting.MOD_ID + ".jei.miniaturization.component")
+                                .mergeStyle(TextFormatting.GRAY)
+                                .mergeStyle(TextFormatting.ITALIC);
+
+                tooltip.add(text);
+            }
+
+            if (slot == catalystSlot) {
+                IFormattableTextComponent text = new TranslationTextComponent(CompactCrafting.MOD_ID + ".jei.miniaturization.catalyst")
+                        .mergeStyle(TextFormatting.YELLOW)
+                        .mergeStyle(TextFormatting.ITALIC);
+
+                tooltip.add(text);
+            }
+        });
+    }
+
+    private int addCatalystSlots(MiniaturizationRecipe recipe, int GUTTER_X, int OFFSET_Y, IGuiItemStackGroup guiItemStacks, int numComponentSlots) {
+        int catalystSlot = numComponentSlots + 5 + 1;
+        guiItemStacks.init(catalystSlot, true, GUTTER_X, OFFSET_Y);
+        guiItemStacks.set(catalystSlot, recipe.getCatalyst());
+        guiItemStacks.setBackground(catalystSlot, slotDrawable);
+        return catalystSlot;
+    }
+
+    private void addMaterialSlots(MiniaturizationRecipe recipe, int GUTTER_X, int OFFSET_Y, IGuiItemStackGroup guiItemStacks, int numComponentSlots) {
+        for (int slot = 0; slot < numComponentSlots; slot++) {
+            int slotX = GUTTER_X + (slot % 9) * 18;
+            int slotY = (OFFSET_Y + 24) + ((slot / 9) * 18);
+
+            guiItemStacks.init(slot, true, slotX, slotY);
+            guiItemStacks.setBackground(slot, this.slotDrawable);
+        }
+
+        AtomicInteger inputOffset = new AtomicInteger();
+        recipe.getRecipeComponentTotals()
+                .entrySet()
+                .stream()
+                .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
+                .forEach((comp) -> {
+                    String component = comp.getKey();
+                    int required = comp.getValue();
+                    int finalInputOffset = inputOffset.get();
+
+                    BlockState bs = recipe.getRecipeComponent(component).get();
+                    Item bi = Item.getItemFromBlock(bs.getBlock());
+                    guiItemStacks.set(finalInputOffset, new ItemStack(bi, required));
+
+                    inputOffset.getAndIncrement();
+                });
+    }
+
+    private void addOutputSlots(MiniaturizationRecipe recipe, int GUTTER_X, int OFFSET_Y, IGuiItemStackGroup guiItemStacks, int numComponentSlots) {
+        int outputOffset = numComponentSlots;
+        for (int outputNum = 0; outputNum < 5; outputNum++) {
+            guiItemStacks.init(outputOffset + outputNum, false, GUTTER_X + (outputNum * 18) + (4 * 18), OFFSET_Y);
+            guiItemStacks.setBackground(outputOffset + outputNum, this.slotDrawable);
+        }
+
+        for (ItemStack output : recipe.getOutputs()) {
+            guiItemStacks.set(outputOffset, output);
+        }
+    }
+
+    @Override
+    public void draw(MiniaturizationRecipe recipe, MatrixStack mx, double mouseX, double mouseY) {
+        mx.push();
+        // mx.scale(3, 3, 1);
+        // this.getIcon().draw(mx, 7, 0);
+        mx.pop();
+    }
+}
diff --git a/src/main/java/com/robotgryphon/compactcrafting/compat/jei/JeiMiniaturizationPlugin.java b/src/main/java/com/robotgryphon/compactcrafting/compat/jei/JeiMiniaturizationPlugin.java
@@ -0,0 +1,38 @@
+package com.robotgryphon.compactcrafting.compat.jei;
+
+import com.robotgryphon.compactcrafting.CompactCrafting;
+import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
+import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipeManager;
+import mezz.jei.api.IModPlugin;
+import mezz.jei.api.JeiPlugin;
+import mezz.jei.api.registration.IGuiHandlerRegistration;
+import mezz.jei.api.registration.IRecipeCategoryRegistration;
+import mezz.jei.api.registration.IRecipeRegistration;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.Collection;
+
+@JeiPlugin
+public class JeiMiniaturizationPlugin implements IModPlugin {
+    @Override
+    public ResourceLocation getPluginUid() {
+        return new ResourceLocation(CompactCrafting.MOD_ID, "miniaturization_crafting");
+    }
+
+    @Override
+    public void registerCategories(IRecipeCategoryRegistration registration) {
+        registration.addRecipeCategories(new JeiMiniaturizationCraftingCategory(registration.getJeiHelpers().getGuiHelper()));
+    }
+
+    @Override
+    public void registerGuiHandlers(IGuiHandlerRegistration registration) {
+
+    }
+
+    @Override
+    public void registerRecipes(IRecipeRegistration registration) {
+        Collection<MiniaturizationRecipe> miniaturizationRecipes = MiniaturizationRecipeManager.getAll();
+
+        registration.addRecipes(miniaturizationRecipes, JeiMiniaturizationCraftingCategory.UID);
+    }
+}
diff --git a/src/main/java/com/robotgryphon/compactcrafting/recipes/MiniaturizationRecipe.java b/src/main/java/com/robotgryphon/compactcrafting/recipes/MiniaturizationRecipe.java
@@ -22,10 +22,10 @@ public class MiniaturizationRecipe {
 
     private ResourceLocation registryName;
     private IRecipeLayer[] layers;
-    public ItemStack catalyst;
-    public ItemStack[] outputs;
+    private ItemStack catalyst;
+    private ItemStack[] outputs;
     private AxisAlignedBB dimensions;
-
+    private Map<String, Integer> cachedComponentTotals;
     /**
      * Contains a mapping of all known components in the recipe.
      * Vanilla style; C = CHARCOAL_BLOCK
@@ -43,6 +43,7 @@ public MiniaturizationRecipe(ResourceLocation rl) {
 
     public void setLayers(IRecipeLayer[] layers) {
         this.layers = layers;
+        this.cachedComponentTotals = null;
         this.recalculateDimensions();
     }
 
@@ -53,7 +54,7 @@ private void recalculateDimensions() {
 
         for (IRecipeLayer layer : this.layers) {
             // We only need to worry about fixed-dimension layers; the fluid layers will adapt
-            if(layer instanceof IFixedLayerDimensions) {
+            if (layer instanceof IFixedLayerDimensions) {
                 AxisAlignedBB dimensions = ((IFixedLayerDimensions) layer).getDimensions();
                 if (dimensions.getXSize() > x)
                     x = (int) Math.ceil(dimensions.getXSize());
@@ -71,6 +72,7 @@ public boolean addComponent(String key, BlockState block) {
             return false;
 
         components.put(key, block);
+        this.cachedComponentTotals = null;
         return true;
     }
 
@@ -122,7 +124,7 @@ private boolean checkRotation(IWorldReader world, Rotation rot, AxisAlignedBB fi
 
             // If we have no layer definition do lighter processing
             // TODO: Consider changing the layers to a map so we can make air layers null/nonexistent
-            if(!layer.isPresent() && layerFilled.length > 0) {
+            if (!layer.isPresent() && layerFilled.length > 0) {
                 // We're being safe here - if there's no layer definition we assume the layer is all-air
                 return false;
             }
@@ -135,7 +137,7 @@ private boolean checkRotation(IWorldReader world, Rotation rot, AxisAlignedBB fi
                 return false;
 
             // Check the states are correct
-            for(BlockPos unrotatedPos : layerFilled) {
+            for (BlockPos unrotatedPos : layerFilled) {
                 BlockPos rotatedPos = layerRotated.get(unrotatedPos);
                 BlockPos normalizedRotatedPos = BlockSpaceUtil.normalizeLayerPosition(filledBounds, rotatedPos).down(offset);
 
@@ -145,14 +147,14 @@ private boolean checkRotation(IWorldReader world, Rotation rot, AxisAlignedBB fi
                 String requiredComponentKeyForPosition = l.getRequiredComponentKeyForPosition(normalizedRotatedPos);
                 Optional<String> recipeComponentKey = this.getRecipeComponentKey(actualState);
 
-                if(!recipeComponentKey.isPresent()) {
+                if (!recipeComponentKey.isPresent()) {
                     // At this point we don't have a lookup for the state that's at the position
                     // No match can be made here
                     return false;
                 }
 
                 boolean statesEqual = recipeComponentKey.get().equals(requiredComponentKeyForPosition);
-                if(!statesEqual)
+                if (!statesEqual)
                     return false;
             }
         }
@@ -164,6 +166,20 @@ public ItemStack[] getOutputs() {
         return outputs;
     }
 
+    public Map<String, Integer> getRecipeComponentTotals() {
+        if(this.cachedComponentTotals != null)
+            return this.cachedComponentTotals;
+
+        HashMap<String, Integer> totals = new HashMap<>();
+        this.components.keySet().forEach(comp -> {
+            int count = this.getComponentRequiredCount(comp);
+            totals.put(comp, count);
+        });
+
+        this.cachedComponentTotals = totals;
+        return totals;
+    }
+
     public Optional<BlockState> getRecipeComponent(String i) {
         if (this.components.containsKey(i)) {
             BlockState component = components.get(i);
@@ -173,6 +189,21 @@ public Optional<BlockState> getRecipeComponent(String i) {
         return Optional.empty();
     }
 
+    public int getComponentRequiredCount(String i) {
+        if (!this.components.containsKey(i))
+            return 0;
+
+        int required = 0;
+        for (IRecipeLayer layer : this.layers) {
+            Map<String, Integer> layerTotals = layer.getComponentTotals(this.dimensions);
+
+            if (layerTotals.containsKey(i))
+                required += layerTotals.get(i);
+        }
+
+        return required;
+    }
+
     public Optional<String> getRecipeComponentKey(BlockState state) {
         for (String comp : this.components.keySet()) {
             if (components.get(comp) == state)
@@ -211,7 +242,6 @@ public boolean areLayerPositionsCorrect(IRecipeLayer layer, AxisAlignedBB fieldF
 
         BlockPos[] fieldNormalizedPositionsFieldOffset = BlockSpaceUtil.normalizeLayerPositions(fieldFilledBounds, filledPositions);
 
-        // TODO: Make recipe loading respect multiple layers as Y=0, 1, etc
         int extraYOffset = fieldNormalizedPositionsFieldOffset[0].getY();
 
         // We'll need an extra offset layer to match against the recipe layer's Y=0
@@ -237,6 +267,10 @@ public ResourceLocation getRegistryName() {
         return registryName;
     }
 
+    public Set<String> getComponentKeys() {
+        return this.components.keySet();
+    }
+
     public void addOutput(ItemStack itemStack) {
         List<ItemStack> oTmp = new ArrayList<>(Arrays.asList(this.outputs));
         oTmp.add(itemStack);
@@ -247,4 +281,16 @@ public void addOutput(ItemStack itemStack) {
     public int getNumberComponents() {
         return this.components.size();
     }
+
+    public Map<String, BlockState> getComponents() {
+        return this.components;
+    }
+
+    public ItemStack getCatalyst() {
+        return this.catalyst;
+    }
+
+    public void setCatalyst(ItemStack c) {
+        this.catalyst = c;
+    }
 }
diff --git a/src/main/java/com/robotgryphon/compactcrafting/recipes/json/MiniaturizationPatternLoader.java b/src/main/java/com/robotgryphon/compactcrafting/recipes/json/MiniaturizationPatternLoader.java
@@ -104,7 +104,7 @@ private boolean loadCatalyst(MiniaturizationRecipe recipe, JsonObject root) {
             c.setCount(1);
         }
 
-        recipe.catalyst = c;
+        recipe.setCatalyst(c);
 
         return true;
     }
diff --git a/src/main/resources/assets/compactcrafting/lang/en_us.json b/src/main/resources/assets/compactcrafting/lang/en_us.json

Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ private boolean loadCatalyst(MiniaturizationRecipe recipe, JsonObject root) {`
`104`	`104`	`c.setCount(1);`
`105`	`105`	`}`
`106`	`106`
`107`		`- recipe.catalyst = c;`
	`107`	`+ recipe.setCatalyst(c);`
`108`	`108`
`109`	`109`	`return true;`
`110`	`110`	`}`