Make Output Chances Deterministic

src/main/java/gregtech/api/capability/impl/AbstractRecipeLogic.java

@@ -21,9 +21,11 @@
 import gregtech.api.recipes.recipeproperties.CleanroomProperty;
 import gregtech.api.recipes.recipeproperties.DimensionProperty;
 import gregtech.api.recipes.recipeproperties.IRecipePropertyStorage;
+import gregtech.api.util.FluidStackHashStrategy;
 import gregtech.api.util.GTLog;
 import gregtech.api.util.GTTransferUtils;
 import gregtech.api.util.GTUtility;
+import gregtech.api.util.ItemStackHashStrategy;
 import gregtech.common.ConfigHolder;
 
 import net.minecraft.item.ItemStack;
@@ -37,12 +39,14 @@
 import net.minecraftforge.fluids.IFluidTank;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import it.unimi.dsi.fastutil.objects.Object2IntOpenCustomHashMap;
 import org.jetbrains.annotations.MustBeInvokedByOverriders;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 import static gregtech.api.GTValues.ULV;
 import static gregtech.api.recipes.logic.OverclockingLogic.*;
@@ -70,7 +74,16 @@ public abstract class AbstractRecipeLogic extends MTETrait implements IWorkable,
  protected int maxProgressTime;
  protected long recipeEUt;
  protected List<FluidStack> fluidOutputs;
+ protected Map<FluidStack, Integer> fluidChancesCache = new Object2IntOpenCustomHashMap<>(
+ FluidStackHashStrategy.builder()
+ .compareFluid(true)
+ .build());
  protected List<ItemStack> itemOutputs;
+ protected Map<ItemStack, Integer> itemChancesCache = new Object2IntOpenCustomHashMap<>(
+ ItemStackHashStrategy.builder()
+ .compareItem(true)
+ .compareDamage(true)
+ .build());
 
  protected boolean isActive;
  protected boolean workingEnabled = true;
@@ -390,6 +403,12 @@ protected void trySearchNewRecipe() {
  }
  // If a recipe was found, then inputs were valid. Cache found recipe.
  if (currentRecipe != null) {
+
+ // we found a new recipe, clear the cache
+ if (this.previousRecipe != null && !currentRecipe.equals(this.previousRecipe)) {
+ this.itemChancesCache.clear();
+ this.fluidChancesCache.clear();
+ }
  this.previousRecipe = currentRecipe;
  }
  this.invalidInputsForRecipes = (currentRecipe == null);
@@ -947,9 +966,9 @@ protected void setupRecipe(@NotNull Recipe recipe) {
  RecipeMap<?> map = getRecipeMap();
  if (map != null) {
  this.fluidOutputs = GTUtility
- .copyFluidList(recipe.getResultFluidOutputs(recipeTier, machineTier, map));
+ .copyFluidList(recipe.getResultFluidOutputs(recipeTier, machineTier, map, fluidChancesCache));
  this.itemOutputs = GTUtility
- .copyStackList(recipe.getResultItemOutputs(recipeTier, machineTier, map));
+ .copyStackList(recipe.getResultItemOutputs(recipeTier, machineTier, map, itemChancesCache));
  }
 
  if (this.wasActiveAndNeedsUpdate) {
@@ -1209,6 +1228,21 @@ public NBTTagCompound serializeNBT() {
  }
  compound.setTag("ItemOutputs", itemOutputsList);
  compound.setTag("FluidOutputs", fluidOutputsList);
+
+ NBTTagList itemCache = new NBTTagList();
+ for (var entry : itemChancesCache.entrySet()) {
+ var tag = entry.getKey().serializeNBT();
+ tag.setInteger("CachedChance", entry.getValue());
+ itemCache.appendTag(tag);
+ }
+ NBTTagList fluidCache = new NBTTagList();
+ for (var entry : fluidChancesCache.entrySet()) {
+ var tag = entry.getKey().writeToNBT(new NBTTagCompound());
+ tag.setInteger("CachedChance", entry.getValue());
+ fluidCache.appendTag(tag);
+ }
+ compound.setTag("ItemChanceCache", itemCache);
+ compound.setTag("FluidChanceCache", fluidCache);
  }
  return compound;
  }
