diff options
Diffstat (limited to 'src/main/java/gregtech')
4 files changed, 163 insertions, 74 deletions
diff --git a/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java b/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java index 26f9dedd7d..7a2d8661dd 100644 --- a/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java +++ b/src/main/java/gregtech/api/recipe/check/CheckRecipeResultRegistry.java @@ -102,10 +102,18 @@ public final class CheckRecipeResultRegistry { return new ResultInsufficientMachineTier(required); } + /** + * Cannot process recipe because the machine doesn't have enough startup power. + */ + public static CheckRecipeResult insufficientStartupPower(int required) { + return new ResultInsufficientStartupPower(required); + } + static { register(new SimpleCheckRecipeResult(false, "")); register(new ResultInsufficientPower(0)); register(new ResultInsufficientHeat(0)); register(new ResultInsufficientMachineTier(0)); + register(new ResultInsufficientStartupPower(0)); } } diff --git a/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java b/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java new file mode 100644 index 0000000000..42b352563d --- /dev/null +++ b/src/main/java/gregtech/api/recipe/check/ResultInsufficientStartupPower.java @@ -0,0 +1,54 @@ +package gregtech.api.recipe.check; + +import net.minecraft.network.PacketBuffer; +import net.minecraft.util.StatCollector; + +import gregtech.api.util.GT_Utility; + +public class ResultInsufficientStartupPower implements CheckRecipeResult { + + private int required; + + ResultInsufficientStartupPower(int required) { + this.required = required; + } + + @Override + public String getID() { + return "insufficient_startup_power"; + } + + @Override + public boolean wasSuccessful() { + return false; + } + + @Override + public String getDisplayString() { + return StatCollector + .translateToLocalFormatted("GT5U.gui.text.insufficient_startup_power", GT_Utility.formatNumbers(required)); + } + + @Override + public CheckRecipeResult newInstance() { + return new ResultInsufficientStartupPower(0); + } + + @Override + public void encode(PacketBuffer buffer) { + buffer.writeVarIntToBuffer(required); + } + + @Override + public void decode(PacketBuffer buffer) { + required = buffer.readVarIntFromBuffer(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ResultInsufficientStartupPower that = (ResultInsufficientStartupPower) o; + return required == that.required; + } +} diff --git a/src/main/java/gregtech/api/util/GT_OverclockCalculator.java b/src/main/java/gregtech/api/util/GT_OverclockCalculator.java index 026f5e3fc9..d8948fc265 100644 --- a/src/main/java/gregtech/api/util/GT_OverclockCalculator.java +++ b/src/main/java/gregtech/api/util/GT_OverclockCalculator.java @@ -40,6 +40,13 @@ public class GT_OverclockCalculator { */ private boolean mHeatOC, mOneTickDiscount, calculated, mHeatDiscount; + /** If the OC calculator should only do a given amount of overclocks. Mainly used in fusion reactors */ + private boolean limitOverclocks; + /** Maximum amount of overclocks to perform, when limitOverclocks = true */ + private int maxOverclocks; + /** How many overclocks have been performed */ + private int overclockCount; + private static final int HEAT_DISCOUNT_THRESHOLD = 900; private static final int HEAT_PERFECT_OVERCLOCK_THRESHOLD = 1800; @@ -213,6 +220,16 @@ public class GT_OverclockCalculator { } /** + * Limit the amount of overclocks that can be performed, regardless of how much power is available. Mainly used for + * fusion reactors. + */ + public GT_OverclockCalculator limitOverclockCount(int maxOverclocks) { + this.limitOverclocks = true; + this.maxOverclocks = maxOverclocks; + return this; + } + + /** * Call this when all values have been put it. */ public GT_OverclockCalculator calculate() { @@ -250,7 +267,8 @@ public class GT_OverclockCalculator { long tNextConsumption = ((long) Math .ceil(mRecipeEUt * mParallel * mRecipeAmps * mEUtDiscount * heatDiscountMultiplier)) << mEUtIncreasePerOC; - while (tTierDifference > 0 && tNextConsumption < mEUt * mAmps) { + while (tTierDifference > 0 && tNextConsumption < mEUt * mAmps + && (!limitOverclocks || overclockCount++ < maxOverclocks)) { if (mDuration <= 1) { break; } @@ -263,7 +281,7 @@ public class GT_OverclockCalculator { long tNextConsumption = ((long) Math .ceil(mRecipeEUt * mParallel * mRecipeAmps * mEUtDiscount * heatDiscountMultiplier)) << mEUtIncreasePerOC; - while (tNextConsumption < mEUt * mAmps) { + while (tNextConsumption < mEUt * mAmps && (!limitOverclocks || overclockCount++ < maxOverclocks)) { if (mDuration <= 1) { break; } @@ -307,4 +325,14 @@ public class GT_OverclockCalculator { } return mDuration; } + + /** + * @return Number of performed overclocks + */ + public int getPerformedOverclocks() { + if (!calculated) { + calculate(); + } + return overclockCount; + } } diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java index fd77caa201..9f839ccdda 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java @@ -12,8 +12,6 @@ import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; import static gregtech.api.util.GT_StructureUtility.filterByMTETier; -import java.util.ArrayList; - import net.minecraft.block.Block; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -48,6 +46,7 @@ import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.modularui.IAddUIWidgets; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.logic.ProcessingLogic; import gregtech.api.metatileentity.MetaTileEntity; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy; @@ -58,6 +57,8 @@ import gregtech.api.recipe.check.CheckRecipeResult; import gregtech.api.recipe.check.CheckRecipeResultRegistry; import gregtech.api.render.TextureFactory; import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_OverclockCalculator; +import gregtech.api.util.GT_ParallelHelper; import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Utility; import gregtech.common.power.FusionPower; @@ -170,13 +171,11 @@ public abstract class GT_MetaTileEntity_FusionComputer } @Override - public void saveNBTData(NBTTagCompound aNBT) { - super.saveNBTData(aNBT); - } - - @Override public void loadNBTData(NBTTagCompound aNBT) { super.loadNBTData(aNBT); + if (mEUt > 0) { + mEUt = -mEUt; + } } @Override @@ -276,65 +275,82 @@ public abstract class GT_MetaTileEntity_FusionComputer public int overclock(int mStartEnergy) { if (tierOverclock() == 1) { - return 1; + return 0; } if (tierOverclock() == 2) { - return mStartEnergy < 160000000 ? 2 : 1; + return mStartEnergy <= 160000000 ? 1 : 0; } if (this.tierOverclock() == 4) { - return (mStartEnergy < 160000000 ? 4 : (mStartEnergy < 320000000 ? 2 : 1)); + return (mStartEnergy <= 160000000 ? 2 : (mStartEnergy <= 320000000 ? 1 : 0)); } - return (mStartEnergy < 160000000) ? 8 : ((mStartEnergy < 320000000) ? 4 : (mStartEnergy < 640000000) ? 2 : 1); + return (mStartEnergy <= 160000000) ? 3 + : ((mStartEnergy <= 320000000) ? 2 : (mStartEnergy <= 640000000) ? 1 : 0); } @Override - @NotNull - public CheckRecipeResult checkProcessing() { - ArrayList<FluidStack> tFluidList = getStoredFluids(); - int tFluidList_sS = tFluidList.size(); - for (int i = 0; i < tFluidList_sS - 1; i++) { - for (int j = i + 1; j < tFluidList_sS; j++) { - if (GT_Utility.areFluidsEqual(tFluidList.get(i), tFluidList.get(j))) { - if (tFluidList.get(i).amount >= tFluidList.get(j).amount) { - tFluidList.remove(j--); - tFluidList_sS = tFluidList.size(); - } else { - tFluidList.remove(i--); - tFluidList_sS = tFluidList.size(); - break; - } + public GT_Recipe.GT_Recipe_Map getRecipeMap() { + return GT_Recipe.GT_Recipe_Map.sFusionRecipes; + } + + @Override + protected ProcessingLogic createProcessingLogic() { + return new ProcessingLogic() { + + @NotNull + @Override + protected GT_ParallelHelper createParallelHelper(@NotNull GT_Recipe recipe) { + // When the fusion first loads and is still processing, it does the recipe check without consuming. + if (mRunningOnLoad) { + return new GT_ParallelHelper().setRecipe(recipe) + .setItemInputs(inputItems) + .setFluidInputs(inputFluids) + .setAvailableEUt(availableVoltage * availableAmperage) + .setMachine(machine, protectItems, protectFluids) + .setRecipeLocked(recipeLockableMachine, isRecipeLocked) + .setMaxParallel(maxParallel) + .enableBatchMode(batchSize) + .enableOutputCalculation(); } - } - } - if (tFluidList.size() > 1) { - FluidStack[] tFluids = tFluidList.toArray(new FluidStack[0]); - GT_Recipe tRecipe; - - tRecipe = GT_Recipe.GT_Recipe_Map.sFusionRecipes - .findRecipe(this.getBaseMetaTileEntity(), this.mLastRecipe, false, GT_Values.V[tier()], tFluids); - if (tRecipe == null) { - tRecipe = GT_Recipe.GT_Recipe_Map.sComplexFusionRecipes - .findRecipe(this.getBaseMetaTileEntity(), this.mLastRecipe, false, GT_Values.V[tier()], tFluids); + return super.createParallelHelper(recipe); } - if ((tRecipe == null && !mRunningOnLoad) || (maxEUStore() < tRecipe.mSpecialValue)) { - turnCasingActive(false); - this.mLastRecipe = null; - return CheckRecipeResultRegistry.NO_RECIPE; + @NotNull + @Override + protected GT_OverclockCalculator createOverclockCalculator(@NotNull GT_Recipe recipe, + @NotNull GT_ParallelHelper helper) { + return super.createOverclockCalculator(recipe, helper) + .limitOverclockCount(overclock(recipe.mSpecialValue)); } - if (!canOutputAll(tRecipe)) return CheckRecipeResultRegistry.OUTPUT_FULL; - if (mRunningOnLoad || tRecipe.isRecipeInputEqual(true, tFluids)) { - this.mLastRecipe = tRecipe; - this.mEUt = (this.mLastRecipe.mEUt * overclock(this.mLastRecipe.mSpecialValue)); - this.mMaxProgresstime = this.mLastRecipe.mDuration / overclock(this.mLastRecipe.mSpecialValue); - this.mEfficiencyIncrease = 10000; - this.mOutputFluids = this.mLastRecipe.mFluidOutputs; - turnCasingActive(true); - mRunningOnLoad = false; + + @NotNull + @Override + protected CheckRecipeResult validateRecipe(@NotNull GT_Recipe recipe) { + if (!mRunningOnLoad && recipe.mSpecialValue > maxEUStore()) { + return CheckRecipeResultRegistry.insufficientStartupPower(recipe.mSpecialValue); + } return CheckRecipeResultRegistry.SUCCESSFUL; } - } - return CheckRecipeResultRegistry.NO_RECIPE; + + @NotNull + @Override + public CheckRecipeResult process() { + CheckRecipeResult result = super.process(); + if (mRunningOnLoad) mRunningOnLoad = false; + turnCasingActive(result.wasSuccessful()); + if (result.wasSuccessful()) { + mLastRecipe = lastRecipe; + } else { + mLastRecipe = null; + } + return result; + } + }.setOverclock(1, 1); + } + + @Override + protected void setProcessingLogicPower(ProcessingLogic logic) { + logic.setAvailableVoltage(GT_Values.V[tier()]); + logic.setAvailableAmperage(1); } public abstract int tierOverclock(); @@ -392,7 +408,7 @@ public abstract class GT_MetaTileEntity_FusionComputer } if (mMaxProgresstime > 0) { this.getBaseMetaTileEntity() - .decreaseStoredEnergyUnits(mEUt, true); + .decreaseStoredEnergyUnits(-mEUt, true); if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) { if (mOutputItems != null) for (ItemStack tStack : mOutputItems) if (tStack != null) addOutput(tStack); @@ -422,11 +438,11 @@ public abstract class GT_MetaTileEntity_FusionComputer if (aBaseMetaTileEntity.isAllowedToWork()) { this.mEUStore = aBaseMetaTileEntity.getStoredEU(); if (checkRecipe()) { - if (this.mEUStore < this.mLastRecipe.mSpecialValue - this.mEUt) { + if (this.mEUStore < this.mLastRecipe.mSpecialValue + this.mEUt) { criticalStopMachine(); } aBaseMetaTileEntity - .decreaseStoredEnergyUnits(this.mLastRecipe.mSpecialValue - this.mEUt, true); + .decreaseStoredEnergyUnits(this.mLastRecipe.mSpecialValue + this.mEUt, true); } } if (mMaxProgresstime <= 0) mEfficiency = Math.max(0, mEfficiency - 1000); @@ -444,23 +460,6 @@ public abstract class GT_MetaTileEntity_FusionComputer } @Override - public boolean onRunningTick(ItemStack aStack) { - if (mEUt < 0) { - if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) { - this.mLastRecipe = null; - criticalStopMachine(); - return false; - } - } - if (this.mEUStore <= 0) { - this.mLastRecipe = null; - criticalStopMachine(); - return false; - } - return true; - } - - @Override public boolean drainEnergyInput(long aEU) { return false; } |