From 3724fbbcb67ee2566419654e31eb88eb5b7f88f6 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Sat, 22 Jun 2024 15:36:54 +0800 Subject: Refactors --- .../api/metatileentity/BaseMetaPipeEntity.java | 16 +- .../api/metatileentity/BaseMetaTileEntity.java | 44 +- .../api/metatileentity/BaseTileEntity.java | 188 ++++---- .../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 +- .../gregtech/api/util/GT_StructureUtilityMuTE.java | 6 +- src/main/java/gregtech/api/util/GT_Util.java | 100 ++-- src/main/java/gregtech/api/util/GT_Utility.java | 10 + .../common/render/GT_MultiTile_Renderer.java | 23 +- .../automation/GT_MetaTileEntity_RecipeFilter.java | 6 +- .../tileentities/casings/upgrade/Ampere.java | 4 +- .../tileentities/casings/upgrade/Cleanroom.java | 4 +- .../tileentities/casings/upgrade/Inventory.java | 28 +- .../common/tileentities/casings/upgrade/Laser.java | 4 +- .../tileentities/casings/upgrade/Wireless.java | 4 +- .../tileentities/machines/multiblock/CokeOven.java | 6 +- .../machines/multiblock/DistillationTower.java | 8 +- .../preload/GT_Loader_MultiTileEntities.java | 42 +- 31 files changed, 1094 insertions(+), 1309 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') diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java index 1dc0e34d53..2bc560f8e7 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java @@ -116,22 +116,22 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity public BaseMetaPipeEntity() {} @Override - public void writeToNBT(NBTTagCompound aNBT) { + public void writeToNBT(NBTTagCompound nbt) { try { - super.writeToNBT(aNBT); + super.writeToNBT(nbt); } catch (Throwable e) { GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity", e); } try { - aNBT.setInteger("mID", mID); - writeCoverNBT(aNBT, false); - aNBT.setByte("mConnections", mConnections); - aNBT.setByte("mColor", mColor); - aNBT.setBoolean("mWorks", !mWorks); + nbt.setInteger("mID", mID); + writeCoverNBT(nbt, false); + nbt.setByte("mConnections", mConnections); + nbt.setByte("mColor", mColor); + nbt.setBoolean("mWorks", !mWorks); } catch (Throwable e) { GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity", e); } - saveMetaTileNBT(aNBT); + saveMetaTileNBT(nbt); } @Override diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index 386975dd6d..eb26cd7883 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -132,36 +132,36 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity public BaseMetaTileEntity() {} @Override - public void writeToNBT(NBTTagCompound aNBT) { + public void writeToNBT(NBTTagCompound nbt) { try { - super.writeToNBT(aNBT); + super.writeToNBT(nbt); } catch (Throwable e) { GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity.", e); } try { - aNBT.setInteger("mID", mID); - aNBT.setLong("mStoredSteam", mStoredSteam); - aNBT.setLong("mStoredEnergy", mStoredEnergy); - writeCoverNBT(aNBT, false); - aNBT.setByte("mColor", mColor); - aNBT.setByte("mLightValue", mLightValue); - aNBT.setByte("mOtherUpgrades", mOtherUpgrades); - aNBT.setByte("mWorkData", mWorkData); - aNBT.setShort("mFacing", (short) mFacing.ordinal()); - aNBT.setString("mOwnerName", mOwnerName); - aNBT.setString("mOwnerUuid", mOwnerUuid == null ? "" : mOwnerUuid.toString()); - aNBT.setBoolean("mLockUpgrade", mLockUpgrade); - aNBT.setBoolean("mMuffler", mMuffler); - aNBT.setBoolean("mSteamConverter", mSteamConverter); - aNBT.setBoolean("mActive", mActive); - aNBT.setBoolean("mWorks", !mWorks); - aNBT.setBoolean("mInputDisabled", mInputDisabled); - aNBT.setBoolean("mOutputDisabled", mOutputDisabled); - aNBT.setTag("GT.CraftingComponents", mRecipeStuff); + nbt.setInteger("mID", mID); + nbt.setLong("mStoredSteam", mStoredSteam); + nbt.setLong("mStoredEnergy", mStoredEnergy); + writeCoverNBT(nbt, false); + nbt.setByte("mColor", mColor); + nbt.setByte("mLightValue", mLightValue); + nbt.setByte("mOtherUpgrades", mOtherUpgrades); + nbt.setByte("mWorkData", mWorkData); + nbt.setShort("mFacing", (short) mFacing.ordinal()); + nbt.setString("mOwnerName", mOwnerName); + nbt.setString("mOwnerUuid", mOwnerUuid == null ? "" : mOwnerUuid.toString()); + nbt.setBoolean("mLockUpgrade", mLockUpgrade); + nbt.setBoolean("mMuffler", mMuffler); + nbt.setBoolean("mSteamConverter", mSteamConverter); + nbt.setBoolean("mActive", mActive); + nbt.setBoolean("mWorks", !mWorks); + nbt.setBoolean("mInputDisabled", mInputDisabled); + nbt.setBoolean("mOutputDisabled", mOutputDisabled); + nbt.setTag("GT.CraftingComponents", mRecipeStuff); } catch (Throwable e) { GT_FML_LOGGER.error("Encountered CRITICAL ERROR while saving MetaTileEntity.", e); } - saveMetaTileNBT(aNBT); + saveMetaTileNBT(nbt); } @Override diff --git a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java index d8b0086f0f..ac523eb82c 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java @@ -106,15 +106,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje private final ChunkCoordinates mReturnedCoordinates = new ChunkCoordinates(); - public static ForgeDirection getSideForPlayerPlacing(Entity aPlayer, ForgeDirection defaultFacing, + public static ForgeDirection getSideForPlayerPlacing(Entity player, ForgeDirection defaultFacing, boolean[] aAllowedFacings) { - if (aPlayer != null) { - if (aPlayer.rotationPitch >= 65 && aAllowedFacings[SIDE_UP]) return ForgeDirection.UP; - if (aPlayer.rotationPitch <= -65 && aAllowedFacings[SIDE_DOWN]) return ForgeDirection.DOWN; - final byte rFacing = COMPASS_DIRECTIONS[MathHelper.floor_double(0.5D + 4.0F * aPlayer.rotationYaw / 360.0F) - & 0x3]; - if (aAllowedFacings[rFacing]) return ForgeDirection.getOrientation(rFacing); - } + + final ForgeDirection facingFromPlayer = GT_Utility.getSideFromPlayerFacing(player); + if (facingFromPlayer != ForgeDirection.UNKNOWN && aAllowedFacings[facingFromPlayer.ordinal()]) + return facingFromPlayer; + for (final ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) if (aAllowedFacings[dir.ordinal()]) return dir; return defaultFacing; } @@ -160,18 +158,18 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final int getOffsetX(ForgeDirection side, int aMultiplier) { - return xCoord + side.offsetX * aMultiplier; + public final int getOffsetX(ForgeDirection side, int multiplier) { + return xCoord + side.offsetX * multiplier; } @Override - public final short getOffsetY(ForgeDirection side, int aMultiplier) { - return (short) (yCoord + side.offsetY * aMultiplier); + public final short getOffsetY(ForgeDirection side, int multiplier) { + return (short) (yCoord + side.offsetY * multiplier); } @Override - public final int getOffsetZ(ForgeDirection side, int aMultiplier) { - return zCoord + side.offsetZ * aMultiplier; + public final int getOffsetZ(ForgeDirection side, int multiplier) { + return zCoord + side.offsetZ * multiplier; } @Override @@ -194,15 +192,15 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje @Override @Deprecated - public final boolean openGUI(EntityPlayer aPlayer) { - return openGUI(aPlayer, 0); + public final boolean openGUI(EntityPlayer player) { + return openGUI(player, 0); } @Override @Deprecated - public final boolean openGUI(EntityPlayer aPlayer, int aID) { - if (aPlayer == null) return false; - aPlayer.openGui(GT, aID, worldObj, xCoord, yCoord, zCoord); + public final boolean openGUI(EntityPlayer player, int aID) { + if (player == null) return false; + player.openGui(GT, aID, worldObj, xCoord, yCoord, zCoord); return true; } @@ -218,8 +216,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final BiomeGenBase getBiome(int aX, int aZ) { - return worldObj.getBiomeGenForCoords(aX, aZ); + public final BiomeGenBase getBiome(int x, int z) { + return worldObj.getBiomeGenForCoords(x, z); } @Override @@ -228,8 +226,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final Block getBlockOffset(int aX, int aY, int aZ) { - return getBlock(xCoord + aX, yCoord + aY, zCoord + aZ); + public final Block getBlockOffset(int x, int y, int z) { + return getBlock(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -238,13 +236,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final Block getBlockAtSideAndDistance(ForgeDirection side, int aDistance) { - return getBlock(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final Block getBlockAtSideAndDistance(ForgeDirection side, int distance) { + return getBlock(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final byte getMetaIDOffset(int aX, int aY, int aZ) { - return getMetaID(xCoord + aX, yCoord + aY, zCoord + aZ); + public final byte getMetaIDOffset(int x, int y, int z) { + return getMetaID(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -253,13 +251,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final byte getMetaIDAtSideAndDistance(ForgeDirection side, int aDistance) { - return getMetaID(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final byte getMetaIDAtSideAndDistance(ForgeDirection side, int distance) { + return getMetaID(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final byte getLightLevelOffset(int aX, int aY, int aZ) { - return getLightLevel(xCoord + aX, yCoord + aY, zCoord + aZ); + public final byte getLightLevelOffset(int x, int y, int z) { + return getLightLevel(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -268,13 +266,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final byte getLightLevelAtSideAndDistance(ForgeDirection side, int aDistance) { - return getLightLevel(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final byte getLightLevelAtSideAndDistance(ForgeDirection side, int distance) { + return getLightLevel(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final boolean getOpacityOffset(int aX, int aY, int aZ) { - return getOpacity(xCoord + aX, yCoord + aY, zCoord + aZ); + public final boolean getOpacityOffset(int x, int y, int z) { + return getOpacity(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -283,13 +281,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getOpacityAtSideAndDistance(ForgeDirection side, int aDistance) { - return getOpacity(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final boolean getOpacityAtSideAndDistance(ForgeDirection side, int distance) { + return getOpacity(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final boolean getSkyOffset(int aX, int aY, int aZ) { - return getSky(xCoord + aX, yCoord + aY, zCoord + aZ); + public final boolean getSkyOffset(int x, int y, int z) { + return getSky(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -298,13 +296,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getSkyAtSideAndDistance(ForgeDirection side, int aDistance) { - return getSky(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final boolean getSkyAtSideAndDistance(ForgeDirection side, int distance) { + return getSky(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final boolean getAirOffset(int aX, int aY, int aZ) { - return getAir(xCoord + aX, yCoord + aY, zCoord + aZ); + public final boolean getAirOffset(int x, int y, int z) { + return getAir(xCoord + x, yCoord + y, zCoord + z); } @Override @@ -313,31 +311,31 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getAirAtSideAndDistance(ForgeDirection side, int aDistance) { - return getAir(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final boolean getAirAtSideAndDistance(ForgeDirection side, int distance) { + return getAir(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final TileEntity getTileEntityOffset(int aX, int aY, int aZ) { - return getTileEntity(xCoord + aX, yCoord + aY, zCoord + aZ); + public final TileEntity getTileEntityOffset(int x, int y, int z) { + return getTileEntity(xCoord + x, yCoord + y, zCoord + z); } @Override - public final TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int aDistance) { - if (aDistance == 1) return getTileEntityAtSide(side); - return getTileEntity(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); + public final TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int distance) { + if (distance == 1) return getTileEntityAtSide(side); + return getTileEntity(getOffsetX(side, distance), getOffsetY(side, distance), getOffsetZ(side, distance)); } @Override - public final IInventory getIInventory(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntity(aX, aY, aZ); + public final IInventory getIInventory(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntity(x, y, z); if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity; return null; } @Override - public final IInventory getIInventoryOffset(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ); + public final IInventory getIInventoryOffset(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntityOffset(x, y, z); if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity; return null; } @@ -350,22 +348,22 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); + public final IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int distance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance); if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity; return null; } @Override - public final IFluidHandler getITankContainer(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntity(aX, aY, aZ); + public final IFluidHandler getITankContainer(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntity(x, y, z); if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity; return null; } @Override - public final IFluidHandler getITankContainerOffset(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ); + public final IFluidHandler getITankContainerOffset(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntityOffset(x, y, z); if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity; return null; } @@ -378,22 +376,22 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); + public final IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int distance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance); if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity; return null; } @Override - public final IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntity(aX, aY, aZ); + public final IGregTechTileEntity getIGregTechTileEntity(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntity(x, y, z); if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity; return null; } @Override - public final IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ) { - final TileEntity tTileEntity = getTileEntityOffset(aX, aY, aZ); + public final IGregTechTileEntity getIGregTechTileEntityOffset(int x, int y, int z) { + final TileEntity tTileEntity = getTileEntityOffset(x, y, z); if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity; return null; } @@ -406,16 +404,16 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); + public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int distance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, distance); if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity; return null; } @Override - public final Block getBlock(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return Blocks.air; - return worldObj.getBlock(aX, aY, aZ); + public final Block getBlock(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return Blocks.air; + return worldObj.getBlock(x, y, z); } public Block getBlock(ChunkCoordinates aCoords) { @@ -426,39 +424,39 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final byte getMetaID(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return 0; - return (byte) worldObj.getBlockMetadata(aX, aY, aZ); + public final byte getMetaID(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return 0; + return (byte) worldObj.getBlockMetadata(x, y, z); } @Override - public final byte getLightLevel(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return 0; - return (byte) (worldObj.getLightBrightness(aX, aY, aZ) * 15); + public final byte getLightLevel(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return 0; + return (byte) (worldObj.getLightBrightness(x, y, z) * 15); } @Override - public final boolean getSky(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return true; - return worldObj.canBlockSeeTheSky(aX, aY, aZ); + public final boolean getSky(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return true; + return worldObj.canBlockSeeTheSky(x, y, z); } @Override - public final boolean getOpacity(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return false; - return GT_Utility.isOpaqueBlock(worldObj, aX, aY, aZ); + public final boolean getOpacity(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return false; + return GT_Utility.isOpaqueBlock(worldObj, x, y, z); } @Override - public final boolean getAir(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return true; - return GT_Utility.isBlockAir(worldObj, aX, aY, aZ); + public final boolean getAir(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return true; + return GT_Utility.isBlockAir(worldObj, x, y, z); } @Override - public TileEntity getTileEntity(int aX, int aY, int aZ) { - if (ignoreUnloadedChunks && crossedChunkBorder(aX, aZ) && !worldObj.blockExists(aX, aY, aZ)) return null; - return worldObj.getTileEntity(aX, aY, aZ); + public TileEntity getTileEntity(int x, int y, int z) { + if (ignoreUnloadedChunks && crossedChunkBorder(x, z) && !worldObj.blockExists(x, y, z)) return null; + return worldObj.getTileEntity(x, y, z); } @Override @@ -492,8 +490,8 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public void writeToNBT(NBTTagCompound aNBT) { - super.writeToNBT(aNBT); + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); } @Override @@ -567,12 +565,12 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje zCoord); } - protected boolean crossedChunkBorder(int aX, int aZ) { - return aX >> 4 != xCoord >> 4 || aZ >> 4 != zCoord >> 4; + protected boolean crossedChunkBorder(int x, int z) { + return x >> 4 != xCoord >> 4 || z >> 4 != zCoord >> 4; } - public final boolean crossedChunkBorder(ChunkCoordinates aCoords) { - return aCoords.posX >> 4 != xCoord >> 4 || aCoords.posZ >> 4 != zCoord >> 4; + public final boolean crossedChunkBorder(ChunkCoordinates coords) { + return coords.posX >> 4 != xCoord >> 4 || coords.posZ >> 4 != zCoord >> 4; } public final void setOnFire() { 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.setCover