mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 04:52:25 +00:00
Update auto-sorting in factories
This commit is contained in:
1 parent
1dc04f3d81
commit
38ff4a5d19
1 file changed
+221
-87
@@ -1,29 +1,14 @@
|
||||
package mekanism.common.tile;
|
||||
|
||||
import io.netty.buffer.ByteBuf;
|
||||
import java.util.Arrays;
|
||||
import java.util.Objects;
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import mekanism.api.EnumColor;
|
||||
import mekanism.api.IConfigCardAccess.ISpecialConfigData;
|
||||
import mekanism.api.TileNetworkList;
|
||||
import mekanism.api.gas.Gas;
|
||||
import mekanism.api.gas.GasStack;
|
||||
import mekanism.api.gas.GasTank;
|
||||
import mekanism.api.gas.GasTankInfo;
|
||||
import mekanism.api.gas.IGasHandler;
|
||||
import mekanism.api.gas.IGasItem;
|
||||
import mekanism.api.gas.*;
|
||||
import mekanism.api.infuse.InfuseObject;
|
||||
import mekanism.api.infuse.InfuseRegistry;
|
||||
import mekanism.api.transmitters.TransmissionType;
|
||||
import mekanism.common.InfuseStorage;
|
||||
import mekanism.common.Mekanism;
|
||||
import mekanism.common.MekanismBlocks;
|
||||
import mekanism.common.MekanismItems;
|
||||
import mekanism.common.PacketHandler;
|
||||
import mekanism.common.SideData;
|
||||
import mekanism.common.Upgrade;
|
||||
import mekanism.common.*;
|
||||
import mekanism.common.base.IComparatorSupport;
|
||||
import mekanism.common.base.IFactory.MachineFuelType;
|
||||
import mekanism.common.base.IFactory.RecipeType;
|
||||
@@ -40,28 +25,17 @@ import mekanism.common.recipe.inputs.AdvancedMachineInput;
|
||||
import mekanism.common.recipe.inputs.DoubleMachineInput;
|
||||
import mekanism.common.recipe.inputs.InfusionInput;
|
||||
import mekanism.common.recipe.inputs.ItemStackInput;
|
||||
import mekanism.common.recipe.machines.AdvancedMachineRecipe;
|
||||
import mekanism.common.recipe.machines.BasicMachineRecipe;
|
||||
import mekanism.common.recipe.machines.ChanceMachineRecipe;
|
||||
import mekanism.common.recipe.machines.DoubleMachineRecipe;
|
||||
import mekanism.common.recipe.machines.MachineRecipe;
|
||||
import mekanism.common.recipe.machines.MetallurgicInfuserRecipe;
|
||||
import mekanism.common.recipe.machines.*;
|
||||
import mekanism.common.recipe.outputs.ChanceOutput;
|
||||
import mekanism.common.recipe.outputs.ItemStackOutput;
|
||||
import mekanism.common.recipe.outputs.PressurizedOutput;
|
||||
import mekanism.common.tier.BaseTier;
|
||||
import mekanism.common.tier.FactoryTier;
|
||||
import mekanism.common.tile.component.TileComponentConfig;
|
||||
import mekanism.common.tile.component.TileComponentEjector;
|
||||
import mekanism.common.tile.prefab.TileEntityAdvancedElectricMachine;
|
||||
import mekanism.common.tile.prefab.TileEntityMachine;
|
||||
import mekanism.common.util.ChargeUtils;
|
||||
import mekanism.common.util.GasUtils;
|
||||
import mekanism.common.util.InventoryUtils;
|
||||
import mekanism.common.util.ItemDataUtils;
|
||||
import mekanism.common.util.LangUtils;
|
||||
import mekanism.common.util.MekanismUtils;
|
||||
import mekanism.common.util.StackUtils;
|
||||
import mekanism.common.util.StatUtils;
|
||||
import mekanism.common.util.TileUtils;
|
||||
import mekanism.common.util.*;
|
||||
import net.minecraft.inventory.Container;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
@@ -69,12 +43,26 @@ import net.minecraft.util.EnumFacing;
|
||||
import net.minecraft.util.NonNullList;
|
||||
import net.minecraftforge.common.capabilities.Capability;
|
||||
import net.minecraftforge.fml.common.FMLCommonHandler;
|
||||
import net.minecraftforge.items.ItemHandlerHelper;
|
||||
import org.apache.commons.lang3.tuple.ImmutablePair;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.*;
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public class TileEntityFactory extends TileEntityMachine implements IComputerIntegration, ISideConfiguration, IGasHandler, ISpecialConfigData, ITierUpgradeable,
|
||||
ISustainedData, IComparatorSupport {
|
||||
ISustainedData, IComparatorSupport {
|
||||
|
||||
private static final String[] methods = new String[]{"getEnergy", "getProgress", "facing", "canOperate", "getMaxEnergy", "getEnergyNeeded"};
|
||||
/**
|
||||
* How long it takes this factory to switch recipe types.
|
||||
*/
|
||||
private static final int RECIPE_TICKS_REQUIRED = 40;
|
||||
/**
|
||||
* The amount of infuse this machine has stored.
|
||||
*/
|
||||
public final InfuseStorage infuseStored = new InfuseStorage();
|
||||
public final GasTank gasTank;
|
||||
private final MachineRecipe[] cachedRecipe;
|
||||
/**
|
||||
* This Factory's tier.
|
||||
@@ -94,34 +82,20 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
* How many ticks it takes, with upgrades, to run an operation
|
||||
*/
|
||||
public int ticksRequired = 200;
|
||||
public boolean sorting;
|
||||
public boolean upgraded;
|
||||
public double lastUsage;
|
||||
public TileComponentEjector ejectorComponent;
|
||||
public TileComponentConfig configComponent;
|
||||
/**
|
||||
* How much secondary energy each operation consumes per tick
|
||||
*/
|
||||
private double secondaryEnergyPerTick = 0;
|
||||
private int secondaryEnergyThisTick;
|
||||
/**
|
||||
* How long it takes this factory to switch recipe types.
|
||||
*/
|
||||
private static int RECIPE_TICKS_REQUIRED = 40;
|
||||
/**
|
||||
* How many recipe ticks have progressed.
|
||||
*/
|
||||
private int recipeTicks;
|
||||
/**
|
||||
* The amount of infuse this machine has stored.
|
||||
*/
|
||||
public final InfuseStorage infuseStored = new InfuseStorage();
|
||||
|
||||
public final GasTank gasTank;
|
||||
|
||||
public boolean sorting;
|
||||
|
||||
public boolean upgraded;
|
||||
|
||||
public double lastUsage;
|
||||
|
||||
public TileComponentEjector ejectorComponent;
|
||||
public TileComponentConfig configComponent;
|
||||
/**
|
||||
* This machine's recipe type.
|
||||
*/
|
||||
@@ -278,7 +252,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
|
||||
for (int process = 0; process < tier.processes; process++) {
|
||||
if (MekanismUtils.canFunction(this) && canOperate(getInputSlot(process), getOutputSlot(process))
|
||||
&& getEnergy() >= energyPerTick && gasTank.getStored() >= secondaryEnergyThisTick) {
|
||||
&& getEnergy() >= energyPerTick && gasTank.getStored() >= secondaryEnergyThisTick) {
|
||||
if ((progress[process] + 1) < ticksRequired) {
|
||||
progress[process]++;
|
||||
gasTank.draw(secondaryEnergyThisTick, true);
|
||||
@@ -362,38 +336,174 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
//If something went wrong finding the tier don't sort it
|
||||
return;
|
||||
}
|
||||
for (int i = 0; i < inputSlots.length; i++) {
|
||||
int slotID = inputSlots[i];
|
||||
ItemStack stack = inventory.get(slotID);
|
||||
int count = stack.getCount();
|
||||
ItemStack output = inventory.get(tier.processes + slotID);
|
||||
for (int j = i + 1; j < inputSlots.length; j++) {
|
||||
int checkSlotID = inputSlots[j];
|
||||
ItemStack checkStack = inventory.get(checkSlotID);
|
||||
if (Math.abs(count - checkStack.getCount()) < 2 ||
|
||||
!InventoryUtils.areItemsStackable(stack, checkStack)) {
|
||||
continue;
|
||||
}
|
||||
//Output/Input will not match
|
||||
// Only check if the input spot is empty otherwise assume it works
|
||||
if (stack.isEmpty() && !inputProducesOutput(checkSlotID, checkStack, output, true) ||
|
||||
checkStack.isEmpty() && !inputProducesOutput(slotID, stack, inventory.get(tier.processes + checkSlotID), true)) {
|
||||
continue;
|
||||
Map<String, ProcessDescription> recipeSlots = new HashMap<>();
|
||||
List<Integer> freeSlots = new ArrayList<>();
|
||||
List<Integer> outputBlockedSlots = new ArrayList<>();
|
||||
for (int slotID : inputSlots) {
|
||||
ItemStack inStack = inventory.get(slotID);
|
||||
ItemStack outStack = inventory.get(slotID + tier.processes);
|
||||
MachineRecipe slotRecipe = getSlotRecipe(slotID, inStack);
|
||||
if (slotRecipe != null) {
|
||||
ItemStack recipeIn = getRecipeInput(slotRecipe);
|
||||
ItemStack recipeOut = getRecipeOutput(slotRecipe);
|
||||
|
||||
// We don't care about extras here since there's no possibility to have
|
||||
// recipes with different extras in one factory at the same time
|
||||
String id = new ImmutablePair<>(recipeIn, recipeOut).toString();
|
||||
|
||||
if (!recipeSlots.containsKey(id)) {
|
||||
recipeSlots.put(id, new ProcessDescription(recipeIn, recipeOut));
|
||||
}
|
||||
|
||||
//Balance the two slots
|
||||
int total = count + checkStack.getCount();
|
||||
ItemStack newStack = stack.isEmpty() ? checkStack : stack;
|
||||
inventory.set(slotID, StackUtils.size(newStack, (total + 1) / 2));
|
||||
inventory.set(checkSlotID, StackUtils.size(newStack, total / 2));
|
||||
recipeSlots.get(id).occupySlot(slotID);
|
||||
} else {
|
||||
if (outStack.getCount() <= 0 || outStack.isEmpty()) {
|
||||
freeSlots.add(slotID);
|
||||
} else {
|
||||
outputBlockedSlots.add(slotID);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
markDirty();
|
||||
return;
|
||||
if (recipeSlots.size() == 0) return;
|
||||
|
||||
int freePerSlot = freeSlots.size() / recipeSlots.size();
|
||||
int excess = freeSlots.size() - (freePerSlot * recipeSlots.size());
|
||||
|
||||
for (Map.Entry<String, ProcessDescription> line : recipeSlots.entrySet()) {
|
||||
int takeSlots = freePerSlot;
|
||||
|
||||
if (excess > 0) {
|
||||
takeSlots += 1;
|
||||
excess -= 1;
|
||||
}
|
||||
|
||||
while (takeSlots > 0) {
|
||||
line.getValue().occupySlot(freeSlots.get(0));
|
||||
freeSlots.remove(0);
|
||||
takeSlots -= 1;
|
||||
}
|
||||
|
||||
Set<Integer> taken = new HashSet<>();
|
||||
|
||||
outputBlockedSlots.forEach(slot -> {
|
||||
ItemStack outStack = inventory.get(slot + tier.processes);
|
||||
ItemStack recipeOutStack = line.getValue().getOutput();
|
||||
|
||||
if (taken.contains(slot)) return;
|
||||
|
||||
if (outStack.isItemEqual(recipeOutStack) || recipeOutStack.isEmpty()) {
|
||||
taken.add(slot);
|
||||
line.getValue().occupySlot(slot);
|
||||
}
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
for (Map.Entry<String, ProcessDescription> line : recipeSlots.entrySet()) {
|
||||
int total = line.getValue().getOccupiedSlots().stream()
|
||||
.map(v -> inventory.get(v).getCount())
|
||||
.reduce(0, Integer::sum);
|
||||
int count = line.getValue().getOccupiedSlots().size();
|
||||
|
||||
if (count == 0) continue;
|
||||
|
||||
int minCount = line.getValue().getInput().getCount();
|
||||
|
||||
int itemsPerSlot = total / count;
|
||||
int excessItems = total - (itemsPerSlot * count);
|
||||
|
||||
for (Integer slot : line.getValue().getOccupiedSlots()) {
|
||||
int actualCount = itemsPerSlot;
|
||||
|
||||
if (excessItems > 0) {
|
||||
excessItems -= 1;
|
||||
actualCount += 1;
|
||||
}
|
||||
|
||||
actualCount = Math.max(actualCount, minCount);
|
||||
|
||||
if (total - actualCount < minCount) {
|
||||
actualCount = total;
|
||||
}
|
||||
|
||||
inventory.set(slot, StackUtils.size(line.getValue().getInput(), actualCount));
|
||||
|
||||
total -= actualCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public ItemStack getRecipeOutput(MachineRecipe recipe) {
|
||||
if (recipe.recipeOutput instanceof ItemStackOutput) {
|
||||
return ((ItemStackOutput) recipe.recipeOutput).output;
|
||||
} else if (recipe.recipeOutput instanceof ChanceOutput) {
|
||||
return ((ChanceOutput) recipe.recipeOutput).primaryOutput;
|
||||
} else if (recipe.recipeOutput instanceof PressurizedOutput) {
|
||||
return ((PressurizedOutput) recipe.recipeOutput).getItemOutput();
|
||||
} else {
|
||||
return ItemStack.EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
public ItemStack getRecipeInput(MachineRecipe recipe) {
|
||||
if (recipe.recipeInput instanceof ItemStackInput) {
|
||||
return ((ItemStackInput) recipe.recipeInput).ingredient;
|
||||
} else if (recipe.recipeInput instanceof AdvancedMachineInput) {
|
||||
AdvancedMachineInput advancedInput = (AdvancedMachineInput) recipe.recipeInput;
|
||||
return advancedInput.itemStack;
|
||||
} else if (recipe.recipeInput instanceof DoubleMachineInput) {
|
||||
DoubleMachineInput doubleMachineInput = (DoubleMachineInput) recipe.recipeInput;
|
||||
return doubleMachineInput.itemStack;
|
||||
} else if (recipe.recipeInput instanceof InfusionInput) {
|
||||
InfusionInput infusionInput = (InfusionInput) recipe.recipeInput;
|
||||
return infusionInput.inputStack;
|
||||
} else {
|
||||
return ItemStack.EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
public MachineRecipe getSlotRecipe(int slotID, ItemStack fallbackInput) {
|
||||
int process = getOperation(slotID);
|
||||
//cached recipe may be invalid
|
||||
MachineRecipe cached = cachedRecipe[process];
|
||||
ItemStack extra = inventory.get(4);
|
||||
if (cached == null) {
|
||||
cached = recipeType.getAnyRecipe(fallbackInput, extra, gasTank.getGasType(), infuseStored);
|
||||
|
||||
if (cached == null) { // We have not enough input probably
|
||||
cached = recipeType.getAnyRecipe(StackUtils.size(fallbackInput, fallbackInput.getMaxStackSize()), extra, gasTank.getGasType(), infuseStored);
|
||||
}
|
||||
} else {
|
||||
ItemStack recipeInput = ItemStack.EMPTY;
|
||||
boolean secondaryMatch = true;
|
||||
if (cached.recipeInput instanceof ItemStackInput) {
|
||||
recipeInput = ((ItemStackInput) cached.recipeInput).ingredient;
|
||||
} else if (cached.recipeInput instanceof AdvancedMachineInput) {
|
||||
AdvancedMachineInput advancedInput = (AdvancedMachineInput) cached.recipeInput;
|
||||
recipeInput = advancedInput.itemStack;
|
||||
secondaryMatch = gasTank.getGasType() == null || advancedInput.gasType == gasTank.getGasType();
|
||||
} else if (cached.recipeInput instanceof DoubleMachineInput) {
|
||||
DoubleMachineInput doubleMachineInput = (DoubleMachineInput) cached.recipeInput;
|
||||
recipeInput = doubleMachineInput.itemStack;
|
||||
secondaryMatch = extra.isEmpty() || ItemStack.areItemsEqual(doubleMachineInput.extraStack, extra);
|
||||
} else if (cached.recipeInput instanceof InfusionInput) {
|
||||
InfusionInput infusionInput = (InfusionInput) cached.recipeInput;
|
||||
recipeInput = infusionInput.inputStack;
|
||||
secondaryMatch = infuseStored.getAmount() == 0 || infuseStored.getType() == infusionInput.infuse.getType();
|
||||
}
|
||||
//If there is no cached item input or it doesn't match our fallback
|
||||
// then it is an out of date cache so we compare against the new one
|
||||
// and update the cache while we are at it
|
||||
if (recipeInput.isEmpty() || !secondaryMatch || !ItemStack.areItemsEqual(recipeInput, fallbackInput)) {
|
||||
cached = recipeType.getAnyRecipe(fallbackInput, extra, gasTank.getGasType(), infuseStored);
|
||||
}
|
||||
}
|
||||
|
||||
return cached;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the cached recipe (or recipe for current factory if the cache is out of date) can produce a specific output.
|
||||
*
|
||||
@@ -401,7 +511,6 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
* @param fallbackInput Used if the cached recipe is null or to validate the cached recipe is not out of date.
|
||||
* @param output The output we want.
|
||||
* @param updateCache True to make the cached recipe get updated if it is out of date.
|
||||
*
|
||||
* @return True if the recipe produces the given output.
|
||||
*/
|
||||
public boolean inputProducesOutput(int slotID, ItemStack fallbackInput, ItemStack output, boolean updateCache) {
|
||||
@@ -524,10 +633,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
return true;
|
||||
} else if (tier == FactoryTier.ELITE && slotID >= 12 && slotID <= 18) {
|
||||
return true;
|
||||
} else if (recipeType.getFuelType() == MachineFuelType.CHANCE && slotID == 4) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
} else return recipeType.getFuelType() == MachineFuelType.CHANCE && slotID == 4;
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -608,7 +714,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
|
||||
if (recipeType.getFuelType() == MachineFuelType.ADVANCED) {
|
||||
if (cachedRecipe[process] instanceof AdvancedMachineRecipe &&
|
||||
((AdvancedMachineRecipe) cachedRecipe[process]).inputMatches(inventory, inputSlot, gasTank, secondaryEnergyThisTick)) {
|
||||
((AdvancedMachineRecipe) cachedRecipe[process]).inputMatches(inventory, inputSlot, gasTank, secondaryEnergyThisTick)) {
|
||||
return ((AdvancedMachineRecipe) cachedRecipe[process]).canOperate(inventory, inputSlot, outputSlot, gasTank, secondaryEnergyThisTick);
|
||||
}
|
||||
AdvancedMachineRecipe<?> recipe = recipeType.getRecipe(inventory.get(inputSlot), gasTank.getGasType());
|
||||
@@ -851,7 +957,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
return new Object[]{"No such operation found."};
|
||||
}
|
||||
return new Object[]{
|
||||
canOperate(getInputSlot(index), getOutputSlot(index))};
|
||||
canOperate(getInputSlot(index), getOutputSlot(index))};
|
||||
case 4:
|
||||
return new Object[]{getMaxEnergy()};
|
||||
case 5:
|
||||
@@ -925,7 +1031,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
return false;
|
||||
}
|
||||
return capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY
|
||||
|| capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY || super.hasCapability(capability, side);
|
||||
|| capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY || super.hasCapability(capability, side);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -934,7 +1040,7 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
return null;
|
||||
}
|
||||
if (capability == Capabilities.GAS_HANDLER_CAPABILITY || capability == Capabilities.CONFIG_CARD_CAPABILITY
|
||||
|| capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY) {
|
||||
|| capability == Capabilities.SPECIAL_CONFIG_DATA_CAPABILITY) {
|
||||
return (T) this;
|
||||
}
|
||||
return super.getCapability(capability, side);
|
||||
@@ -1003,4 +1109,32 @@ public class TileEntityFactory extends TileEntityMachine implements IComputerInt
|
||||
public int getRedstoneLevel() {
|
||||
return Container.calcRedstoneFromInventory(this);
|
||||
}
|
||||
|
||||
private class ProcessDescription {
|
||||
private final ItemStack input;
|
||||
private final ItemStack output;
|
||||
private final Set<Integer> occupiedSlots;
|
||||
|
||||
public ProcessDescription(ItemStack input, ItemStack output) {
|
||||
this.input = input;
|
||||
this.output = output;
|
||||
this.occupiedSlots = new HashSet<>();
|
||||
}
|
||||
|
||||
public ItemStack getInput() {
|
||||
return input;
|
||||
}
|
||||
|
||||
public ItemStack getOutput() {
|
||||
return output;
|
||||
}
|
||||
|
||||
public Set<Integer> getOccupiedSlots() {
|
||||
return occupiedSlots;
|
||||
}
|
||||
|
||||
void occupySlot(Integer slot) {
|
||||
occupiedSlots.add(slot);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user