diff options
Diffstat (limited to 'src/Java/gtPlusPlus/xmod')
12 files changed, 1122 insertions, 83 deletions
diff --git a/src/Java/gtPlusPlus/xmod/eio/handler/HandlerTooltip_EIO.java b/src/Java/gtPlusPlus/xmod/eio/handler/HandlerTooltip_EIO.java index 788e4d6d9f..6d50f64e6d 100644 --- a/src/Java/gtPlusPlus/xmod/eio/handler/HandlerTooltip_EIO.java +++ b/src/Java/gtPlusPlus/xmod/eio/handler/HandlerTooltip_EIO.java @@ -17,15 +17,9 @@ import net.minecraftforge.event.entity.player.ItemTooltipEvent; public class HandlerTooltip_EIO { - private static volatile Item mIngot; - private static volatile ItemStack mPulsatingIron; - private static volatile ItemStack mConductiveIron; - private static volatile ItemStack mRedstoneAlloy; - private static volatile ItemStack mElectricalSteel; - private static volatile ItemStack mEnergeticAlloy; - private static volatile ItemStack mVibrantAlloy; - private static volatile ItemStack mSoularium; - private static volatile ItemStack mDarkIron; + private static Item mIngot; + Class oMainClass; + Class oIngotClass; @SubscribeEvent public void onItemTooltip(ItemTooltipEvent event){ @@ -36,19 +30,16 @@ public class HandlerTooltip_EIO { //If it is, reflect in. if (mIngot == null){ try { - Class<?> oMainClass = Class.forName("crazypants.enderio.EnderIO"); - Class<?> oIngotClass = Class.forName("crazypants.enderio.material.ItemAlloy"); + oMainClass = Class.forName("crazypants.enderio.EnderIO"); + oIngotClass = Class.forName("crazypants.enderio.material.ItemAlloy"); if (oMainClass != null && oIngotClass != null){ - Field oAlloyField = oMainClass.getDeclaredField("itemAlloy"); oAlloyField.setAccessible(true); Object oAlloy = oAlloyField.get(oMainClass); - if (oAlloy != null){ if (oIngotClass.isInstance(oAlloy) || Item.class.isInstance(oAlloy)){ mIngot = (Item) oAlloy; } - } } } @@ -56,77 +47,41 @@ public class HandlerTooltip_EIO { } } - try { - if (mIngot != null){ - //If the Item is an instance of ItemAlloy.class then proceed - if (Class.forName("crazypants.enderio.material.ItemAlloy").isInstance(event.itemStack.getItem()) || event.itemStack.getUnlocalizedName().toLowerCase().contains("item.itemAlloy")){ - - //If EIO Item Is not Null, see if the ItemStacks for the ingots are null - //if they stacks are null, set the stack using the item set via reflection. - //The meta data is based on the oridinals of the materials in the EIO enum. - - if (mElectricalSteel == null){ - mElectricalSteel = ItemUtils.simpleMetaStack(mIngot, 0, 1); - } - if (mEnergeticAlloy == null){ - mEnergeticAlloy = ItemUtils.simpleMetaStack(mIngot, 1, 1); - } - if (mVibrantAlloy == null){ - mVibrantAlloy = ItemUtils.simpleMetaStack(mIngot, 2, 1); - } - if (mRedstoneAlloy == null){ - mRedstoneAlloy = ItemUtils.simpleMetaStack(mIngot, 3, 1); - } - if (mConductiveIron == null){ - mConductiveIron = ItemUtils.simpleMetaStack(mIngot, 4, 1); - } - if (mPulsatingIron == null){ - mPulsatingIron = ItemUtils.simpleMetaStack(mIngot, 5, 1); - } - if (mDarkIron == null){ - mDarkIron = ItemUtils.simpleMetaStack(mIngot, 6, 1); - } - if (mSoularium == null){ - mSoularium = ItemUtils.simpleMetaStack(mIngot, 7, 1); - } + if (mIngot != null){ + //If the Item is an instance of ItemAlloy.class then proceed + if (event.itemStack.getItem() == mIngot || oIngotClass.isInstance(event.itemStack.getItem()) || event.itemStack.getUnlocalizedName().toLowerCase().contains("item.itemAlloy")){ - - //If stacks match, add a tooltip. - if (mIngot != null){ - if (event.itemStack.getItem() == mIngot){ - if (event.itemStack.getItemDamage() == 0){ - event.toolTip.add(MaterialEIO.ELECTRICAL_STEEL.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 1){ - event.toolTip.add(MaterialEIO.ENERGETIC_ALLOY.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 2){ - event.toolTip.add(MaterialEIO.VIBRANT_ALLOY.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 3){ - event.toolTip.add(MaterialEIO.REDSTONE_ALLOY.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 4){ - event.toolTip.add(MaterialEIO.CONDUCTIVE_IRON.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 5){ - event.toolTip.add(MaterialEIO.PULSATING_IRON.vChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 6){ - event.toolTip.add(Materials.DarkSteel.mChemicalFormula); - } - else if (event.itemStack.getItemDamage() == 7){ - event.toolTip.add(MaterialEIO.SOULARIUM.vChemicalFormula); - } + //If stacks match, add a tooltip. + if (mIngot != null){ + if (event.itemStack.getItem() == mIngot){ + if (event.itemStack.getItemDamage() == 0){ + event.toolTip.add(MaterialEIO.ELECTRICAL_STEEL.vChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 1){ + event.toolTip.add(MaterialEIO.ENERGETIC_ALLOY.vChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 2){ + event.toolTip.add(MaterialEIO.VIBRANT_ALLOY.vChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 3){ + event.toolTip.add(MaterialEIO.REDSTONE_ALLOY.vChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 4){ + event.toolTip.add(MaterialEIO.CONDUCTIVE_IRON.vChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 5){ + event.toolTip.add(MaterialEIO.PULSATING_IRON.vChemicalFormula); } - } - } + else if (event.itemStack.getItemDamage() == 6){ + event.toolTip.add(Materials.DarkSteel.mChemicalFormula); + } + else if (event.itemStack.getItemDamage() == 7){ + event.toolTip.add(MaterialEIO.SOULARIUM.vChemicalFormula); + } + } + } } } - catch (ClassNotFoundException e) { - } } - } - } diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java index 81b40cc301..76ebac2cae 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/enums/GregtechItemList.java @@ -340,7 +340,13 @@ public enum GregtechItemList implements GregtechItemContainer { //Crate Box CrateStorage, - Thaumcraft_Researcher, + Thaumcraft_Researcher, + + Automation_Threaded_SuperBuffer_ULV, Automation_Threaded_SuperBuffer_LV, Automation_Threaded_SuperBuffer_MV, Automation_Threaded_SuperBuffer_HV, Automation_Threaded_SuperBuffer_EV, + Automation_Threaded_SuperBuffer_IV, Automation_Threaded_SuperBuffer_LuV, Automation_Threaded_SuperBuffer_ZPM, Automation_Threaded_SuperBuffer_UV, Automation_Threaded_SuperBuffer_MAX, + + Infinite_Item_Chest, + ; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_ThreadedSuperBuffer.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_ThreadedSuperBuffer.java new file mode 100644 index 0000000000..51ad334a01 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/CONTAINER_ThreadedSuperBuffer.java @@ -0,0 +1,86 @@ +package gtPlusPlus.xmod.gregtech.api.gui; + +import gregtech.api.util.GT_Utility; + +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ThreadedBuffer; +import gtPlusPlus.xmod.gregtech.common.tileentities.automation.GT_MetaTileEntity_ThreadedChestBuffer; + +import net.minecraft.item.ItemStack; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.IInventory; +import gregtech.api.gui.GT_Slot_Holo; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.entity.player.InventoryPlayer; +import gregtech.api.gui.GT_ContainerMetaTile_Machine; + +public class CONTAINER_ThreadedSuperBuffer extends GT_ContainerMetaTile_Machine { + + protected int cacheTime = 0; + + public CONTAINER_ThreadedSuperBuffer(final InventoryPlayer aInventoryPlayer, final IGregTechTileEntity aTileEntity) { + super(aInventoryPlayer, aTileEntity); + cacheTime = ((GT_MetaTileEntity_ThreadedBuffer)aTileEntity.getMetaTileEntity()).mThreadTimeLeft; + } + + public void addSlots(final InventoryPlayer aInventoryPlayer) { + this.addSlotToContainer((Slot) new GT_Slot_Holo((IInventory) this.mTileEntity, 256, 8, 63, false, true, 1)); + this.addSlotToContainer((Slot) new GT_Slot_Holo((IInventory) this.mTileEntity, 256, 26, 63, false, true, 1)); + this.addSlotToContainer((Slot) new GT_Slot_Holo((IInventory) this.mTileEntity, 256, 44, 63, false, true, 1)); + } + + public ItemStack slotClick(final int aSlotIndex, final int aMouseclick, final int aShifthold, + final EntityPlayer aPlayer) { + if (aSlotIndex < 0) { + return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer); + } + final Slot tSlot = (Slot) this.inventorySlots.get(aSlotIndex); + if (tSlot != null) { + if (this.mTileEntity.getMetaTileEntity() == null) { + return null; + } + if (aSlotIndex == 0) { + ((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bOutput = !((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bOutput; + if (((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity.getMetaTileEntity()).bOutput) { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("116", "Emit Energy to Outputside")); + } else { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("117", "Don't emit Energy")); + } + return null; + } + if (aSlotIndex == 1) { + ((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bRedstoneIfFull = !((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bRedstoneIfFull; + if (((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity.getMetaTileEntity()).bRedstoneIfFull) { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("118", "Emit Redstone if no Slot is free")); + } else { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("119", "Don't emit Redstone")); + } + return null; + } + if (aSlotIndex == 2) { + ((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bInvert = !((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity + .getMetaTileEntity()).bInvert; + if (((GT_MetaTileEntity_ThreadedChestBuffer) this.mTileEntity.getMetaTileEntity()).bInvert) { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("120", "Invert Redstone")); + } else { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("121", "Don't invert Redstone")); + } + return null; + } + } + return super.slotClick(aSlotIndex, aMouseclick, aShifthold, aPlayer); + } + + public int getSlotCount() { + return 0; + } + + public int getShiftClickSlotCount() { + return 0; + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_ThreadedSuperBuffer.java b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_ThreadedSuperBuffer.java new file mode 100644 index 0000000000..2ca0b25e23 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/gui/GUI_ThreadedSuperBuffer.java @@ -0,0 +1,32 @@ +package gtPlusPlus.xmod.gregtech.api.gui; + +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import net.minecraft.entity.player.InventoryPlayer; +import gregtech.api.gui.GT_GUIContainerMetaTile_Machine; + +public class GUI_ThreadedSuperBuffer extends GT_GUIContainerMetaTile_Machine { + + int cacheTime = 0; + + public GUI_ThreadedSuperBuffer(final InventoryPlayer aInventoryPlayer, final IGregTechTileEntity aTileEntity) { + super(new CONTAINER_ThreadedSuperBuffer(aInventoryPlayer, aTileEntity), "gregtech:textures/gui/SuperBuffer.png"); + } + + private void updateVars(){ + this.cacheTime = ((CONTAINER_ThreadedSuperBuffer)this.mContainer).cacheTime; + } + + @Override + protected void drawGuiContainerForegroundLayer(final int par1, final int par2){ + this.updateVars(); + this.fontRendererObj.drawString("Time Remaining: "+cacheTime, 76, 61, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(final float par1, final int par2, final int par3) { + super.drawGuiContainerBackgroundLayer(par1, par2, par3); + final int x = (this.width - this.xSize) / 2; + final int y = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(x, y, 0, 0, this.xSize, this.ySize); + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_ThreadedBuffer.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_ThreadedBuffer.java new file mode 100644 index 0000000000..9642ff63ee --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_ThreadedBuffer.java @@ -0,0 +1,418 @@ +package gtPlusPlus.xmod.gregtech.api.metatileentity.implementations; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.entity.player.EntityPlayer; +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Utility; + +import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.core.util.data.ArrayUtils; +import gtPlusPlus.xmod.gregtech.api.objects.GregtechBufferThread; + +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Buffer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; + +public abstract class GT_MetaTileEntity_ThreadedBuffer extends GT_MetaTileEntity_Buffer { + + protected GregtechBufferThread mLogicThread; + protected BlockPos mPos; + public final ItemStack[] mInventorySynchro; + public int mThreadTimeLeft = 0; + + public GT_MetaTileEntity_ThreadedBuffer(final int aID, final String aName, final String aNameRegional, final int aTier, + final int aInvSlotCount, final String aDescription) { + super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription); + this.bOutput = false; + this.bRedstoneIfFull = false; + this.bInvert = false; + this.mSuccess = 0; + this.mTargetStackSize = 0; + this.mInventorySynchro = new ItemStack[aInvSlotCount]; + } + + public GT_MetaTileEntity_ThreadedBuffer(final int aID, final String aName, final String aNameRegional, final int aTier, + final int aInvSlotCount, final String[] aDescription) { + super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription); + this.bOutput = false; + this.bRedstoneIfFull = false; + this.bInvert = false; + this.mSuccess = 0; + this.mTargetStackSize = 0; + this.mInventorySynchro = new ItemStack[aInvSlotCount]; + } + + public GT_MetaTileEntity_ThreadedBuffer(final String aName, final int aTier, final int aInvSlotCount, + final String aDescription, final ITexture[][][] aTextures) { + super(aName, aTier, aInvSlotCount, aDescription, aTextures); + this.bOutput = false; + this.bRedstoneIfFull = false; + this.bInvert = false; + this.mSuccess = 0; + this.mTargetStackSize = 0; + this.mInventorySynchro = new ItemStack[aInvSlotCount]; + } + + public GT_MetaTileEntity_ThreadedBuffer(final String aName, final int aTier, final int aInvSlotCount, + final String[] aDescription, final ITexture[][][] aTextures) { + super(aName, aTier, aInvSlotCount, aDescription, aTextures); + this.bOutput = false; + this.bRedstoneIfFull = false; + this.bInvert = false; + this.mSuccess = 0; + this.mTargetStackSize = 0; + this.mInventorySynchro = new ItemStack[aInvSlotCount]; + } + + public synchronized final GregtechBufferThread getLogicThread() { + if (mLogicThread != null) { + return mLogicThread; + } + else { + return this.mLogicThread = GregtechBufferThread.getBufferThread(mPos); + } + } + + public ITexture[][][] getTextureSet(final ITexture[] aTextures) { + final ITexture[][][] rTextures = new ITexture[6][17][]; + final ITexture tIcon = this.getOverlayIcon(); + final ITexture tOut = (ITexture) new GT_RenderedTexture((IIconContainer) Textures.BlockIcons.OVERLAY_PIPE_OUT); + final ITexture tUp = (ITexture) new GT_RenderedTexture((IIconContainer) Textures.BlockIcons.ARROW_UP); + final ITexture tDown = (ITexture) new GT_RenderedTexture((IIconContainer) Textures.BlockIcons.ARROW_DOWN); + final ITexture tLeft = (ITexture) new GT_RenderedTexture((IIconContainer) Textures.BlockIcons.ARROW_LEFT); + final ITexture tRight = (ITexture) new GT_RenderedTexture((IIconContainer) Textures.BlockIcons.ARROW_RIGHT); + for (byte i = -1; i < 16; ++i) { + rTextures[0][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tOut}; + rTextures[1][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tRight, tIcon}; + rTextures[2][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tDown, tIcon}; + rTextures[3][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tLeft, tIcon}; + rTextures[4][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tUp, tIcon}; + rTextures[5][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][i + 1], tIcon}; + } + return rTextures; + } + + public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing, + final byte aColorIndex, final boolean aActive, final boolean aRedstone) { + if (aSide == aFacing) { + return this.mTextures[5][aColorIndex + 1]; + } + if (GT_Utility.getOppositeSide((int) aSide) == aFacing) { + return this.mTextures[0][aColorIndex + 1]; + } + Label_0356 : { + switch (aFacing) { + case 0 : { + return this.mTextures[4][aColorIndex + 1]; + } + case 1 : { + return this.mTextures[2][aColorIndex + 1]; + } + case 2 : { + switch (aSide) { + case 0 : { + return this.mTextures[2][aColorIndex + 1]; + } + case 1 : { + return this.mTextures[2][aColorIndex + 1]; + } + case 4 : { + return this.mTextures[1][aColorIndex + 1]; + } + case 5 : { + return this.mTextures[3][aColorIndex + 1]; + } + default : { + break Label_0356; + } + } + } + case 3 : { + switch (aSide) { + case 0 : { + return this.mTextures[4][aColorIndex + 1]; + } + case 1 : { + return this.mTextures[4][aColorIndex + 1]; + } + case 4 : { + return this.mTextures[3][aColorIndex + 1]; + } + case 5 : { + return this.mTextures[1][aColorIndex + 1]; + } + default : { + break Label_0356; + } + } + } + case 4 : { + switch (aSide) { + case 0 : { + return this.mTextures[3][aColorIndex + 1]; + } + case 1 : { + return this.mTextures[1][aColorIndex + 1]; + } + case 2 : { + return this.mTextures[3][aColorIndex + 1]; + } + case 3 : { + return this.mTextures[1][aColorIndex + 1]; + } + default : { + break Label_0356; + } + } + } + case 5 : { + switch (aSide) { + case 0 : { + return this.mTextures[1][aColorIndex + 1]; + } + case 1 : { + return this.mTextures[3][aColorIndex + 1]; + } + case 2 : { + return this.mTextures[1][aColorIndex + 1]; + } + case 3 : { + return this.mTextures[3][aColorIndex + 1]; + } + default : { + break Label_0356; + } + } + } + } + } + return this.mTextures[5][aColorIndex + 1]; + } + + public boolean isSimpleMachine() { + return false; + } + + public boolean isValidSlot(final int aIndex) { + return aIndex < this.mInventorySynchro.length - 1; + } + + public boolean isFacingValid(final byte aFacing) { + return true; + } + + public boolean isEnetInput() { + return true; + } + + public boolean isEnetOutput() { + return true; + } + + public boolean isInputFacing(final byte aSide) { + return !this.isOutputFacing(aSide); + } + + public boolean isOutputFacing(final byte aSide) { + return this.getBaseMetaTileEntity().getBackFacing() == aSide; + } + + public boolean isTeleporterCompatible() { + return false; + } + + public long getMinimumStoredEU() { + return 512L; + } + + public long maxEUStore() { + return 512L + GT_Values.V[this.mTier] * 50L; + } + + public long maxEUInput() { + return GT_Values.V[this.mTier]; + } + + public long maxEUOutput() { + return this.bOutput ? GT_Values.V[this.mTier] : 0L; + } + + public long maxAmperesIn() { + return 2L; + } + + public long maxAmperesOut() { + return 2L; + } + + public boolean isAccessAllowed(final EntityPlayer aPlayer) { + return true; + } + + public abstract ITexture getOverlayIcon(); + + public boolean onRightclick(final IGregTechTileEntity aBaseMetaTileEntity, final EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) { + return true; + } + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + + public void saveNBTData(final NBTTagCompound aNBT) { + aNBT.setBoolean("bInvert", this.bInvert); + aNBT.setBoolean("bOutput", this.bOutput); + aNBT.setBoolean("bRedstoneIfFull", this.bRedstoneIfFull); + aNBT.setInteger("mTargetStackSize", this.mTargetStackSize); + } + + public void loadNBTData(final NBTTagCompound aNBT) { + this.bInvert = aNBT.getBoolean("bInvert"); + this.bOutput = aNBT.getBoolean("bOutput"); + this.bRedstoneIfFull = aNBT.getBoolean("bRedstoneIfFull"); + this.mTargetStackSize = aNBT.getInteger("mTargetStackSize"); + } + + public void setItemNBT(final NBTTagCompound aNBT) { + super.setItemNBT(aNBT); + if (this.mTargetStackSize > 0) { + aNBT.setInteger("mTargetStackSize", this.mTargetStackSize); + } + } + + public void onScrewdriverRightClick(final byte aSide, final EntityPlayer aPlayer, final float aX, final float aY, + final float aZ) { + if (aSide == this.getBaseMetaTileEntity().getBackFacing()) { + this.mTargetStackSize = (byte) ((this.mTargetStackSize + (aPlayer.isSneaking() ? -1 : 1)) % 65); + if (this.mTargetStackSize < 0) { + this.mTargetStackSize = 64; + } + if (this.mTargetStackSize == 0) { + GT_Utility.sendChatToPlayer(aPlayer, this.trans("098", "Do not regulate Item Stack Size")); + } else { + GT_Utility.sendChatToPlayer(aPlayer, + this.trans("099", "Regulate Item Stack Size to: ") + this.mTargetStackSize); + } + } + } + + public synchronized void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTimer) { + if (aBaseMetaTileEntity.isServerSide()) { + if (mPos == null) { + mPos = new BlockPos(this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord(), this.getBaseMetaTileEntity().getWorld()); + } + if (mLogicThread == null) { + mLogicThread = GregtechBufferThread.getBufferThread(mPos); + } + if (mLogicThread!= null) { + getLogicThread().onPostTick(aBaseMetaTileEntity, aTimer, this); + this.mThreadTimeLeft = this.mLogicThread.getTimeLeft(); + } + } + } + + public void onFirstTick(final IGregTechTileEntity aBaseMetaTileEntity) { + for (byte b = 0; b < 6; ++b) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, (byte) 0); + } + } + + protected synchronized void moveItems(final IGregTechTileEntity aBaseMetaTileEntity, final long aTimer) { + if (aBaseMetaTileEntity.isServerSide()) + getLogicThread().moveItems(aBaseMetaTileEntity, aTimer, this); + } + + public boolean allowPullStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, + final ItemStack aStack) { + return true; + } + + public boolean allowPutStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, + final ItemStack aStack) { + return aSide != aBaseMetaTileEntity.getBackFacing(); + } + + public boolean allowGeneralRedstoneOutput() { + return true; + } + + //Custom inventory handler + + @Override + public synchronized ItemStack[] getRealInventory() { + return this.mInventorySynchro; + } + + @Override + public synchronized boolean canInsertItem(final int aIndex, final ItemStack aStack, final int aSide) { + return this.isValidSlot(aIndex) && aStack != null && aIndex < getSizeInventory() + && (this.mInventorySynchro[aIndex] == null || GT_Utility.areStacksEqual(aStack, this.mInventorySynchro[aIndex])) + && this.allowPutStack(this.getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + } + + @Override + public synchronized boolean canExtractItem(final int aIndex, final ItemStack aStack, final int aSide) { + return this.isValidSlot(aIndex) && aStack != null && aIndex < getSizeInventory() + && this.allowPullStack(this.getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + } + + @Override + public synchronized int getSizeInventory() { + return this.mInventorySynchro.length; + } + + @Override + public synchronized ItemStack getStackInSlot(final int aIndex) { + if (aIndex >= 0 && aIndex < getSizeInventory()) { + return this.mInventorySynchro[aIndex]; + } + return null; + } + + @Override + public synchronized void setInventorySlotContents(final int aIndex, final ItemStack aStack) { + if (aIndex >= 0 && aIndex < getSizeInventory()) { + this.mInventorySynchro[aIndex] = aStack; + } + } + + private synchronized void cleanup() { + if (this.mLogicThread != null) { + this.mLogicThread.destroy(); + this.mLogicThread = null; + } + } + + @Override + public void onExplosion() { + cleanup(); + super.onExplosion(); + } + + @Override + public void onRemoval() { + cleanup(); + super.onRemoval(); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + String mResult[] = super.getInfoData(); + String mAdditive[] = new String[] { + "info" + }; + for (String s : mAdditive) { + ArrayUtils.expandArray(mResult, s); + } + return mResult; + } +}
\ No newline at end of file diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/objects/GregtechBufferThread.java b/src/Java/gtPlusPlus/xmod/gregtech/api/objects/GregtechBufferThread.java new file mode 100644 index 0000000000..1e7d73bacd --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/objects/GregtechBufferThread.java @@ -0,0 +1,242 @@ +package gtPlusPlus.xmod.gregtech.api.objects; + +import java.util.List; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +import net.minecraft.init.Items; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; + +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.util.GT_Utility; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.minecraft.BlockPos; +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ThreadedBuffer; +import gtPlusPlus.xmod.gregtech.common.tileentities.automation.GT_MetaTileEntity_ThreadedChestBuffer; + +public class GregtechBufferThread extends Thread { + + public static final ConcurrentMap<String, GregtechBufferThread> mBufferThreadAllocation = new ConcurrentHashMap<String, GregtechBufferThread>(); + private final BlockPos mBlockPos; + private final int mMaxLife = 300; + private int mLifeCycleTime = mMaxLife; + private final String mID; + + public static synchronized final GregtechBufferThread getBufferThread(BlockPos pos) { + if (pos != null && mBufferThreadAllocation.containsKey(""+pos.getUniqueIdentifier())){ + Logger.INFO("[SB] Found an existing thread for this Buffer."); + return mBufferThreadAllocation.get(""+pos.getUniqueIdentifier()); + } + else { + return new GregtechBufferThread(pos); + } + } + + public GregtechBufferThread(BlockPos pos) { + super(); + String aID = pos != null ? pos.getUniqueIdentifier() : ""+Short.MIN_VALUE; + this.mID = aID; + if (pos != null && !mBufferThreadAllocation.containsKey(mID)){ + mBlockPos = pos; + mBufferThreadAllocation.put(mID, this); + } + else { + this.mLifeCycleTime = 1; + mBlockPos = null; + } + this.setName("GTPP-SuperBuffer("+mID+")"); + this.setDaemon(true); + if (mBlockPos != null && !this.isAlive()) { + try { + start(); + Logger.INFO("[SB] Created a SuperBuffer Thread for dimension "+mID+"."); + } + catch (Throwable t_) { + //Do nothing. + } + } + } + + public synchronized int getTimeLeft() { + return this.mLifeCycleTime; + } + + public synchronized void fillStacksIntoFirstSlots(GT_MetaTileEntity_ThreadedChestBuffer mBuffer) { + for (int i = 0; i < mBuffer.mInventorySynchro.length - 1; ++i) { + for (int j = i + 1; j < mBuffer.mInventorySynchro.length - 1; ++j) { + if (mBuffer.mInventorySynchro[j] != null && (mBuffer.mInventorySynchro[i] == null + || areStacksEqual(mBuffer.mInventorySynchro[i], mBuffer.mInventorySynchro[j]))) { + moveStackFromSlotAToSlotB((IInventory) mBuffer.getBaseMetaTileEntity(), + (IInventory) mBuffer.getBaseMetaTileEntity(), j, i, (byte) 64, (byte) 1, (byte) 64, (byte) 1); + } + } + } + } + + public synchronized boolean moveItems(final IGregTechTileEntity aBaseMetaTileEntity, final long aTimer, GT_MetaTileEntity_ThreadedBuffer mBuffer) { + final byte mTargetStackSize = (byte) mBuffer.mTargetStackSize; + final int tCost = GT_Utility.moveOneItemStack((Object) aBaseMetaTileEntity, + (Object) aBaseMetaTileEntity.getTileEntityAtSide(aBaseMetaTileEntity.getBackFacing()), + aBaseMetaTileEntity.getBackFacing(), aBaseMetaTileEntity.getFrontFacing(), (List<ItemStack>) null, false, + (byte) ((mTargetStackSize == 0) ? 64 : ((byte) mTargetStackSize)), + (byte) ((mTargetStackSize == 0) ? 1 : ((byte) mTargetStackSize)), (byte) 64, (byte) 1); + if (tCost > 0 || aBaseMetaTileEntity.hasInventoryBeenModified()) { + mBuffer.mSuccess = 50; + aBaseMetaTileEntity.decreaseStoredEnergyUnits((long) Math.abs(tCost), true); + return true; + } + return false; + } + + public synchronized void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTimer, GT_MetaTileEntity_ThreadedBuffer mBuffer) { + if (aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.isServerSide() + && aBaseMetaTileEntity.isUniversalEnergyStored(mBuffer.getMinimumStoredEU()) + && (aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified() + || aTimer % 200L == 0L || mBuffer.mSuccess > 0)) { + --mBuffer.mSuccess; + if (mLifeCycleTime < (mMaxLife-1)){ + mLifeCycleTime += 1; + } + //Logger.INFO("Ticking SB @ "+mBuffer.getLogicThread().mBlockPos.getUniqueIdentifier() + " | Time Left: "+mLifeCycleTime); + moveItems(aBaseMetaTileEntity, aTimer, mBuffer); + for (byte b = 0; b < 6; ++b) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, (byte) (mBuffer.bInvert ? 15 : 0)); + } + if (mBuffer.bRedstoneIfFull) { + for (byte b = 0; b < 6; ++b) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, (byte) (mBuffer.bInvert ? 0 : 15)); + } + for (int i = 0; i < mBuffer.mInventorySynchro.length; ++i) { + if (mBuffer.isValidSlot(i) && mBuffer.mInventorySynchro[i] == null) { + for (byte b2 = 0; b2 < 6; ++b2) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b2, (byte) (mBuffer.bInvert ? 15 : 0)); + } + aBaseMetaTileEntity.decreaseStoredEnergyUnits(1L, true); + break; + } + } + } + } + } + + /** + * Some GT logic we'd like to move off thread + */ + + public synchronized boolean areStacksEqual(final ItemStack aStack1, final ItemStack aStack2) { + return areStacksEqual(aStack1, aStack2, false); + } + + public synchronized boolean areStacksEqual(final ItemStack aStack1, final ItemStack aStack2, final boolean aIgnoreNBT) { + return aStack1 != null && aStack2 != null && aStack1.getItem() == aStack2.getItem() + && (aIgn |