diff --git a/build.gradle b/build.gradle index 59a955c..e83de69 100644 --- a/build.gradle +++ b/build.gradle @@ -159,9 +159,11 @@ dependencies { compileOnly fg.deobf("dev.architectury:architectury-forge:9.2.14") compileOnly fg.deobf("me.shedaniel:RoughlyEnoughItems-forge:12.1.785") + compileOnly fg.deobf("me.shedaniel.cloth:cloth-config-forge:11.1.136") if (enableREI) { runtimeOnly fg.deobf("dev.architectury:architectury-forge:9.2.14") runtimeOnly fg.deobf("me.shedaniel:RoughlyEnoughItems-forge:12.1.785") + runtimeOnly fg.deobf("me.shedaniel.cloth:cloth-config-forge:11.1.136") } } diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/EXAREIClientPlugin.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/EXAREIClientPlugin.java new file mode 100644 index 0000000..2faf7b5 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/EXAREIClientPlugin.java @@ -0,0 +1,91 @@ +package com.rempler.exnihiloadditions.compat.rei; + +import me.shedaniel.rei.api.client.plugins.REIClientPlugin; +import me.shedaniel.rei.api.client.registry.category.CategoryRegistry; +import me.shedaniel.rei.api.client.registry.display.DisplayRegistry; +import me.shedaniel.rei.api.common.util.EntryStacks; +import me.shedaniel.rei.forge.REIPluginClient; +import net.minecraft.world.item.Item; +import com.rempler.exnihiloadditions.compat.rei.compost.CompostRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.compost.CompostRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.crushing.CrushingRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.crushing.CrushingRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.harvest.HarvestRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.harvest.HarvestRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.heat.HeatRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.heat.HeatRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.melting.MeltingRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.melting.MeltingRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.precipitate.PrecipitateRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.precipitate.PrecipitateRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.sifting.SiftingRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.sifting.SiftingRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.solidifying.SolidifyingRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.solidifying.SolidifyingRecipeDisplay; +import com.rempler.exnihiloadditions.compat.rei.transition.TransitionRecipeCategory; +import com.rempler.exnihiloadditions.compat.rei.transition.TransitionRecipeDisplay; +import novamachina.exnihilosequentia.world.item.EXNItems; +import novamachina.exnihilosequentia.world.item.crafting.CompostRecipe; +import novamachina.exnihilosequentia.world.item.crafting.CrushingRecipe; +import novamachina.exnihilosequentia.world.item.crafting.EXNRecipeTypes; +import novamachina.exnihilosequentia.world.item.crafting.HarvestRecipe; +import novamachina.exnihilosequentia.world.item.crafting.HeatRecipe; +import novamachina.exnihilosequentia.world.item.crafting.MeltingRecipe; +import novamachina.exnihilosequentia.world.item.crafting.PrecipitateRecipe; +import novamachina.exnihilosequentia.world.item.crafting.SiftingRecipe; +import novamachina.exnihilosequentia.world.item.crafting.SolidifyingRecipe; +import novamachina.exnihilosequentia.world.item.crafting.TransitionRecipe; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; +import novamachina.novacore.world.item.ItemDefinition; + +//@REIPluginClient +public class EXAREIClientPlugin implements REIClientPlugin { + + public void registerCategories(CategoryRegistry registry) { + registry.add(new CompostRecipeCategory()); + registry.add(new CrushingRecipeCategory()); + registry.add(new HarvestRecipeCategory()); + registry.add(new HeatRecipeCategory()); + registry.add(new MeltingRecipeCategory()); + registry.add(new PrecipitateRecipeCategory()); + registry.add(new SiftingRecipeCategory()); + registry.add(new SolidifyingRecipeCategory()); + registry.add(new TransitionRecipeCategory()); + + for (ItemDefinition item : EXNBlocks.getDefinitions()) { + if (item.getEnglishName().toLowerCase().contains("barrel")) { + registry.addWorkstations(CompostRecipeCategory.COMPOSTING, EntryStacks.of(item)); + registry.addWorkstations(PrecipitateRecipeCategory.PRECIPITATE, EntryStacks.of(item)); + registry.addWorkstations(SolidifyingRecipeCategory.SOLIDIFY, EntryStacks.of(item)); + registry.addWorkstations(TransitionRecipeCategory.TRANSITION, EntryStacks.of(item)); + } + if (item.getEnglishName().toLowerCase().contains("crucible")) { + registry.addWorkstations(MeltingRecipeCategory.MELTING, EntryStacks.of(item)); + registry.addWorkstations(HeatRecipeCategory.HEATING, EntryStacks.of(item)); + } + if (item.getEnglishName().toLowerCase().contains("sieve")) { + registry.addWorkstations(SiftingRecipeCategory.SIFTING, EntryStacks.of(item)); + } + } + for (ItemDefinition item : EXNItems.getDefinitions()) { + if (item.getEnglishName().toLowerCase().contains("hammer")) { + registry.addWorkstations(CrushingRecipeCategory.CRUSHING, EntryStacks.of(item)); + } + if (item.getEnglishName().toLowerCase().contains("crook")) { + registry.addWorkstations(HarvestRecipeCategory.HARVESTING, EntryStacks.of(item)); + } + } + } + + public void registerDisplays(DisplayRegistry registry) { + registry.registerRecipeFiller(CompostRecipe.class, EXNRecipeTypes.COMPOST, CompostRecipeDisplay::new); + registry.registerRecipeFiller(CrushingRecipe.class, EXNRecipeTypes.CRUSHING, CrushingRecipeDisplay::new); + registry.registerRecipeFiller(HarvestRecipe.class, EXNRecipeTypes.HARVEST, HarvestRecipeDisplay::new); + registry.registerRecipeFiller(HeatRecipe.class, EXNRecipeTypes.HEAT, HeatRecipeDisplay::new); + registry.registerRecipeFiller(MeltingRecipe.class, EXNRecipeTypes.MELTING, MeltingRecipeDisplay::new); + registry.registerRecipeFiller(PrecipitateRecipe.class, EXNRecipeTypes.PRECIPITATE, PrecipitateRecipeDisplay::new); + registry.registerRecipeFiller(SiftingRecipe.class, EXNRecipeTypes.SIFTING, SiftingRecipeDisplay::new); + registry.registerRecipeFiller(SolidifyingRecipe.class, EXNRecipeTypes.SOLIDIFYING, SolidifyingRecipeDisplay::new); + registry.registerRecipeFiller(TransitionRecipe.class, EXNRecipeTypes.TRANSITION, TransitionRecipeDisplay::new); + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/SimpleBasicDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/SimpleBasicDisplay.java new file mode 100644 index 0000000..a47d070 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/SimpleBasicDisplay.java @@ -0,0 +1,12 @@ +package com.rempler.exnihiloadditions.compat.rei; + +import me.shedaniel.rei.api.common.display.basic.BasicDisplay; +import me.shedaniel.rei.api.common.entry.EntryIngredient; + +import java.util.List; + +public abstract class SimpleBasicDisplay extends BasicDisplay { + public SimpleBasicDisplay(List inputs, List outputs) { + super(inputs, outputs); + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeCategory.java new file mode 100644 index 0000000..07a4114 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeCategory.java @@ -0,0 +1,90 @@ +package com.rempler.exnihiloadditions.compat.rei.compost; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.ItemStack; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.Config; +import novamachina.exnihilosequentia.common.registries.ExNihiloRegistries; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.crafting.CompostRecipe; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import java.util.Arrays; +import java.util.List; + +public class CompostRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "compost"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_mid.png"); + public static final CategoryIdentifier COMPOSTING = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return COMPOSTING; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.compost"); + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.OAK_BARREL); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 168, 166, 54)); + + EntryIngredient output = display.getOutputEntries().get(0); + for (CompostRecipe recipe : ExNihiloRegistries.COMPOST_REGISTRY.getRecipeList()) { + if (Arrays.stream(recipe.getInput().getItems()).toList().get(0).is(((ItemStack) display.getInputEntries().get(0).get(0).castValue()).getItem())) { + output.get(0).tooltip(Component.literal(String.format("Amount: %d / %d", recipe.getAmount(), Config.getBarrelMaxSolidAmount()))); + } + } + widgets.add(Widgets.createSlot(new Point(startPoint.x + 3, startPoint.y + 21)) + .entries(output).markOutput()); + + int rerolls = 1; + if (display.getInputEntries().size() > 21) { + rerolls = (int) Math.ceil(display.getInputEntries().size() / 21.0); + } + while (rerolls > 0) { + for (int xf = 0; xf < display.getInputEntries().size(); xf++) { + final int slotX = 39 + (xf % 7 * 18); + final int slotY = 3 + xf / 7 * 18; + widgets.add(Widgets.createSlot(new Point(startPoint.x + slotX, startPoint.y + slotY)) + .entries(display.getInputEntries().get(xf)).tooltipsEnabled(true).markInput()); + } + rerolls--; + } + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeDisplay.java new file mode 100644 index 0000000..0e9dc7f --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/compost/CompostRecipeDisplay.java @@ -0,0 +1,31 @@ +package com.rempler.exnihiloadditions.compat.rei.compost; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.world.item.Items; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.CompostRecipe; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class CompostRecipeDisplay extends SimpleBasicDisplay { + public CompostRecipeDisplay(CompostRecipe recipe) { + //TODO: should be changed if compost recipe will have different outputs! + super(getIngredients(recipe), Collections.singletonList(EntryIngredient.of(EntryStacks.of(Items.DIRT)))); + } + + private static List getIngredients(CompostRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.ofIngredient(recipe.getInput())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return CompostRecipeCategory.COMPOSTING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeCategory.java new file mode 100644 index 0000000..0bdd356 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeCategory.java @@ -0,0 +1,90 @@ +package com.rempler.exnihiloadditions.compat.rei.crushing; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.registries.ExNihiloRegistries; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.EXNItems; +import novamachina.exnihilosequentia.world.item.crafting.CrushingRecipe; +import novamachina.novacore.util.StringUtils; + +import javax.annotation.Nonnull; +import java.util.List; + +public class CrushingRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "crushing"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_mid.png"); + public static final CategoryIdentifier CRUSHING = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return CRUSHING; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.crushing"); + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNItems.HAMMER_WOOD); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 56, 166, 54)); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 11, startPoint.y + 39)) + .entries(display.getInputEntries().get(0)).markInput()); + + int rerolls = 1; + List list = display.getOutputEntries(); + if (list.size() > 21) { + rerolls = (int) Math.ceil(list.size() / 21.0); + } + while (rerolls > 0) { + for (int i = 0; i < list.size(); i++) { + final int slotX = 39 + (i % 7 * 18); + final int slotY = 3 + i / 7 * 18; + + @Nonnull final EntryIngredient outputStack = list.get(i); + CrushingRecipe recipeOptional = ExNihiloRegistries.HAMMER_REGISTRY.getRecipeList().get(i); + if (recipeOptional.getDrops().get(i).getChance() != 1.0) { + outputStack.get(i).tooltip(Component.literal(String.format( + "Chance: %s", StringUtils.formatPercent((recipeOptional.getDrops().get(i).getChance()))))); + } + widgets.add(Widgets.createSlot(new Point(startPoint.x + slotX, startPoint.y + slotY)) + .entries(outputStack).disableBackground().markOutput()); + } + rerolls--; + } + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeDisplay.java new file mode 100644 index 0000000..ff66324 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/crushing/CrushingRecipeDisplay.java @@ -0,0 +1,32 @@ +package com.rempler.exnihiloadditions.compat.rei.crushing; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.CrushingRecipe; +import novamachina.exnihilosequentia.world.item.crafting.ItemStackWithChance; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class CrushingRecipeDisplay extends SimpleBasicDisplay { + public CrushingRecipeDisplay(CrushingRecipe recipe) { + super(Collections.singletonList(EntryIngredient.of(EntryIngredients.ofIngredient(recipe.getInput()))), getIngredients(recipe)); + } + + + private static List getIngredients(CrushingRecipe recipe) { + List list = new ArrayList<>(); + for (ItemStackWithChance entry : recipe.getDrops()) { + list.add(EntryIngredients.of(entry.getStack())); + } + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return CrushingRecipeCategory.CRUSHING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeCategory.java new file mode 100644 index 0000000..8d8e953 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeCategory.java @@ -0,0 +1,88 @@ +package com.rempler.exnihiloadditions.compat.rei.harvest; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import com.rempler.exnihiloadditions.compat.rei.crushing.CrushingRecipeDisplay; +import novamachina.exnihilosequentia.common.registries.ExNihiloRegistries; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.EXNItems; +import novamachina.exnihilosequentia.world.item.crafting.HarvestRecipe; +import novamachina.novacore.util.StringUtils; + +import javax.annotation.Nonnull; +import java.util.List; + +public class HarvestRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "harvest"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_mid.png"); + public static final CategoryIdentifier HARVESTING = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return HARVESTING; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.harvest"); + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNItems.CROOK_WOOD); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 112, 166, 54)); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 11, startPoint.y + 39)) + .entries(display.getInputEntries().get(0)).markInput()); + + int rerolls = 1; + if (display.getInputEntries().size() > 21) { + rerolls = (int) Math.ceil(display.getInputEntries().size() / 21.0); + } + while (rerolls > 0) { + for (int i = 0; i < display.getOutputEntries().size(); i++) { + final int slotX = 39 + (i % 7 * 18); + final int slotY = 3 + i / 7 * 18; + + @Nonnull final EntryIngredient outputStack = display.getOutputEntries().get(i); + HarvestRecipe recipe = ExNihiloRegistries.CROOK_REGISTRY.getRecipeList().get(i); + outputStack.get(0).tooltip(Component.literal(String.format( + "Chance: %s", StringUtils.formatPercent(recipe.getDrops().get(i).getChance())))); + widgets.add(Widgets.createSlot(new Point(startPoint.x + slotX, startPoint.y + slotY)) + .entries(outputStack).disableBackground().markOutput()); + } + rerolls--; + } + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeDisplay.java new file mode 100644 index 0000000..1c08a2f --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/harvest/HarvestRecipeDisplay.java @@ -0,0 +1,31 @@ +package com.rempler.exnihiloadditions.compat.rei.harvest; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.HarvestRecipe; +import novamachina.exnihilosequentia.world.item.crafting.ItemStackWithChance; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class HarvestRecipeDisplay extends SimpleBasicDisplay { + public HarvestRecipeDisplay(HarvestRecipe recipe) { + super(Collections.singletonList(EntryIngredient.of(EntryIngredients.ofIngredient(recipe.getInput()))), getIngredients(recipe)); + } + + private static List getIngredients(HarvestRecipe recipe) { + List list = new ArrayList<>(); + for (ItemStackWithChance entry : recipe.getDrops()) { + list.add(EntryIngredients.of(entry.getStack())); + } + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return HarvestRecipeCategory.HARVESTING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeCategory.java new file mode 100644 index 0000000..a790276 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeCategory.java @@ -0,0 +1,89 @@ +package com.rempler.exnihiloadditions.compat.rei.heat; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.BlockItem; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.Items; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.Blocks; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.registries.ExNihiloRegistries; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.crafting.HeatRecipe; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.List; + +public class HeatRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "heat"); + public static final ResourceLocation texture = new ResourceLocation( + "roughlyenoughitems", "textures/gui/display.png"); + public static final CategoryIdentifier HEATING = CategoryIdentifier.of(UID); + + @Nullable + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.FIRED_CRUCIBLE); + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return HEATING; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.heat"); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 9, bounds.getCenterY() - 7); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 74, 18, 34)); + widgets.add(Widgets.createSlot(new Point(startPoint.x + 1, startPoint.y - 18)) + .entries(EntryIngredients.of(EXNBlocks.FIRED_CRUCIBLE))); + widgets.add(Widgets.createBurningFire(new Point(startPoint.x + 1, startPoint.y)) + .animationDurationTicks(60 * 5)); + EntryIngredient ingredient = display.getInputEntries().get(0); + + HeatRecipe recipe = ExNihiloRegistries.HEAT_REGISTRY.getRecipeList().get(0); + + ingredient.get(0).tooltip(Component.literal(recipe.getAmount() + "X")); + ItemStack stack = ingredient.get(0).castValue(); + Block block = Blocks.AIR; + if (!stack.isEmpty()) { + block = ((BlockItem) stack.getItem()).getBlock(); + } + + if (!stack.is(Items.AIR) || !block.defaultBlockState().is(Blocks.AIR)) { + widgets.add(Widgets.createSlot(new Point(startPoint.x + 1, startPoint.y + 17)) + .entries(ingredient).markInput()); + } + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeDisplay.java new file mode 100644 index 0000000..781a9ab --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/heat/HeatRecipeDisplay.java @@ -0,0 +1,19 @@ +package com.rempler.exnihiloadditions.compat.rei.heat; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.HeatRecipe; + +import java.util.Collections; + +public class HeatRecipeDisplay extends SimpleBasicDisplay { + public HeatRecipeDisplay(HeatRecipe recipe) { + super(Collections.singletonList(EntryIngredients.of(recipe.getInputBlock())), Collections.emptyList()); + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return HeatRecipeCategory.HEATING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeCategory.java new file mode 100644 index 0000000..c03bfbc --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeCategory.java @@ -0,0 +1,95 @@ +package com.rempler.exnihiloadditions.compat.rei.melting; + +import com.google.common.collect.Lists; +import dev.architectury.fluid.FluidStack; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.item.ItemStack; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.registries.ExNihiloRegistries; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.crafting.MeltingRecipe; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +public class MeltingRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "melting"); + public static final CategoryIdentifier MELTING = CategoryIdentifier.of(UID); + @Override + public CategoryIdentifier getCategoryIdentifier() { + return MELTING; + } + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.melting"); + } + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation( + ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_mid.png"); + + @Nullable + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.FIRED_CRUCIBLE); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 168, 166, 54)); + + List list = display.getInputEntries(); + FluidStack fluid = display.getOutputEntries().get(0).get(0).castValue(); + ItemStack stack = list.get(0).get(0).castValue(); + Optional recipeOptional = ExNihiloRegistries.CRUCIBLE_REGISTRY.findRecipe(stack.getItem()); + int amount = 0; + if (recipeOptional.isPresent()) { + amount = recipeOptional.get().getResultFluid().getAmount(); + String name = recipeOptional.get().getCrucibleType().getName(); + if (name.equals("fired")) { + name = "Fired crucibles only"; + } else { + name = "All crucibles"; + } + widgets.add(Widgets.createTooltip(new Rectangle(startPoint.x + 21, startPoint.y + 21, 18, 18), + Component.literal(String.format("%s", name)))); + } + for (int i = 0; i < list.size(); i++) { + final int slotX = 39 + (i % 7 * 18); + final int slotY = 3 + i / 7 * 18; + widgets.add(Widgets.createSlot(new Point(startPoint.x + slotX, startPoint.y + slotY)) + .entries(list.get(i)).disableBackground().markInput()); + } + + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 3, startPoint.y + 21)) + .entries(Collections.singletonList(EntryStacks.of(fluid.getFluid(), amount))).markOutput()); + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeDisplay.java new file mode 100644 index 0000000..1a852dc --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/melting/MeltingRecipeDisplay.java @@ -0,0 +1,29 @@ +package com.rempler.exnihiloadditions.compat.rei.melting; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.MeltingRecipe; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class MeltingRecipeDisplay extends SimpleBasicDisplay { + public MeltingRecipeDisplay(MeltingRecipe recipe) { + super(getIngredients(recipe), Collections.singletonList(EntryIngredient.of(EntryStacks.of(recipe.getResultFluid().getFluid())))); + } + + private static List getIngredients(MeltingRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.ofIngredient(recipe.getInput())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return MeltingRecipeCategory.MELTING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeCategory.java new file mode 100644 index 0000000..489adca --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeCategory.java @@ -0,0 +1,71 @@ +package com.rempler.exnihiloadditions.compat.rei.precipitate; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import java.util.List; + +public class PrecipitateRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "precipitate"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation( + ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, + "textures/gui/jei_fluid_block_transform.png"); + public static final CategoryIdentifier PRECIPITATE = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return PRECIPITATE; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.precipitate"); + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.OAK_BARREL); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 0, 166, 54)); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 48, startPoint.y + 37)) + .entries(display.getInputEntries().get(1)).markInput()); + widgets.add(Widgets.createSlot(new Point(startPoint.x + 75, startPoint.y + 10)) + .entries(display.getInputEntries().get(0)).markInput()); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 102, startPoint.y + 37)) + .entries(display.getOutputEntries().get(0)).disableBackground().markOutput()); + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeDisplay.java new file mode 100644 index 0000000..c7c9bd5 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/precipitate/PrecipitateRecipeDisplay.java @@ -0,0 +1,30 @@ +package com.rempler.exnihiloadditions.compat.rei.precipitate; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.PrecipitateRecipe; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class PrecipitateRecipeDisplay extends SimpleBasicDisplay { + public PrecipitateRecipeDisplay(PrecipitateRecipe recipe) { + super(getIngredients(recipe), Collections.singletonList(EntryIngredient.of(EntryStacks.of(recipe.getOutput())))); + } + + private static List getIngredients(PrecipitateRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.ofIngredient(recipe.getInput())); + list.add(EntryIngredients.of(recipe.getFluid().getFluid())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return PrecipitateRecipeCategory.PRECIPITATE; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeCategory.java new file mode 100644 index 0000000..888d1e3 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeCategory.java @@ -0,0 +1,131 @@ +package com.rempler.exnihiloadditions.compat.rei.sifting; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.client.Minecraft; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.item.MeshItem; +import novamachina.exnihilosequentia.world.item.MeshType; +import novamachina.exnihilosequentia.world.item.crafting.EXNRecipeTypes; +import novamachina.exnihilosequentia.world.item.crafting.SiftingRecipe; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; +import novamachina.novacore.util.StringUtils; + +import javax.annotation.Nonnull; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class SiftingRecipeCategory implements DisplayCategory { + private static final List removah = new ArrayList<>(); + @Nonnull + public static final ResourceLocation UID = new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "dry_sifting"); + public static final CategoryIdentifier SIFTING = CategoryIdentifier.of(UID); + @Nonnull + public static final ResourceLocation WET_UID = new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "wet_sifting"); + public static final CategoryIdentifier WET_SIFTING = CategoryIdentifier.of(WET_UID); + @Nonnull + protected static final ResourceLocation texture = new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_mid.png"); + + public SiftingRecipeCategory() { + + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.OAK_SIEVE); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createSlot(new Point(startPoint.x + 11, startPoint.y + 3)) + .entries(display.getInputEntries().get(0)).markInput()); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 0, 166, 54)); + List recipes = Minecraft.getInstance().level.getRecipeManager().getAllRecipesFor(EXNRecipeTypes.SIFTING); + recipes.removeAll(removah); + Iterator recipeIterator = recipes.iterator(); + while (recipeIterator.hasNext()) { + SiftingRecipe recipeTest1 = recipeIterator.next(); + List tempList = new ArrayList<>(); + tempList.add(recipeTest1); + removah.add(recipeTest1); + + for (SiftingRecipe recipeTest2 : recipes) { + if (!(recipeTest1 == recipeTest2)) { + if (recipeTest1.getInput().test(recipeTest2.getInput().getItems()[0])) { + if (recipeTest1.isWaterlogged() == recipeTest2.isWaterlogged()) { + for (int i = 0; i < recipeTest1.getRolls().size(); i++) { + for (int j = 0; j < recipeTest2.getRolls().size(); j++) { + if (recipeTest1.getRolls().get(i).getMesh() == recipeTest2.getRolls().get(j).getMesh()) { + tempList.add(recipeTest2); + removah.add(recipeTest2); + } + } + } + } + } + } + } + + for (int i = 0; i < tempList.size(); i++) { + SiftingRecipe recipe = tempList.get(i); + if (recipeTest1.getInput().test(recipe.getInput().getItems()[0])) { + @Nonnull final EntryIngredient outputStack = EntryIngredient.of(EntryStacks.of(recipe.getDrop())); + for (int j = 0; j < recipeTest1.getRolls().size(); j++) { + //String name = recipeTest1.isWaterlogged() ? "Wet Sifting" : "Dry Sifting"; + //widgets.add(Widgets.createTooltip(new Rectangle(startPoint.x + 21, startPoint.y + 21, 18, 18), + // Component.literal(String.format("%s", name)))); + MeshType mesh = recipeTest1.getRolls().get(j).getMesh(); + for (int k = 0; k < recipe.getRolls().size(); k++) { + if (recipe.getRolls().get(k).getMesh() == mesh) { + outputStack.get(0).tooltip(Component.literal(String.format( + "Chance: %s", StringUtils.formatPercent(recipe.getRolls().get(k).getChance())))); + } + } + widgets.add(Widgets.createSlot(new Point(startPoint.x + 11, startPoint.y + 38)) + .entries(EntryIngredients.of(MeshItem.getMesh(mesh))).markInput()); + } + + final int slotX = 39 + (i % 7 * 18); + final int slotY = 3 + i / 7 * 18; + widgets.add(Widgets.createSlot(new Point(startPoint.x + slotX, startPoint.y + slotY)) + .entries(outputStack).disableBackground().markOutput()); + } + } + recipeIterator.remove(); + } + + + return widgets; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return SIFTING; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.dry_sifting"); + } + + @Override + public int getDisplayHeight() { + return 56; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeDisplay.java new file mode 100644 index 0000000..82b9cb8 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/sifting/SiftingRecipeDisplay.java @@ -0,0 +1,33 @@ +package com.rempler.exnihiloadditions.compat.rei.sifting; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.SiftingRecipe; + +import java.util.ArrayList; +import java.util.List; + +public class SiftingRecipeDisplay extends SimpleBasicDisplay { + public SiftingRecipeDisplay(SiftingRecipe recipe) { + super(getInputs(recipe), getIngredients(recipe)); + } + + private static List getInputs(SiftingRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.ofIngredient(recipe.getInput())); + return list; + } + + private static List getIngredients(SiftingRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.of(recipe.getDrop())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return SiftingRecipeCategory.SIFTING; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeCategory.java new file mode 100644 index 0000000..3e8b9c2 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeCategory.java @@ -0,0 +1,70 @@ +package com.rempler.exnihiloadditions.compat.rei.solidifying; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import java.util.List; + +public class SolidifyingRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "solidifying"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation( + ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_fluid_on_top.png"); + + public static final CategoryIdentifier SOLIDIFY = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return SOLIDIFY; + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.OAK_BARREL); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 0, 166, 54)); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 48, startPoint.y + 37)) + .entries(display.getInputEntries().get(1)).markInput()); + widgets.add(Widgets.createSlot(new Point(startPoint.x + 75, startPoint.y + 10)) + .entries(display.getInputEntries().get(0)).markInput()); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 102, startPoint.y + 37)) + .entries(display.getOutputEntries().get(0)).disableBackground().markOutput()); + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.solidifying"); + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeDisplay.java new file mode 100644 index 0000000..6fc3e7e --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/solidifying/SolidifyingRecipeDisplay.java @@ -0,0 +1,30 @@ +package com.rempler.exnihiloadditions.compat.rei.solidifying; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.SolidifyingRecipe; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class SolidifyingRecipeDisplay extends SimpleBasicDisplay { + public SolidifyingRecipeDisplay(SolidifyingRecipe recipe) { + super(getIngredients(recipe), Collections.singletonList(EntryIngredient.of(EntryStacks.of(recipe.getResult())))); + } + + private static List getIngredients(SolidifyingRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.of(recipe.getFluidOnTop().getFluid())); + list.add(EntryIngredients.of(recipe.getFluidInTank().getFluid())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return SolidifyingRecipeCategory.SOLIDIFY; + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeCategory.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeCategory.java new file mode 100644 index 0000000..7a429b0 --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeCategory.java @@ -0,0 +1,71 @@ +package com.rempler.exnihiloadditions.compat.rei.transition; + +import com.google.common.collect.Lists; +import me.shedaniel.math.Point; +import me.shedaniel.math.Rectangle; +import me.shedaniel.rei.api.client.gui.Renderer; +import me.shedaniel.rei.api.client.gui.widgets.Widget; +import me.shedaniel.rei.api.client.gui.widgets.Widgets; +import me.shedaniel.rei.api.client.registry.display.DisplayCategory; +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.util.EntryStacks; +import net.minecraft.network.chat.Component; +import net.minecraft.resources.ResourceLocation; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.common.utility.ExNihiloConstants; +import novamachina.exnihilosequentia.world.level.block.EXNBlocks; + +import javax.annotation.Nonnull; +import java.util.List; + +public class TransitionRecipeCategory implements DisplayCategory { + + @Nonnull + public static final ResourceLocation UID = + new ResourceLocation(ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "transition"); + + @Nonnull + private static final ResourceLocation texture = + new ResourceLocation( + ExNihiloConstants.ModIds.EX_NIHILO_SEQUENTIA, "textures/gui/jei_fluid_transform.png"); + + public static final CategoryIdentifier TRANSITION = CategoryIdentifier.of(UID); + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return TRANSITION; + } + + @Override + public Renderer getIcon() { + return EntryStacks.of(EXNBlocks.OAK_BARREL); + } + + @Override + public List setupDisplay(SimpleBasicDisplay display, Rectangle bounds) { + final Point startPoint = new Point(bounds.getCenterX() - 83, bounds.getCenterY() - 27); + List widgets = Lists.newArrayList(); + widgets.add(Widgets.createTexturedWidget(texture, startPoint.x, startPoint.y, 0, 0, 166, 54)); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 48, startPoint.y + 10)) + .entries(display.getInputEntries().get(1)).markInput()); + widgets.add(Widgets.createSlot(new Point(startPoint.x + 75, startPoint.y + 37)) + .entries(display.getInputEntries().get(0)).markInput()); + + widgets.add(Widgets.createSlot(new Point(startPoint.x + 102, startPoint.y + 10)) + .entries(display.getOutputEntries().get(0)).disableBackground().markOutput()); + + return widgets; + } + + @Override + public int getDisplayHeight() { + return 56; + } + + @Nonnull + @Override + public Component getTitle() { + return Component.translatable("jei.category.transition"); + } +} diff --git a/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeDisplay.java b/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeDisplay.java new file mode 100644 index 0000000..0e6ce2e --- /dev/null +++ b/src/main/java/com/rempler/exnihiloadditions/compat/rei/transition/TransitionRecipeDisplay.java @@ -0,0 +1,30 @@ +package com.rempler.exnihiloadditions.compat.rei.transition; + +import me.shedaniel.rei.api.common.category.CategoryIdentifier; +import me.shedaniel.rei.api.common.entry.EntryIngredient; +import me.shedaniel.rei.api.common.util.EntryIngredients; +import me.shedaniel.rei.api.common.util.EntryStacks; +import com.rempler.exnihiloadditions.compat.rei.SimpleBasicDisplay; +import novamachina.exnihilosequentia.world.item.crafting.TransitionRecipe; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class TransitionRecipeDisplay extends SimpleBasicDisplay { + public TransitionRecipeDisplay(TransitionRecipe recipe) { + super(getIngredients(recipe), Collections.singletonList(EntryIngredient.of(EntryStacks.of(recipe.getResult().getFluid())))); + } + + private static List getIngredients(TransitionRecipe recipe) { + List list = new ArrayList<>(); + list.add(EntryIngredients.ofIngredient(recipe.getCatalyst())); + list.add(EntryIngredients.of(recipe.getFluidInTank().getFluid())); + return list; + } + + @Override + public CategoryIdentifier getCategoryIdentifier() { + return TransitionRecipeCategory.TRANSITION; + } +}