@@ -1235,6 +1269,20 @@ public void deserializeNBT(@NotNull NBTTagCompound compound) {
  for (int i = 0; i < fluidOutputsList.tagCount(); i++) {
  this.fluidOutputs.add(FluidStack.loadFluidStackFromNBT(fluidOutputsList.getCompoundTagAt(i)));
  }
+
+ NBTTagList itemCache = compound.getTagList("ItemChanceCache", Constants.NBT.TAG_COMPOUND);
+ for (int i = 0; i < itemCache.tagCount(); i++) {
+ var stack = itemCache.getCompoundTagAt(i);
+ int cache = stack.getInteger("CachedChance");
+ this.itemChancesCache.put(new ItemStack(stack), cache);
+ }
+
+ NBTTagList fluidCache = compound.getTagList("FluidChanceCache", Constants.NBT.TAG_COMPOUND);
+ for (int i = 0; i < fluidCache.tagCount(); i++) {
+ var stack = fluidCache.getCompoundTagAt(i);
+ int cache = stack.getInteger("CachedChance");
+ this.fluidChancesCache.put(FluidStack.loadFluidStackFromNBT(stack), cache);
+ }
  }
  }
 }

src/main/java/gregtech/api/recipes/Recipe.java

@@ -470,10 +470,11 @@ public List<ItemStack> getOutputs() {
  * @param recipeMap The RecipeMap that the recipe is being performed upon, used for chanced output calculation
  * @return A list of all resulting ItemStacks from the recipe, after chance has been applied to any chanced outputs
  */
- public List<ItemStack> getResultItemOutputs(int recipeTier, int machineTier, RecipeMap<?> recipeMap) {
+ public List<ItemStack> getResultItemOutputs(int recipeTier, int machineTier, RecipeMap<?> recipeMap,
+ Map<ItemStack, Integer> cache) {
  List<ItemStack> outputs = new ArrayList<>(getOutputs());
  ChanceBoostFunction function = recipeMap.getChanceFunction();
- List<ChancedItemOutput> chancedOutputsList = getChancedOutputs().roll(function, recipeTier, machineTier);
+ List<ChancedItemOutput> chancedOutputsList = getChancedOutputs().roll(function, recipeTier, machineTier, cache);
 
  if (chancedOutputsList == null) return outputs;
 
@@ -503,6 +504,10 @@ public List<ItemStack> getResultItemOutputs(int recipeTier, int machineTier, Rec
  return outputs;
  }
 
+ public List<ItemStack> getResultItemOutputs(int recipeTier, int machineTier, RecipeMap<?> recipeMap) {
+ return getResultItemOutputs(recipeTier, machineTier, recipeMap, null);
+ }
+
  /**
  * Returns the maximum possible recipe outputs from a recipe, divided into regular and chanced outputs
  * Takes into account any specific output limiters, ie macerator slots, to trim down the output list
@@ -665,11 +670,13 @@ public List<FluidStack> getAllFluidOutputs() {
  * @param recipeMap The RecipeMap that the recipe is being performed upon, used for chanced output calculation
  * @return A list of all resulting ItemStacks from the recipe, after chance has been applied to any chanced outputs
  */
- public List<FluidStack> getResultFluidOutputs(int recipeTier, int machineTier, RecipeMap<?> recipeMap) {
+ public List<FluidStack> getResultFluidOutputs(int recipeTier, int machineTier, RecipeMap<?> recipeMap,
+ Map<FluidStack, Integer> cache) {
  List<FluidStack> outputs = new ArrayList<>(GTUtility.copyFluidList(getFluidOutputs()));
 
  ChanceBoostFunction function = recipeMap.getChanceFunction();
- List<ChancedFluidOutput> chancedOutputsList = getChancedFluidOutputs().roll(function, recipeTier, machineTier);
+ List<ChancedFluidOutput> chancedOutputsList = getChancedFluidOutputs().roll(function, recipeTier, machineTier,
+ cache);
 
  if (chancedOutputsList == null) return outputs;
 

src/main/java/gregtech/api/recipes/RecipeBuilder.java

@@ -658,6 +658,68 @@ public R chancedOutput(MetaItem<?>.MetaValueItem item, int chance, int tierChanc
  return chancedOutput(item, 1, chance, tierChanceBoost);
  }
 
+ public R chancedOutput(ItemStack stack, String fraction, int tierChanceBoost) {
+ if (stack == null || stack.isEmpty()) {
+ return (R) this;
+ }
+
+ String[] split = fraction.split("/");
+ if (split.length != 2) {
+ GTLog.logger.error("Fraction was not parsed correctly! Expected format is \"1/3\". Actual: \"{}\".",
+ fraction, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ int chance;
+ int maxChance;
+ try {
+ chance = Integer.parseInt(split[0]);
+ maxChance = Integer.parseInt(split[1]);
+ } catch (NumberFormatException e) {
+ GTLog.logger.error("Fraction was not parsed correctly! Expected format is \"1/3\". Actual: \"{}\".",
+ fraction, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ if (0 >= chance || chance > ChancedOutputLogic.getMaxChancedValue()) {
+ GTLog.logger.error("Chance cannot be less or equal to 0 or more than {}. Actual: {}.",
+ ChancedOutputLogic.getMaxChancedValue(), chance, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+ if (chance >= maxChance || maxChance > ChancedOutputLogic.getMaxChancedValue()) {
+ GTLog.logger.error("Max Chance cannot be less or equal to Chance or more than {}. Actual: {}.",
+ ChancedOutputLogic.getMaxChancedValue(), maxChance, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ int scalar = Math.floorDiv(ChancedOutputLogic.getMaxChancedValue(), maxChance);
+ chance *= scalar;
+ maxChance *= scalar;
+
+ this.chancedOutputs.add(new ChancedItemOutput(stack.copy(), chance, maxChance, tierChanceBoost));
+ return (R) this;
+ }
+
+ public R chancedOutput(OrePrefix prefix, Material material, int count, String fraction, int tierChanceBoost) {
+ return chancedOutput(OreDictUnifier.get(prefix, material, count), fraction, tierChanceBoost);
+ }
+
+ public R chancedOutput(OrePrefix prefix, Material material, String fraction, int tierChanceBoost) {
+ return chancedOutput(prefix, material, 1, fraction, tierChanceBoost);
+ }
+
+ public R chancedOutput(MetaItem<?>.MetaValueItem item, int count, String fraction, int tierChanceBoost) {
+ return chancedOutput(item.getStackForm(count), fraction, tierChanceBoost);
+ }
+
+ public R chancedOutput(MetaItem<?>.MetaValueItem item, String fraction, int tierChanceBoost) {
+ return chancedOutput(item, 1, fraction, tierChanceBoost);
+ }
+
  public R chancedOutputs(List<ChancedItemOutput> chancedOutputs) {
  for (ChancedItemOutput output : chancedOutputs) {
  this.chancedOutputs.add(output.copy());
@@ -689,6 +751,52 @@ public R chancedFluidOutput(FluidStack stack, int chance, int tierChanceBoost) {
  return (R) this;
  }
 
+ public R chancedFluidOutput(FluidStack stack, String fraction, int tierChanceBoost) {
+ if (stack == null || stack.amount == 0) {
+ return (R) this;
+ }
+
+ String[] split = fraction.split("/");
+ if (split.length != 2) {
+ GTLog.logger.error("Fraction was not parsed correctly! Expected format is \"1/3\". Actual: \"{}\".",
+ fraction, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ int chance;
+ int maxChance;
+ try {
+ chance = Integer.parseInt(split[0]);
+ maxChance = Integer.parseInt(split[1]);
+ } catch (NumberFormatException e) {
+ GTLog.logger.error("Fraction was not parsed correctly! Expected format is \"1/3\". Actual: \"{}\".",
+ fraction, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ if (0 >= chance || chance > ChancedOutputLogic.getMaxChancedValue()) {
+ GTLog.logger.error("Chance cannot be less or equal to 0 or more than {}. Actual: {}.",
+ ChancedOutputLogic.getMaxChancedValue(), chance, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+ if (chance >= maxChance || maxChance > ChancedOutputLogic.getMaxChancedValue()) {
+ GTLog.logger.error("Max Chance cannot be less or equal to Chance or more than {}. Actual: {}.",
+ ChancedOutputLogic.getMaxChancedValue(), maxChance, new Throwable());
+ recipeStatus = EnumValidationResult.INVALID;
+ return (R) this;
+ }
+
+ int scalar = Math.floorDiv(ChancedOutputLogic.getMaxChancedValue(), maxChance);
+ chance *= scalar;
+ maxChance *= scalar;
+
+ this.chancedFluidOutputs.add(new ChancedFluidOutput(stack.copy(), chance, maxChance, tierChanceBoost));
+ return (R) this;
+ }
+
  public R chancedFluidOutputs(List<ChancedFluidOutput> chancedOutputs) {
  for (ChancedFluidOutput output : chancedOutputs) {
  this.chancedFluidOutputs.add(output.copy());
@@ -757,25 +865,25 @@ private static GTRecipeInput ofGroovyIngredient(IIngredient ingredient) {
 
  public void chancedOutputsMultiply(Recipe chancedOutputsFrom, int numberOfOperations) {
  for (ChancedItemOutput entry : chancedOutputsFrom.getChancedOutputs().getChancedEntries()) {
- int chance = entry.getChance();
+ String fraction = String.format("%d/%d", entry.getChance(), entry.getMaxChance());
  int boost = entry.getChanceBoost();
 
  // Add individual chanced outputs per number of parallel operations performed, to mimic regular recipes.
  // This is done instead of simply batching the chanced outputs by the number of parallel operations
  // performed
  for (int i = 0; i < numberOfOperations; i++) {
- this.chancedOutput(entry.getIngredient().copy(), chance, boost);
+ this.chancedOutput(entry.getIngredient().copy(), fraction, boost);
  }
  }
  for (ChancedFluidOutput entry : chancedOutputsFrom.getChancedFluidOutputs().getChancedEntries()) {
- int chance = entry.getChance();
+ String fraction = String.format("%d/%d", entry.getChance(), entry.getMaxChance());
  int boost = entry.getChanceBoost();
 
  // Add individual chanced outputs per number of parallel operations performed, to mimic regular recipes.
  // This is done instead of simply batching the chanced outputs by the number of parallel operations
  // performed
  for (int i = 0; i < numberOfOperations; i++) {
- this.chancedFluidOutput(entry.getIngredient().copy(), chance, boost);
+ this.chancedFluidOutput(entry.getIngredient().copy(), fraction, boost);
  }
  }
  }

src/main/java/gregtech/api/recipes/chance/ChanceEntry.java

@@ -20,6 +20,8 @@ public interface ChanceEntry<T> {
  */
  int getChance();
 
+ int getMaxChance();
+
  /**
  * @return a copy of the chance entry
  */

src/main/java/gregtech/api/recipes/chance/output/BoostableChanceOutput.java

@@ -14,20 +14,40 @@ public abstract class BoostableChanceOutput<T> extends ChancedOutput<T> implemen
  private final int chanceBoost;
 
  public BoostableChanceOutput(@NotNull T ingredient, int chance, int chanceBoost) {
- super(ingredient, chance);
- this.chanceBoost = chanceBoost;
+ this(ingredient, chance, ChancedOutputLogic.getMaxChancedValue(), chanceBoost);
+ }
+
+ public BoostableChanceOutput(@NotNull T ingredient, int chance, int maxChance, int chanceBoost) {
+ super(ingredient, chance, maxChance);
+ this.chanceBoost = fixBoost(chanceBoost);
  }
 
  @Override
  public int getChanceBoost() {
  return this.chanceBoost;
  }
 
+ /**
+ * Attempts to fix and round the given chance boost due to potential differences
+ * between the max chance and {@link ChancedOutputLogic#getMaxChancedValue()}.
+ * <br />
+ * The worst case would be {@code 5,001 / 10,000} , meaning the boost would
+ * have to be halved to have the intended effect.
+ * 
+ * @param chanceBoost the chance boost to be fixed
+ * @return the fixed chance boost
+ */
+ private int fixBoost(int chanceBoost) {
+ float error = (float) ChancedOutputLogic.getMaxChancedValue() / getMaxChance();
+ return Math.round(chanceBoost / error);
+ }
+
  @Override
  public String toString() {
  return "BoostableChanceOutput{" +
  "ingredient=" + getIngredient() +
  ", chance=" + getChance() +
+ ", maxChance=" + getMaxChance() +
  ", chanceBoost=" + getChanceBoost() +
  '}';
  }