diff options
Diffstat (limited to 'src/main/java/gregtech/api/interfaces/tileentity')
22 files changed, 1010 insertions, 0 deletions
diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java new file mode 100644 index 0000000000..6b39391d46 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java @@ -0,0 +1,99 @@ +package gregtech.api.interfaces.tileentity; + +/** + * Interface for internal Code, which is mainly used for independent Energy conversion. + */ +public interface IBasicEnergyContainer extends IEnergyConnected { + /** + * Gets if that Amount of Energy is stored inside the Machine. + * It is used for checking the contained Energy before consuming it. + * If this returns false, it will also give a Message inside the Scanner, that this Machine doesn't have enough Energy. + */ + public boolean isUniversalEnergyStored(long aEnergyAmount); + + /** + * Gets the stored electric, kinetic or steam Energy (with EU as reference Value) + * Always returns the largest one. + */ + public long getUniversalEnergyStored(); + + /** + * Gets the largest electric, kinetic or steam Energy Capacity (with EU as reference Value) + */ + public long getUniversalEnergyCapacity(); + + /** + * Gets the amount of Energy Packets per tick. + */ + public long getOutputAmperage(); + + /** + * Gets the Output in EU/p. + */ + public long getOutputVoltage(); + + /** + * Gets the amount of Energy Packets per tick. + */ + public long getInputAmperage(); + + /** + * Gets the maximum Input in EU/p. + */ + public long getInputVoltage(); + + /** + * Decreases the Amount of stored universal Energy. If ignoring too less Energy, then it just sets the Energy to 0 and returns false. + */ + public boolean decreaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooLessEnergy); + + /** + * Increases the Amount of stored electric Energy. If ignoring too much Energy, then the Energy Limit is just being ignored. + */ + public boolean increaseStoredEnergyUnits(long aEnergy, boolean aIgnoreTooMuchEnergy); + + /** + * Drain Energy Call for Electricity. + */ + public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage); + + /** + * returns the amount of Electricity, accepted by this Block the last 5 ticks as Average. + */ + public long getAverageElectricInput(); + + /** + * returns the amount of Electricity, outputted by this Block the last 5 ticks as Average. + */ + public long getAverageElectricOutput(); + + /** + * returns the amount of electricity contained in this Block, in EU units! + */ + public long getStoredEU(); + + /** + * returns the amount of electricity containable in this Block, in EU units! + */ + public long getEUCapacity(); + + /** + * returns the amount of Steam contained in this Block, in EU units! + */ + public long getStoredSteam(); + + /** + * returns the amount of Steam containable in this Block, in EU units! + */ + public long getSteamCapacity(); + + /** + * Increases stored Energy. Energy Base Value is in EU, even though it's Steam! + * @param aEnergy The Energy to add to the Machine. + * @param aIgnoreTooMuchEnergy if it shall ignore if it has too much Energy. + * @return if it was successful + * + * And yes, you can't directly decrease the Steam of a Machine. That is done by decreaseStoredEnergyUnits + */ + public boolean increaseStoredSteam(long aEnergy, boolean aIgnoreTooMuchEnergy); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IColoredTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IColoredTileEntity.java new file mode 100644 index 0000000000..dc511f3050 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IColoredTileEntity.java @@ -0,0 +1,14 @@ +package gregtech.api.interfaces.tileentity; + +public interface IColoredTileEntity { + /** + * @return 0 - 15 are Colors, while -1 means uncolored + */ + public byte getColorization(); + + /** + * Sets the Color Modulation of the Block + * @param aColor the Color you want to set it to. -1 for reset. + */ + public byte setColorization(byte aColor); +} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java new file mode 100644 index 0000000000..546b8d81c6 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java @@ -0,0 +1,35 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.util.GT_CoverBehavior; +import net.minecraft.item.ItemStack; + +public interface ICoverable extends IRedstoneTileEntity, IHasInventory, IBasicEnergyContainer { + public boolean canPlaceCoverIDAtSide (byte aSide, int aID); + public boolean canPlaceCoverItemAtSide (byte aSide, ItemStack aCover); + public boolean dropCover (byte aSide, byte aDroppedSide, boolean aForced); + public void setCoverDataAtSide (byte aSide, int aData); + public void setCoverIDAtSide (byte aSide, int aID); + public void setCoverItemAtSide (byte aSide, ItemStack aCover); + public int getCoverDataAtSide (byte aSide); + public int getCoverIDAtSide (byte aSide); + public ItemStack getCoverItemAtSide (byte aSide); + public GT_CoverBehavior getCoverBehaviorAtSide (byte aSide); + + /** + * For use by the regular MetaTileEntities. Returns the Cover Manipulated input Redstone. + * Don't use this if you are a Cover Behavior. Only for MetaTileEntities. + */ + public byte getInternalInputRedstoneSignal(byte aSide); + + /** + * For use by the regular MetaTileEntities. This makes it not conflict with Cover based Redstone Signals. + * Don't use this if you are a Cover Behavior. Only for MetaTileEntities. + */ + public void setInternalOutputRedstoneSignal(byte aSide, byte aStrength); + + /** + * Causes a general Cover Texture update. + * Sends 6 Integers to Client + causes @issueTextureUpdate() + */ + public void issueCoverUpdate(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IDigitalChest.java b/src/main/java/gregtech/api/interfaces/tileentity/IDigitalChest.java new file mode 100644 index 0000000000..d017a1d7c4 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IDigitalChest.java @@ -0,0 +1,29 @@ +package gregtech.api.interfaces.tileentity; + +import net.minecraft.item.ItemStack; + +/** + * You are allowed to include this File in your Download, as i will not change it. + */ +public interface IDigitalChest extends IHasWorldObjectAndCoords { + /** + * Is this even a TileEntity of a Digital Chest? + * I need things like this Function for MetaTileEntities, you MUST check this!!! + * Do not assume that it's a Digital Chest or similar Device, when it just implements this Interface. + */ + public boolean isDigitalChest(); + /** + * Gives an Array of Stacks with Size (of all the Data-stored Items) of the correspondent Item kinds (regular QChests have only one) + * Does NOT include the 64 "ready" Items inside the Slots, and neither the 128 Items in the overflow Buffer. + */ + public ItemStack[] getStoredItemData(); + /** + * A generic Interface for just setting the amount of contained Items + */ + public void setItemCount(int aCount); + + /** + * Gets the maximum Item count for this QChest alike Storage. This applies to the Data-Storage, not for the up to 192 buffered Items! + */ + public int getMaxItemCount(); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConductor.java b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConductor.java new file mode 100644 index 0000000000..96684de6e3 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConductor.java @@ -0,0 +1,40 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.enums.Materials; + +/** + * Informative Class for Cables. Not used for now. + * + * Not all Data might be reliable. This is just for Information sake. + */ +public interface IEnergyConductor extends IEnergyConnected { + /** + * @return if this is actually a Cable. (you must check this) + */ + public boolean isConductor(); + + /** + * @return the maximum Voltage of the Cable. + */ + public long getMaxVoltage(); + + /** + * @return the maximum Amperage of the Cable, per Wire. + */ + public long getMaxAmperage(); + + /** + * @return the Loss of the Cable, per Meter. + */ + public long getLossPerMeter(); + + /** + * @return the Material the Cable consists of. (may return Materials._NULL) + */ + public Materials getCableMaterial(); + + /** + * @return the Material the Cable Insulation consists of. (may return Materials._NULL) + */ + public Materials getInsulationMaterial(); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java new file mode 100644 index 0000000000..097493807d --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java @@ -0,0 +1,89 @@ +package gregtech.api.interfaces.tileentity; + +import static gregtech.api.enums.GT_Values.V; +import cofh.api.energy.IEnergyReceiver; +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_Utility; +import ic2.api.energy.tile.IEnergySink; +import net.minecraft.init.Blocks; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +/** + * Interface for getting Connected to the GregTech Energy Network. + * + * This is all you need to connect to the GT Network. + * IColoredTileEntity is needed for not connecting differently coloured Blocks to each other. + * IHasWorldObjectAndCoords is needed for the InWorld related Stuff. @BaseTileEntity does implement most of that Interface. + */ +public interface IEnergyConnected extends IColoredTileEntity, IHasWorldObjectAndCoords { + /** + * Inject Energy Call for Electricity. Gets called by EnergyEmitters to inject Energy into your Block + * + * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself. + * + * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do Side checks for this Side) + * @return amount of used Amperes. 0 if not accepted anything. + */ + public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage); + + /** + * Sided Energy Input + */ + public boolean inputEnergyFrom(byte aSide); + + /** + * Sided Energy Output + */ + public boolean outputsEnergyTo(byte aSide); + + /** + * Utility for the Network + */ + public static class Util { + /** + * Emits Energy to the E-net. Also compatible with adjacent IC2 TileEntities. + * @return the used Amperage. + */ + public static final long emitEnergyToNetwork(long aVoltage, long aAmperage, IEnergyConnected aEmitter) { + long rUsedAmperes = 0; + for (byte i = 0, j = 0; i < 6 && aAmperage > rUsedAmperes; i++) if (aEmitter.outputsEnergyTo(i)) { + j = GT_Utility.getOppositeSide(i); + TileEntity tTileEntity = aEmitter.getTileEntityAtSide(i); + if (tTileEntity instanceof IEnergyConnected) { + if (aEmitter.getColorization() >= 0) { + byte tColor = ((IEnergyConnected)tTileEntity).getColorization(); + if (tColor >= 0 && tColor != aEmitter.getColorization()) continue; + } + rUsedAmperes+=((IEnergyConnected)tTileEntity).injectEnergyUnits(j, aVoltage, aAmperage-rUsedAmperes); +// } else if (tTileEntity instanceof IEnergySink) { +// if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aEmitter, ForgeDirection.getOrientation(j))) { +// while (aAmperage > rUsedAmperes && ((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(ForgeDirection.getOrientation(j), aVoltage) < aVoltage) rUsedAmperes++; +// } + } else if (tTileEntity instanceof IEnergySink) { + if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aEmitter, ForgeDirection.getOrientation(j))) { + while (aAmperage > rUsedAmperes && ((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(ForgeDirection.getOrientation(j), aVoltage, aVoltage) < aVoltage) rUsedAmperes++; + } + } else if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver){ + ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite(); + int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100); + if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)==rfOut){ + ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, false); rUsedAmperes++; + } + if(GregTech_API.mRFExplosions && GregTech_API.sMachineExplosions && ((IEnergyReceiver)tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600){ + if(rfOut > 32 * GregTech_API.mEUtoRF / 100) { + int aExplosionPower = rfOut; + float tStrength = aExplosionPower<V[0]?1.0F:aExplosionPower<V[1]?2.0F:aExplosionPower<V[2]?3.0F:aExplosionPower<V[3]?4.0F:aExplosionPower<V[4]?5.0F:aExplosionPower<V[4]*2?6.0F:aExplosionPower<V[5]?7.0F:aExplosionPower<V[6]?8.0F:aExplosionPower<V[7]?9.0F:10.0F; + int tX=tTileEntity.xCoord, tY=tTileEntity.yCoord, tZ=tTileEntity.zCoord; + World tWorld = tTileEntity.getWorldObj(); + GT_Utility.sendSoundToPlayers(tWorld, GregTech_API.sSoundList.get(209), 1.0F, -1, tX, tY, tZ); + tWorld.setBlock(tX, tY, tZ, Blocks.air); + if (GregTech_API.sMachineExplosions) tWorld.createExplosion(null, tX+0.5, tY+0.5, tZ+0.5, tStrength, true);} + } + } + } + return rUsedAmperes; + } + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java new file mode 100644 index 0000000000..9bb3fec13e --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java @@ -0,0 +1,86 @@ +package gregtech.api.interfaces.tileentity; + +import static gregtech.api.enums.GT_Values.F; +import static gregtech.api.enums.GT_Values.T; +import gregtech.api.enums.SubTag; +import gregtech.api.util.GT_Utility; +import ic2.api.energy.tile.IEnergySink; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import cofh.api.energy.IEnergyReceiver; + +/** + * THIS IS GOING TO BE USED IN 1.8 + * + * Interface for getting Connected to the GregTech Energy Network. + * + * This is all you need to connect to the GT Network. + * IColoredTileEntity is needed for not connecting differently coloured Blocks to each other. + * IHasWorldObjectAndCoords is needed for the InWorld related Stuff. @BaseTileEntity does implement most of that Interface. + */ +public interface IExperimentalEnergyTileEntity extends IColoredTileEntity, IHasWorldObjectAndCoords { + /** + * Inject Energy Call for Electricity. Gets called by EnergyEmitters to inject Energy into your Block + * + * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself. + * + * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do Side checks for this Side) + * @return amount of used Amperes. 0 if not accepted anything. + */ + public long injectEnergy(SubTag aEnergyType, byte aSide, long aPrimary, long aSecondary); + + /** Sided Energy Input */ + public boolean inputEnergyFrom(SubTag aEnergyType, byte aSide); + + /** Sided Energy Output */ + public boolean outputsEnergyTo(SubTag aEnergyType, byte aSide); + + /** Utility for the Network */ + public static class Util { + private static boolean RF_ENERGY = F, IC_ENERGY = F, CHECK_ALL = T; + public static int RF_PER_EU = 4; + + private static void checkAvailabilities() { + if (CHECK_ALL) { + try { + Class tClass = cofh.api.energy.IEnergyReceiver.class; + tClass.getCanonicalName(); + RF_ENERGY = T; + } catch(Throwable e) {/**/} + try { + Class tClass = ic2.api.energy.tile.IEnergySink.class; + tClass.getCanonicalName(); + IC_ENERGY = T; + } catch(Throwable e) {/**/} + CHECK_ALL = F; + } + } + + /** + * Emits Energy to the adjacent Blocks. Also compatible with adjacent IC2 TileEntities when electric and RF TileEntities when RedstoneFlux. + * @return the amount of used secondary value. + */ + public static final long emitEnergyToNetwork(SubTag aEnergyType, long aPrimary, long aSecondary, IExperimentalEnergyTileEntity aEmitter) { + long rUsedSecondary = 0; + checkAvailabilities(); + for (byte i = 0, j = 0; i < 6 && aSecondary > rUsedSecondary; i++) if (aEmitter.outputsEnergyTo(aEnergyType, i)) { + j = GT_Utility.getOppositeSide(i); + TileEntity tTileEntity = aEmitter.getTileEntityAtSide(i); + if (tTileEntity instanceof IExperimentalEnergyTileEntity) { + if (aEmitter.getColorization() >= 0) { + byte tColor = ((IExperimentalEnergyTileEntity)tTileEntity).getColorization(); + if (tColor >= 0 && tColor != aEmitter.getColorization()) continue; + } + rUsedSecondary+=((IExperimentalEnergyTileEntity)tTileEntity).injectEnergy(aEnergyType, j, aPrimary, aSecondary-rUsedSecondary); + } else if (IC_ENERGY && aEnergyType == SubTag.ENERGY_ELECTRICITY && tTileEntity instanceof IEnergySink) { + if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aEmitter, ForgeDirection.getOrientation(j))) { + while (aSecondary > rUsedSecondary && ((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(ForgeDirection.getOrientation(j), aPrimary, aPrimary) < aPrimary) rUsedSecondary++; + } + } else if (RF_ENERGY && aEnergyType == SubTag.ENERGY_REDSTONE_FLUX && tTileEntity instanceof IEnergyReceiver && ((IEnergyReceiver)tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))) { + rUsedSecondary+=((IEnergyReceiver)tTileEntity).receiveEnergy(ForgeDirection.getOrientation(j), (int)aSecondary, F); + } + } + return rUsedSecondary; + } + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java new file mode 100644 index 0000000000..7694b3d1c3 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java @@ -0,0 +1,31 @@ +package gregtech.api.interfaces.tileentity; + +/** + * This File has just internal Information about the Fibre Redstone State of a TileEntity + */ +public interface IFibreConnected extends IColoredTileEntity, IHasWorldObjectAndCoords { + /** + * If this Blocks accepts Fibre from this Side + */ + public void inputFibreFrom(byte aSide); + + /** + * If this Blocks emits Fibre to this Side + */ + public void outputsFibreTo(byte aSide); + + /** + * Sets the Signal this Blocks outputs to this Fibre Color + */ + public void setFibreOutput(byte aSide, byte aColor, byte aRedstoneStrength); + + /** + * Gets the Signal this Blocks outputs to this Fibre Color + */ + public byte getFibreOutput(byte aSide, byte aColor); + + /** + * Gets the Signal this Blocks receives from this Fibre Color + */ + public byte getFibreInput(byte aSide, byte aColor); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java new file mode 100644 index 0000000000..6ae032b874 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java @@ -0,0 +1,16 @@ +package gregtech.api.interfaces.tileentity; + +public interface IGearEnergyTileEntity { + /** + * If Rotation Energy can be accepted on this Side. + * This means that the Gear/Axle will connect to this Side, and can cause the Gear/Axle to stop if the Energy isn't accepted. + */ + public boolean acceptsRotationalEnergy(byte aSide); + + /** + * Inject Energy Call for Rotational Energy. + * Rotation Energy can't be stored, this is just for things like internal Dynamos, which convert it into Energy, or into Progress. + * @param aSpeed Positive = Clockwise, Negative = Counterclockwise + */ + public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy); +} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechDeviceInformation.java b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechDeviceInformation.java new file mode 100644 index 0000000000..f6393f5d10 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechDeviceInformation.java @@ -0,0 +1,20 @@ +package gregtech.api.interfaces.tileentity; + +/** + * You are allowed to include this File in your Download, as i will not change it. + */ +public interface IGregTechDeviceInformation { + /** + * Is this even a TileEntity which allows GregTech Sensor Kits? + * I need things like this Function for MetaTileEntities, you MUST check this!!! + * Do not assume that it's a Information returning Device, when it just implements this Interface. + */ + public boolean isGivingInformation(); + + /** + * Up to 8 Strings can be returned. + * Note: If you insert "\\\\" in the String it tries to translate seperate Parts of the String instead of the String as a whole. + * @return an Array of Information Strings. Don't return null! + */ + public String[] getInfoData(); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java new file mode 100644 index 0000000000..7419214dcb --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java @@ -0,0 +1,124 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.interfaces.IDescribable; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.world.World; +import net.minecraftforge.fluids.IFluidHandler; + +/** + * A simple compound Interface for all my TileEntities. + * + * Also delivers most of the Informations about my TileEntities. + * + * It can cause Problems to include this Interface! + */ +public interface IGregTechTileEntity extends ITexturedTileEntity, IGearEnergyTileEntity, ICoverable, IFluidHandler, ITurnable, IGregTechDeviceInformation, IUpgradableMachine, IDigitalChest, IDescribable, IMachineBlockUpdateable { + /** + * gets the Error displayed on the GUI + */ + public int getErrorDisplayID(); + + /** + * sets the Error displayed on the GUI + */ + public void setErrorDisplayID(int aErrorID); + + /** + * @return the MetaID of the Block or the MetaTileEntity ID. + */ + public int getMetaTileID(); + + /** + * Internal Usage only! + */ + public int setMetaTileID(short aID); + + /** + * @return the MetaTileEntity which is belonging to this, or null if it doesnt has one. + */ + public IMetaTileEntity getMetaTileEntity(); + + /** + * Sets the MetaTileEntity. + * Even though this uses the Universal Interface, certain BaseMetaTileEntities only accept one kind of MetaTileEntity + * so only use this if you are sure its the correct one or you will get a Class cast Error. + * @param aMetaTileEntity + */ + public void setMetaTileEntity(IMetaTileEntity aMetaTileEntity); + + /** + * Causes a general Texture update. + * + * Only used Client Side to mark Blocks dirty. + */ + public void issueTextureUpdate(); + + /** + * Causes the Machine to send its initial Data, like Covers and its ID. + */ + public void issueClientUpdate(); + + /** + * causes Explosion. Strength in Overload-EU + */ + public void doExplosion(long aExplosionEU); + + /** + * Sets the Block on Fire in all 6 Directions + */ + public void setOnFire(); + + /** + * Sets the Block to Fire + */ + public void setToFire(); + + /** + * Sets the Owner of the Machine. Returns the set Name. + */ + public String setOwnerName(String aName); + + /** + * gets the Name of the Machines Owner or "Player" if not set. + */ + public String getOwnerName(); + + /** + * Sets initial Values from NBT + * @param tNBT is the NBTTag of readFromNBT + * @param aID is the MetaTileEntityID + */ + public void setInitialValuesAsNBT(NBTTagCompound aNBT, short aID); + + /** + * Called when leftclicking the TileEntity + */ + public void onLeftclick(EntityPlayer aPlayer); + + /** + * Called when rightclicking the TileEntity + */ + public boolean onRightclick(EntityPlayer aPlayer, byte aSide, float par1, float par2, float par3); + + public float getBlastResistance(byte aSide); + + public ArrayList<ItemStack> getDrops(); + + /** + * 255 = 100% + */ + public int getLightOpacity(); + + public void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB inputAABB, List<AxisAlignedBB> outputAABB, Entity collider); + public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ); + public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity collider); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IHasInventory.java b/src/main/java/gregtech/api/interfaces/tileentity/IHasInventory.java new file mode 100644 index 0000000000..3b3d4ee75d --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IHasInventory.java @@ -0,0 +1,33 @@ +package gregtech.api.interfaces.tileentity; + +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; + +public interface IHasInventory extends ISidedInventory, IHasWorldObjectAndCoords { + + /** + * if the Inventory of this TileEntity got modified this tick + */ + public boolean hasInventoryBeenModified(); + + /** + * if this is just a Holoslot + */ + public boolean isValidSlot(int aIndex); + + /** + * Tries to add a Stack to the Slot. + * It doesn't matter if the Slot is valid or invalid as described at the Function above. + * + * @return true if aStack == null, then false if aIndex is out of bounds, then false if aStack cannot be added, and then true if aStack has been added + */ + public boolean addStackToSlot(int aIndex, ItemStack aStack); + + /** + * Tries to add X Items of a Stack to the Slot. + * It doesn't matter if the Slot is valid or invalid as described at the Function above. + * + * @return true if aStack == null, then false if aIndex is out of bounds, then false if aStack cannot be added, and then true if aStack has been added + */ + public boolean addStackToSlot(int aIndex, ItemStack aStack, int aAmount); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java new file mode 100644 index 0000000000..c6ebb56e40 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java @@ -0,0 +1,132 @@ +package gregtech.api.interfaces.tileentity; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; +import net.minecraftforge.fluids.IFluidHandler; + +/** + * This is a bunch of Functions my TileEntities provide, to make life much easier, and to get rid of internal TileEntity stuff. + * + * This also makes access to adjacent TileEntities more Efficient. + * + * Note: It doesn't have to be a TileEntity in certain cases! And only certain cases, such as the Recipe checking of the findRecipe Function. + */ +public interface IHasWorldObjectAndCoords { + public World getWorld(); + public int getXCoord(); + public short getYCoord(); + public int getZCoord(); + + public boolean isServerSide(); + public boolean isClientSide(); + + public int getRandomNumber(int aRange); + + public TileEntity getTileEntity(int aX, int aY, int aZ); + public TileEntity getTileEntityOffset(int aX, int aY, int aZ); + public TileEntity getTileEntityAtSide(byte aSide); + public TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance); + + public IInventory getIInventory(int aX, int aY, int aZ); + public IInventory getIInventoryOffset(int aX, int aY, int aZ); + public IInventory getIInventoryAtSide(byte aSide); + public IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance); + + public IFluidHandler getITankContainer(int aX, int aY, int aZ); + public IFluidHandler getITankContainerOffset(int aX, int aY, int aZ); + public IFluidHandler getITankContainerAtSide(byte aSide); + public IFluidHandler getITankContainerAtSideAndDistance(byte aSide, int aDistance); + + public IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ); + public IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ); + public IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide); + public IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte aSide, int aDistance); + + public Block getBlock(int aX, int aY, int aZ); + public Block getBlockOffset(int aX, int aY, int aZ); + public Block getBlockAtSide(byte aSide); + public Block getBlockAtSideAndDistance(byte aSide, int aDistance); + + public byte getMetaID(int aX, int aY, int aZ); + public byte getMetaIDOffset(int aX, int aY, int aZ); + public byte getMetaIDAtSide(byte aSide); + public byte getMetaIDAtSideAndDistance(byte aSide, int aDistance); + + public byte getLightLevel(int aX, int aY, int aZ); + public byte getLightLevelOffset(int aX, int aY, int aZ); + public byte getLightLevelAtSide(byte aSide); + public byte getLightLevelAtSideAndDistance(byte aSide, int aDistance); + + public boolean getOpacity(int aX, int aY, int aZ); + public boolean getOpacityOffset(int aX, int aY, int aZ); + public boolean getOpacityAtSide(byte aSide); + public boolean getOpacityAtSideAndDistance(byte aSide, int aDistance); + + public boolean getSky(int aX, int aY, int aZ); + public boolean getSkyOffset(int aX, int aY, int aZ); + public boolean getSkyAtSide(byte aSide); + public boolean getSkyAtSideAndDistance(byte aSide, int aDistance); + + public boolean getAir(int aX, int aY, int aZ); + public boolean getAirOffset(int aX, int aY, int aZ); + public boolean getAirAtSide(byte aSide); + public boolean getAirAtSideAndDistance(byte aSide, int aDistance); + + public BiomeGenBase getBiome(); + public BiomeGenBase getBiome(int aX, int aZ); + + public int getOffsetX(byte aSide, int aMultiplier); + public short getOffsetY(byte aSide, int aMultiplier); + public int getOffsetZ(byte aSide, int aMultiplier); + + /** + * Checks if the TileEntity is Invalid or Unloaded. Stupid Minecraft cannot do that btw. + */ + public boolean isDead(); + + /** + * Sends a Block Event to the Client TileEntity, the byte Parameters are only for validation as Minecraft doesn't properly write Packet Data. + */ + public void sendBlockEvent(byte aID, byte aValue); + + /** + * @return the Time this TileEntity has been loaded. + */ + public long getTimer(); + + /** + * Sets the Light Level of this Block on a Scale of 0 - 15 + * It could be that it doesn't work. This is just for convenience. + */ + public void setLightValue(byte aLightValue); + + /** + * Function of the regular TileEntity + */ + public void writeToNBT(NBTTagCompound aNBT); + + /** + * Function of the regular TileEntity + */ + public void readFromNBT(NBTTagCompound aNBT); + + /** + * Function of the regular TileEntity + */ + public boolean isInvalidTileEntity(); + + /** + * Opens the GUI with this ID of this MetaTileEntity + */ + public boolean openGUI(EntityPlayer aPlayer, int aID); + + /** + * Opens the GUI with the ID = 0 of this TileEntity + */ + public boolean openGUI(EntityPlayer aPlayer); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IMachineBlockUpdateable.java b/src/main/java/gregtech/api/interfaces/tileentity/IMachineBlockUpdateable.java new file mode 100644 index 0000000000..ba8650f245 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IMachineBlockUpdateable.java @@ -0,0 +1,16 @@ +package gregtech.api.interfaces.tileentity; + +/** + * You are allowed to include this File in your Download, as i will not change it. + * Simple Interface for Machines, which need my Machine Blocks for MultiBlockStructures. + * + * Every Machine implementing this Interface will conduct Machine updates. + */ +public interface IMachineBlockUpdateable { + /** + * The Machine Update, which is called when the Machine needs an Update of its Parts. + * I suggest to wait 1-5 seconds before actually checking the Machine Parts. + * RP-Frames could for example cause Problems when you instacheck the Machine Parts. + */ + public void onMachineBlockUpdate(); +} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IMachineProgress.java b/src/main/java/gregtech/api/interfaces/tileentity/IMachineProgress.java new file mode 100644 index 0000000000..78f238aa3e --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IMachineProgress.java @@ -0,0 +1,69 @@ +package gregtech.api.interfaces.tileentity; + +/** + * For Machines which have Progress + */ +public interface IMachineProgress extends IHasWorldObjectAndCoords { + /** + * returns the Progress this Machine has made. Warning, this can also be negative! + */ + public int getProgress(); + + /** + * returns the Progress the Machine needs to complete its task. + */ + public int getMaxProgress(); + + /** + * increases the Progress of the Machine + */ + public boolean increaseProgress(int aProgressAmountInTicks); + + /** + * returns if the Machine currently does something. + */ + public boolean hasThingsToDo(); + + /** + * returns if the Machine just got enableWorking called after being disabled. + * Used for Translocators, which need to check if they need to transfer immediately. + */ + public boolean hasWorkJustBeenEnabled(); + + /** + * allows Machine to work + */ + public void enableWorking(); + + /** + * disallows Machine to work + */ + public void disableWorking(); + + /** + * if the Machine is allowed to Work + */ + public boolean isAllowedToWork(); + + /** + * used to control Machines via Redstone Signal Strength by special Covers + * only Values between 0 and 15! + */ + public void setWorkDataValue(byte aValue); + + /** + * used to control Machines via Redstone Signal Strength by special Covers + * In case of 0 the Machine is very likely doing nothing, or is just not being controlled at all. + */ + public byte getWorkDataValue(); + + /** + * gives you the Active Status of the Machine + */ + public boolean isActive(); + + /** + * sets the visible Active Status of the Machine + */ + public void setActive(boolean aActive); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java new file mode 100644 index 0000000000..0ddc76a6d6 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java @@ -0,0 +1,9 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.interfaces.ITexture; + +public interface IPipeRenderedTileEntity extends ICoverable, ITexturedTileEntity { + public float getThickNess(); + public byte getConnections(); + public ITexture[] getTextureUncovered(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java new file mode 100644 index 0000000000..720f7e9bc5 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java @@ -0,0 +1,37 @@ +package gregtech.api.interfaces.tileentity; + +/** + * This File has just internal Information about the Redstone State of a TileEntity + */ +public interface IRedstoneEmitter extends IHasWorldObjectAndCoords { + /** + * gets the Redstone Level the TileEntity should emit to the given Output Side + */ + byte getOutputRedstoneSignal(byte aSide); + + /** + * sets the Redstone Level the TileEntity should emit to the given Output Side + * + * Do not use this if ICoverable is implemented. ICoverable has @getInternalOutputRedstoneSignal for Machine internal Output Redstone, so that it doesnt conflict with Cover Redstone. + * This sets the true Redstone Output Signal. Only Cover Behaviors should use it, not MetaTileEntities. + */ + void setOutputRedstoneSignal(byte aSide, byte aStrength); + + /** + * gets the Redstone Level the TileEntity should emit to the given Output Side + */ + byte getStrongOutputRedstoneSignal(byte aSide); + + /** + * sets the Redstone Level the TileEntity should emit to the given Output Side + * + * Do not use this if ICoverable is implemented. ICoverable has @getInternalOutputRedstoneSignal for Machine internal Output Redstone, so that it doesnt conflict with Cover Redstone. + * This sets the true Redstone Output Signal. Only Cover Behaviors should use it, not MetaTileEntities. + */ + void setStrongOutputRedstoneSignal(byte aSide, byte aStrength); + + /** + * Gets the Output for the comparator on the given Side + */ + byte getComparatorValue(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java new file mode 100644 index 0000000000..f4c63c803e --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java @@ -0,0 +1,29 @@ +package gregtech.api.interfaces.tileentity; + +/** + * This File has just internal Information about the Redstone State of a TileEntity + */ +public interface IRedstoneReceiver extends IHasWorldObjectAndCoords { + /** + * gets the Redstone Level of the TileEntity to the given Input Side + * + * Do not use this if ICoverable is implemented. ICoverable has @getInternalInputRedstoneSignal for Machine internal Input Redstone + * This returns the true incoming Redstone Signal. Only Cover Behaviors should check it, not MetaTileEntities. + */ + public byte getInputRedstoneSignal(byte aSide); + + /** + * gets the strongest Redstone Level the TileEntity receives + */ + public byte getStrongestRedstone(); + + /** + * gets if the TileEntity receives Redstone + */ + public boolean getRedstone(); + + /** + * gets if the TileEntity receives Redstone at this Side + */ + public boolean getRedstone(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneTileEntity.java new file mode 100644 index 0000000000..a1d2b533cb --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneTileEntity.java @@ -0,0 +1,17 @@ +package gregtech.api.interfaces.tileentity; + +/** + * This File has just internal Information about the Redstone State of a TileEntity + */ +public interface IRedstoneTileEntity extends IRedstoneEmitter, IRedstoneReceiver { + /** + * enables/disables Redstone Output in general. + */ + void setGenericRedstoneOutput(boolean aOnOff); + + /** + * Causes a general Block update. + * Sends nothing to Client, just causes a Block Update. + */ + public void issueBlockUpdate(); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java new file mode 100644 index 0000000000..3c0782ba2e --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java @@ -0,0 +1,10 @@ +package gregtech.api.interfaces.tileentity; + +import gregtech.api.interfaces.ITexture; + +public interface ITexturedTileEntity { + /** + * @return the Textures rendered by the GT Rendering + */ + public ITexture[] getTexture(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java new file mode 100644 index 0000000000..1605bd677e --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java @@ -0,0 +1,33 @@ +package gregtech.api.interfaces.tileentity; + + +/** + * Implemented by all my Machines. However without any security checks, if the Players are even allowed to rotate it. + */ +public interface ITurnable { + /** + * Get the block's facing. + * + * @return front Block facing + */ + byte getFrontFacing(); + + /** + * Get the block's back facing. + * + * @return opposite Block facing + */ + byte getBackFacing(); + + /** + * Determine if the wrench can be used to set the block's facing. + */ + boolean isValidFacing(byte aSide); + + /** + * Set the block's facing + * + * @param facing facing to set the block to + */ + void setFrontFacing(byte aSide); +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IUpgradableMachine.java b/src/main/java/gregtech/api/interfaces/tileentity/IUpgradableMachine.java new file mode 100644 index 0000000000..97360fd514 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/tileentity/IUpgradableMachine.java @@ -0,0 +1,42 @@ +package gregtech.api.interfaces.tileentity; + + +/** + * To access my Machines a bit easier + */ +public interface IUpgradableMachine extends IMachineProgress { + /** + * Accepts Upgrades. Some Machines have an Upgrade Limit. + */ + boolean isUpgradable(); + + /** + * Accepts Muffler Upgrades + */ + boolean isMufflerUpgradable(); + + /** + * Accepts Steam-Converter Upgrades + */ + boolean isSteamEngineUpgradable(); + + /** + * Adds Muffler Upgrade + */ + boolean addMufflerUpgrade(); + + /** + * Adds MJ-Converter Upgrade + */ + boolean addSteamEngineUpgrade(); + + /** + * Does this Machine have an Muffler + */ + boolean hasMufflerUpgrade(); + + /** + * Does this Machine have a Steam-Converter + */ + boolean hasSteamEngineUpgrade(); +} |