From 877312184c472d9845e5ef1008bc538f4634059f Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:50:56 +0300 Subject: fix missing source folder --- .../storage/GT_MetaTileEntity_Locker.java | 225 +++++++++++++++++++++ .../storage/GT_MetaTileEntity_QuantumChest.java | 202 ++++++++++++++++++ .../storage/GT_MetaTileEntity_QuantumTank.java | 104 ++++++++++ 3 files changed, 531 insertions(+) create mode 100644 main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java create mode 100644 main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java create mode 100644 main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java (limited to 'main/java/gregtech/common/tileentities/storage') diff --git a/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java new file mode 100644 index 0000000..9cc60ce --- /dev/null +++ b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java @@ -0,0 +1,225 @@ +/* 1: */ package gregtech.common.tileentities.storage; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.interfaces.ITexture; +/* 6: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; +/* 9: */ import gregtech.api.objects.GT_ItemStack; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.entity.player.EntityPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ import net.minecraft.nbt.NBTTagCompound; +/* 17: */ +/* 18: */ public class GT_MetaTileEntity_Locker +/* 19: */ extends GT_MetaTileEntity_TieredMachineBlock +/* 20: */ { +/* 21: 24 */ public byte mType = 0; +/* 22: */ +/* 23: */ public GT_MetaTileEntity_Locker(int aID, String aName, String aNameRegional, int aTier) +/* 24: */ { +/* 25: 27 */ super(aID, aName, aNameRegional, aTier, 4, "Stores and recharges Armor", new ITexture[0]); +/* 26: */ } +/* 27: */ +/* 28: */ public GT_MetaTileEntity_Locker(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 29: */ { +/* 30: 31 */ super(aName, aTier, 4, aDescription, aTextures); +/* 31: */ } +/* 32: */ +/* 33: */ @Override +public String[] getDescription() +/* 34: */ { +/* 35: 36 */ return new String[] { this.mDescription, "Click with Screwdriver to change Style" }; +/* 36: */ } +/* 37: */ +/* 38: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 39: */ { +/* 40: 41 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 41: 42 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 42: */ {ITexture[] tmp0 ={ Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)] }; +/* 43: 43 */ rTextures[0][(i + 1)] = tmp0; +/* 44: 44 */ ITexture[] tmp1 ={ Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)], Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier] }; +rTextures[1][(i + 1)] = tmp1; +/* 45: 45 */ ITexture[] tmp2 = { Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_LOCKER) }; +rTextures[2][(i + 1)] =tmp2; +/* 46: */ } +/* 47: 47 */ return rTextures; +/* 48: */ } +/* 49: */ +/* 50: */ @Override +public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) +/* 51: */ { +/* 52: 52 */ if (aSide == aFacing) { +/* 53: 52 */ return new ITexture[] { this.mTextures[2][(aColorIndex + 1)][0], this.mTextures[2][(aColorIndex + 1)][1], Textures.BlockIcons.LOCKERS[java.lang.Math.abs(this.mType % Textures.BlockIcons.LOCKERS.length)] }; +/* 54: */ } +/* 55: 53 */ return this.mTextures[0][(aColorIndex + 1)]; +/* 56: */ } +/* 57: */ +/* 58: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 59: */ { +/* 60: 58 */ return new GT_MetaTileEntity_Locker(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 61: */ } +/* 62: */ +/* 63: */ @Override +public boolean isSimpleMachine() +/* 64: */ { +/* 65: 61 */ return false; +/* 66: */ } +/* 67: */ +/* 68: */ @Override +public boolean isElectric() +/* 69: */ { +/* 70: 62 */ return true; +/* 71: */ } +/* 72: */ +/* 73: */ @Override +public boolean isValidSlot(int aIndex) +/* 74: */ { +/* 75: 63 */ return true; +/* 76: */ } +/* 77: */ +/* 78: */ @Override +public boolean isFacingValid(byte aFacing) +/* 79: */ { +/* 80: 64 */ return aFacing > 1; +/* 81: */ } +/* 82: */ +/* 83: */ @Override +public boolean isEnetInput() +/* 84: */ { +/* 85: 65 */ return true; +/* 86: */ } +/* 87: */ +/* 88: */ @Override +public boolean isInputFacing(byte aSide) +/* 89: */ { +/* 90: 66 */ return aSide == getBaseMetaTileEntity().getBackFacing(); +/* 91: */ } +/* 92: */ +/* 93: */ @Override +public boolean isTeleporterCompatible() +/* 94: */ { +/* 95: 67 */ return false; +/* 96: */ } +/* 97: */ +/* 98: */ @Override +public long maxEUStore() +/* 99: */ { +/* 100: 68 */ return gregtech.api.enums.GT_Values.V[this.mTier] * maxAmperesIn(); +/* 101: */ } +/* 102: */ +/* 103: */ @Override +public long maxEUInput() +/* 104: */ { +/* 105: 69 */ return gregtech.api.enums.GT_Values.V[this.mTier]; +/* 106: */ } +/* 107: */ +/* 108: */ @Override +public long maxAmperesIn() +/* 109: */ { +/* 110: 70 */ return this.mInventory.length * 2; +/* 111: */ } +/* 112: */ +/* 113: */ @Override +public int rechargerSlotStartIndex() +/* 114: */ { +/* 115: 71 */ return 0; +/* 116: */ } +/* 117: */ +/* 118: */ @Override +public int rechargerSlotCount() +/* 119: */ { +/* 120: 72 */ return getBaseMetaTileEntity().isAllowedToWork() ? this.mInventory.length : 0; +/* 121: */ } +/* 122: */ +/* 123: */ @Override +public boolean isAccessAllowed(EntityPlayer aPlayer) +/* 124: */ { +/* 125: 73 */ return true; +/* 126: */ } +/* 127: */ +/* 128: */ @Override +public void saveNBTData(NBTTagCompound aNBT) +/* 129: */ { +/* 130: 77 */ aNBT.setByte("mType", this.mType); +/* 131: */ } +/* 132: */ +/* 133: */ @Override +public void loadNBTData(NBTTagCompound aNBT) +/* 134: */ { +/* 135: 82 */ this.mType = aNBT.getByte("mType"); +/* 136: */ } +/* 137: */ +/* 138: */ @Override +public void onValueUpdate(byte aValue) +/* 139: */ { +/* 140: 87 */ this.mType = aValue; +/* 141: */ } +/* 142: */ +/* 143: */ @Override +public byte getUpdateData() +/* 144: */ { +/* 145: 92 */ return this.mType; +/* 146: */ } +/* 147: */ +/* 148: */ @Override +public void doSound(byte aIndex, double aX, double aY, double aZ) +/* 149: */ { +/* 150: 97 */ if (aIndex == 16) { +/* 151: 97 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(3)), 1, 1.0F); +/* 152: */ } +/* 153: */ } +/* 154: */ +/* 155: */ @Override +public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 156: */ { +/* 157:102 */ if (aSide == getBaseMetaTileEntity().getFrontFacing()) { +/* 158:102 */ this.mType = ((byte)(this.mType + 1)); +/* 159: */ } +/* 160: */ } +/* 161: */ +/* 162: */ @Override +public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) +/* 163: */ { +/* 164:107 */ return aSide != getBaseMetaTileEntity().getFrontFacing(); +/* 165: */ } +/* 166: */ +/* 167: */ @Override +public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) +/* 168: */ { +/* 169:112 */ if ((aBaseMetaTileEntity.isServerSide()) && (aSide == aBaseMetaTileEntity.getFrontFacing())) +/* 170: */ { +/* 171:113 */ for (int i = 0; i < 4; i++) +/* 172: */ { +/* 173:114 */ ItemStack tSwapStack = this.mInventory[i]; +/* 174:115 */ this.mInventory[i] = aPlayer.inventory.armorInventory[i]; +/* 175:116 */ aPlayer.inventory.armorInventory[i] = tSwapStack; +/* 176: */ } +/* 177:118 */ aPlayer.inventoryContainer.detectAndSendChanges(); +/* 178:119 */ sendSound((byte)16); +/* 179: */ } +/* 180:121 */ return true; +/* 181: */ } +/* 182: */ +/* 183: */ @Override +public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 184: */ { +/* 185:126 */ return false; +/* 186: */ } +/* 187: */ +/* 188: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 189: */ { +/* 190:131 */ return false; +/* 191: */ } +/* 192: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.storage.GT_MetaTileEntity_Locker + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java new file mode 100644 index 0000000..18a9bd3 --- /dev/null +++ b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java @@ -0,0 +1,202 @@ +package gregtech.common.tileentities.storage; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Utility; +import gregtech.common.gui.GT_Container_QuantumChest; +import gregtech.common.gui.GT_GUIContainer_QuantumChest; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class GT_MetaTileEntity_QuantumChest extends GT_MetaTileEntity_TieredMachineBlock { + public GT_MetaTileEntity_QuantumChest(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 3, "This Chest stores "+((int)((Math.pow(6, aTier))*270000))+" Blocks"); + } + + + public int mItemCount = 0; + public ItemStack mItemStack = null; + + public GT_MetaTileEntity_QuantumChest(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 3, aDescription, aTextures); + } + + @Override public boolean isSimpleMachine() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return true;} + @Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;} + @Override public boolean isValidSlot(int aIndex) {return true;} + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_QuantumChest(mName, mTier, mDescription, mTextures); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + +// public void onRightclick(EntityPlayer aPlayer) +// { +// ItemStack tPlayerItem = aPlayer.inventory.getCurrentItem(); +// if (tPlayerItem == null) +// { +// if (this.mItemID > 0) +// { +// for (int i = 0; (this.mItemCount < getMaxItemCount()) && (i < aPlayer.field_71071_by.func_70302_i_()); i++) +// { +// if ((aPlayer.field_71071_by.func_70301_a(i) != null) && (aPlayer.field_71071_by.func_70301_a(i).field_77993_c == this.mItemID) && (aPlayer.field_71071_by.func_70301_a(i).func_77960_j() == this.mItemMeta) && (!aPlayer.field_71071_by.func_70301_a(i).func_77942_o())) +// { +// this.mItemCount += aPlayer.field_71071_by.func_70301_a(i).field_77994_a; +// if (aPlayer.field_71071_by.func_70301_a(i).field_77994_a == 111) +// { +// this.mItemCount = (getMaxItemCount() + 192 - (this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].field_77994_a) + (this.mInventory[1] == null ? 0 : this.mInventory[1].field_77994_a) + (this.mInventory[2] == null ? 0 : this.mInventory[2].field_77994_a))); +// } +// else if (this.mItemCount > getMaxItemCount()) +// { +// aPlayer.field_71071_by.func_70301_a(i).field_77994_a = (this.mItemCount - getMaxItemCount()); +// this.mItemCount = getMaxItemCount(); +// } +// else +// { +// aPlayer.field_71071_by.func_70301_a(i).field_77994_a = 0; +// } +// } +// if ((aPlayer.field_71071_by.func_70301_a(i) != null) && (aPlayer.field_71071_by.func_70301_a(i).field_77994_a <= 0)) { +// aPlayer.field_71071_by.func_70299_a(i, null); +// } +// } +// GT_Utility.sendChatToPlayer(aPlayer, this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].field_77994_a) + (this.mInventory[1] == null ? 0 : this.mInventory[1].field_77994_a) + (this.mInventory[2] == null ? 0 : this.mInventory[2].field_77994_a) + " of " + new ItemStack(this.mItemID, 1, this.mItemMeta).func_82833_r()); +// } +// } +// if (aPlayer.field_71069_bz != null) { +// aPlayer.field_71069_bz.func_75142_b(); +// } +// } + + @Override + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_Container_QuantumChest(aPlayerInventory, aBaseMetaTileEntity); + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_GUIContainer_QuantumChest(aPlayerInventory, aBaseMetaTileEntity, getLocalName()); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) { + + if (getBaseMetaTileEntity().isServerSide()&& getBaseMetaTileEntity().isAllowedToWork()) + { + if ((getItemCount() <= 0) ){ + this.mItemStack = null; + this.mItemCount = 0; + } + if (this.mItemStack == null&&this.mInventory[0]!=null) + { + this.mItemStack = mInventory[0].copy(); + } + if ((this.mInventory[0]!=null)&&(this.mItemCount < getMaxItemCount()) && GT_Utility.areStacksEqual(this.mInventory[0],this.mItemStack)) + { + this.mItemCount += this.mInventory[0].stackSize; + if (this.mItemCount > getMaxItemCount()) + { + this.mInventory[0].stackSize = (this.mItemCount - getMaxItemCount()); + this.mItemCount = getMaxItemCount(); + } + else + { + this.mInventory[0] = null; + } + } + if (this.mInventory[1] == null&&mItemStack!=null) + { + this.mInventory[1] = mItemStack.copy(); + this.mInventory[1].stackSize = Math.min(mItemStack.getMaxStackSize(), this.mItemCount); + this.mItemCount -= this.mInventory[1].stackSize; + } + else if ((this.mItemCount > 0) && GT_Utility.areStacksEqual(this.mInventory[1],this.mItemStack)&&this.mInventory[1].getMaxStackSize()>this.mInventory[1].stackSize) + { + int tmp = Math.min(this.mItemCount, this.mInventory[1].getMaxStackSize()-this.mInventory[1].stackSize); + this.mInventory[1].stackSize += tmp; + this.mItemCount -= tmp; + } + if(this.mItemStack!=null){ + this.mInventory[2]= this.mItemStack.copy(); + }else{this.mInventory[2]=null;} + } + } + + private int getItemCount() + { + return this.mItemCount; + } + + @Override + public int getProgresstime() + { + return this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].stackSize) + (this.mInventory[1] == null ? 0 : this.mInventory[1].stackSize); + } + + @Override + public int maxProgresstime() + { + return getMaxItemCount(); + } + + @Override + public int getMaxItemCount() + { + return (int) (((Math.pow(6, mTier))*270000) - 128); + } + + @Override + public void setItemCount(int aCount) + { + this.mItemCount = aCount; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return true; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return true; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("mItemCount", this.mItemCount); + if(this.mItemStack!=null) + aNBT.setTag("mItemStack", this.mItemStack.writeToNBT(new NBTTagCompound())); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + if(aNBT.hasKey("mItemCount")) + this.mItemCount = aNBT.getInteger("mItemCount"); + if(aNBT.hasKey("mItemStack")) + this.mItemStack = ItemStack.loadItemStackFromNBT((NBTTagCompound) aNBT.getTag("mItemStack")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity,byte aSide, byte aFacing, byte aColorIndex, boolean aActive,boolean aRedstone) { + return aSide == aBaseMetaTileEntity.getFrontFacing() ? new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1],new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SCREEN)} :new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]};//aSide != aFacing ? mMachineBlock != 0 ? new ITexture[] {Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]} : new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]} : mMachineBlock != 0 ? aActive ? getTexturesActive(Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]) : getTexturesInactive(Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]) : aActive ? getTexturesActive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]) : getTexturesInactive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return new ITexture[0][0][0]; + } +} \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java new file mode 100644 index 0000000..599da17 --- /dev/null +++ b/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java @@ -0,0 +1,104 @@ +package gregtech.common.tileentities.storage; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; +import gregtech.api.objects.GT_RenderedTexture; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; + +public class GT_MetaTileEntity_QuantumTank + extends GT_MetaTileEntity_BasicTank +{ + public GT_MetaTileEntity_QuantumTank(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 3, "Stores "+((int)(Math.pow(6, aTier)*267000))+"L of fluid"); + } + + public GT_MetaTileEntity_QuantumTank(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 3, aDescription, aTextures); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return new ITexture[0][0][0]; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + return aSide ==1 ? new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1],new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SCREEN)} :new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]}; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + + @Override public boolean isSimpleMachine() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return true;} + @Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;} + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + } + + @Override + public final byte getUpdateData() { + return 0x00; + } + + @Override + public boolean doesFillContainers() { + return true; + } + + @Override + public boolean doesEmptyContainers() { + return true; + } + + @Override + public boolean canTankBeFilled() { + return true; + } + + @Override + public boolean canTankBeEmptied() { + return true; + } + + @Override + public boolean displaysItemStack() { + return true; + } + + @Override + public boolean displaysStackSize() { + return false; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_QuantumTank(mName, mTier, mDescription, mTextures); + } + + @Override + public int getCapacity() { + return (int) (Math.pow(6, mTier)*267000); + } + + @Override + public int getTankPressure() { + return 100; + } + +} \ No newline at end of file -- cgit v1.2.3