diff options
Diffstat (limited to 'src/Java/gtPlusPlus/xmod/gregtech')
| -rw-r--r-- | src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMultiMachine.java | 339 |
1 files changed, 294 insertions, 45 deletions
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMultiMachine.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMultiMachine.java index 892b91a365..21c21edb7a 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMultiMachine.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialMultiMachine.java @@ -238,7 +238,7 @@ extends GregtechMeta_MultiBlockBase { //Get Circuit info for this recipe. ItemStack tCircuit = getCircuit(aItemInputs); int tCircuitID = getCircuitID(tCircuit); - + if (tCircuitID == MODE_REPLICATOR) { return checkReplicatorRecipe(aItemInputs, aFluidInputs); } @@ -387,14 +387,30 @@ extends GregtechMeta_MultiBlockBase { private FluidStack mReplicatorFluidOutput; //Replicator handling - public boolean checkReplicatorRecipe(ItemStack[] aItemInputs, FluidStack[] aFluidInputs) { + public boolean checkReplicatorRecipe( + ItemStack[] aItemInputs, FluidStack[] aFluidInputs, + int aMaxParallelRecipes, int aEUPercent, + int aSpeedBonusPercent, int aOutputChanceRoll) { + + // Based on the Processing Array. A bit overkill, but very flexible. + // Reset outputs and progress stats + this.mEUt = 0; + this.mMaxProgresstime = 0; + this.mOutputItems = new ItemStack[]{}; + this.mOutputFluids = new FluidStack[]{}; - //Must Have An Item and Fluid (Data Orb and UUM) - if (aItemInputs.length <= 0 || aFluidInputs.length <= 0) { + long tVoltage = getMaxInputVoltage(); + byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); + + //Get Circuit info for this recipe. + ItemStack tCircuit = getCircuit(aItemInputs); + int tCircuitID = getCircuitID(tCircuit); + + if (!this.canBufferOutputs(aItemInputs, aMaxParallelRecipes)) { + Logger.WARNING("BAD RETURN - 2"); return false; } - byte tTier = (byte) Math.max(1, GT_Utility.getTier(getMaxInputVoltage())); ItemStack tDataOrb = null; ItemStack tCellStack = null; ItemStack tReplicatedItem; @@ -416,57 +432,170 @@ extends GregtechMeta_MultiBlockBase { } } + //No Data Orb found? if (tDataOrb == null) { return false; } - for (FluidStack F : aFluidInputs) { - if (F != null && F.isFluidEqual(Materials.UUMatter.getFluid(1L))) { - final FluidStack tFluid = F; - final Materials tMaterial = Element.get(Behaviour_DataOrb.getDataName(tDataOrb)).mLinkedMaterials - .get(0); - final long tMass = tMaterial.getMass(); - if (tFluid.amount >= tMass && tMass > 0L) { - this.mEUt = (int) GT_Values.V[(int) this.getInputTier()]; - this.mMaxProgresstime = (int) (tMass * 512L / (1 << tTier - 1)); - if ((tReplicatedItem = GT_OreDictUnificator.get(OrePrefixes.dust, (Object) tMaterial, 1L)) == null) { - if ((tReplicatedItem = GT_OreDictUnificator.get(OrePrefixes.cell, (Object) tMaterial, 1L)) != null) { - if ((tOutputFluid = GT_Utility.getFluidForFilledItem(tReplicatedItem, true)) == null) { - - if (ItemList.Cell_Empty.isStackEqual((Object) tCellStack) - && this.canBufferOutput(new ItemStack[]{tReplicatedItem})) { - final ItemStack input = tCellStack; - --input.stackSize; - final FluidStack UUM = tFluid; - UUM.amount -= (int) tMass; - return true; - } + final Materials tMaterial = Element.get(Behaviour_DataOrb.getDataName(tDataOrb)).mLinkedMaterials.get(0); + final long tMass = tMaterial.getMass(); + //Temp Values + int tEUt = (int) GT_Values.V[(int) this.getInputTier()]; + int tMaxProgresstime = (int) (tMass * 512L / (1 << tTier - 1)); + float tRecipeEUt = (tEUt * aEUPercent) / 100.0f; + float tTotalEUt = 0.0f; + int parallelRecipes = 0; + ItemStack[] expectedInputs = {tDataOrb}; + FluidStack[] expectedFluidInputs = {Materials.UUMatter.getFluid(tMass)}; + // Count recipes to do in parallel, consuming input items and fluids and considering input voltage limits + for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tVoltage - tRecipeEUt); parallelRecipes++) { + if (!isRecipeInputEqual(true, aFluidInputs, aItemInputs, expectedFluidInputs, expectedInputs)) { + Logger.WARNING("Broke at "+parallelRecipes+"."); + break; + } + Logger.WARNING("Bumped EU from "+tTotalEUt+" to "+(tTotalEUt+tRecipeEUt)+"."); + tTotalEUt += tRecipeEUt; + } - } else { - tReplicatedItem = null; - if (this.getDrainableStack() == null - || (this.getDrainableStack().isFluidEqual(tOutputFluid) - && this.getDrainableStack().amount < 16000)) { - final FluidStack UUM = tFluid; - UUM.amount -= (int) tMass; - return true; - } - } - } - } else if (this.canBufferOutput(new ItemStack[]{tReplicatedItem})) { - final FluidStack UUM = tFluid; - UUM.amount -= (int) tMass; - return true; + if (parallelRecipes == 0) { + Logger.WARNING("BAD RETURN - 3"); + return false; + } + + + /** + * Magic + */ + + int COST_UUM = 0; + int COST_CELLS = 0; + + //Determine Output Item + if ((tReplicatedItem = GT_OreDictUnificator.get(OrePrefixes.dust, (Object) tMaterial, 1L)) == null) { + if ((tReplicatedItem = GT_OreDictUnificator.get(OrePrefixes.cell, (Object) tMaterial, 1L)) != null) { + if ((tOutputFluid = GT_Utility.getFluidForFilledItem(tReplicatedItem, true)) == null) { + if (ItemList.Cell_Empty.isStackEqual((Object) tCellStack) && this.canBufferOutputs(new ItemStack[]{tReplicatedItem}, parallelRecipes)) { + COST_CELLS = 1 * parallelRecipes; + COST_UUM = (int) tMass * parallelRecipes; + } + } else { + tReplicatedItem = null; + if (this.getDrainableStack() == null || (this.getDrainableStack().isFluidEqual(tOutputFluid) && this.getDrainableStack().amount < 16000)) { + COST_UUM = (int) tMass * parallelRecipes; } - } + } } + } else if (this.canBufferOutputs(new ItemStack[]{tReplicatedItem}, parallelRecipes)) { + COST_UUM = (int) tMass * parallelRecipes; } + //Costs no UUM and no valid outputs? Let's bail gracefully before we consume inputs. + if (COST_UUM <= 0 || (tReplicatedItem == null && tOutputFluid == null)) { + return false; + } + - return false; + + + + // -- Try not to fail after this point - inputs have already been consumed! -- + + + // Convert speed bonus to duration multiplier + // e.g. 100% speed bonus = 200% speed = 100%/200% = 50% recipe duration. + aSpeedBonusPercent = Math.max(-99, aSpeedBonusPercent); + float tTimeFactor = 100.0f / (100.0f + aSpeedBonusPercent); + this.mMaxProgresstime = (int)(tMaxProgresstime * tTimeFactor); + + this.mEUt = (int)Math.ceil(tTotalEUt); + + this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000); + this.mEfficiencyIncrease = 10000; + + // Overclock + if (this.mEUt <= 16) { + this.mEUt = (this.mEUt * (1 << tTier - 1) * (1 << tTier - 1)); + this.mMaxProgresstime = (this.mMaxProgresstime / (1 << tTier - 1)); + } else { + while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) { + this.mEUt *= 4; + this.mMaxProgresstime /= 2; + } + } + + if (this.mEUt > 0) { + this.mEUt = (-this.mEUt); + } + + this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); + + // Collect fluid outputs - Not Required? + /*FluidStack[] tOutputFluids = new FluidStack[tRecipe.mFluidOutputs.length]; + for (int h = 0; h < tRecipe.mFluidOutputs.length; h++) { + if (tRecipe.getFluidOutput(h) != null) { + tOutputFluids[h] = tRecipe.getFluidOutput(h).copy(); + tOutputFluids[h].amount *= parallelRecipes; + } + }*/ + + // Collect output item types + ItemStack[] tOutputItems = new ItemStack[1]; + for (int h = 0; h < 1; h++) { + if (tRecipe.getOutput(h) != null) { + tOutputItems[h] = tRecipe.getOutput(h).copy(); + tOutputItems[h].stackSize = 0; + } + } + + // Set output item stack sizes (taking output chance into account) + for (int f = 0; f < tOutputItems.length; f++) { + if (tRecipe.mOutputs[f] != null && tOutputItems[f] != null) { + for (int g = 0; g < parallelRecipes; g++) { + if (getBaseMetaTileEntity().getRandomNumber(aOutputChanceRoll) < tRecipe.getOutputChance(f)) + tOutputItems[f].stackSize += tRecipe.mOutputs[f].stackSize; + } + } + } + + tOutputItems = removeNulls(tOutputItems); + + // Sanitize item stack size, splitting any stacks greater than max stack size + List<ItemStack> splitStacks = new ArrayList<ItemStack>(); + for (ItemStack tItem : tOutputItems) { + while (tItem.getMaxStackSize() < tItem.stackSize) { + ItemStack tmp = tItem.copy(); + tmp.stackSize = tmp.getMaxStackSize(); + tItem.stackSize = tItem.stackSize - tItem.getMaxStackSize(); + splitStacks.add(tmp); + } + } + + if (splitStacks.size() > 0) { + ItemStack[] tmp = new ItemStack[splitStacks.size()]; + tmp = splitStacks.toArray(tmp); + tOutputItems = ArrayUtils.addAll(tOutputItems, tmp); + } + + // Strip empty stacks + List<ItemStack> tSList = new ArrayList<ItemStack>(); + for (ItemStack tS : tOutputItems) { + if (tS.stackSize > 0) tSList.add(tS); + } + tOutputItems = tSList.toArray(new ItemStack[tSList.size()]); + + // Commit outputs + this.mOutputItems = tOutputItems; + this.mOutputFluids = tOutputFluids; + updateSlots(); + + // Play sounds (GT++ addition - GT multiblocks play no sounds) + startProcess(); + + Logger.WARNING("GOOD RETURN - 1"); + return true; } - private boolean canBufferOutput(ItemStack[] aInputs) { + private boolean canBufferOutputs(ItemStack[] aInputs, int aParallelRecipes) { // Count slots available in output buses ArrayList<ItemStack> tBusStacks = new ArrayList<>(); @@ -489,7 +618,7 @@ extends GregtechMeta_MultiBlockBase { int slotsNeeded = aInputs.length; for (final ItemStack tRecipeOutput: aInputs) { if (tRecipeOutput == null) continue; - int amount = tRecipeOutput.stackSize; + int amount = tRecipeOutput.stackSize * aParallelRecipes; for (final ItemStack tBusStack : tBusStacks) { if (GT_Utility.areStacksEqual(tBusStack, tRecipeOutput)) { if (tBusStack.stackSize + amount <= tBusStack.getMaxStackSize()) { @@ -513,5 +642,125 @@ extends GregtechMeta_MultiBlockBase { return this.mReplicatorFluidOutput = aFluid; } + public boolean isRecipeInputEqual(final boolean aDecreaseStacksizeBySuccess, + final FluidStack[] aFluidInputs, + final ItemStack[] aInputs, + final FluidStack[] mFluidInputs, + final ItemStack[] mInputs) { + return this.isRecipeInputEqual(aDecreaseStacksizeBySuccess, false, aFluidInputs, aInputs, mFluidInputs, mInputs); + } + + public boolean isRecipeInputEqual( + final boolean aDecreaseStacksizeBySuccess, + final boolean aDontCheckStackSizes, + final FluidStack[] aFluidInputs, + final ItemStack[] aInputs, + final FluidStack[] aExpectedFluidInputs, + final ItemStack[] mExpectedInputs) { + if (aExpectedFluidInputs.length > 0 && aFluidInputs == null) { + return false; + } + for (final FluidStack tFluid : aExpectedFluidInputs) { + if (tFluid != null) { + boolean temp = true; + int amt = tFluid.amount; + for (final FluidStack aFluid : aFluidInputs) { + if (aFluid != null && aFluid.isFluidEqual(tFluid)) { + if (aDontCheckStackSizes) { + temp = false; + break; + } + amt -= aFluid.amount; + if (amt < 1) { + temp = false; + break; + } + } + } + if (temp) { + return false; + } + } + } + if (mExpectedInputs.length > 0 && aInputs == null) { + return false; + } + for (final ItemStack tStack : mExpectedInputs) { + if (tStack != null) { + int amt = tStack.stackSize; + boolean temp = true; + for (final ItemStack aStack : aInputs) { + if (GT_Utility.areUnificationsEqual(aStack, tStack, true) + || GT_Utility.areUnificationsEqual(GT_OreDictUnificator.get(false, aStack), tStack, true)) { + if (aDontCheckStackSizes) { + temp = false; + break; + } + amt -= aStack.stackSize; + if (amt < 1) { + temp = false; + break; + } + } + } + if (temp) { + return false; + } + } + } + if (aDecreaseStacksizeBySuccess) { + if (aFluidInputs != null) { + for (final FluidStack tFluid : aExpectedFluidInputs) { + if (tFluid != null) { + int amt = tFluid.amount; + for (final FluidStack aFluid2 : aFluidInputs) { + if (aFluid2 != null && aFluid2.isFluidEqual(tFluid)) { + if (aDontCheckStackSizes) { + final FluidStack fluidStack = aFluid2; + fluidStack.amount -= amt; + break; + } + if (aFluid2.amount >= amt) { + final FluidStack fluidStack2 = aFluid2; + fluidStack2.amount -= amt; + amt = 0; + break; + } + amt -= aFluid2.amount; + aFluid2.amount = 0; + } + } + } + } + } + if (aInputs != null) { + for (final ItemStack tStack : mExpectedInputs) { + if (tStack != null) { + int amt = tStack.stackSize; + for (final ItemStack aStack2 : aInputs) { + if (GT_Utility.areUnificationsEqual(aStack2, tStack, true) || GT_Utility + .areUnificationsEqual(GT_OreDictUnificator.get(false, aStack2), tStack, true)) { + if (aDontCheckStackSizes) { + final ItemStack itemStack = aStack2; + itemStack.stackSize -= amt; + break; + } + if (aStack2.stackSize >= amt) { + final ItemStack itemStack2 = aStack2; + itemStack2.stackSize -= amt; + amt = 0; + break; + } + amt -= aStack2.stackSize; + aStack2.stackSize = 0; + } + } + } + } + } + } + return true; + } + }
\ No newline at end of file |