From 3724fbbcb67ee2566419654e31eb88eb5b7f88f6 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Sat, 22 Jun 2024 15:36:54 +0800 Subject: Refactors --- .../api/multitileentity/MultiTileEntityBlock.java | 526 +++++++++------------ .../MultiTileEntityBlockInternal.java | 118 ----- .../MultiTileEntityBlockRegistryInternal.java | 47 ++ .../MultiTileEntityClassContainer.java | 96 ++-- .../multitileentity/MultiTileEntityContainer.java | 28 +- .../api/multitileentity/MultiTileEntityItem.java | 318 +++++++++++++ .../MultiTileEntityItemInternal.java | 354 -------------- .../multitileentity/MultiTileEntityRegistry.java | 210 ++++---- .../api/multitileentity/base/MultiTileEntity.java | 52 +- .../base/TickableMultiTileEntity.java | 3 +- .../interfaces/IMultiBlockPart.java | 9 + .../interfaces/IMultiTileEntity.java | 121 ++--- .../multiblock/base/Controller.java | 6 +- .../multiblock/base/MultiBlockPart.java | 20 +- .../multiblock/base/WallShareablePart.java | 2 +- 15 files changed, 836 insertions(+), 1074 deletions(-) delete mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java create mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java delete mode 100644 src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java (limited to 'src/main/java/gregtech/api/multitileentity') diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java index 6ee760553e..800e9af20a 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java @@ -8,9 +8,7 @@ import static gregtech.api.util.GT_Util.getTileEntity; import static gregtech.api.util.GT_Util.setTileEntity; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; -import java.util.Map; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -54,15 +52,6 @@ import gregtech.api.interfaces.tileentity.IDebugableTileEntity; import gregtech.api.metatileentity.BaseTileEntity; import gregtech.api.metatileentity.CoverableTileEntity; 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; @@ -75,142 +64,95 @@ import gregtech.common.render.GT_MultiTile_Renderer; @Optional.Interface(iface = "com.cricketcraft.chisel.api.IFacade", modid = "ChiselAPI") public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITileEntityProvider, 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); + private boolean registered = false, normalCube; + protected String internalName, toolName, materialName, modID; + + public String getName() { + return String.join( + ".", + "gt.block.multiblock", + materialName, + stepSound.soundName, + toolName, + Boolean.toString(opaque), + Boolean.toString(normalCube)); + } + + public MultiTileEntityBlock(Material material) { + super(material); 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; + public MultiTileEntityBlock tool(String toolName) { + this.toolName = toolName.toLowerCase(); + return this; } - @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); + public MultiTileEntityBlock sound(SoundType soundtype) { + setStepSound(soundtype); + return this; + } - aWorld.removeTileEntity(aX, aY, aZ); + public MultiTileEntityBlock opaque(Boolean opaque) { + this.opaque = opaque; + return this; } - @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 mte) { - return mte.getDebugInfo(aPlayer, aLogLevel); - } - return new ArrayList<>(); + public MultiTileEntityBlock normalCube(Boolean normalCube) { + this.normalCube = normalCube; + return this; } - @Override - public final boolean func_149730_j /* isFullBlock */() { - return mOpaque; + public MultiTileEntityBlock modID(String modID) { + this.modID = modID; + return this; + } + + public MultiTileEntityBlock materialName(String materialName) { + this.materialName = materialName; + return this; + } + + public MultiTileEntityBlock register() { + if (registered) throw new IllegalStateException("Block already registered " + internalName); + if (GregTech_API.sPreloadFinished) + throw new IllegalStateException("Blocks can only be initialized within preInit!"); + + registered = true; + internalName = getName(); + lightOpacity = isOpaqueCube() ? 255 : 0; + + GameRegistry.registerBlock(this, ItemBlock.class, internalName); + return this; } @Override - public final boolean isNormalCube() { - return mNormalCube; + public final void breakBlock(World world, int x, int y, int z, Block block, int metadata) { + final TileEntity tileEntity = getTileEntity(world, x, y, z, true); + if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity); + if (tileEntity == null || !tileEntity.shouldRefresh(this, block, metadata, metadata, world, x, y, z)) return; + if (tileEntity instanceof IMultiTileEntity mute) mute.onBlockBroken(); + // spotless:off + // if (aTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData + // && ((IMTE_HasMultiBlockMachineRelevantData) aTileEntity).hasMultiBlockMachineRelevantData()) + // GregTech_API.causeMachineUpdate(world, x, y, z); + // spotless:on + + world.removeTileEntity(x, y, z); + super.breakBlock(world, x, y, z, block, metadata); + } @Override - public final boolean renderAsNormalBlock() { - return mOpaque || mNormalCube; + public ArrayList getDebugInfo(EntityPlayer aPlayer, int x, int y, int z, int aLogLevel) { + final TileEntity tileEntity = aPlayer.worldObj.getTileEntity(x, y, z); + if (tileEntity instanceof IDebugableTileEntity mte) { + return mte.getDebugInfo(aPlayer, aLogLevel); + } + return new ArrayList<>(); } @Override @@ -220,182 +162,181 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @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; + public final float getBlockHardness(World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity ? ((IMultiTileEntity) tileEntity).getBlockHardness() : 1.0F; } @SideOnly(Side.CLIENT) @Override - public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int ordinalSide) { + public IIcon getIcon(IBlockAccess aIBlockAccess, int x, int y, int z, int ordinalSide) { return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); } @SideOnly(Side.CLIENT) @Override - public IIcon getIcon(int ordinalSide, int aMeta) { + public IIcon getIcon(int ordinalSide, int meta) { return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); } @Override @SuppressWarnings("unchecked") - public final void addCollisionBoxesToList(World aWorld, int aX, int aY, int aZ, AxisAlignedBB aAABB, + public final void addCollisionBoxesToList(World world, int x, int y, int z, 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); + final TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof IMultiTileEntity) + ((IMultiTileEntity) tileEntity).addCollisionBoxesToList(aAABB, aList, aEntity); + else super.addCollisionBoxesToList(world, x, y, z, 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 mte ? mte.getCollisionBoundingBoxFromPool() - : aTileEntity == null ? null : super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ); + public final AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mte ? mte.getCollisionBoundingBoxFromPool() + : tileEntity == null ? null : super.getCollisionBoundingBoxFromPool(world, x, y, z); } @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 mte ? mte.getSelectedBoundingBoxFromPool() - : super.getSelectedBoundingBoxFromPool(aWorld, aX, aY, aZ); + public final AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mte ? mte.getSelectedBoundingBoxFromPool() + : super.getSelectedBoundingBoxFromPool(world, x, y, z); } @Override - public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int aX, int aY, int aZ) { - final TileEntity aTileEntity = blockAccess.getTileEntity(aX, aY, aZ); - if (aTileEntity instanceof IMultiTileEntity mte) { + public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int x, int y, int z) { + final TileEntity tileEntity = blockAccess.getTileEntity(x, y, z); + if (tileEntity instanceof IMultiTileEntity mte) { mte.setBlockBoundsBasedOnState(this); return; } - super.setBlockBoundsBasedOnState(blockAccess, aX, aY, aZ); + super.setBlockBoundsBasedOnState(blockAccess, x, y, z); } @Override public final boolean isOpaqueCube() { - return mOpaque; + return opaque; } @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); + public final void onNeighborChange(IBlockAccess world, int x, int y, int z, int aTileX, int aTileY, int aTileZ) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); if (!LOCK) { LOCK = true; - if (aTileEntity instanceof BaseTileEntity) - ((BaseTileEntity) aTileEntity).onAdjacentBlockChange(aTileX, aTileY, aTileZ); + if (tileEntity instanceof BaseTileEntity) + ((BaseTileEntity) tileEntity).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); + public void onNeighborBlockChange(World world, int x, int y, int z, Block block) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); if (!LOCK) { LOCK = true; - if (aTileEntity instanceof BaseTileEntity bte) bte.onAdjacentBlockChange(aX, aY, aZ); + if (tileEntity instanceof BaseTileEntity bte) bte.onAdjacentBlockChange(x, y, z); LOCK = false; } - if (aTileEntity instanceof IMTE_OnNeighborBlockChange change) change.onNeighborBlockChange(aWorld, aBlock); - if (aTileEntity == null) aWorld.setBlockToAir(aX, aY, aZ); + if (tileEntity instanceof IMultiTileEntity change) change.onNeighborBlockChange(world, block); + + if (tileEntity == null) world.setBlockToAir(x, y, z); } @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 mte) mte.onBlockAdded(); + public final void onBlockAdded(World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof IMultiTileEntity mte) mte.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 mte && mte.privateAccess() - && !((IMultiTileEntity) aTileEntity).playerOwnsThis(aPlayer, true) ? -1.0F - : super.getPlayerRelativeBlockHardness(aPlayer, aWorld, aX, aY, aZ); + public float getPlayerRelativeBlockHardness(EntityPlayer aPlayer, World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mte && mte.privateAccess() + && !((IMultiTileEntity) tileEntity).playerOwnsThis(aPlayer, true) ? -1.0F + : super.getPlayerRelativeBlockHardness(aPlayer, world, x, y, z); } @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 mte) mte.onLeftClick(aPlayer); - else super.onBlockClicked(aWorld, aX, aY, aZ, aPlayer); + public final void onBlockClicked(World world, int x, int y, int z, EntityPlayer aPlayer) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof IMultiTileEntity mte) mte.onLeftClick(aPlayer); + else super.onBlockClicked(world, x, y, z, aPlayer); } @Override - public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int ordinalSide, + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer aPlayer, int ordinalSide, float aHitX, float aHitY, float aHitZ) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + final TileEntity tileEntity = world.getTileEntity(x, y, z); if (aPlayer != null && ItemList.TC_Thaumometer.isStackEqual(aPlayer.getHeldItem(), true, true)) return false; - return aTileEntity instanceof IMultiTileEntity mte + return tileEntity instanceof IMultiTileEntity mte && mte.onBlockActivated(aPlayer, ForgeDirection.getOrientation(ordinalSide), aHitX, aHitY, aHitZ); } @Override - public final int isProvidingWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMTE_IsProvidingWeakPower power + public final int isProvidingWeakPower(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity power ? power.isProvidingWeakPower(ForgeDirection.getOrientation(ordinalSide)) - : super.isProvidingWeakPower(aWorld, aX, aY, aZ, ordinalSide); + : super.isProvidingWeakPower(world, x, y, z, ordinalSide); } @Override - public final int isProvidingStrongPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMTE_IsProvidingStrongPower power + public final int isProvidingStrongPower(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity power ? power.isProvidingStrongPower(ForgeDirection.getOrientation(ordinalSide)) - : super.isProvidingStrongPower(aWorld, aX, aY, aZ, ordinalSide); + : super.isProvidingStrongPower(world, x, y, z, ordinalSide); } @Override - public final boolean shouldCheckWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMTE_ShouldCheckWeakPower power + public final boolean shouldCheckWeakPower(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity power ? power.shouldCheckWeakPower(ForgeDirection.getOrientation(ordinalSide)) - : isNormalCube(aWorld, aX, aY, aZ); + : isNormalCube(world, x, y, z); } @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 changes ? changes.getWeakChanges() - : super.getWeakChanges(aWorld, aX, aY, aZ); + public final boolean getWeakChanges(IBlockAccess world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity changes ? changes.getWeakChanges() + : super.getWeakChanges(world, x, y, z); } @Override - public final void harvestBlock(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, int aMeta) { + public final void harvestBlock(World world, EntityPlayer aPlayer, int x, int y, int z, int meta) { 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); + final TileEntity tileEntity = getTileEntity(world, x, y, z, true); - if (!(aTileEntity instanceof IMultiTileEntity mte)) { + if (!(tileEntity instanceof IMultiTileEntity mte)) { return; } final ArrayList tList = mte.getDrops(aFortune, aSilkTouch); aChance = ForgeEventFactory - .fireBlockHarvesting(tList, aWorld, this, aX, aY, aZ, aMeta, aFortune, aChance, aSilkTouch, aPlayer); + .fireBlockHarvesting(tList, world, this, x, y, z, meta, aFortune, aChance, aSilkTouch, aPlayer); for (final ItemStack tStack : tList) - if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(aWorld, aX, aY, aZ, tStack); + if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(world, x, y, z, tStack); } @Override - public final boolean shouldSideBeRendered(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity aTileEntity = aWorld - .getTileEntity(aX - OFFX[ordinalSide], aY - OFFY[ordinalSide], aZ - OFFZ[ordinalSide]); - return aTileEntity instanceof IMultiTileEntity mte + public final boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tileEntity = world + .getTileEntity(x - OFFX[ordinalSide], y - OFFY[ordinalSide], z - OFFZ[ordinalSide]); + return tileEntity instanceof IMultiTileEntity mte ? mte.shouldSideBeRendered(ForgeDirection.getOrientation(ordinalSide)) - : super.shouldSideBeRendered(aWorld, aX, aY, aZ, ordinalSide); + : super.shouldSideBeRendered(world, x, y, z, ordinalSide); } @Override - public Block getFacade(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + public Block getFacade(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tTileEntity = world.getTileEntity(x, y, z); if (tTileEntity instanceof CoverableTileEntity tile) { final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); if (ordinalSide != -1) { @@ -418,8 +359,8 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public int getFacadeMetadata(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + public int getFacadeMetadata(IBlockAccess world, int x, int y, int z, int ordinalSide) { + final TileEntity tTileEntity = world.getTileEntity(x, y, z); if (tTileEntity instanceof CoverableTileEntity tile) { final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); if (ordinalSide != -1) { @@ -446,25 +387,20 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil return false; } - @Override - public final boolean canProvidePower() { - return !mNormalCube; - } - @Override public final String getLocalizedName() { - return StatCollector.translateToLocal(mNameInternal + ".name"); + return StatCollector.translateToLocal(internalName + ".name"); } @Override public final String getUnlocalizedName() { - return mNameInternal; + return internalName; } @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); + public final boolean onBlockEventReceived(World world, int x, int y, int z, int aID, int aData) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity == null || tileEntity.receiveClientEvent(aID, aData); } @Override @@ -478,172 +414,164 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public final int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int ordinalSide) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - if (aTileEntity instanceof IMTE_GetComparatorInputOverride override) { - return override.getComparatorInputOverride(ForgeDirection.getOrientation(ordinalSide)); - } - - if (aTileEntity instanceof IMTE_IsProvidingWeakPower power) { - return power.isProvidingWeakPower( + public final int getComparatorInputOverride(World world, int x, int y, int z, int ordinalSide) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof IMultiTileEntity mute) { + if (mute.hasComparatorInputOverride()) + return mute.getComparatorInputOverride(ForgeDirection.getOrientation(ordinalSide)); + else return mute.isProvidingWeakPower( ForgeDirection.getOrientation(ordinalSide) .getOpposite()); } - return super.getComparatorInputOverride(aWorld, aX, aY, aZ, ordinalSide); + return super.getComparatorInputOverride(world, x, y, z, ordinalSide); } @Override public final void registerBlockIcons(IIconRegister aIconRegister) { - /**/ - } - - @Override - public final boolean isNormalCube(IBlockAccess aWorld, int aX, int aY, int aZ) { - return mNormalCube; + /* Do Nothing */ } @Override - public final boolean isSideSolid(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection side) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMultiTileEntity mte ? mte.isSideSolid(side) : mOpaque; + public final boolean isSideSolid(IBlockAccess world, int x, int y, int z, ForgeDirection side) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mute ? mute.isSideSolid(side) : opaque; } @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); + public boolean removedByPlayer(World world, EntityPlayer aPlayer, int x, int y, int z, boolean aWillHarvest) { + final TileEntity tileEntity = GT_Util.getTileEntity(world, x, y, z, true); + if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity); + return super.removedByPlayer(world, aPlayer, x, y, z, aWillHarvest); } @Override - public int getFlammability(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection face) { + public int getFlammability(IBlockAccess world, int x, int y, int z, 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; + public int getFireSpreadSpeed(IBlockAccess world, int x, int y, int z, ForgeDirection face) { + return GregTech_API.sMachineFlammable && (world.getBlockMetadata(x, y, z) == 0) ? 100 : 0; } @Override - public boolean hasTileEntity(int aMeta) { + public boolean hasTileEntity(int meta) { 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 mte) return mte.getDrops(aFortune, false); + public final ArrayList getDrops(World world, int x, int y, int z, int aUnusableMetaData, int aFortune) { + final TileEntity tileEntity = getTileEntity(world, x, y, z, true); + if (tileEntity instanceof IMultiTileEntity mute) return mute.getDrops(aFortune, false); return new ArrayList<>(); } @Override - public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess aWorld, int aX, int aY, int aZ) { + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) { 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 mte - ? mte.getExplosionResistance(aExploder, aExplosionX, aExplosionY, aExplosionZ) + public final float getExplosionResistance(Entity aExploder, World world, int x, int y, int z, double aExplosionX, + double aExplosionY, double aExplosionZ) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mute + ? mute.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 mte) { + public final void onBlockExploded(World world, int x, int y, int z, Explosion aExplosion) { + if (world.isRemote) return; + final TileEntity tileEntity = getTileEntity(world, x, y, z, true); + if (tileEntity != null) LAST_BROKEN_TILEENTITY.set(tileEntity); + if (tileEntity instanceof IMultiTileEntity mute) { GT_Log.exp.printf( "Explosion at : %d | %d | %d DIMID: %s due to near explosion!%n", - aX, - aY, - aZ, - aWorld.provider.dimensionId); - mte.onExploded(aExplosion); - } else aWorld.setBlockToAir(aX, aY, aZ); + x, + y, + z, + world.provider.dimensionId); + mute.onExploded(aExplosion); + } else world.setBlockToAir(x, y, z); } @Override - public final boolean canConnectRedstone(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { + public final boolean canConnectRedstone(IBlockAccess world, int x, int y, int z, int ordinalSide) { return true; } @Override - public final boolean recolourBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection side, int aColor) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMultiTileEntity mte && mte.recolourBlock(side, (byte) aColor); + public final boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int color) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mute && mute.recolourBlock(side, (byte) color); } @Override - public final String getHarvestTool(int aMeta) { - return mTool; + public final String getHarvestTool(int meta) { + return toolName; } @Override - public final int getHarvestLevel(int aMeta) { - return Math.max(mHarvestLevelMinimum, Math.min(mHarvestLevelMaximum, mHarvestLevelOffset + aMeta)); + public int getHarvestLevel(int meta) { + return meta % 4; } @Override - public final boolean isToolEffective(String aType, int aMeta) { - return getHarvestTool(aMeta).equals(aType); + public final boolean isToolEffective(String toolType, int meta) { + return getHarvestTool(meta).equals(toolType); } @Override - public final ItemStack getPickBlock(MovingObjectPosition aTarget, World aWorld, int aX, int aY, int aZ, + public final ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer aPlayer) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(aTarget) : null; + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(target) : 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 mte ? mte.getPickBlock(aTarget) : null; + public final ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof IMultiTileEntity mte ? mte.getPickBlock(target) : null; } @Nullable - public final IMultiTileEntity receiveMultiTileEntityData(@Nonnull IBlockAccess aWorld, int aX, int aY, int aZ, + public final IMultiTileEntity receiveMultiTileEntityData(@Nonnull IBlockAccess world, int x, int y, int z, int registryId, int aID) { - if (!(aWorld instanceof World)) return null; - TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (!(world instanceof World)) return null; + TileEntity tileEntity = world.getTileEntity(x, y, z); - if (!(aTileEntity instanceof IMultiTileEntity mte) || mte.getMultiTileEntityRegistryID() != registryId - || mte.getMultiTileEntityID() != aID) { + if (!(tileEntity instanceof IMultiTileEntity mute) || mute.getMultiTileEntityRegistryID() != registryId + || mute.getMultiTileEntityID() != aID) { final MultiTileEntityRegistry tRegistry = MultiTileEntityRegistry.getRegistry(registryId); if (tRegistry == null) return null; - aTileEntity = tRegistry.getNewTileEntity((World) aWorld, aX, aY, aZ, aID); - if (!(aTileEntity instanceof IMultiTileEntity)) return null; + tileEntity = tRegistry.getNewTileEntity((World) world, x, y, z, aID); + if (!(tileEntity instanceof IMultiTileEntity)) return null; - setTileEntity((World) aWorld, aX, aY, aZ, aTileEntity, false); + setTileEntity((World) world, x, y, z, tileEntity, false); } - return (IMultiTileEntity) aTileEntity; + return (IMultiTileEntity) tileEntity; } - public void receiveCoverData(IMultiTileEntity mte, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4, + public void receiveCoverData(IMultiTileEntity mute, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4, int aCover5) { boolean updated; - updated = mte.setCoverIDAtSideNoUpdate(ForgeDirection.DOWN, aCover0); - updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.UP, aCover1); - updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.NORTH, aCover2); - updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.SOUTH, aCover3); - updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.WEST, aCover4); - updated |= mte.setCoverIDAtSideNoUpdate(ForgeDirection.EAST, aCover5); + updated = mute.setCoverIDAtSideNoUpdate(ForgeDirection.DOWN, aCover0); + updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.UP, aCover1); + updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.NORTH, aCover2); + updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.SOUTH, aCover3); + updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.WEST, aCover4); + updated |= mute.setCoverIDAtSideNoUpdate(ForgeDirection.EAST, aCover5); if (updated) { - mte.issueBlockUpdate(); + mute.issueBlockUpdate(); } } @Override - public final TileEntity createTileEntity(World aWorld, int aMeta) { + public final TileEntity createTileEntity(World world, int meta) { return null; } diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java deleted file mode 100644 index 17e217ae7e..0000000000 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java +++ /dev/null @@ -1,118 +0,0 @@ -package gregtech.api.multitileentity; - -import static gregtech.GT_Mod.GT_FML_LOGGER; -import static gregtech.api.util.GT_Util.setTileEntity; - -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.nbt.NBTTagCompound; -import net.minecraft.util.StatCollector; -import net.minecraft.world.World; -import net.minecraftforge.common.util.ForgeDirection; - -import gregtech.api.GregTech_API; -import gregtech.api.multitileentity.interfaces.IMultiTileEntity; -import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_HasMultiBlockMachineRelevantData; -import gregtech.common.render.GT_MultiTile_Renderer; - -public class MultiTileEntityBlockInternal extends Block { - - public MultiTileEntityRegistry mMultiTileEntityRegistry; - - public MultiTileEntityBlockInternal() { - super(Material.anvil); - } - - @Override - public void registerBlockIcons(IIconRegister aIconRegister) { - /* Do Nothing */ - } - - @Override - public int getRenderType() { - return GT_MultiTile_Renderer.INSTANCE == null ? super.getRenderType() - : GT_MultiTile_Renderer.INSTANCE.getRenderId(); - } - - @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, ForgeDirection side, 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, 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, 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; - } - - public MultiTileEntityRegistry getRegistry() { - return mMultiTileEntityRegistry; - } -} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java new file mode 100644 index 0000000000..3d8da5d796 --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockRegistryInternal.java @@ -0,0 +1,47 @@ +package gregtech.api.multitileentity; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.util.StatCollector; + +import gregtech.common.render.GT_MultiTile_Renderer; + +/* + * The internal block used in the registry for lookup. + * - Not the same as the block spawned with the MuTE to allow for multiple different types of blocks/materials + * in each registry. + */ +public class MultiTileEntityBlockRegistryInternal extends Block { + + public MultiTileEntityRegistry registry; + + public MultiTileEntityBlockRegistryInternal() { + super(Material.anvil); + } + + @Override + public void registerBlockIcons(IIconRegister aIconRegister) { + /* Do Nothing */ + } + + @Override + public int getRenderType() { + return GT_MultiTile_Renderer.INSTANCE == null ? super.getRenderType() + : GT_MultiTile_Renderer.INSTANCE.getRenderId(); + } + + @Override + public final String getUnlocalizedName() { + return registry.getInternalName(); + } + + @Override + public final String getLocalizedName() { + return StatCollector.translateToLocal(registry.getInternalName() + ".name"); + } + + public MultiTileEntityRegistry getRegistry() { + return registry; + } +} diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java index 4ce4c3c886..6eba28bad9 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityClassContainer.java @@ -17,77 +17,78 @@ import gregtech.common.tileentities.casings.upgrade.Tank; public class MultiTileEntityClassContainer { - private final WeakReference mRegistry; - private String mLocalized; - private String mCategoryName; + private final WeakReference registry; + private String localized; + private String categoryName; - public final short mID; - public Class mClass; - public MultiTileEntityBlock mBlock; - public MultiTileEntity mCanonicalTileEntity; - public NBTTagCompound mParameters; + public final short muteID; + public Class muteClass; + public MultiTileEntityBlock block; + public MultiTileEntity referenceTileEntity; + public NBTTagCompound parameters; // These have defaults - public byte mBlockMetaData = 1; - public byte mStackSize = 64; - public boolean mHidden = false; + public byte blockMetaData = 1; + public byte maxStackSize = 64; + public boolean hidden = false; public MultiTileEntityClassContainer(MultiTileEntityRegistry aRegistry, int aID, Class aClass) { /* Start the Builder */ - mRegistry = new WeakReference<>(aRegistry); - mID = (short) aID; - mClass = aClass; - mParameters = new NBTTagCompound(); + registry = new WeakReference<>(aRegistry); + muteID = (short) aID; + muteClass = aClass; + parameters = new NBTTagCompound(); } public boolean register() { /* End and register the Builder with the registry */ - final MultiTileEntityRegistry registry = mRegistry.get(); + final MultiTileEntityRegistry registry = this.registry.get(); - if (mParameters.hasKey(NBT.MATERIAL) && !mParameters.hasKey(NBT.COLOR)) mParameters.setInteger( + if (parameters.hasKey(NBT.MATERIAL) && !parameters.hasKey(NBT.COLOR)) parameters.setInteger( NBT.COLOR, GT_Util.getRGBInt( - Materials.get(mParameters.getString(NBT.MATERIAL)) + Materials.get(parameters.getString(NBT.MATERIAL)) .getRGBA())); try { - mCanonicalTileEntity = mClass.newInstance(); + referenceTileEntity = muteClass.getDeclaredConstructor() + .newInstance(); } catch (Throwable e) { throw new IllegalArgumentException(e); } - mCanonicalTileEntity.initFromNBT(mParameters, mID, (short) -1); + referenceTileEntity.initFromNBT(parameters, muteID, (short) -1); - return registry != null && registry.add(this.mLocalized, this.mCategoryName, this) != null; + return registry != null && registry.add(this.localized, this) != null; } public MultiTileEntityClassContainer name(String aName) { - mLocalized = aName; + localized = aName; return this; } public MultiTileEntityClassContainer category(String aCategoryName) { - mCategoryName = aCategoryName; + categoryName = aCategoryName; return this; } public MultiTileEntityClassContainer meta(int aMeta) { - mBlockMetaData = (byte) aMeta; + blockMetaData = (byte) aMeta; return this; } public MultiTileEntityClassContainer stackSize(int aStackSize) { - mStackSize = (byte) aStackSize; + maxStackSize = (byte) aStackSize; return this; } public MultiTileEntityClassContainer hide() { - mHidden = true; + hidden = true; return this; } public MultiTileEntityClassContainer setBlock(MultiTileEntityBlock aBlock) { - mBlock = aBlock; + block = aBlock; return this; } @@ -97,68 +98,68 @@ public class MultiTileEntityClassContainer { public MultiTileEntityClassContainer material(Materials material) { // Sets the material, and the color from the material, if not already set - mParameters.setString(NBT.MATERIAL, material.toString()); - if (!mParameters.hasKey(NBT.COLOR)) mParameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(material.getRGBA())); + parameters.setString(NBT.MATERIAL, material.toString()); + if (!parameters.hasKey(NBT.COLOR)) parameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(material.getRGBA())); return this; } public MultiTileEntityClassContainer color(int rbg) { - mParameters.setInteger(NBT.COLOR, rbg); + parameters.setInteger(NBT.COLOR, rbg); return this; } public MultiTileEntityClassContainer color(short[] rgba) { - mParameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(rgba)); + parameters.setInteger(NBT.COLOR, GT_Util.getRGBInt(rgba)); return this; } public MultiTileEntityClassContainer textureFolder(String texture) { - mParameters.setString(NBT.TEXTURE_FOLDER, texture); + parameters.setString(NBT.TEXTURE_FOLDER, texture); return this; } public MultiTileEntityClassContainer inputInventorySize(int aSize) { - mParameters.setInteger(NBT.INV_INPUT_SIZE, aSize); + parameters.setInteger(NBT.INV_INPUT_SIZE, aSize); return this; } public MultiTileEntityClassContainer outputInventorySize(int aSize) { - mParameters.setInteger(NBT.INV_OUTPUT_SIZE, aSize); + parameters.setInteger(NBT.INV_OUTPUT_SIZE, aSize); return this; } public MultiTileEntityClassContainer tankCapacity(Long aCapacity) { - mParameters.setLong(NBT.TANK_CAPACITY, aCapacity); + parameters.setLong(NBT.TANK_CAPACITY, aCapacity); return this; } public MultiTileEntityClassContainer tier(int aTier) { verifyDescendentOfMultiple(true, UpgradeCasing.class, FunctionalCasing.class); - mParameters.setInteger(NBT.TIER, aTier); + parameters.setInteger(NBT.TIER, aTier); return this; } public MultiTileEntityClassContainer upgradeInventorySize(int aSize) { verifyDescendentOf(Inventory.class); - mParameters.setInteger(NBT.UPGRADE_INVENTORY_SIZE, aSize); + parameters.setInteger(NBT.UPGRADE_INVENTORY_SIZE, aSize); return this; } public MultiTileEntityClassContainer upgradeTankCount(int count) { verifyDescendentOf(Tank.class); - mParameters.setInteger(NBT.UPGRADE_TANK_COUNT, count); + parameters.setInteger(NBT.UPGRADE_TANK_COUNT, count); return this; } public MultiTileEntityClassContainer upgradeTankCapacity(Long aCapacity) { - mParameters.setLong(NBT.UPGRADE_TANK_CAPACITY, aCapacity); + parameters.setLong(NBT.UPGRADE_TANK_CAPACITY, aCapacity); return this; } public MultiTileEntityClassContainer upgradeAmperage(long amperage) { - mParameters.setLong(NBT.UPGRADE_AMPERAGE, amperage); + parameters.setLong(NBT.UPGRADE_AMPERAGE, amperage); return this; } @@ -172,34 +173,35 @@ public class MultiTileEntityClassContainer { * Merge in arbitrary NBT tuples of (key, value). Useful for anything for which a custom method has not yet been * exposed */ - mParameters = GT_Util.fuseNBT(mParameters, GT_Util.makeNBT(aTags)); + parameters = GT_Util.fuseNBT(parameters, GT_Util.makeNBT(aTags)); return this; } private void verifyDescendentOf(Class cls) { // Check if cls is extended by mClass - if (!cls.isAssignableFrom(mClass)) { + if (!cls.isAssignableFrom(muteClass)) { throw new IllegalArgumentException( - "Expected a descendent of " + cls.getName() + " got " + mClass.getName() + " instead."); + "Expected a descendent of " + cls.getName() + " got " + muteClass.getName() + " instead."); } } private void verifyDescendentOfMultiple(boolean onlyOne, Class... classes) { boolean atLeastOne = false; - String classNames = ""; + final StringBuilder classNames = new StringBuilder(); for (Class cls : classes) { - classNames += cls.getName() + " "; + classNames.append(cls.getName()) + .append(" "); if (!onlyOne) { verifyDescendentOf(cls); atLeastOne = true; - } else if (cls.isAssignableFrom(mClass)) { + } else if (cls.isAssignableFrom(muteClass)) { atLeastOne = true; } } if (!atLeastOne) { throw new IllegalArgumentException( - "Expected a descendent of any of these " + classNames + " got " + mClass.getName() + " instead."); + "Expected a descendent of any of these " + classNames + " got " + muteClass.getName() + " instead."); } } } diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java index 3510140c12..3ca0ee46f4 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityContainer.java @@ -1,30 +1,24 @@ package gregtech.api.multitileentity; -import static gregtech.api.util.GT_Util.setTileEntity; - -import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; -import gregtech.api.multitileentity.interfaces.IMultiTileEntity; +import gregtech.api.multitileentity.base.MultiTileEntity; +import gregtech.api.util.GT_Util; public class MultiTileEntityContainer { - public final TileEntity mTileEntity; - public final MultiTileEntityBlock mBlock; - public final byte mBlockMetaData; + public final MultiTileEntity tileEntity; + public final MultiTileEntityBlock block; + public final byte blockMetaData; - public MultiTileEntityContainer(TileEntity aTileEntity, MultiTileEntityBlock aBlock, byte aBlockMetaData) { - mBlockMetaData = aBlockMetaData; - mTileEntity = aTileEntity; - mBlock = aBlock; + public MultiTileEntityContainer(MultiTileEntity tileEntity, MultiTileEntityBlock block, byte blockMetaData) { + this.blockMetaData = blockMetaData; + this.tileEntity = tileEntity; + this.block = block; } 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); + GT_Util.setBlock(aWorld, aX, aY, aZ, block, blockMetaData, 0, false); + GT_Util.setTileEntity(aWorld, aX, aY, aZ, tileEntity, true); } } diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java new file mode 100644 index 0000000000..8dc1d348ff --- /dev/null +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItem.java @@ -0,0 +1,318 @@ +package gregtech.api.multitileentity; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.enums.GT_Values.SIDE_TOP; + +import java.util.List; + +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.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidContainerItem; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.metatileentity.CoverableTileEntity; +import gregtech.api.multitileentity.interfaces.IItemUpdatable; +import gregtech.api.multitileentity.interfaces.IMultiTileEntity; + +public class MultiTileEntityItem extends ItemBlock implements IFluidContainerItem, IItemUpdatable { + + public final MultiTileEntityBlockRegistryInternal mBlock; + + public MultiTileEntityItem(Block aBlock) { + super(aBlock); + setMaxDamage(0); + setHasSubtypes(true); + mBlock = (MultiTileEntityBlockRegistryInternal) aBlock; + } + + @Override + @SuppressWarnings("unchecked") + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) { + final MultiTileEntityContainer tTileEntityContainer = mBlock.registry.getCachedTileEntityContainer(aStack); + if (tTileEntityContainer == null) { + aList.add("INVALID ITEM!"); + return; + } + try { + tTileEntityContainer.tileEntity.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.registry.registrations) { + if (!tClass.hidden && ((IMultiTileEntity) tClass.referenceTileEntity) + .getSubItems(mBlock, aItem, aTab, aList, tClass.muteID)) { + aList.add(mBlock.registry.getItem(tClass.muteID)); + } + } + } + + @Override + public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + int ordinalSide, float aHitX, float aHitY, float aHitZ) { + + if (aY < 0 || aY > aWorld.getHeight()) return false; + + if (aPlayer == null) return false; + + try { + ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + final Block tClickedBlock = aWorld.getBlock(aX, aY, aZ); + + if (tClickedBlock instanceof BlockSnow && (aWorld.getBlockMetadata(aX, aY, aZ) & 7) < 1) { + ordinalSide = SIDE_TOP; + side = ForgeDirection.UP; + } else if (tClickedBlock != Blocks.vine && tClickedBlock != Blocks.tallgrass + && tClickedBlock != Blocks.deadbush + && !tClickedBlock.isReplaceable(aWorld, aX, aY, aZ)) { + aX += side.offsetX; + aY += side.offsetY; + aZ += side.offsetZ; + } + final Block tReplacedBlock = aWorld.getBlock(aX, aY, aZ); + + if (!tReplacedBlock.isReplaceable(aWorld, aX, aY, aZ) + || !mBlock.canReplace(aWorld, aX, aY, aZ, ordinalSide, aStack)) { + return false; + } + + if (aStack.stackSize == 0 || (!aPlayer.canPlayerEdit(aX, aY, aZ, ordinalSide, aStack))) { + return false; + } + + final MultiTileEntityContainer MuTEContainer = mBlock.registry + .getNewTileEntityContainer(aWorld, aX, aY, aZ, aStack); + + if (MuTEContainer == null) return false; + + if (!aWorld.setBlock(aX, aY, aZ, MuTEContainer.block, 15 - MuTEContainer.blockMetaData, 2)) { + return false; + } + + MuTEContainer.setMultiTile(aWorld, aX, aY, aZ); + + try { + if (((IMultiTileEntity) MuT