Port Chanced Outputs TOP Enhancements from NomiLabs

Exaxxion · Exaxxion · commit 0d3437e44080 · 2025-03-12T01:10:58.000-07:00
Chanced outputs no longer display as normal outputs in TOP when rolled,
which allowed players to see the outcome before the recipe completed.

Instead, all potential outputs are now displayed with an indicator
overlaid on each chanced output to display the percent chance (including
applicable overclocking bonuses) via a new ElementFactory.

Support for getting this information to TOP has been added to
AbstractRecipeLogic.
diff --git a/src/main/java/gregtech/api/capability/impl/AbstractRecipeLogic.java b/src/main/java/gregtech/api/capability/impl/AbstractRecipeLogic.java
@@ -24,6 +24,7 @@
 import net.minecraftforge.fluids.IFluidTank;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
+import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
@@ -42,6 +43,9 @@ public abstract class AbstractRecipeLogic extends MTETrait implements IWorkable
     private static final String RECIPE_EUT = "RecipeEUt";
     private static final String ITEM_OUTPUTS = "ItemOutputs";
     private static final String FLUID_OUTPUTS = "FluidOutputs";
+    private static final String CHANCE = "Chance";
+    private static final String CHANCED_ITEM_OUTPUTS = "ChancedItemOutputs";
+    private static final String NON_CHANCED_ITEM_AMOUNT = "NonChancedItemAmt";
 
     public final RecipeMap<?> recipeMap;
 
@@ -63,6 +67,14 @@ public abstract class AbstractRecipeLogic extends MTETrait implements IWorkable
     protected boolean wasActiveAndNeedsUpdate;
     protected boolean isOutputsFull;
     protected boolean invalidInputsForRecipes;
+    protected int nonChancedItemAmt;
+
+    /**
+     * A list containing all possible chanced item outputs from the active recipe, paired with their
+     * overclock-boosted chance value.
+     */
+    protected List<Pair<ItemStack, Integer>> chancedItemOutputs;
+
 
     public AbstractRecipeLogic(MetaTileEntity tileEntity, RecipeMap<?> recipeMap) {
         super(tileEntity);
@@ -350,6 +362,8 @@ protected void setupRecipe(Recipe recipe) {
         this.recipeEUt = resultOverclock[0];
         this.fluidOutputs = GTUtility.copyFluidList(recipe.getFluidOutputs());
         int overclocks = getMachineTierForRecipe(recipe) - recipe.getBaseTier();
+        this.nonChancedItemAmt = recipe.getOutputs().size();
+        this.chancedItemOutputs = recipe.getChancedRecipeOutputsAtTier(overclocks);
         this.itemOutputs = GTUtility.copyStackList(recipe.getResultItemOutputs(getOutputInventory().getSlots(), random, overclocks));
         if (this.wasActiveAndNeedsUpdate) {
             this.wasActiveAndNeedsUpdate = false;
@@ -376,6 +390,15 @@ protected void setupRecipe(Recipe recipe) {
         return GTUtility.copyFluidList(fluidOutputs);
     }
 
+    /**
+     * @return all possible chanced item outputs paired with their computed chances for the currently active recipe
+     */
+    public List<Pair<ItemStack, Integer>> getChancedItemOutputs() {
+        if(itemOutputs == null)
+            return Collections.emptyList();
+        return chancedItemOutputs;
+    }
+
     protected int getMachineTierForRecipe(Recipe recipe) {
         return GTUtility.getTierByVoltage(getMaxVoltage());
     }
@@ -388,6 +411,8 @@ protected void completeRecipe() {
         this.recipeEUt = 0;
         this.fluidOutputs = null;
         this.itemOutputs = null;
+        this.chancedItemOutputs = null;
+        this.nonChancedItemAmt = 0;
         setHasNotEnoughEnergy(false);
         this.wasActiveAndNeedsUpdate = true;
     }
@@ -414,6 +439,13 @@ public int getRecipeEUt() {
         return recipeEUt;
     }
 
+    /**
+     * @return the number of non-chanced item outputs this recipe produces
+     */
+    public int getNonChancedItemAmt() {
+        return nonChancedItemAmt;
+    }
+
     public void setMaxProgress(int maxProgress) {
         this.maxProgressTime = maxProgress;
         metaTileEntity.markDirty();
@@ -562,6 +594,16 @@ public NBTTagCompound serializeNBT() {
             }
             compound.setTag(ITEM_OUTPUTS, itemOutputsList);
             compound.setTag(FLUID_OUTPUTS, fluidOutputsList);
+
+            NBTTagList chancedItemOutputsList = new NBTTagList();
+            for(var entry : chancedItemOutputs) {
+                NBTTagCompound tag = entry.getKey().writeToNBT(new NBTTagCompound());
+                tag.setInteger(CHANCE, entry.getValue());
+                chancedItemOutputsList.appendTag(tag);
+            }
+
+            compound.setTag(CHANCED_ITEM_OUTPUTS, chancedItemOutputsList);
+            compound.setInteger(NON_CHANCED_ITEM_AMOUNT, nonChancedItemAmt);
         }
         return compound;
     }
@@ -596,6 +638,14 @@ public void deserializeNBT(NBTTagCompound compound) {
             for(var f : fluidOutputsList)
                 if(f instanceof NBTTagCompound tag)
                     this.fluidOutputs.add(FluidStack.loadFluidStackFromNBT(tag));
+
+            NBTTagList chancedItemOutputsList = compound.getTagList(CHANCED_ITEM_OUTPUTS, Constants.NBT.TAG_COMPOUND);
+            this.chancedItemOutputs = new ArrayList<>();
+            for(var ci : chancedItemOutputsList)
+                if(ci instanceof NBTTagCompound tag)
+                    this.chancedItemOutputs.add(Pair.of(new ItemStack(tag), tag.getInteger(CHANCE)));
+
+            this.nonChancedItemAmt = compound.getInteger(NON_CHANCED_ITEM_AMOUNT);
         }
     }
 }
