diff options
Diffstat (limited to 'src/main/java/gregtech')
58 files changed, 2719 insertions, 2455 deletions
diff --git a/src/main/java/gregtech/api/enums/HeatingCoilLevel.java b/src/main/java/gregtech/api/enums/HeatingCoilLevel.java index f80f8139c6..f281695d5a 100644 --- a/src/main/java/gregtech/api/enums/HeatingCoilLevel.java +++ b/src/main/java/gregtech/api/enums/HeatingCoilLevel.java @@ -1,5 +1,7 @@ package gregtech.api.enums; +import javax.annotation.Nonnull; + import net.minecraft.util.StatCollector; public enum HeatingCoilLevel { @@ -32,7 +34,7 @@ public enum HeatingCoilLevel { } /** - * @return the coil tier, used for discount in the Pyrolyse Oven for example. + * @return the coil tier, used for discount in the Pyrolyse Oven for example. LV == 0 */ public byte getTier() { return (byte) (this.ordinal() - 2); @@ -52,16 +54,43 @@ public enum HeatingCoilLevel { return 1 << Math.max(0, this.ordinal() - 5); } + /** + * @return Translated name of this coil + */ public String getName() { return StatCollector.translateToLocal("GT5U.coil." + this); } + @Nonnull public static HeatingCoilLevel getFromTier(byte tier) { if (tier < 0 || tier > getMaxTier()) return HeatingCoilLevel.None; return VALUES[tier + 2]; } + /** + * @param applyColor Whether to apply tiered color + * @return Translated coil name. Heat exceeding MAX is represented as "Eternal+". + */ + @Nonnull + public static String getDisplayNameFromHeat(int heat, boolean applyColor) { + for (HeatingCoilLevel heatLevel : VALUES) { + if (heatLevel == HeatingCoilLevel.None || heatLevel == HeatingCoilLevel.ULV) continue; + if (heatLevel.getHeat() >= heat) { + String name = heatLevel.getName(); + if (applyColor) { + name = GT_Values.TIER_COLORS[heatLevel.getTier() + 1] + name; + } + return name; + } + } + String name = HeatingCoilLevel.MAX.getName() + "+"; + if (applyColor) { + name = GT_Values.TIER_COLORS[HeatingCoilLevel.MAX.getTier() + 1] + name; + } + return name; + } + public static int size() { return VALUES.length; } diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java index 9a60092121..7b29f185c6 100644 --- a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java @@ -298,8 +298,7 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand void receiveClientEvent(byte aEventID, byte aValue); /** - * Called to actually play the Sound. Do not insert Client/Server checks. That is already done for you. Do not - * use @playSoundEffect, Minecraft doesn't like that at all. Use @playSound instead. + * Called to actually play the sound on client side. Client/Server check is already done. */ void doSound(byte aIndex, double aX, double aY, double aZ); diff --git a/src/main/java/gregtech/api/interfaces/modularui/ControllerWithOptionalFeatures.java b/src/main/java/gregtech/api/interfaces/modularui/ControllerWithOptionalFeatures.java index 9f862e254d..3d4ed80f67 100644 --- a/src/main/java/gregtech/api/interfaces/modularui/ControllerWithOptionalFeatures.java +++ b/src/main/java/gregtech/api/interfaces/modularui/ControllerWithOptionalFeatures.java @@ -20,6 +20,7 @@ import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; import gregtech.api.enums.SoundResource; import gregtech.api.enums.VoidingMode; import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.tileentity.IRecipeLockable; import gregtech.api.interfaces.tileentity.IVoidable; /** @@ -33,7 +34,7 @@ import gregtech.api.interfaces.tileentity.IVoidable; * <li>Recipe locking</li> * </ul> */ -public interface ControllerWithOptionalFeatures extends IVoidable { +public interface ControllerWithOptionalFeatures extends IVoidable, IRecipeLockable { boolean isAllowedToWork(); @@ -233,22 +234,6 @@ public interface ControllerWithOptionalFeatures extends IVoidable { return (ButtonWidget) button; } - /** - * Override this if you are a multi-block that has added support for single recipe locking. - */ - boolean supportsSingleRecipeLocking(); - - /** - * @return true if recipe locking is enabled, else false. This is getter is used for displaying the icon in the GUI - */ - boolean isRecipeLockingEnabled(); - - void setRecipeLocking(boolean enabled); - - default boolean getDefaultRecipeLockingMode() { - return false; - } - Pos2d getRecipeLockingButtonPos(); default ButtonWidget createLockToSingleRecipeButton(IWidgetBuilder<?> builder) { diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java index 64d206aff7..6d81d5c401 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java @@ -136,8 +136,9 @@ public interface IHasWorldObjectAndCoords { boolean isDead(); /** - * Sends a Block Event to the Client TileEntity, the byte Parameters are only for validation as Minecraft doesn't - * properly write Packet Data. + * Sends a Block Event to the Client TileEntity. + * + * @param aValue value to sync */ void sendBlockEvent(byte aID, byte aValue); diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRecipeLockable.java b/src/main/java/gregtech/api/interfaces/tileentity/IRecipeLockable.java new file mode 100644 index 0000000000..f793221a50 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRecipeLockable.java @@ -0,0 +1,34 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.recipe.check.SingleRecipeCheck; +import gregtech.api.util.GT_Recipe; + +/** + * Machines implementing this interface can have logic to lock to a single recipe. + */ +public interface IRecipeLockable { + + /** + * @return if this machine supports single recipe locking. + */ + boolean supportsSingleRecipeLocking(); + + /** + * @return true if recipe locking is enabled, else false. This is getter is used for displaying the icon in the GUI + */ + boolean isRecipeLockingEnabled(); + + void setRecipeLocking(boolean enabled); + + default boolean getDefaultRecipeLockingMode() { + return false; + } + + default SingleRecipeCheck getSingleRecipeCheck() { + return null; + } + + default void setSingleRecipeCheck(SingleRecipeCheck recipeCheck) {} + + GT_Recipe.GT_Recipe_Map getRecipeMap(); +} diff --git a/src/main/java/gregtech/api/logic/ProcessingLogic.java b/src/main/java/gregtech/api/logic/ProcessingLogic.java index fa0d285401..db97ac151f 100644 --- a/src/main/java/gregtech/api/logic/ProcessingLogic.java +++ b/src/main/java/gregtech/api/logic/ProcessingLogic.java @@ -1,39 +1,89 @@ package gregtech.api.logic; +import java.util.List; +import java.util.function.Supplier; + +import javax.annotation.Nonnull; + import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.FluidStack; +import gregtech.api.interfaces.tileentity.IRecipeLockable; +import gregtech.api.interfaces.tileentity.IVoidable; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.recipe.check.FindRecipeResult; +import gregtech.api.recipe.check.SingleRecipeCheck; +import gregtech.api.util.GT_OverclockCalculator; +import gregtech.api.util.GT_ParallelHelper; +import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Recipe.GT_Recipe_Map; -public abstract class ProcessingLogic { +/** + * Logic class to calculate result of recipe check from inputs, based on recipemap. + */ +@SuppressWarnings({ "unused", "UnusedReturnValue" }) +public class ProcessingLogic { - protected GT_Recipe_Map recipeMap; + protected IVoidable machine; + protected IRecipeLockable recipeLockableMachine; + protected Supplier<GT_Recipe_Map> recipeMapSupplier; + protected GT_Recipe lastRecipe; protected ItemStack[] inputItems; protected ItemStack[] outputItems; protected ItemStack[] currentOutputItems; protected FluidStack[] inputFluids; protected FluidStack[] outputFluids; protected FluidStack[] currentOutputFluids; - protected long eut; - protected long duration; + protected long calculatedEut; + protected int duration; + protected long availableVoltage; + protected long availableAmperage; + protected int overClockTimeReduction = 1; + protected int overClockPowerIncrease = 2; + protected boolean protectItems; + protected boolean protectFluids; + protected boolean isRecipeLocked; + protected int maxParallel = 1; + protected int calculatedParallels = 0; + protected Supplier<Integer> maxParallelSupplier; + protected int batchSize = 1; public ProcessingLogic() {} + // region Setters + public ProcessingLogic setInputItems(ItemStack... itemInputs) { this.inputItems = itemInputs; return this; } + public ProcessingLogic setInputItems(List<ItemStack> itemOutputs) { + this.inputItems = itemOutputs.toArray(new ItemStack[0]); + return this; + } + public ProcessingLogic setInputFluids(FluidStack... fluidInputs) { this.inputFluids = fluidInputs; return this; } + public ProcessingLogic setInputFluids(List<FluidStack> fluidInputs) { + this.inputFluids = fluidInputs.toArray(new FluidStack[0]); + return this; + } + + /** + * Overwrites item output result of the calculation. + */ public ProcessingLogic setOutputItems(ItemStack... itemOutputs) { this.outputItems = itemOutputs; return this; } + /** + * Overwrites fluid output result of the calculation. + */ public ProcessingLogic setOutputFluids(FluidStack... fluidOutputs) { this.outputFluids = fluidOutputs; return this; @@ -49,35 +99,263 @@ public abstract class ProcessingLogic { return this; } + /** + * Enables single recipe locking mode. + */ + public ProcessingLogic setRecipeLocking(IRecipeLockable recipeLockableMachine, boolean isRecipeLocked) { + this.recipeLockableMachine = recipeLockableMachine; + this.isRecipeLocked = isRecipeLocked; + return this; + } + + /** + * Sets max amount of parallel. + */ + public ProcessingLogic setMaxParallel(int maxParallel) { + this.maxParallel = maxParallel; + return this; + } + + /** + * Sets method to get max amount of parallel. + */ + public ProcessingLogic setMaxParallelSupplier(Supplier<Integer> supplier) { + this.maxParallelSupplier = supplier; + return this; + } + + /** + * Sets batch size for batch mode. + */ + public ProcessingLogic setBatchSize(int size) { + this.batchSize = size; + return this; + } + public ProcessingLogic setRecipeMap(GT_Recipe_Map recipeMap) { - this.recipeMap = recipeMap; + return setRecipeMapSupplier(() -> recipeMap); + } + + public ProcessingLogic setRecipeMapSupplier(Supplier<GT_Recipe_Map> supplier) { + this.recipeMapSupplier = supplier; + return this; + } + + /** + * Sets machine used for void protection logic. + */ + public ProcessingLogic setMachine(IVoidable machine) { + this.machine = machine; return this; } - public ProcessingLogic setDuration(long duration) { + /** + * Overwrites duration result of the calculation. + */ + public ProcessingLogic setDuration(int duration) { this.duration = duration; return this; } - public ProcessingLogic setEut(long eut) { - this.eut = eut; + /** + * Overwrites EU/t result of the calculation. + */ + public ProcessingLogic setCalculatedEut(long calculatedEut) { + this.calculatedEut = calculatedEut; + return this; + } + + /** + * Sets voltage of the machine. It doesn't need to be actual voltage (excluding amperage) of the machine; + * For example, most of the multiblock machines set maximum possible input power (including amperage) as voltage + * and 1 as amperage. That way recipemap search will be executed with overclocked voltage. + */ + public ProcessingLogic setAvailableVoltage(long voltage) { + availableVoltage = voltage; + return this; + } + + /** + * Sets amperage of the machine. This amperage doesn't involve in EU/t when searching recipemap. + * Useful for preventing tier skip but still considering amperage for parallel. + */ + public ProcessingLogic setAvailableAmperage(long amperage) { + availableAmperage = amperage; return this; } + public ProcessingLogic setVoidProtection(boolean protectItems, boolean protectFluids) { + this.protectItems = protectItems; + this.protectFluids = protectFluids; + return this; + } + + /** + * Sets custom overclock ratio. 2/4 by default. + * Parameters represent number of bit shift, so 1 -> 2x, 2 -> 4x. + */ + public ProcessingLogic setOverclock(int timeReduction, int powerIncrease) { + this.overClockTimeReduction = timeReduction; + this.overClockPowerIncrease = powerIncrease; + return this; + } + + /** + * Sets overclock ratio to 4/4. + */ + public ProcessingLogic enablePerfectOverclock() { + return this.setOverclock(2, 2); + } + /** - * Clears everything stored in the Processing Logic other than the Recipe map used + * Clears calculated results and provided machine inputs to prepare for the next machine operation. */ public ProcessingLogic clear() { this.inputItems = null; this.inputFluids = null; this.outputItems = null; this.outputFluids = null; - this.eut = 0; + this.calculatedEut = 0; this.duration = 0; + this.calculatedParallels = 0; return this; } - public abstract boolean process(); + // endregion + + // region Logic + + /** + * Executes the recipe check: Find recipe from recipemap, Calculate parallel, overclock and outputs. + */ + @Nonnull + public CheckRecipeResult process() { + if (recipeMapSupplier == null) return CheckRecipeResultRegistry.NO_RECIPE; + + GT_Recipe_Map recipeMap = recipeMapSupplier.get(); + if (recipeMap == null) return CheckRecipeResultRegistry.NO_RECIPE; + + if (maxParallelSupplier != null) { + maxParallel = maxParallelSupplier.get(); + } + + FindRecipeResult findRecipeResult; + if (isRecipeLocked && recipeLockableMachine != null && recipeLockableMachine.getSingleRecipeCheck() != null) { + // Recipe checker is already built, we'll use it + SingleRecipeCheck singleRecipeCheck = recipeLockableMachine.getSingleRecipeCheck(); + // Validate recipe here, otherwise machine will show "not enough output space" + // even if recipe cannot be found + if (singleRecipeCheck.checkRecipeInputs(false, 1, inputItems, inputFluids) == 0) { + return CheckRecipeResultRegistry.NO_RECIPE; + } + findRecipeResult = FindRecipeResult.ofSuccess( + recipeLockableMachine.getSingleRecipeCheck() + .getRecipe()); + } else { + findRecipeResult = recipeMap + .findRecipeWithResult(lastRecipe, false, false, availableVoltage, inputFluids, null, inputItems); + } + + GT_Recipe recipe; + if (findRecipeResult.isSuccessful()) { + recipe = findRecipeResult.getRecipeNonNull(); + CheckRecipeResult result = validateRecipe(recipe); + if (!result.wasSuccessful()) { + return result; + } else { + lastRecipe = recipe; + } + } else { + if (findRecipeResult.getState() == FindRecipeResult.State.INSUFFICIENT_VOLTAGE) { + return CheckRecipeResultRegistry.insufficientPower(findRecipeResult.getRecipeNonNull().mEUt); + } else { + return CheckRecipeResultRegistry.NO_RECIPE; + } + } + + GT_ParallelHelper helper = createParallelHelper(recipe); + + helper.build(); + + if (helper.getCurrentParallel() <= 0) return CheckRecipeResultRegistry.OUTPUT_FULL; + + calculatedParallels = helper.getCurrentParallel(); + + GT_OverclockCalculator calculator = createOverclockCalculator(recipe, helper); + + calculator.calculate(); + if (calculator.getConsumption() == Long.MAX_VALUE) { + return CheckRecipeResultRegistry.POWER_OVERFLOW; |