diff options
Diffstat (limited to 'src/Java/gtPlusPlus')
6 files changed, 571 insertions, 168 deletions
diff --git a/src/Java/gtPlusPlus/api/objects/GenericStack.java b/src/Java/gtPlusPlus/api/objects/GenericStack.java new file mode 100644 index 0000000000..b3bc94364f --- /dev/null +++ b/src/Java/gtPlusPlus/api/objects/GenericStack.java @@ -0,0 +1,41 @@ +package gtPlusPlus.api.objects; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +public class GenericStack { + + private ItemStack mItemStack; + private FluidStack mFluidStack; + + public GenericStack(ItemStack s){ + this.mItemStack = s; + this.mFluidStack = null; + } + + public GenericStack(FluidStack f){ + this.mItemStack = null; + this.mFluidStack = f; + } + + public GenericStack() { + this.mItemStack = null; + this.mFluidStack = null; + } + + public synchronized final FluidStack getFluidStack() { + return mFluidStack; + } + + public synchronized final ItemStack getItemStack() { + return mItemStack; + } + + public synchronized final void setItemStack(ItemStack mItemStack) { + this.mItemStack = mItemStack; + } + + public synchronized final void setFluidStack(FluidStack mFluidStack) { + this.mFluidStack = mFluidStack; + } +} diff --git a/src/Java/gtPlusPlus/core/lib/CORE.java b/src/Java/gtPlusPlus/core/lib/CORE.java index 1e24ab510a..c43c8dd3e7 100644 --- a/src/Java/gtPlusPlus/core/lib/CORE.java +++ b/src/Java/gtPlusPlus/core/lib/CORE.java @@ -47,7 +47,7 @@ public class CORE { public static final String name = "GT++"; public static final String MODID = "miscutils"; - public static final String VERSION = "1.7.0-prerelease-3"; + public static final String VERSION = "1.7.0-prerelease-4"; public static String MASTER_VERSION = NetworkUtils.getContentFromURL("https://raw.githubusercontent.com/draknyte1/GTplusplus/master/Recommended.txt").toLowerCase(); public static String USER_COUNTRY = GeoUtils.determineUsersCountry(); public static boolean isModUpToDate = Utils.isModUpToDate(); diff --git a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java index be94e0c67e..bd53c4f38a 100644 --- a/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java +++ b/src/Java/gtPlusPlus/core/recipe/RECIPES_GREGTECH.java @@ -40,7 +40,7 @@ public class RECIPES_GREGTECH { private static void execute(){ cokeOvenRecipes(); - matterFabRecipes(); + //matterFabRecipes(); assemblerRecipes(); fluidcannerRecipes(); distilleryRecipes(); diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java index 492872d37d..22248814ce 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMeta_MultiBlockBase.java @@ -20,6 +20,7 @@ import gregtech.api.metatileentity.implementations.*; import gregtech.api.util.GT_Recipe; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.recipe.common.CI; import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_MultiMachine; import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine; @@ -27,6 +28,7 @@ import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEn import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBattery; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.IInventory; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import static gtPlusPlus.core.util.array.ArrayUtils.removeNulls; @@ -36,6 +38,7 @@ extends GT_MetaTileEntity_MultiBlockBase { public GT_Recipe mLastRecipe; + private boolean mInternalCircuit = false; public ArrayList<GT_MetaTileEntity_Hatch_InputBattery> mChargeHatches = new ArrayList<GT_MetaTileEntity_Hatch_InputBattery>(); public ArrayList<GT_MetaTileEntity_Hatch_OutputBattery> mDischargeHatches = new ArrayList<GT_MetaTileEntity_Hatch_OutputBattery>(); @@ -405,6 +408,29 @@ GT_MetaTileEntity_MultiBlockBase { } super.explodeMultiblock(); } + + protected int getGUICircuit(ItemStack[] t) { + Item g = CI.getNumberedCircuit(0).getItem(); + ItemStack guiSlot = this.mInventory[1]; + int mMode = -1; + if (guiSlot != null && guiSlot.getItem() == g) { + this.mInternalCircuit = true; + return guiSlot.getItemDamage(); + } + else { + this.mInternalCircuit = false; + } + + if (!this.mInternalCircuit) { + for (ItemStack j : t) { + if (j.getItem() == g) { + mMode = j.getItemDamage(); + break; + } + } + } + return mMode; + } @Override public void updateSlots() { diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialFishingPond.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialFishingPond.java index 0c3dcf0903..98dc3140bb 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialFishingPond.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_IndustrialFishingPond.java @@ -16,7 +16,6 @@ import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.FishPondFakeRecipe; import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_Utility; -import gregtech.api.util.Recipe_GT; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.core.block.ModBlocks; import gtPlusPlus.core.lib.CORE; @@ -26,8 +25,6 @@ import gtPlusPlus.core.util.fluid.FluidUtils; import gtPlusPlus.core.util.item.ItemUtils; import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.core.util.reflect.ReflectionUtils; -import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_MultiMachine; -import gtPlusPlus.xmod.gregtech.api.gui.GUI_MultiMachine; import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; import ic2.core.init.BlocksItems; import ic2.core.init.InternalName; @@ -102,7 +99,7 @@ extends GregtechMeta_MultiBlockBase { @Override public GT_Recipe.GT_Recipe_Map getRecipeMap() { - return Recipe_GT.Gregtech_Recipe_Map.sFishPondRecipes; + return null; } @Override @@ -305,7 +302,7 @@ extends GregtechMeta_MultiBlockBase { for (int j = mOffsetZ_Lower + 1; j <= mOffsetZ_Upper - 1; ++j) { for (int h = 0; h < 2; ++h) { Block tBlock = aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j); - byte tMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j); + //byte tMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j); if (tBlock == Blocks.air || tBlock == Blocks.flowing_water || tBlock == Blocks.water) { if (this.getStoredFluids() != null) { for (FluidStack stored : this.getStoredFluids()) { @@ -348,7 +345,7 @@ extends GregtechMeta_MultiBlockBase { return (tAmount >= 80); } - private static AutoMap<AutoMap> categories = new AutoMap<AutoMap>(); + private static AutoMap<AutoMap<WeightedRandomFishable>> categories = new AutoMap<AutoMap<WeightedRandomFishable>>(); private static AutoMap<WeightedRandomFishable> categoryFish = new AutoMap<WeightedRandomFishable>(); private static AutoMap<WeightedRandomFishable> categoryJunk = new AutoMap<WeightedRandomFishable>(); private static AutoMap<WeightedRandomFishable> categoryLoot = new AutoMap<WeightedRandomFishable>(); @@ -514,7 +511,7 @@ extends GregtechMeta_MultiBlockBase { } // EU discount - float tRecipeEUt = (32 * aEUPercent) / 100.0f; + //float tRecipeEUt = (32 * aEUPercent) / 100.0f; float tTotalEUt = 0.0f; // Reset outputs and progress stats diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java index 8abc63e1df..80fc673700 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntity_MassFabricator.java @@ -1,50 +1,73 @@ package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi; +import static gtPlusPlus.core.util.array.ArrayUtils.removeNulls; + import java.util.ArrayList; -import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; import org.apache.commons.lang3.ArrayUtils; import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; import gregtech.api.enums.TAE; import gregtech.api.enums.Textures; import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.GT_Config; import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Recipe.GT_Recipe_Map; import gregtech.api.util.GT_Utility; import gregtech.api.util.Recipe_GT; +import gtPlusPlus.api.objects.GenericStack; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.core.block.ModBlocks; import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.array.AutoMap; +import gtPlusPlus.core.util.array.Pair; import gtPlusPlus.core.util.fluid.FluidUtils; import gtPlusPlus.core.util.item.ItemUtils; +import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.xmod.gregtech.api.gui.GUI_MatterFab; import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase; import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; import net.minecraft.block.Block; import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.Item; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; public class GregtechMetaTileEntity_MassFabricator extends GregtechMeta_MultiBlockBase { + + public final static int JUNK_TO_SCRAP = 19; + public final static int JUNK_TO_UUA = 20; + public final static int SCRAP_UUA = 21; + public final static int PRODUCE_UUM = 22; public static int sUUAperUUM = 1; public static int sUUASpeedBonus = 4; - public static int sDurationMultiplier = 3215; - public static boolean sRequiresUUA = false; - private int mAmplifierUsed = 0; + public static int sDurationMultiplier = 3200; private int mMatterProduced = 0; - ItemStack scrapPile = ItemUtils.getSimpleStack(ItemUtils.getItem("IC2:itemScrap")); - ItemStack scrapBox = ItemUtils.getSimpleStack(ItemUtils.getItem("IC2:itemScrapbox")); + private int mScrapProduced = 0; + private int mAmplifierProduced = 0; + private int mScrapUsed = 0; + private int mAmplifierUsed = 0; + private int mMode = 0; + public static boolean sRequiresUUA = false; + private static FluidStack[] mUU = new FluidStack[2]; + private static ItemStack mScrap[] = new ItemStack[2]; private static Block IC2Glass = Block.getBlockFromItem(ItemUtils.getItem("IC2:blockAlloyGlass")); - FluidStack tempFake = FluidUtils.getFluidStack("uuamplifier", 1); - GT_Recipe fakeRecipe; + + private GT_Recipe mFakeRecipe; public int getAmplifierUsed(){ return this.mAmplifierUsed; @@ -94,6 +117,19 @@ public class GregtechMetaTileEntity_MassFabricator extends GregtechMeta_MultiBlo return false; } + public ItemStack getScrapPile() { + if (mScrap[0] == null) { + mScrap[0] = ItemUtils.getSimpleStack(ItemUtils.getItem("IC2:itemScrap")); + } + return mScrap[0]; + } + public ItemStack getScrapBox() { + if (mScrap[1] == null) { + mScrap[1] = ItemUtils.getSimpleStack(ItemUtils.getItem("IC2:itemScrapbox")); + } + return mScrap[1]; + } + @Override public Object getClientGUI(final int aID, final InventoryPlayer aPlayerInventory, final IGregTechTileEntity aBaseMetaTileEntity) { return new GUI_MatterFab(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(), "MatterFabricator.png"); @@ -111,161 +147,18 @@ public class GregtechMetaTileEntity_MassFabricator extends GregtechMeta_MultiBlo @Override public boolean checkRecipe(final ItemStack aStack) { - Logger.WARNING("Fabricating Matter."); - if (this.mInputHatches.size() != 1){ - Logger.INFO("Too many input hatches. Found: "+this.mInputHatches.size()+" | Expected: 1"); - return false; - } - Logger.WARNING("Step 1"); - - final ArrayList<ItemStack> tInputList = this.getStoredInputs(); - for (int i = 0; i < (tInputList.size() - 1); i++) { - for (int j = i + 1; j < tInputList.size(); j++) { - if (GT_Utility.areStacksEqual(tInputList.get(i), tInputList.get(j))) { - if (tInputList.get(i).stackSize >= tInputList.get(j).stackSize) { - tInputList.remove(j--); - } else { - tInputList.remove(i--); - break; - } - } - } - } - Logger.WARNING("Step 2"); - - final ItemStack[] tInputs = Arrays.copyOfRange(tInputList.toArray(new ItemStack[tInputList.size()]), 0, 2); - - + ArrayList<ItemStack> tItems = getStoredInputs(); + ArrayList<FluidStack> tFluids = getStoredFluids(); + ItemStack[] tItemInputs = tItems.toArray(new ItemStack[tItems.size()]); + FluidStack[] tFluidInputs = tFluids.toArray(new FluidStack[tFluids.size()]); - final ArrayList<FluidStack> tFluidList = this.getStoredFluids(); - for (int i = 0; i < (tFluidList.size() - 1); i++) { - for (int j = i + 1; j < tFluidList.size(); j++) { - if (GT_Utility.areFluidsEqual(tFluidList.get(i), tFluidList.get(j))) { - if (tFluidList.get(i).amount >= tFluidList.get(j).amount) { - tFluidList.remove(j--); - } else { - tFluidList.remove(i--); - break; - } - } - } - } - Logger.WARNING("Step 3"); - - final long tVoltage = this.getMaxInputVoltage(); - final byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); - FluidStack[] tFluids = Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tFluidList.size()]), 0, tFluidList.size()); - - - //Find Scrap and make UU-A - /*if (tInputs.length >= 1){ - Utils.LOG_INFO("Found Items in input bus."); - if (getStoredInputs().contains(this.scrapPile.getItem())){ - Utils.LOG_INFO("Step 3.5"); - for (int scrapSlots=0;scrapSlots<tInputs.length;scrapSlots++){ - if (tInputs[scrapSlots].getItem() == this.scrapPile.getItem()){ - if (tInputs[scrapSlots].stackSize >= 9 ){ - Utils.LOG_INFO("Found enough scrap for a special recipe. x"+tInputs[scrapSlots].stackSize+", recipe requires 9."); - for (final GT_MetaTileEntity_Hatch_Input tHatch : this.mInputHatches) { - if (isValidMetaTileEntity(tHatch)) { - Utils.LOG_INFO("Input fluid empty - Time to generate 2L of UU-A."); - if (tHatch.mFluid == null){ - tHatch.mFluid = FluidUtils.getFluidStack("uuamplifier", 2); - } - else{ - tHatch.mFluid.amount++; - tHatch.mFluid.amount++; - } - tInputs[scrapSlots].stackSize = tInputs[scrapSlots].stackSize - 9; - Utils.LOG_INFO("Remaining after recipe. x"+tInputs[scrapSlots].stackSize); - } - } - } - } - } - } - else { - Utils.LOG_INFO("Did not find an itemstack containing 9 IC2 Scrap or more."); - } - }*/ - Logger.WARNING("Step 4"); - - tFluids = Arrays.copyOfRange(tFluidList.toArray(new FluidStack[tFluidList.size()]), 0, tFluidList.size()); - - if (tFluids.length > 0) { - Logger.WARNING("Input fluid found"); - for(int i = 0;i<tFluids.length;i++){ - final GT_Recipe tRecipe = Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.findRecipe(this.getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], new FluidStack[]{tFluids[i]}, new ItemStack[]{}); - if (tRecipe != null) { - if (tRecipe.isRecipeInputEqual(true, tFluids, new ItemStack[]{})) { - this.mEfficiency = (10000 - ((this.getIdealStatus() - this.getRepairStatus()) * 1000)); - this.mEfficiencyIncrease = 10000; - if (tRecipe.mEUt <= 16) { - this.mEUt = (tRecipe.mEUt * (1 << (tTier - 1)) * (1 << (tTier - 1))); - this.mMaxProgresstime = ((tRecipe.mDuration/**sDurationMultiplier*/) / (1 << (tTier - 1))); - } else { - this.mEUt = tRecipe.mEUt; - this.mMaxProgresstime = (tRecipe.mDuration/**sDurationMultiplier*/); - while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) { - this.mEUt *= 2; - this.mMaxProgresstime /= 4; - } - } - if (this.mEUt > 0) { - this.mEUt = (-this.mEUt); - } - this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); - this.mOutputItems = new ItemStack[]{tRecipe.getOutput(0)}; - this.mOutputFluids = tRecipe.mFluidOutputs.clone(); - ArrayUtils.reverse(this.mOutputFluids); - this.mMatterProduced++; - this.mAmplifierUsed++; - this.updateSlots(); - //Utils.LOG_INFO("Recipes Finished: "+mMatterProduced); - return true; - } - } - else { - Logger.INFO("Invalid Recipe"); - return false; - } - } + if (tItems.size() == 0) { + return false; } - else if (tFluids.length == 0) { - Logger.WARNING("Input fluid not found"); - this.fakeRecipe = Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.findRecipe(this.getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[tTier], new FluidStack[]{this.tempFake}, new ItemStack[]{}); - this.mEfficiency = (10000 - ((this.getIdealStatus() - this.getRepairStatus()) * 1000)); - this.mEfficiencyIncrease = 10000; + return checkRecipeGeneric(tItemInputs, tFluidInputs, 1, 500, 75, 100); + } - this.mEUt = 32; - this.mMaxProgresstime = (160*20); - 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); - } - - if (this.fakeRecipe != null) { - this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime); - this.mOutputItems = new ItemStack[]{this.fakeRecipe.getOutput(0)}; - this.mOutputFluids = this.fakeRecipe.mFluidOutputs.clone(); - ArrayUtils.reverse(this.mOutputFluids); - this.mMatterProduced++; - this.updateSlots(); - //Utils.LOG_INFO("Recipes Finished: "+mMatterProduced); - return true; - } - } - else { - Logger.INFO("Invalid no input Recipe"); - } - Logger.INFO("Fabricating Matter.bad"); - return false; - } @Override public boolean checkMachine(final IGregTechTileEntity aBaseMetaTileEntity, final ItemStack aStack) { @@ -411,4 +304,450 @@ public class GregtechMetaTileEntity_MassFabricator extends GregtechMeta_MultiBlo return new GregtechMetaTileEntity_MassFabricator(this.mName); } + public static Map<Integer, GT_Recipe> mCachedRecipeMap = new ConcurrentHashMap<Integer, GT_Recipe>(); + + /** + * Special Recipe Generator + */ + + private GT_Recipe generateCustomRecipe(int mode, ItemStack[] aItemInputs) { + ItemStack[] inputs = null; + ItemStack[] outputs = null; + FluidStack fluidIn = null; + FluidStack fluidOut = null; + Pair<Integer, ItemStack[]> K = new Pair<Integer, ItemStack[]>(mode, aItemInputs); + if (mCachedRecipeMap.containsKey(K.hashCode())) { + return mCachedRecipeMap.get(K.hashCode()); + } + + final boolean oldRecipe = Utils.invertBoolean(CORE.MAIN_GREGTECH_5U_EXPERIMENTAL_FORK); + + int baseEuCost = 0; + int baseTimeCost = 0; + + final int mEuPerRecycleOperation = 32; + final int mTicksPerRecycleOperation = 4; + final int mEuPerAmplifabOperation = 32; + final int mTicksPerAmplifabOperation = 160*20; + final int mEuPerMatterFabOperation = 32; + final int mTicksPerMatterFabOperation = 160*20; + + final Item SP = this.getScrapPile().getItem(); + final Item SB = this.getScrapBox().getItem(); + + /** + * Count Inputs + */ + + int inputCount = 0; + if (aItemInputs.length > 0) { + for (int y=0;y<aItemInputs.length;y++) { + if (aItemInputs[y].getItem() != SP && aItemInputs[y].getItem() != SB) { + inputCount += aItemInputs[y].stackSize; + } + } + } + + + /** + * Set Inputs and Outputs depending on mode. + */ + + //Recycler mode + if (mode == JUNK_TO_SCRAP) { + if (aItemInputs.length > 0) { + inputs = aItemInputs; + outputs = getScrapPiles(inputCount); + baseEuCost = mEuPerRecycleOperation; + baseTimeCost = mTicksPerRecycleOperation; + } + } + + //Hybrid mode + else if (mode == JUNK_TO_UUA) { + if (aItemInputs.length > 0) { + inputs = aItemInputs; + GenericStack x = getUUAFromScrapStack(getScrapPiles(inputCount)); + outputs = new ItemStack[]{x.getItemStack()}; + fluidOut = x.getFluidStack(); + baseEuCost = 512; + baseTimeCost = mTicksPerRecycleOperation; + } + } + + //Amplifabricator mode + else if (mode == SCRAP_UUA) { + if (aItemInputs.length > 0) { + inputs = aItemInputs; + GenericStack x = getUUAFromScrapStack(inputs); + outputs = new ItemStack[]{x.getItemStack()}; + fluidOut = x.getFluidStack(); + baseEuCost = mEuPerAmplifabOperation; + baseTimeCost = mTicksPerAmplifabOperation; + } + } + + //Matter Fabricator mode + else if (mode == PRODUCE_UUM) { + if (sDurationMultiplier != 0) { + baseTimeCost = sDurationMultiplier; + } + if (doesHatchContainUUA()) { + fluidIn = FluidUtils.getFluidStack(mUU[0], sUUAperUUM); + } + else { + if (sRequiresUUA) { + //Return null because if this is the case, the machine cannot run at all. + return null; + } + else { + fluidIn = GT_Values.NF; + } + } + fluidOut = FluidUtils.getFluidStack(mUU[1], 1); + baseEuCost = mEuPerMatterFabOperation; + baseTimeCost = (fluidIn == GT_Values.NF ? mTicksPerMatterFabOperation: mTicksPerMatterFabOperation/sUUASpeedBonus); + } + + + //Pre 5.09 compat + if (oldRecipe) { + baseEuCost = (baseEuCost/8); + } + + + Recipe_GT B = new Recipe_GT( + true, + inputs, //Inputs + outputs, //Outputs + null, // Special? + new int[] {10000}, //Chances + new FluidStack[] {fluidIn}, //Fluid Inputs + new FluidStack[] {fluidOut}, //Fluid Outputs + baseTimeCost, //duration + baseEuCost, //eu/t + 0); + + mCachedRecipeMap.put(K.hashCode(), B); + Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes.add(B); + + //The Recipe Itself. + return B; + } + + private ItemStack[] getScrapPiles(int inputSize) { + //Generate Trash + ItemStack[] mOutputs; + AutoMap<ItemStack> mTemp = new AutoMap<ItemStack>(); + for (int r=0;r<inputSize;r++) { + if (MathUtils.randInt(0, 5) == 5) { + mTemp.put(getScrapPile()); + } + } + int mSlots = (int) Math.ceil((mTemp.size()/64) / 100.0); + mOutputs = new ItemStack[mSlots]; + int totalScrap = mTemp.size(); + int index = 0; + while (totalScrap > 0) { + if (mOutputs[index].stackSize == 64) { + index++; + } + else { + if (mOutputs[index] == null) { + mOutputs[index] = getScrapPile(); + totalScrap--; + } + else { + mOutputs[index].stackSize++; + totalScrap--; + } + } + } + return mOutputs; + } + + public GenericStack getUUAFromScrapStack(ItemStack[] scrapStack) { + //9=1 + int mbUUA = 0; + int temp = 0; + for (int u=0;u<scrapStack.length;u++) { + temp++; + if(temp == 9) { + temp = 0; + mbUUA++; + } + } + + int remainder = (scrapStack.length % 9); + GenericStack mOutput = new GenericStack(); + ItemStack mScrapOutput = null; + FluidStack mUUAOutput = null; + if (remainder > 0) { + mScrapOutput= ItemUtils.getSimpleStack(getScrapPile(), remainder); + } + if (mbUUA > 0) { + mUUAOutput = FluidUtils.getFluidStack(mUU[0], mbUUA); + } + mOutput.setItemStack(mScrapOutput); + mOutput.setFluidStack(mUUAOutput); + return mOutput; + } + + private GT_Recipe getFakeRecipeForMode(ItemStack[] aItemInputs) { + if (this.mMode == JUNK_TO_SCRAP) { + return generateCustomRecipe(JUNK_TO_SCRAP, aItemInputs); + } + else if (this.mMode == JUNK_TO_UUA) { + return generateCustomRecipe(JUNK_TO_UUA, aItemInputs); + } + else if (this.mMode == SCRAP_UUA) { + return generateCustomRecipe(SCRAP_UUA, aItemInputs); + } + else if (this.mMode == PRODUCE_UUM) { + return generateCustomRecipe(PRODUCE_UUM, aItemInputs); + } + else { + return null; + } + } + + + public boolean doesHatchContainUUA() { + if (mUU[0] == null) { + mUU[0] = Materials.UUAmplifier.getFluid(100); + } + if (mUU[1] == null) { + mUU[1] = Materials.UUMatter.getFluid(100); + } + + if (mUU[0] != null && mUU[1] != null) { + for (GT_MetaTileEntity_Hatch_Input g : this.mInputHatches) { + if (g.getFluid() != null) { + if (g.mFluid.isFluidEqual(mUU[0])) { + return true; + } + } + } + } + + return false; + } + + + /** + * Special Recipe Handling + */ + + + @Override + public GT_Recipe_Map getRecipeMap() { + return null; + //return Recipe_GT.Gregtech_Recipe_Map.sMatterFab2Recipes; + } + + @Override + public boolean checkRecipeGeneric( + 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[]{}; + //Set Mode + this.mMode = getGUICircuit(aItemInputs); + mFakeRecipe = getFakeRecipeForMode(aItemInputs); + + long tVoltage = getMaxInputVoltage(); + byte tTier = (byte) Math.max(1, GT_Utility.getTier(tVoltage)); + + GT_Recipe tRecipe = mFakeRecipe; + + // Remember last recipe - an optimization for findRecipe() + this.mLastRecipe = tRecipe; + + if (tRecipe == null) { + return false; + } + + if (!this.canBufferOutputs(tRecipe, aMaxParallelRecipes)) { + return false; + } + + // EU discount + float tRecipeEUt = (tRecipe.mEUt * aEUPercent) / 100.0f; + float tTotalEUt = 0.0f; + + int parallelRecipes = 0; + + // Count recipes to do in parallel, consuming input items and fluids and considering input voltage limits + for (; parallelRecipes < aMaxParallelRecipes && tTotalEUt < (tVoltage - tRecipeEUt); parallelRecipes++) { + if (!tRecipe.isRecipeInputEqual(true, aFluidInputs, aItemInputs)) { + break; + } + tTotalEUt += tRecipeEUt; + } + + if (parallelRecipes == 0) { + 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)(tRecipe.mDuration * 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 + 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[tRecipe.mOutputs.length]; + for (int h = 0; h < tRecipe.mOutputs.length; 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(); + + /** + * Amp Stat Recording + */ + + for (int u=0;u<tRecipe.mFluidInputs.length;u++) { + if (tRecipe.mFluidInputs[u].isFluidEqual(mUU[0])) { + if (tRecipe.mFluidInputs[u].amount > 0) { + mAmplifierUsed += tRecipe.mFluidInputs[u].amount; + } + } + } + for (int u=0;u<tOutputFluids.length;u++) { + if (tOutputFluids[u].isFluidEqual(mUU[0])) { + mAmplifierProduced += tOutputFluids[u].amount; + } + /** + * UUM Stat Recording + */ + if (tOutputFluids[u].isFluidEqual(mUU[1])) { + mMatterProduced += tOutputFluids[u].amount; + } + } + + /** + * Scrap Stat Recording + */ + for (int u=0;u<tRecipe.mInputs.length;u++) { + if (tRecipe.mInputs[u].getItem() == getScrapPile().getItem()) { + mScrapUsed += tRecipe.mInputs[u].stackSize; + } + } + for (int u=0;u<tOutputItems.length;u++) { + if (tOutputItems[u].getItem() == getScrapPile().getItem()) { + mScrapProduced += tOutputItems[u].stackSize; + } + } + + // Play sounds (GT++ addition - GT multiblocks play no sounds) + startProcess(); + + return true; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("mScrapProduced", mScrapProduced); + aNBT.setInteger("mAmplifierProduced", mAmplifierProduced); + aNBT.setInteger("mMatterProduced", mMatterProduced); + aNBT.setInteger("mScrapUsed", mScrapUsed); + aNBT.setInteger("mAmplifierUsed", mAmplifierUsed); + aNBT.setInteger("mMode", mMode); + super.saveNBTData(aNBT); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + mScrapProduced = aNBT.getInteger("mScrapProduced"); + mAmplifierProduced = aNBT.getInteger("mAmplifierProduced"); + mMatterProduced = aNBT.getInteger("mMatterProduced"); + mScrapUsed = aNBT.getInteger("mScrapUsed"); + mAmplifierUsed = aNBT.getInteger("mAmplifierUsed"); + mMode = aNBT.getInteger("mMode"); + super.loadNBTData(aNBT); + } + }
\ No newline at end of file |