diff --git a/src/main/java/gregtech/integration/nomilabs/element/LabsChancedItemStackElement.java b/src/main/java/gregtech/integration/nomilabs/element/LabsChancedItemStackElement.java
@@ -0,0 +1,75 @@
+/*
+    Code adapted from Nomi-Labs https://github.com/Nomi-CEu/Nomi-Labs @ d2d6e89
+ */
+package gregtech.integration.nomilabs.element;
+
+import gregtech.integration.theoneprobe.TheOneProbeCompatibility;
+import io.netty.buffer.ByteBuf;
+import mcjty.theoneprobe.api.IItemStyle;
+import mcjty.theoneprobe.apiimpl.elements.ElementItemStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.text.DecimalFormat;
+
+public class LabsChancedItemStackElement extends ElementItemStack {
+
+    private static final DecimalFormat format = new DecimalFormat("#.#");
+
+    private final int chance;
+
+    public LabsChancedItemStackElement(ItemStack itemStack, int chance, IItemStyle style) {
+        super(itemStack, style);
+        this.chance = chance;
+    }
+
+    public LabsChancedItemStackElement(ByteBuf buf) {
+        super(buf);
+        chance = buf.readInt();
+    }
+
+    @Override
+    public void render(int x, int y) {
+        super.render(x, y);
+        renderChance(chance, x, y);
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        super.toBytes(buf);
+        buf.writeInt(chance);
+    }
+
+    @Override
+    public int getID() {
+        return TheOneProbeCompatibility.CHANCED_ITEM_STACK_ELEMENT;
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static void renderChance(int chance, int x, int y) {
+        GlStateManager.disableLighting();
+        GlStateManager.disableDepth();
+        GlStateManager.disableBlend();
+
+        GlStateManager.pushMatrix();
+        GlStateManager.scale(0.5f, 0.5f, 1);
+        Minecraft mc = Minecraft.getMinecraft();
+
+        String chanceTxt = formatChance(chance);
+        mc.fontRenderer.drawStringWithShadow(chanceTxt, (x + 17) * 2 - 1 - mc.fontRenderer.getStringWidth(chanceTxt),
+                                             y * 2, 0xffffffff);
+
+        GlStateManager.popMatrix();
+
+        GlStateManager.enableLighting();
+        GlStateManager.enableDepth();
+        GlStateManager.enableBlend();
+    }
+
+    public static String formatChance(int chance) {
+        return format.format(chance / 100.0) + "%";
+    }
+}
diff --git a/src/main/java/gregtech/integration/theoneprobe/TheOneProbeCompatibility.java b/src/main/java/gregtech/integration/theoneprobe/TheOneProbeCompatibility.java
@@ -10,12 +10,14 @@ public class TheOneProbeCompatibility {
     public static int FLUID_NAME_ELEMENT;
     public static int FLUID_STACK_ELEMENT;
     public static int CUSTOM_NAME_ELEMENT;
+    public static int CHANCED_ITEM_STACK_ELEMENT;
 
     public static void registerCompatibility() {
         ITheOneProbe oneProbe = TheOneProbe.theOneProbeImp;
         FLUID_NAME_ELEMENT = oneProbe.registerElementFactory(LabsFluidNameElement::new);
         FLUID_STACK_ELEMENT = oneProbe.registerElementFactory(LabsFluidStackElement::new);
         CUSTOM_NAME_ELEMENT = oneProbe.registerElementFactory(CustomNameElement::new);
+        CHANCED_ITEM_STACK_ELEMENT = oneProbe.registerElementFactory(LabsChancedItemStackElement::new);
 
         oneProbe.registerProvider(new ElectricContainerInfoProvider());
         oneProbe.registerProvider(new FuelableInfoProvider());
diff --git a/src/main/java/gregtech/integration/theoneprobe/provider/RecipeOutputsProvider.java b/src/main/java/gregtech/integration/theoneprobe/provider/RecipeOutputsProvider.java
@@ -1,5 +1,5 @@
 /*
-    Code adapted from Nomi-Labs https://github.com/Nomi-CEu/Nomi-Labs @ 6e14c06
+    Code adapted from Nomi-Labs https://github.com/Nomi-CEu/Nomi-Labs @ d2d6e89
  */
 package gregtech.integration.theoneprobe.provider;
 
@@ -10,20 +10,23 @@
 import gregtech.integration.nomilabs.element.*;
 import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 import mcjty.theoneprobe.api.*;
+import mcjty.theoneprobe.apiimpl.elements.ElementItemStack;
 import mcjty.theoneprobe.apiimpl.styles.*;
 import mcjty.theoneprobe.config.Config;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.fluids.*;
+import org.apache.commons.lang3.tuple.Pair;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
-import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import static mcjty.theoneprobe.api.ElementAlignment.*;
 import static mcjty.theoneprobe.api.TextStyleClass.*;
+import static gregtech.integration.nomilabs.element.LabsChancedItemStackElement.formatChance;
 
 public class RecipeOutputsProvider extends CapabilityInfoProvider<IWorkable> {
 
@@ -48,71 +51,67 @@ protected void addProbeInfo(IWorkable capability, IProbeInfo info, EntityPlayer
         // Generators, Ignore
         if (recipe.getRecipeEUt() < 0) return;
 
-        var outputs = getUniqueItems(recipe.getItemOutputs());
-        var fluidOutputs = getUniqueFluids(recipe.getFluidOutputs());
+        var lists = createItemFluidElementLists(recipe);
+        var items = lists.getLeft();
+        var fluids = lists.getRight();
 
-        if (outputs.isEmpty() && fluidOutputs.isEmpty()) return;
+        if (items.isEmpty() && fluids.isEmpty()) return;
 
-        boolean showDetailed = outputs.size() + fluidOutputs.size() <= Config.showItemDetailThresshold &&
-                player.isSneaking();
+        boolean showDetailed = items.size() + fluids.size() <= Config.showItemDetailThresshold && player.isSneaking();
         IProbeInfo mainPanel = info.vertical()
                 .text("{*gregtech.top.crafting*}")
                 .vertical(info.defaultLayoutStyle().borderColor(Config.chestContentsBorderColor)
                         .spacing(5));
 
         if (showDetailed) {
-            for (var entry : outputs.entrySet()) {
-                ItemStack stack = entry.getKey().toStack(entry.getValue());
+            for (var entry : items)
                 mainPanel.horizontal(new LayoutStyle().spacing(10).alignment(ALIGN_CENTER))
-                        .item(stack, new ItemStyle().width(16).height(16))
-                        .text(INFO + stack.getDisplayName());
-            }
+                         .element(entry.getValue())
+                         .text(INFO + entry.getKey());
 
-            for (var entry : fluidOutputs.entrySet()) {
-                FluidStack stack = new FluidStack(entry.getKey(), entry.getValue());
+            for (var entry : fluids)
                 mainPanel.horizontal(new LayoutStyle().spacing(10).alignment(ALIGN_CENTER))
-                        .element(new LabsFluidStackElement(stack))
-                        .element(new LabsFluidNameElement(stack, false));
-            }
+                         .element(entry.getValue())
+                         .element(entry.getKey());
+
             return;
         }
 
         // If outputs and fluid outputs are both of size 1, show on same row instead of over two rows
-        boolean condense = outputs.size() == 1 && fluidOutputs.size() == 1;
+        boolean condense = items.size() == 1 && fluids.size() == 1;
         IProbeInfo sharedHorizontal = null;
 
         if (condense)
             sharedHorizontal = createHorizontalLayout(mainPanel);
 
-        if (!outputs.isEmpty()) {
+        if (!items.isEmpty()) {
             IProbeInfo panel;
             if (condense)
                 panel = sharedHorizontal;
             else
                 panel = createHorizontalLayout(mainPanel);
 
-            addOutputs(outputs, (meta, amt) -> panel.item(meta.toStack(amt), new ItemStyle().width(16).height(16)));
+            addOutputs(items, panel, Pair::getValue);
         }
 
-        if (!fluidOutputs.isEmpty()) {
+        if (!fluids.isEmpty()) {
             IProbeInfo panel;
             if (condense)
                 panel = sharedHorizontal;
             else
                 panel = createHorizontalLayout(mainPanel);
 
-            addOutputs(fluidOutputs,
-                    (fluid, amount) -> panel.element(new LabsFluidStackElement(new FluidStack(fluid, amount))));
+            addOutputs(fluids, panel, Pair::getValue);
         }
     }
 
-    private <T> void addOutputs(Map<T, Integer> outputs, BiConsumer<T, Integer> addToPanel) {
+    private <T> void addOutputs(List<T> list, IProbeInfo panel, Function<T, IElement> getElement) {
         int idx = 0;
 
-        for (var output : outputs.entrySet()) {
+        for (var entry : list) {
             if (idx >= AMT_IN_ROW) break;
 
-            addToPanel.accept(output.getKey(), output.getValue());
+            panel.element(getElement.apply(entry));
             idx++;
         }
     }
@@ -121,6 +120,63 @@ private IProbeInfo createHorizontalLayout(IProbeInfo mainPanel) {
         return mainPanel.horizontal(new LayoutStyle().spacing(4));
     }
 
+    private Pair<List<Pair<String, ElementItemStack>>, List<Pair<LabsFluidNameElement, LabsFluidStackElement>>> createItemFluidElementLists(AbstractRecipeLogic recipe) {
+        // Items
+        var outputs =
+            getUnique(recipe.getItemOutputs().subList(0, recipe.getNonChancedItemAmt()),
+                      ItemStack::isEmpty, ItemMeta::new, ItemStack::getCount);
+
+        var chancedOutputs =
+            getUnique(recipe.getChancedItemOutputs(),
+                      (chanced) -> chanced.getKey().isEmpty() || chanced.getValue() == 0,
+                      (chanced) -> Pair.of(new ItemMeta(chanced.getKey()), chanced.getValue()),
+                      (chanced) -> chanced.getKey().getCount());
+
+        IItemStyle style = new ItemStyle().width(16).height(16);
+        List<Pair<String, ElementItemStack>> items = new ArrayList<>();
+
+        for (var output : outputs.entrySet()) {
+            ItemStack stack = output.getKey().toStack(output.getValue());
+            items.add(Pair.of(stack.getDisplayName(), new ElementItemStack(stack, style)));
+        }
+
+        for (var chanced : chancedOutputs.entrySet()) {
+            ItemStack stack = chanced.getKey().getKey().toStack(chanced.getValue());
+            String display = stack.getDisplayName() + " (" + formatChance(chanced.getKey().getValue()) + ")";
+            items.add(Pair.of(display, new LabsChancedItemStackElement(stack, chanced.getKey().getValue(), style)));
+        }
+
+        // Fluids
+        var fluidOutputs =
+            getUnique(recipe.getFluidOutputs(),
+                      (stack) -> stack.amount == 0, FluidStack::getFluid, (stack) -> stack.amount);
+
+        List<Pair<LabsFluidNameElement, LabsFluidStackElement>> fluids = new ArrayList<>();
+
+        for (var output : fluidOutputs.entrySet()) {
+            FluidStack stack = new FluidStack(output.getKey(), output.getValue());
+            fluids.add(Pair.of(new LabsFluidNameElement(stack, false), new LabsFluidStackElement(stack)));
+        }
+
+        return Pair.of(items, fluids);
+    }
+
+    private <T, K> Map<K, Integer> getUnique(List<T> stacks, Function<T, Boolean> emptyCheck, Function<T, K> getKey,
+                                             Function<T, Integer> getCount) {
+        Map<K, Integer> map = new Object2ObjectLinkedOpenHashMap<>();
+
+        for (T stack : stacks) {
+            if (emptyCheck.apply(stack)) continue;
+
+            map.compute(getKey.apply(stack), (key, count) -> {
+                if (count == null) count = 0;
+                return count + getCount.apply(stack);
+            });
+        }
+
+        return map;
+    }
+
     private Map<ItemMeta, Integer> getUniqueItems(List<ItemStack> stacks) {
         Map<ItemMeta, Integer> map = new Object2ObjectLinkedOpenHashMap<>();
 
