From 8c4dd7de80e06875b942b1343f2ca4895ce2d758 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Sun, 17 Jul 2022 12:57:04 -0700 Subject: MultiTileEntity --- src/main/java/gregtech/api/enums/GT_Values.java | 8 + src/main/java/gregtech/api/fluid/FluidTankGT.java | 444 +++++++++ .../api/multitileentity/MultiTileEntityBlock.java | 603 +++++++++++ .../MultiTileEntityBlockInternal.java | 134 +++ .../MultiTileEntityClassContainer.java | 35 + .../multitileentity/MultiTileEntityContainer.java | 27 + .../MultiTileEntityItemInternal.java | 303 ++++++ .../multitileentity/MultiTileEntityRegistry.java | 230 +++++ .../multitileentity/base/BaseMultiTileEntity.java | 1047 ++++++++++++++++++++ .../base/BaseNontickableMultiTileEntity.java | 55 + .../base/BaseTickableMultiTileEntity.java | 113 +++ .../multitileentity/interfaces/IItemUpdatable.java | 15 + .../interfaces/IMultiTileEntity.java | 227 +++++ .../machine/MultiTileBasicMachine.java | 283 ++++++ .../gregtech/api/net/GT_Packet_TileEntity.java | 60 +- src/main/java/gregtech/api/util/GT_Util.java | 152 +++ 16 files changed, 3709 insertions(+), 27 deletions(-) create mode 100644 src/main/java/gregtech/api/fluid/FluidTankGT.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityRegistry.java create mode 100644 src/main/java/gregtech/api/multitileentity/base/BaseMultiTileEntity.java create mode 100644 src/main/java/gregtech/api/multitileentity/base/BaseNontickableMultiTileEntity.java create mode 100644 src/main/java/gregtech/api/multitileentity/base/BaseTickableMultiTileEntity.java create mode 100644 src/main/java/gregtech/api/multitileentity/interfaces/IItemUpdatable.java create mode 100644 src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java create mode 100644 src/main/java/gregtech/api/multitileentity/machine/MultiTileBasicMachine.java create mode 100644 src/main/java/gregtech/api/util/GT_Util.java (limited to 'src/main/java/gregtech/api') diff --git a/src/main/java/gregtech/api/enums/GT_Values.java b/src/main/java/gregtech/api/enums/GT_Values.java index ed22331360..5765fc42c2 100644 --- a/src/main/java/gregtech/api/enums/GT_Values.java +++ b/src/main/java/gregtech/api/enums/GT_Values.java @@ -1,5 +1,6 @@ package gregtech.api.enums; +import gregtech.api.fluid.FluidTankGT; import gregtech.api.interfaces.internal.IGT_Mod; import gregtech.api.interfaces.internal.IGT_RecipeAdder; import gregtech.api.net.IGT_NetworkHandler; @@ -7,6 +8,8 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; import net.minecraft.world.World; import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; import net.minecraftforge.oredict.OreDictionary; import java.util.HashSet; @@ -445,4 +448,9 @@ public class GT_Values { public static boolean worldTickHappened = false; public static final int[] emptyIntArray = new int[0]; + public static final IFluidTank[] emptyFluidTank = new IFluidTank[0]; + public static final FluidTankGT[] emptyFluidTankGT = new FluidTankGT[0]; + public static final FluidTankInfo[] emptyFluidTankInfo = new FluidTankInfo[0]; + public static final FluidStack[] emptyFluidStack = new FluidStack[0]; + public static final ItemStack[] emptyItemStackArray = new ItemStack[0]; } diff --git a/src/main/java/gregtech/api/fluid/FluidTankGT.java b/src/main/java/gregtech/api/fluid/FluidTankGT.java new file mode 100644 index 0000000000..5df9e2638a --- /dev/null +++ b/src/main/java/gregtech/api/fluid/FluidTankGT.java @@ -0,0 +1,444 @@ +package gregtech.api.fluid; + +import gregtech.api.util.GT_Utility; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidTank; + +import java.util.Map; + +import static com.google.common.primitives.Ints.saturatedCast; + +public class FluidTankGT implements IFluidTank { + public final FluidTankGT[] AS_ARRAY = new FluidTankGT[] {this}; + private FluidStack mFluid; + private long mCapacity = 0, mAmount = 0; + private boolean mPreventDraining = false, mVoidExcess = false, mChangedFluids = false; + /** HashMap of adjustable Tank Sizes based on Fluids if needed. */ + private Map mAdjustableCapacity = null; + private long mAdjustableMultiplier = 1; + /** Gives you a Tank Index in case there is multiple Tanks on a TileEntity that cares. */ + public int mIndex = 0; + + public FluidTankGT() { + mCapacity = Long.MAX_VALUE; + } + + public FluidTankGT(long aCapacity) { + mCapacity = aCapacity; + } + + public FluidTankGT(FluidStack aFluid) { + mFluid = aFluid; + if (aFluid != null) { + mCapacity = aFluid.amount; + mAmount = aFluid.amount; + } + } + + public FluidTankGT(FluidStack aFluid, long aCapacity) { + mFluid = aFluid; + mCapacity = aCapacity; + mAmount = (aFluid == null ? 0 : aFluid.amount); + } + + public FluidTankGT(FluidStack aFluid, long aAmount, long aCapacity) { + mFluid = aFluid; + mCapacity = aCapacity; + mAmount = (aFluid == null ? 0 : aAmount); + } + + public FluidTankGT(Fluid aFluid, long aAmount) { + this(new FluidStack(aFluid, saturatedCast(aAmount))); + mAmount = aAmount; + } + + public FluidTankGT(Fluid aFluid, long aAmount, long aCapacity) { + this(new FluidStack(aFluid, saturatedCast(aAmount)), aCapacity); + mAmount = aAmount; + } + + public FluidTankGT(NBTTagCompound aNBT, String aKey, long aCapacity) { + this(aNBT.hasKey(aKey) ? aNBT.getCompoundTag(aKey) : null, aCapacity); + } + + public FluidTankGT(NBTTagCompound aNBT, long aCapacity) { + mCapacity = aCapacity; + if (aNBT != null && !aNBT.hasNoTags()) { + mFluid = FluidStack.loadFluidStackFromNBT(aNBT); + mAmount = (isEmpty() ? 0 : aNBT.hasKey("LAmount") ? aNBT.getLong("LAmount") : mFluid.amount); + } + } + + public FluidTankGT readFromNBT(NBTTagCompound aNBT, String aKey) { + if (aNBT.hasKey(aKey)) { + aNBT = aNBT.getCompoundTag(aKey); + if (aNBT != null && !aNBT.hasNoTags()) { + mFluid = FluidStack.loadFluidStackFromNBT(aNBT); + mAmount = (isEmpty() ? 0 : aNBT.hasKey("LAmount") ? aNBT.getLong("LAmount") : mFluid.amount); + } + } + return this; + } + + public NBTTagCompound writeToNBT(NBTTagCompound aNBT, String aKey) { + if (mFluid != null && (mPreventDraining || mAmount > 0)) { + final NBTTagCompound tNBT = new NBTTagCompound(); + mFluid.amount = (int) mAmount; + aNBT.setTag(aKey, mFluid.writeToNBT(tNBT)); + if (mAmount > Integer.MAX_VALUE) tNBT.setLong("LAmount", mAmount); + } else { + aNBT.removeTag(aKey); + } + return aNBT; + } + + public FluidStack drain(int aDrained) { + return drain(aDrained, true); + } + + @Override + public FluidStack drain(int aDrained, boolean aDoDrain) { + if (isEmpty() || aDrained <= 0) return null; + if (mAmount < aDrained) aDrained = (int)mAmount; + final FluidStack rFluid = new FluidStack(mFluid, aDrained); + if (aDoDrain) { + mAmount -= aDrained; + if (mAmount <= 0) { + if (mPreventDraining) { + mAmount = 0; + } else { + setEmpty(); + } + } + } + return rFluid; + } + + public boolean drainAll(long aDrained) { + if (isEmpty() || mAmount < aDrained) return false; + mAmount -= aDrained; + if (mAmount <= 0) { + if (mPreventDraining) { + mAmount = 0; + } else { + setEmpty(); + } + } + return true; + } + + public long remove(long aDrained) { + if (isEmpty() || mAmount <= 0 || aDrained <= 0) return 0; + if (mAmount < aDrained) aDrained = mAmount; + mAmount -= aDrained; + if (mAmount <= 0) { + if (mPreventDraining) { + mAmount = 0; + } else { + setEmpty(); + } + } + return aDrained; + } + + public long add(long aFilled) { + if (isEmpty() || aFilled <= 0) return 0; + final long tCapacity = capacity(); + if (mAmount + aFilled > tCapacity) { + if (!mVoidExcess) aFilled = tCapacity - mAmount; + mAmount = tCapacity; + return aFilled; + } + mAmount += aFilled; + return aFilled; + } + + public long add(long aFilled, FluidStack aFluid) { + if (aFluid == null || aFilled <= 0) return 0; + if (isEmpty()) { + mFluid = aFluid.copy(); + mChangedFluids = true; + mAmount = Math.min(capacity(aFluid), aFilled); + return mVoidExcess ? aFilled : mAmount; + } + return contains(aFluid) ? add(aFilled) : 0; + } + + public int fill(FluidStack aFluid) { + return fill(aFluid, true); + } + + @Override + public int fill(FluidStack aFluid, boolean aDoFill) { + if (aFluid == null) return 0; + if (aDoFill) { + if (isEmpty()) { + mFluid = aFluid.copy(); + mChangedFluids = true; + mAmount = Math.min(capacity(aFluid), aFluid.amount); + return mVoidExcess ? aFluid.amount : (int) mAmount; + } + if (!contains(aFluid)) return 0; + final long tCapacity = capacity(aFluid); + long tFilled = tCapacity - mAmount; + if (aFluid.amount < tFilled) { + mAmount += aFluid.amount; + tFilled = aFluid.amount; + } else mAmount = tCapacity; + return mVoidExcess ? aFluid.amount : (int) tFilled; + } + return saturatedCast(isEmpty() ? mVoidExcess ? aFluid.amount : Math.min(capacity(aFluid), aFluid.amount) : contains(aFluid) ? mVoidExcess ? aFluid.amount : Math.min(capacity(aFluid) - mAmount, aFluid.amount) : 0); + } + + public boolean canFillAll(FluidStack aFluid) { + return aFluid == null || aFluid.amount <= 0 || (isEmpty() ? mVoidExcess || aFluid.amount <= capacity(aFluid) : contains(aFluid) && (mVoidExcess || mAmount + aFluid.amount <= capacity(aFluid))); + } + + public boolean canFillAll(long aAmount) { + return aAmount <= 0 || mVoidExcess || mAmount + aAmount <= capacity(); + } + + public boolean fillAll(FluidStack aFluid) { + if (aFluid == null || aFluid.amount <= 0) return true; + if (isEmpty()) { + final long tCapacity = capacity(aFluid); + if (aFluid.amount <= tCapacity || mVoidExcess) { + mFluid = aFluid.copy(); + mChangedFluids = true; + mAmount = aFluid.amount; + if (mAmount > tCapacity) mAmount = tCapacity; + return true; + } + return false; + } + if (contains(aFluid)) { + if (mAmount + aFluid.amount <= capacity()) { + mAmount += aFluid.amount; + return true; + } + if (mVoidExcess) { + mAmount = capacity(); + return true; + } + } + return false; + } + + public boolean fillAll(FluidStack aFluid, long aMultiplier) { + if (aMultiplier <= 0) return true; + if (aMultiplier == 1) return fillAll(aFluid); + if (aFluid == null || aFluid.amount <= 0) return true; + if (isEmpty()) { + final long tCapacity = capacity(aFluid); + if (aFluid.amount * aMultiplier <= tCapacity || mVoidExcess) { + mFluid = aFluid.copy(); + mChangedFluids = true; + mAmount = aFluid.amount * aMultiplier; + if (mAmount > tCapacity) mAmount = tCapacity; + return true; + } + return false; + } + if (contains(aFluid)) { + if (mAmount + aFluid.amount * aMultiplier <= capacity()) { + mAmount += aFluid.amount * aMultiplier; + return true; + } + if (mVoidExcess) { + mAmount = capacity(); + return true; + } + } + return false; + } + /** Resets Tank Contents entirely */ + public FluidTankGT setEmpty() { + mFluid = null; + mChangedFluids = true; + mAmount = 0; + return this; + } + + /** Sets Fluid Content, taking Amount from the Fluid Parameter */ + public FluidTankGT setFluid(FluidStack aFluid) { + mFluid = aFluid; + mChangedFluids = true; + mAmount = (aFluid == null ? 0 : aFluid.amount); + return this; + } + + /** Sets Fluid Content and Amount */ + public FluidTankGT setFluid(FluidStack aFluid, long aAmount) { + mFluid = aFluid; + mChangedFluids = true; + mAmount = (aFluid == null ? 0 : aAmount); + return this; + } + + /** Sets Fluid Content, taking Amount from the Tank Parameter */ + public FluidTankGT setFluid(FluidTankGT aTank) { + mFluid = new FluidStack(aTank.mFluid, saturatedCast(aTank.mAmount)); + mChangedFluids = true; + mAmount = aTank.mAmount; + return this; + } + + /** Sets the Tank Index for easier Reverse Mapping. */ + public FluidTankGT setIndex(int aIndex) { + mIndex = aIndex; + return this; + } + + /** Sets the Capacity */ + public FluidTankGT setCapacity(long aCapacity) { + if (aCapacity >= 0) mCapacity = aCapacity; + return this; + } + /** Sets the Capacity Multiplier */ + public FluidTankGT setCapacityMultiplier(long aCapacityMultiplier) { + if (aCapacityMultiplier >= 0) mAdjustableMultiplier = aCapacityMultiplier; + return this; + } + + /** Sets Tank capacity Map, should it be needed. */ + public FluidTankGT setCapacity(Map aMap, long aCapacityMultiplier) { + mAdjustableCapacity = aMap; + mAdjustableMultiplier = aCapacityMultiplier; + return this; + } + + /** Always keeps at least 0 Liters of Fluid instead of setting it to null */ + public FluidTankGT setPreventDraining() { + return setPreventDraining(true); + } + + /** Always keeps at least 0 Liters of Fluid instead of setting it to null */ + public FluidTankGT setPreventDraining(boolean aPrevent) { + mPreventDraining = aPrevent; + return this; + } + + /** Voids any Overlow */ + public FluidTankGT setVoidExcess() { + return setVoidExcess(true); + } + + /** Voids any Overlow */ + public FluidTankGT setVoidExcess(boolean aVoidExcess) { + mVoidExcess = aVoidExcess; + return this; + } + + public boolean isFull() { + return mFluid != null && mAmount >= capacity(); + } + + public long capacity() { + return capacity(mFluid); + } + + public long capacity(FluidStack aFluid) { + if(mAdjustableCapacity == null || aFluid == null) + return mCapacity; + return capacity(aFluid.getFluid()); + } + + public long capacity(Fluid aFluid) { + if(mAdjustableCapacity == null || aFluid == null) + return mCapacity; + return capacity(aFluid.getName()); + } + + public long capacity(String aFluid) { + if( mAdjustableCapacity == null || aFluid == null) + return mCapacity; + + final Long tSize = mAdjustableCapacity.get(aFluid); + return tSize == null ? Math.max(mAmount, mCapacity) : Math.max(tSize * mAdjustableMultiplier, Math.max(mAmount, mCapacity)); + } + + public boolean isHalf() { + return mFluid != null && mAmount * 2 >= capacity(); + } + + public boolean contains(Fluid aFluid) { + return mFluid != null && mFluid.getFluid() == aFluid; + } + + public boolean contains(FluidStack aFluid) { + return GT_Utility.areFluidsEqual(mFluid, aFluid); + } + + public boolean has(long aAmount) { + return mAmount >= aAmount; + } + + public boolean has() { + return mAmount > 0; + } + + public boolean check() { + if (mChangedFluids) { + mChangedFluids = false; + return true; + } + return false; + } + + public boolean update() { + return mChangedFluids = true; + } + + public boolean changed() { + return mChangedFluids; + } + + public long amount() { + return isEmpty() ? 0 : mAmount; + } + + public boolean isEmpty() { + return mFluid == null; + } + + public long amount(long aMax) { + return isEmpty() || aMax <= 0 ? 0 : Math.min(mAmount, aMax); + } + + public String name() { + return mFluid == null ? null : mFluid.getFluid().getName(); + } + + public FluidStack get() { + return mFluid; + } + + public FluidStack get(long aMax) { + return isEmpty() || aMax <= 0 ? null : new FluidStack(mFluid, saturatedCast(Math.min(mAmount, aMax))); + } + + @Override + public FluidStack getFluid() { + if (mFluid != null) mFluid.amount = saturatedCast(mAmount); + return mFluid; + } + + @Override + public int getFluidAmount() { + return saturatedCast(mAmount); + } + + @Override + public int getCapacity() { + return saturatedCast(capacity()); + } + + @Override + public FluidTankInfo getInfo() { + return new FluidTankInfo(isEmpty() ? null : mFluid.copy(), saturatedCast(capacity())); + } + +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java new file mode 100644 index 0000000000..13d2385381 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java @@ -0,0 +1,603 @@ +package gregtech.api.multitileentity; + +import com.cricketcraft.chisel.api.IFacade; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IDebugableBlock; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IDebugableTileEntity; +import gregtech.api.metatileentity.BaseTileEntity; +import gregtech.api.metatileentity.CoverableTileEntity; +import gregtech.api.metatileentity.GregTechTileClientEvents; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_BreakBlock; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetBlockHardness; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetComparatorInputOverride; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetWeakChanges; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IsProvidingStrongPower; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IsProvidingWeakPower; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnNeighborBlockChange; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_ShouldCheckWeakPower; +import gregtech.api.objects.XSTR; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_Util; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.GT_Renderer_Block; +import gregtech.common.render.IRenderedBlock; +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.stats.StatList; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.IIcon; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.StatCollector; +import net.minecraft.world.Explosion; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.event.ForgeEventFactory; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static gregtech.api.enums.GT_Values.OFFX; +import static gregtech.api.enums.GT_Values.OFFY; +import static gregtech.api.enums.GT_Values.OFFZ; +import static gregtech.api.util.GT_Util.LAST_BROKEN_TILEENTITY; +import static gregtech.api.util.GT_Util.getTileEntity; +import static gregtech.api.util.GT_Util.setTileEntity; + +/* + * MultiTileEntityBlock ported from GT6 + */ +public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITileEntityProvider, IRenderedBlock, IFacade { + protected static final Map MULTI_BLOCK_MAP = new HashMap<>(); + private static boolean LOCK = false; + + protected final String mNameInternal, mTool; + protected final int mHarvestLevelOffset, mHarvestLevelMinimum, mHarvestLevelMaximum; + protected final boolean mOpaque, mNormalCube; + + public static String getName(String aMaterialName, SoundType aSoundType, String aTool, int aHarvestLevelOffset, int aHarvestLevelMinimum, int aHarvestLevelMaximum, boolean aOpaque, boolean aNormalCube) { + return "gt.block.multiblock." + aMaterialName + "." + aSoundType.soundName + "." + aTool + "." + aHarvestLevelOffset + "." + aHarvestLevelMinimum + "." + aHarvestLevelMaximum + "." + aOpaque + "." + aNormalCube; + + } + /** + * @param aMaterialName the Name of the vanilla Material Field. In case this is not a vanilla Material, insert the Name you want to give your own Material instead. + * @param aMaterial the Material used to determine the Block. + * @param aSoundType the Sound Type of the Block. + * @param aTool the Tool used to harvest this Block. + * @param aHarvestLevelOffset obvious + * @param aHarvestLevelMinimum obvious + * @param aHarvestLevelMaximum obvious + * @param aOpaque if this Block is Opaque. + * @param aNormalCube if this Block is a normal Cube (for Redstone Stuff). + */ + public static MultiTileEntityBlock getOrCreate( + String aModID, String aMaterialName, Material aMaterial, SoundType aSoundType, String aTool, int aHarvestLevelOffset, int aHarvestLevelMinimum, + int aHarvestLevelMaximum, boolean aOpaque, boolean aNormalCube + ) { + final MultiTileEntityBlock rBlock = MULTI_BLOCK_MAP.get(aModID + ":" + getName(aMaterialName, aSoundType, aTool = aTool.toLowerCase(), aHarvestLevelOffset, aHarvestLevelMinimum, aHarvestLevelMaximum, aOpaque, aNormalCube)); + return rBlock == null ? new MultiTileEntityBlock(aModID, aMaterialName, aMaterial, aSoundType, aTool, aHarvestLevelOffset, aHarvestLevelMinimum, aHarvestLevelMaximum, aOpaque, aNormalCube) : rBlock; + } + protected MultiTileEntityBlock(String aModID, String aMaterialName, Material aMaterial, SoundType aSoundType, String aTool, int aHarvestLevelOffset, int aHarvestLevelMinimum, int aHarvestLevelMaximum, boolean aOpaque, boolean aNormalCube) { + super(aMaterial); + if(GregTech_API.sPreloadFinished) throw new IllegalStateException("Blocks can only be initialized within preInit!"); + + mNameInternal = getName(aMaterialName, aSoundType, aTool, aHarvestLevelOffset, aHarvestLevelMinimum, aHarvestLevelMaximum, aOpaque, aNormalCube); + GameRegistry.registerBlock(this, ItemBlock.class, mNameInternal); + + MULTI_BLOCK_MAP.put(aModID + ":" + mNameInternal, this); + + setStepSound(aSoundType); + mOpaque = aOpaque; + mNormalCube = aNormalCube; + + mTool = aTool.toLowerCase(); + mHarvestLevelOffset = aHarvestLevelOffset; + mHarvestLevelMinimum = Math.max(0, aHarvestLevelMinimum); + mHarvestLevelMaximum = Math.max(aHarvestLevelMinimum, aHarvestLevelMaximum); + + opaque = isOpaqueCube(); + lightOpacity = isOpaqueCube() ? 255 : 0; + + } + + @Override + public final void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true); + if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity); + if (aTileEntity == null || !aTileEntity.shouldRefresh(this, aBlock, aMetaData, aMetaData, aWorld, aX, aY, aZ)) return; + if (aTileEntity instanceof IMTE_BreakBlock && ((IMTE_BreakBlock)aTileEntity).breakBlock()) return; + if (aTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData && ((IMTE_HasMultiBlockMachineRelevantData)aTileEntity).hasMultiBlockMachineRelevantData()) + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + + aWorld.removeTileEntity(aX, aY, aZ); + } + + @Override + public ArrayList getDebugInfo(EntityPlayer aPlayer, int aX, int aY, int aZ, int aLogLevel) { + final TileEntity aTileEntity = aPlayer.worldObj.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IDebugableTileEntity) { + return ((IDebugableTileEntity) aTileEntity).getDebugInfo(aPlayer, aLogLevel); + } + return (ArrayList) Collections.emptyList(); + } + + @Override + public final boolean func_149730_j/*isFullBlock*/() { + return mOpaque; + } + + @Override + public final boolean isNormalCube() { + return mNormalCube; + } + + @Override + public final boolean renderAsNormalBlock() { + return mOpaque || mNormalCube; + } + + @Override + public int getRenderType() { + return GT_Renderer_Block.INSTANCE == null ? super.getRenderType() : GT_Renderer_Block.INSTANCE.mRenderID; + } + + @Override + public final float getBlockHardness(World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_GetBlockHardness ? ((IMTE_GetBlockHardness) aTileEntity).getBlockHardness() : 1.0F; + } + + @SideOnly(Side.CLIENT) + @Override + public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int aSide) { + return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); + } + + @SideOnly(Side.CLIENT) + @Override + public IIcon getIcon(int aSide, int aMeta) { + return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); + } + + @Override + @SuppressWarnings("unchecked") + public final void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB aAABB, List aList, Entity aEntity) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) aTileEntity).addCollisionBoxesToList(aAABB, aList, aEntity); + else super.addCollisionBoxesToList(aWorld, aX, aY, aZ, aAABB, aList, aEntity); + } + + @Override + public final AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).getCollisionBoundingBoxFromPool() + : aTileEntity == null ? null : super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ); + } + + @Override + public final AxisAlignedBB getSelectedBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).getSelectedBoundingBoxFromPool() + : super.getSelectedBoundingBoxFromPool(aWorld, aX, aY, aZ); + } + + @Override + public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int aX, int aY, int aZ) { + final TileEntity aTileEntity = blockAccess.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IMultiTileEntity) { + ((IMultiTileEntity)aTileEntity).setBlockBoundsBasedOnState(this); + return; + } + super.setBlockBoundsBasedOnState(blockAccess, aX, aY, aZ); + } + + @Override + public final boolean isOpaqueCube() { + return mOpaque; + } + + @Override + public final void onNeighborChange(IBlockAccess aWorld, int aX, int aY, int aZ, int aTileX, int aTileY, int aTileZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (!LOCK) { + LOCK = true; + if (aTileEntity instanceof BaseTileEntity) ((BaseTileEntity) aTileEntity).onAdjacentBlockChange(aTileX, aTileY, aTileZ); + LOCK = false; + } + } + + @Override + public void onNeighborBlockChange(World aWorld, int aX, int aY, int aZ, Block aBlock) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (!LOCK) { + LOCK = true; + if (aTileEntity instanceof BaseTileEntity) ((BaseTileEntity) aTileEntity).onAdjacentBlockChange(aX, aY, aZ); + LOCK = false; + } + if (aTileEntity instanceof IMTE_OnNeighborBlockChange) ((IMTE_OnNeighborBlockChange) aTileEntity).onNeighborBlockChange(aWorld, aBlock); + if (aTileEntity == null) aWorld.setBlockToAir(aX, aY, aZ); + } + + @Override + public final void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) aTileEntity).onBlockAdded(); + } + + @Override + public float getPlayerRelativeBlockHardness(EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity && ((IMultiTileEntity) aTileEntity).privateAccess() && !((IMultiTileEntity) aTileEntity).playerOwnsThis(aPlayer, true) ? -1.0F + : super.getPlayerRelativeBlockHardness(aPlayer, aWorld, aX, aY, aZ); + } + + @Override + public final void onBlockClicked(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) aTileEntity).onLeftClick(aPlayer); + else super.onBlockClicked(aWorld, aX, aY, aZ, aPlayer); + } + + @Override + public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int aSide, float aHitX, float aHitY, float aHitZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aPlayer != null && ItemList.TC_Thaumometer.isStackEqual(aPlayer.getHeldItem(), true, true)) return false; + return aTileEntity instanceof IMultiTileEntity && ((IMultiTileEntity) aTileEntity).onBlockActivated(aPlayer, (byte)aSide, aHitX, aHitY, aHitZ); + } + + @Override + public final int isProvidingWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_IsProvidingWeakPower ? ((IMTE_IsProvidingWeakPower) aTileEntity).isProvidingWeakPower((byte)aSide) : + super.isProvidingWeakPower(aWorld, aX, aY, aZ, aSide); + } + + @Override + public final int isProvidingStrongPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_IsProvidingStrongPower ? ((IMTE_IsProvidingStrongPower) aTileEntity).isProvidingStrongPower((byte)aSide) + : super.isProvidingStrongPower(aWorld, aX, aY, aZ, aSide); + } + + + @Override + public final boolean shouldCheckWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_ShouldCheckWeakPower ? ((IMTE_ShouldCheckWeakPower) aTileEntity).shouldCheckWeakPower((byte)aSide) + : isNormalCube(aWorld, aX, aY, aZ); + } + + @Override + public final boolean getWeakChanges(IBlockAccess aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_GetWeakChanges ? ((IMTE_GetWeakChanges) aTileEntity).getWeakChanges() + : super.getWeakChanges(aWorld, aX, aY, aZ); + } + + + @Override + public final void harvestBlock(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, int aMeta) { + if (aPlayer == null) aPlayer = harvesters.get(); + aPlayer.addStat(StatList.mineBlockStatArray[getIdFromBlock(this)], 1); + aPlayer.addExhaustion(0.025F); + final boolean aSilkTouch = EnchantmentHelper.getSilkTouchModifier(aPlayer); + final int aFortune = EnchantmentHelper.getFortuneModifier(aPlayer); + float aChance = 1.0F; + final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true); + if (aTileEntity instanceof IMultiTileEntity) { + final ArrayList tList = ((IMultiTileEntity) aTileEntity).getDrops(aFortune, aSilkTouch); + aChance = ForgeEventFactory.fireBlockHarvesting(tList, aWorld, this, aX, aY, aZ, aMeta, aFortune, aChance, aSilkTouch, aPlayer); + for (ItemStack tStack : tList) if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(aWorld, aX, aY, aZ, tStack); + } + } + + @Override + public ITexture[] getTexture(Block aBlock, byte aSide, int aRenderPass, boolean[] aShouldSideBeRendered) { + return null; + } + + @Override + public ITexture[] getTexture(Block aBlock, byte aSide, boolean isActive, int aRenderPass) { + return null; + } + + @Override + public int getRenderPasses(Block aBlock) { + return 0; + } + + @Override + public boolean usesRenderPass(int aRenderPass) { + return true; + } + + @Override + public boolean setBlockBounds(Block aBlock, int aRenderPass) { + return false; + } + + @Override + public IRenderedBlock passRenderingToObject(ItemStack aStack) { + return null; + } + + @Override + public IRenderedBlock passRenderingToObject(IBlockAccess aWorld, int aX, int aY, int aZ) { + final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return tTileEntity instanceof IRenderedBlock ? (IRenderedBlock) tTileEntity : null; + } + + @Override + public final boolean shouldSideBeRendered(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX - OFFX[aSide], aY - OFFY[aSide], aZ - OFFZ[aSide]); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).shouldSideBeRendered((byte)aSide) : super.shouldSideBeRendered(aWorld, aX, aY, aZ, aSide); + } + + @Override + public Block getFacade(IBlockAccess aWorld, int aX, int aY, int aZ, int side) { + final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (tTileEntity instanceof CoverableTileEntity) { + final byte aSide = (byte) side; + final CoverableTileEntity tile = (CoverableTileEntity) tTileEntity; + if (side != -1) { + final Block facadeBlock = tile.getCoverBehaviorAtSideNew(aSide).getFacadeBlock(aSide, tile.getCoverIDAtSide(aSide), tile.getComplexCoverDataAtSide(aSide), tile); + if (facadeBlock != null) return facadeBlock; + } else { + // we do not allow more than one type of facade per block, so no need to check every side + // see comment in gregtech.common.covers.GT_Cover_FacadeBase.isCoverPlaceable + for (byte i = 0; i < 6; i++) { + final Block facadeBlock = tile.getCoverBehaviorAtSideNew(i).getFacadeBlock(i, tile.getCoverIDAtSide(i), tile.getComplexCoverDataAtSide(i), tile); + if (facadeBlock != null) { + return facadeBlock; + } + } + } + } + return Blocks.air; + } + + @Override + public int getFacadeMetadata(IBlockAccess aWorld, int aX, int aY, int aZ, int side) { + final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (tTileEntity instanceof CoverableTileEntity) { + final byte aSide = (byte) side; + final CoverableTileEntity tile = (CoverableTileEntity) tTileEntity; + if (side != -1) { + final Block facadeBlock = tile.getCoverBehaviorAtSideNew(aSide).getFacadeBlock(aSide, tile.getCoverIDAtSide(aSide), tile.getComplexCoverDataAtSide(aSide), tile); + if (facadeBlock != null) + return tile.getCoverBehaviorAtSideNew(aSide).getFacadeMeta(aSide, tile.getCoverIDAtSide(aSide), tile.getComplexCoverDataAtSide(aSide), tile); + } else { + // we do not allow more than one type of facade per block, so no need to check every side + // see comment in gregtech.common.covers.GT_Cover_FacadeBase.isCoverPlaceable + for (byte i = 0; i < 6; i++) { + final Block facadeBlock = tile.getCoverBehaviorAtSideNew(i).getFacadeBlock(i, tile.getCoverIDAtSide(i), tile.getComplexCoverDataAtSide(i), tile); + if (facadeBlock != null) { + return tile.getCoverBehaviorAtSideNew(i).getFacadeMeta(i, tile.getCoverIDAtSide(i), tile.getComplexCoverDataAtSide(i), tile); + } + } + } + } + return 0; + } + + @Override + protected boolean canSilkHarvest() { + return false; + } + + @Override + public final boolean canProvidePower() { + return !mNormalCube; + } + + @Override + public final String getLocalizedName() { + return StatCollector.translateToLocal(mNameInternal + ".name"); + } + + @Override + public final String getUnlocalizedName() { + return mNameInternal; + } + + @Override + public final boolean onBlockEventReceived(World aWorld, int aX, int aY, int aZ, int aID, int aData) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity == null || aTileEntity.receiveClientEvent(aID, aData); + } + + @Override + public final void getSubBlocks(Item aItem, CreativeTabs aCreativeTab, List aList) {/**/} + + @Override + public boolean hasComparatorInputOverride() { + return true; + } + + @Override + public final int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMTE_GetComparatorInputOverride ? ((IMTE_GetComparatorInputOverride) aTileEntity).getComparatorInputOverride((byte)aSide) + : aTileEntity instanceof IMTE_IsProvidingWeakPower ? ((IMTE_IsProvidingWeakPower) aTileEntity).isProvidingWeakPower(GT_Utility.getOppositeSide(aSide)) + : super.getComparatorInputOverride(aWorld, aX, aY, aZ, aSide); + } + + @Override + public final void registerBlockIcons(IIconRegister aIconRegister) {/**/} + + @Override + public final boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) { + return mNormalCube; + } + + @Override + public final boolean isSideSolid(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection aSide) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).isSideSolid((byte)(aSide != null ? aSide.ordinal() : GT_Values.SIDE_UNKNOWN)) : mOpaque; + } + + @Override + public boolean removedByPlayer(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, boolean aWillHarvest) { + final TileEntity aTileEntity = GT_Util.getTileEntity(aWorld, aX, aY, aZ, true); + if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity); + return super.removedByPlayer(aWorld, aPlayer, aX, aY, aZ, aWillHarvest); + } + + @Override + public int getFlammability(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) { + return 0; + } + + @Override + public int getFireSpreadSpeed(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) { + return GregTech_API.sMachineFlammable && (aWorld.getBlockMetadata(aX, aY, aZ) == 0) ? 100 : 0; + } + + @Override + public boolean hasTileEntity(int aMeta) { + return true; + } + + @Override + public final ArrayList getDrops(World aWorld, int aX, int aY, int aZ, int aUnusableMetaData, int aFortune) { + final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true); + if (aTileEntity instanceof IMultiTileEntity) return ((IMultiTileEntity) aTileEntity).getDrops(aFortune, false); + return new ArrayList<>(); + } + + @Override + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess aWorld, int aX, int aY, int aZ) { + return false; + } + + @Override + public final float getExplosionResistance(Entity aExploder, World aWorld, int aX, int aY, int aZ, double aExplosionX, double aExplosionY, double aExplosionZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).getExplosionResistance(aExploder, aExplosionX, aExplosionY, aExplosionZ) + : 1.0F; + } + + @Override + public final void onBlockExploded(World aWorld, int aX, int aY, int aZ, Explosion aExplosion) { + if (aWorld.isRemote) return; + final TileEntity aTileEntity = getTileEntity(aWorld, aX, aY, aZ, true); + if (aTileEntity != null) LAST_BROKEN_TILEENTITY.set(aTileEntity); + if (aTileEntity instanceof IMultiTileEntity) { + GT_Log.exp.printf("Explosion at : %d | %d | %d DIMID: %s due to near explosion!%n", aX, aY, aZ, aWorld.provider.dimensionId); + ((IMultiTileEntity) aTileEntity).onExploded(aExplosion); + } + else aWorld.setBlockToAir(aX, aY, aZ); + } + + @Override + public final boolean canConnectRedstone(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + return true; + } + + @Override + public final boolean recolourBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection aSide, int aColor) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity && ((IMultiTileEntity) aTileEntity).recolourBlock((byte)aSide.ordinal(), (byte) aColor); + } + + @Override + public final String getHarvestTool(int aMeta) { + return mTool; + } + + @Override + public final int getHarvestLevel(int aMeta) { + return Math.max(mHarvestLevelMinimum, Math.min(mHarvestLevelMaximum, mHarvestLevelOffset + aMeta)); + } + + @Override + public final boolean isToolEffective(String aType, int aMeta) { + return getHarvestTool(aMeta).equals(aType); + } + + + @Override + public final ItemStack getPickBlock(MovingObjectPosition aTarget, World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).getPickBlock(aTarget) : null; + } + + @Override + public final ItemStack getPickBlock(MovingObjectPosition aTarget, World aWorld, int aX, int aY, int aZ) { + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + return aTileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) aTileEntity).getPickBlock(aTarget) : null; + } + + + public final void receiveMultiTileEntityData( + IBlockAccess aWorld, int aX, short aY, int aZ, short aRID, short aID, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4, int aCover5, + byte aTextureData, byte aTexturePage, byte aUpdateData, byte aRedstoneData, byte aColorData + ) { + if (!(aWorld instanceof World)) return; + final IMultiTileEntity te; + + TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + + if (!(aTileEntity instanceof IMultiTileEntity) || ((IMultiTileEntity) aTileEntity).getMultiTileEntityRegistryID() != aRID || ((IMultiTileEntity) aTileEntity).getMultiTileEntityID() != aID) { + final MultiTileEntityRegistry tRegistry = MultiTileEntityRegistry.getRegistry(aRID); + if (tRegistry == null) return; + + aTileEntity = tRegistry.getNewTileEntity((World) aWorld, aX, aY, aZ, aID); + if (!(aTileEntity instanceof IMultiTileEntity)) return; + setTileEntity((World) aWorld, aX, aY, aZ, aTileEntity, false); + } + te = (IMultiTileEntity) aTileEntity; + + boolean updated; + updated = te.setCoverIDAtSideNoUpdate((byte) 0, aCover0); + updated |= te.setCoverIDAtSideNoUpdate((byte) 1, aCover1); + updated |= te.setCoverIDAtSideNoUpdate((byte) 2, aCover2); + updated |= te.setCoverIDAtSideNoUpdate((byte) 3, aCover3); + updated |= te.setCoverIDAtSideNoUpdate((byte) 4, aCover4); + updated |= te.setCoverIDAtSideNoUpdate((byte) 5, aCover5); + + if(updated) { + te.issueBlockUpdate(); + } + + + te.receiveClientEvent(GregTechTileClientEvents.CHANGE_COMMON_DATA, aTextureData); + te.receiveClientEvent(GregTechTileClientEvents.CHANGE_CUSTOM_DATA, aUpdateData & 0x7F); + te.receiveClientEvent(GregTechTileClientEvents.CHANGE_CUSTOM_DATA, aTexturePage | 0x80); + te.receiveClientEvent(GregTechTileClientEvents.CHANGE_COLOR, aColorData); + te.receiveClientEvent(GregTechTileClientEvents.CHANGE_REDSTONE_OUTPUT, aRedstoneData); + } + + + @Override + public final TileEntity createTileEntity(World aWorld, int aMeta) { + return null; + } + + @Override + public TileEntity createNewTileEntity(World world, int i) { return null; } +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java new file mode 100644 index 0000000000..feb2a0a0f5 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java @@ -0,0 +1,134 @@ +package gregtech.api.multitileentity; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData; +import gregtech.common.render.GT_Renderer_Block; +import gregtech.common.render.IRenderedBlock; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.StatCollector; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.util.GT_Util.setTileEntity; + +public class MultiTileEntityBlockInternal extends Block implements IRenderedBlock { + public MultiTileEntityRegistry mMultiTileEntityRegistry; + + public MultiTileEntityBlockInternal() { + super(Material.anvil); + } + + @Override + public void registerBlockIcons(IIconRegister aIconRegister) { /* Do Nothing */ } + + @Override + public int getRenderType() { + return GT_Renderer_Block.INSTANCE == null ? super.getRenderType() : GT_Renderer_Block.INSTANCE.mRenderID; + } + @Override public final String getUnlocalizedName() {return mMultiTileEntityRegistry.mNameInternal;} + @Override public final String getLocalizedName() {return StatCollector.translateToLocal(mMultiTileEntityRegistry.mNameInternal + ".name");} + + public boolean placeBlock(World aWorld, int aX, int aY, int aZ, byte aSide, short aMetaData, NBTTagCompound aNBT, boolean aCauseBlockUpdates, boolean aForcePlacement) { + final MultiTileEntityContainer aMTEContainer = mMultiTileEntityRegistry.getNewTileEntityContainer(aWorld, aX, aY, aZ, aMetaData, aNBT); + if (aMTEContainer == null) return false; + + final Block tReplacedBlock = aWorld.getBlock(aX, aY, aZ); + + + // This is some complicated bullshit Greg had to do to make his MTEs work right. + // Set Block with reverse MetaData first. + aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15-aMTEContainer.mBlockMetaData, 2); + // Make sure the Block has been set, yes I know setBlock has a true/false return value, but guess what, it is not reliable in 0.0001% of cases! -Greg + if (aWorld.getBlock(aX, aY, aZ) != aMTEContainer.mBlock) {aWorld.setBlock(aX, aY, aZ, Blocks.air, 0, 0); return false;} + // TileEntity should not refresh yet! -Greg + ((IMultiTileEntity)aMTEContainer.mTileEntity).setShouldRefresh(false); + // Fake-Set the TileEntity first, bypassing a lot of checks. -Greg + setTileEntity(aWorld, aX, aY, aZ, (TileEntity) aMTEContainer.mTileEntity, false); + // Now set the Block with the REAL MetaData. -Greg + setTileEntity(aWorld, aX, aY, aZ, aMTEContainer.mBlock, aMTEContainer.mBlockMetaData, 0, false); + // When the TileEntity is set now it SHOULD refresh! -Greg + ((IMultiTileEntity)aMTEContainer.mTileEntity).setShouldRefresh(true); + // But make sure again that the Block we have set was actually set properly, because 0.0001%! -Greg + if (aWorld.getBlock(aX, aY, aZ) != aMTEContainer.mBlock) {aWorld.setBlock(aX, aY, aZ, Blocks.air, 0, 0); return false;} + // And finally properly set the TileEntity for real! -Greg + setTileEntity(aWorld, aX, aY, aZ, (TileEntity) aMTEContainer.mTileEntity, aCauseBlockUpdates); + // Yep, all this just to set one Block and its TileEntity properly... -Greg + + + try { + if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData) { + if (((IMTE_HasMultiBlockMachineRelevantData)aMTEContainer.mTileEntity).hasMultiBlockMachineRelevantData()) GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } catch(Throwable e) { + GT_FML_LOGGER.error("causeMachineUpdate", e); + } + + try { + if (!aWorld.isRemote && aCauseBlockUpdates) { + aWorld.notifyBlockChange(aX, aY, aZ, tReplacedBlock); + aWorld.func_147453_f(aX, aY, aZ, aMTEContainer.mBlock); + } + } catch(Throwable e) { + GT_FML_LOGGER.error("aCauseBlockUpdates", e); + } + + try { + ((IMultiTileEntity)aMTEContainer.mTileEntity).onTileEntityPlaced(); + } catch(Throwable e) { + GT_FML_LOGGER.error("onTileEntityPlaced", e); + } + + + try { + aWorld.func_147451_t/*updateAllLightTypes*/(aX, aY, aZ); + } catch(Throwable e) { + GT_FML_LOGGER.error("updateAllLightTypes", e); + } + return true; + } + + @Override + public ITexture[] getTexture(Block aBlock, byte aSide, int aRenderPass, boolean[] aShouldSideBeRendered) { + return null; + } + + @Override + public ITexture[] getTexture(Block aBlock, byte aSide, boolean isActive, int aRenderPass) { + return null; + } + + @Override + public int getRenderPasses(Block aBlock) { + return 0; + } + + @Override + public boolean usesRenderPass(int aRenderPass) { + return true; + } + + @Override + public boolean setBlockBounds(Block aBlock, int aRenderPass) { + return false; + } + + @Override + public IRenderedBlock passRenderingToObject(ItemStack aStack) { + final TileEntity tTileEntity = mMultiTileEntityRegistry.getNewTileEntity(aStack); + return tTileEntity instanceof IRenderedBlock ? (IRenderedBlock)tTileEntity : null; + } + + @Override + public IRenderedBlock passRenderingToObject(IBlockAccess aWorld, int aX, int aY, int aZ) { + return null; + } +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java new file mode 100644 index 0000000000..3443ae52ca --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java @@ -0,0 +1,35 @@ +package gregtech.api.multitileentity; + +import gregtech.api.enums.Materials; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import gregtech.api.util.GT_Util; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import static gregtech.api.enums.GT_Values.NBT; + +public class MultiTileEntityClassContainer { + public final Class mClass; + public final MultiTileEntityBlock mBlock; + public final TileEntity mCanonicalTileEntity; + public final NBTTagCompound mParameters; + public final byte mBlockMetaData, mStackSize; + public final short mID; + public final boolean mHidden; + + + + public MultiTileEntityClassContainer(int aID, Class aClass, int aBlockMetaData, int aStackSize, MultiTileEntityBlock aBlock, NBTTagCompound aParameters) { + if (!IMultiTileEntity.class.isAssignableFrom(aClass)) throw new IllegalArgumentException("MultiTileEntities must implement the Interface IMultiTileEntity!"); + mBlockMetaData = (byte) aBlockMetaData; + mStackSize = (byte) aStackSize; + mParameters = aParameters == null ? new NBTTagCompound() : aParameters; + mHidden = mParameters.getBoolean(NBT.HIDDEN); + mID = (short) aID; + mBlock = aBlock; + mClass = aClass; + if (mParameters.hasKey(NBT.MATERIAL) && !mParameters.hasKey(NBT.COLOR)) + mParameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(Materials.get(mParameters.getString(NBT.MATERIAL)).getRGBA())); + try {mCanonicalTileEntity = aClass.newInstance();} catch (Throwable e) {throw new IllegalArgumentException(e);} + if (mCanonicalTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) mCanonicalTileEntity).initFromNBT(mParameters, mID, (short) -1); + } +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java new file mode 100644 index 0000000000..1c037a45e1 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java @@ -0,0 +1,27 @@ +package gregtech.api.multitileentity; + +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +import static gregtech.api.util.GT_Util.setTileEntity; + +public class MultiTileEntityContainer { + public final TileEntity mTileEntity; + public final MultiTileEntityBlock mBlock; + public final byte mBlockMetaData; + + public MultiTileEntityContainer(TileEntity aTileEntity, MultiTileEntityBlock aBlock, byte aBlockMetaData) { + mBlockMetaData = aBlockMetaData; + mTileEntity = aTileEntity; + mBlock = aBlock; + } + public void setMultiTile(World aWorld, int aX, int aY, int aZ) { + // This is some complicated Bullshit Greg had to do to make his MTEs work right. + ((IMultiTileEntity)mTileEntity).setShouldRefresh(false); + setTileEntity(aWorld, aX, aY, aZ, mTileEntity, false); + setTileEntity(aWorld, aX, aY, aZ, mBlock, mBlockMetaData, 0, false); + ((IMultiTileEntity)mTileEntity).setShouldRefresh(true); + setTileEntity(aWorld, aX, aY, aZ, mTileEntity, true); + } +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java new file mode 100644 index 0000000000..897dbf7991 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java @@ -0,0 +1,303 @@ +package gregtech.api.multitileentity; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.metatileentity.CoverableTileEntity; +import gregtech.api.multitileentity.interfaces.IItemUpdatable; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_AddToolTips; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_GetMaxStackSize; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnlyPlaceableWhenSneaking; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_IgnoreEntityCollisionWhenPlacing; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_CanPlace; +import net.minecraft.block.Block; +import net.minecraft.block.BlockSnow; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +import java.util.List; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.enums.GT_Values.SIDE_TOP; +import static gregtech.api.util.GT_Util.setTileEntity; + +public class MultiTileEntityItemInternal extends ItemBlock implements IFluidContainerItem, IItemUpdatable { + public final MultiTileEntityBlockInternal mBlock; + + public MultiTileEntityItemInternal(Block aBlock) { + super(aBlock); + setMaxDamage(0); + setHasSubtypes(true); + mBlock = (MultiTileEntityBlockInternal)aBlock; + } + @Override + @SuppressWarnings("unchecked") + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) { + final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aStack); + if (tTileEntityContainer == null) { + aList.add("INVALID ITEM!"); + return; + } + if (tTileEntityContainer.mTileEntity instanceof IMTE_AddToolTips) { + try { + ((IMTE_AddToolTips) tTileEntityContainer.mTileEntity).addToolTips(aList, aStack, aF3_H); + } catch (Throwable e) { + GT_FML_LOGGER.error("addInformation", e); + } + } + final NBTTagCompound aNBT = aStack.getTagCompound(); + CoverableTileEntity.addInstalledCoversInformation(aNBT, aList); + // TODO: Add anything else relevant + } + + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings("unchecked") + public void getSubItems(Item aItem, CreativeTabs aTab, List aList) { + for (MultiTileEntityClassContainer tClass : mBlock.mMultiTileEntityRegistry.mRegistrations) { + if (!tClass.mHidden) { + if (((IMultiTileEntity) tClass.mCanonicalTileEntity).getSubItems(mBlock, aItem, aTab, aList, tClass.mID)) { + aList.add(mBlock.mMultiTileEntityRegistry.getItem(tClass.mID)); + } + } + } + } + + @Override + public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, float aHitX, float aHitY, float aHitZ) { + if (aY < 0 || aY > aWorld.getHeight()) return false; + try { + final Block tClickedBlock = aWorld.getBlock(aX, aY, aZ); + if (tClickedBlock instanceof BlockSnow && (aWorld.getBlockMetadata(aX, aY, aZ) & 7) < 1) { + aSide = SIDE_TOP; + } else if (tClickedBlock != Blocks.vine && tClickedBlock != Blocks.tallgrass && tClickedBlock != Blocks.deadbush && !tClickedBlock.isReplaceable(aWorld, aX, aY, aZ)) { + aX += GT_Values.OFFX[aSide]; + aY += GT_Values.OFFY[aSide]; + aZ += GT_Values.OFFZ[aSide]; + } + final Block tReplacedBlock = aWorld.getBlock(aX, aY, aZ); + + if (!tReplacedBlock.isReplaceable(aWorld, aX, aY, aZ) || !mBlock.canReplace(aWorld, aX, aY, aZ, aSide, aStack)) return false; + if (aStack.stackSize == 0 || (aPlayer != null && !aPlayer.canPlayerEdit(aX, aY, aZ, aSide, aStack))) return false; + + final MultiTileEntityContainer aMTEContainer = mBlock.mMultiTileEntityRegistry.getNewTileEntityContainer(aWorld, aX, aY, aZ, aStack); + + if (aMTEContainer != null + && (aPlayer == null || aPlayer.isSneaking() || !(aMTEContainer.mTileEntity instanceof IMTE_OnlyPlaceableWhenSneaking) || !((IMTE_OnlyPlaceableWhenSneaking) aMTEContainer.mTileEntity).onlyPlaceableWhenSneaking()) + && ( + aWorld.checkNoEntityCollision(AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX+1, aY+1, aZ+1)) + || (aMTEContainer.mTileEntity instanceof IMTE_IgnoreEntityCollisionWhenPlacing && ((IMTE_IgnoreEntityCollisionWhenPlacing)aMTEContainer.mTileEntity).ignoreEntityCollisionWhenPlacing(aStack, aPlayer, aWorld, aX, aY, aZ, (byte)aSide, aHitX, aHitY, aHitZ)) + ) + && (!(aMTEContainer.mTileEntity instanceof IMTE_CanPlace) || ((IMTE_CanPlace)aMTEContainer.mTileEntity).canPlace(aStack, aPlayer, aWorld, aX, aY, aZ, (byte)aSide, aHitX, aHitY, aHitZ)) + && aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15 - aMTEContainer.mBlockMetaData, 2)) + { + aMTEContainer.setMultiTile(aWorld, aX, aY, aZ); + + try { + if (((IMultiTileEntity) aMTEContainer.mTileEntity).onPlaced(aStack, aPlayer, aWorld, aX, aY, aZ, (byte) aSide, aHitX, aHitY, aHitZ)) { + aWorld.playSoundEffect( + aX + 0.5, aY + 0.5, aZ + 0.5, aMTEContainer.mBlock.stepSound.func_150496_b(), (aMTEContainer.mBlock.stepSound.getVolume() + 1) / 2, + aMTEContainer.mBlock.stepSound.getPitch() * 0.8F + ); + } + } catch (Throwable e) { + GT_FML_LOGGER.error("onPlaced", e); + } + try { + if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData && (((IMTE_HasMultiBlockMachineRelevantData) aMTEContainer.mTileEntity).hasMultiBlockMachi