diff options
Diffstat (limited to 'src/main/java/gregtech/api')
115 files changed, 3511 insertions, 3480 deletions
diff --git a/src/main/java/gregtech/api/events/BlockScanningEvent.java b/src/main/java/gregtech/api/events/BlockScanningEvent.java index 27eb375a6f..bc2a33bcea 100644 --- a/src/main/java/gregtech/api/events/BlockScanningEvent.java +++ b/src/main/java/gregtech/api/events/BlockScanningEvent.java @@ -6,6 +6,7 @@ import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.event.world.WorldEvent; import cpw.mods.fml.common.eventhandler.Cancelable; @@ -16,7 +17,7 @@ public class BlockScanningEvent extends WorldEvent { public final EntityPlayer mPlayer; public final int mX, mY, mZ, mScanLevel; public final ArrayList<String> mList; - public final byte mSide; + public final ForgeDirection mSide; public final float mClickX, mClickY, mClickZ; public final TileEntity mTileEntity; public final Block mBlock; @@ -26,15 +27,16 @@ public class BlockScanningEvent extends WorldEvent { */ public int mEUCost = 0; - public BlockScanningEvent(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, byte aSide, int aScanLevel, - Block aBlock, TileEntity aTileEntity, ArrayList<String> aList, float aClickX, float aClickY, float aClickZ) { + public BlockScanningEvent(World aWorld, EntityPlayer aPlayer, int aX, int aY, int aZ, ForgeDirection side, + int aScanLevel, Block aBlock, TileEntity aTileEntity, ArrayList<String> aList, float aClickX, float aClickY, + float aClickZ) { super(aWorld); mPlayer = aPlayer; mScanLevel = aScanLevel; mTileEntity = aTileEntity; mBlock = aBlock; mList = aList; - mSide = aSide; + mSide = side; mX = aX; mY = aY; mZ = aZ; diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java index bbdfa40a10..7289f0faad 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java @@ -1,12 +1,12 @@ package gregtech.api.graphs; import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; -import static gregtech.api.util.GT_Utility.getOppositeSide; import java.util.ArrayList; import java.util.HashSet; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.graphs.consumers.ConsumerNode; import gregtech.api.graphs.paths.NodePath; @@ -42,17 +42,17 @@ public abstract class GenerateNodeMap { // get how many connections the pipe have private static int getNumberOfConnections(MetaPipeEntity aPipe) { int tCons = 0; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (aPipe.isConnectedAtSide(side)) tCons++; } return tCons; } // gets the next node - protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, byte aInvalidSide, int aNextNodeValue, - ArrayList<ConsumerNode> tConsumers, HashSet<Node> tNodeMap) { + protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, ForgeDirection aInvalidSide, + int aNextNodeValue, ArrayList<ConsumerNode> tConsumers, HashSet<Node> tNodeMap) { final MetaPipeEntity tMetaPipe = (MetaPipeEntity) aPipe.getMetaTileEntity(); - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side == aInvalidSide) { continue; } @@ -70,12 +70,13 @@ public abstract class GenerateNodeMap { tConsumers, tNodeMap); if (tNextNode != null) { + final int i = side.ordinal(); aNextNodeValue = tNextNode.mHighestNodeValue; aPipeNode.mHighestNodeValue = tNextNode.mHighestNodeValue; - aPipeNode.mNeighbourNodes[side] = tNextNode; - aPipeNode.mNodePaths[side] = aPipeNode.returnValues.mReturnPath; - aPipeNode.locks[side] = aPipeNode.returnValues.returnLock; - aPipeNode.mNodePaths[side].reloadLocks(); + aPipeNode.mNeighbourNodes[i] = tNextNode; + aPipeNode.mNodePaths[i] = aPipeNode.returnValues.mReturnPath; + aPipeNode.locks[i] = aPipeNode.returnValues.returnLock; + aPipeNode.mNodePaths[i].reloadLocks(); } } } @@ -84,10 +85,11 @@ public abstract class GenerateNodeMap { // on a valid tile entity create a new node protected Node generateNode(TileEntity aTileEntity, Node aPreviousNode, int aNextNodeValue, - ArrayList<MetaPipeEntity> aPipes, int aSide, ArrayList<ConsumerNode> aConsumers, HashSet<Node> aNodeMap) { + ArrayList<MetaPipeEntity> aPipes, ForgeDirection side, ArrayList<ConsumerNode> aConsumers, + HashSet<Node> aNodeMap) { if (aTileEntity.isInvalid()) return null; - final byte tSideOp = getOppositeSide(aSide); - final byte tInvalidSide = aPreviousNode == null ? -1 : tSideOp; + final ForgeDirection oppositeSide = side.getOpposite(); + final ForgeDirection tInvalidSide = aPreviousNode == null ? ForgeDirection.UNKNOWN : oppositeSide; Node tThisNode = null; if (isPipe(aTileEntity)) { final BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; @@ -95,33 +97,35 @@ public abstract class GenerateNodeMap { final int tConnections = getNumberOfConnections(tMetaPipe); final Node tPipeNode; if (tConnections == 1) { - tPipeNode = getEmptyNode(aNextNodeValue, tSideOp, aTileEntity, aConsumers); + tPipeNode = getEmptyNode(aNextNodeValue, oppositeSide, aTileEntity, aConsumers); if (tPipeNode == null) return null; } else { - tPipeNode = getPipeNode(aNextNodeValue, tSideOp, aTileEntity, aConsumers); + tPipeNode = getPipeNode(aNextNodeValue, oppositeSide, aTileEntity, aConsumers); } tPipe.setNode(tPipeNode); aNodeMap.add(tPipeNode); tPipeNode.mSelfPath = getNewPath(new MetaPipeEntity[] { tMetaPipe }); tThisNode = tPipeNode; - if (tInvalidSide > -1) { - tPipeNode.mNeighbourNodes[tInvalidSide] = aPreviousNode; - tPipeNode.mNodePaths[tInvalidSide] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + if (tInvalidSide != ForgeDirection.UNKNOWN) { + final int iInvalid = tInvalidSide.ordinal(); + tPipeNode.mNeighbourNodes[iInvalid] = aPreviousNode; + tPipeNode.mNodePaths[iInvalid] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); final Lock lock = new Lock(); - tPipeNode.mNodePaths[tSideOp].lock = lock; - tPipeNode.locks[tInvalidSide] = lock; - aPreviousNode.returnValues.mReturnPath = tPipeNode.mNodePaths[tInvalidSide]; + tPipeNode.mNodePaths[oppositeSide.ordinal()].lock = lock; + tPipeNode.locks[iInvalid] = lock; + aPreviousNode.returnValues.mReturnPath = tPipeNode.mNodePaths[iInvalid]; aPreviousNode.returnValues.returnLock = lock; } if (tConnections > 1) generateNextNode(tPipe, tPipeNode, tInvalidSide, aNextNodeValue, aConsumers, aNodeMap); - } else if (addConsumer(aTileEntity, tSideOp, aNextNodeValue, aConsumers)) { + } else if (addConsumer(aTileEntity, oppositeSide, aNextNodeValue, aConsumers)) { + final int oppositeSideOrdinal = oppositeSide.ordinal(); final ConsumerNode tConsumeNode = aConsumers.get(aConsumers.size() - 1); - tConsumeNode.mNeighbourNodes[tSideOp] = aPreviousNode; - tConsumeNode.mNodePaths[tSideOp] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + tConsumeNode.mNeighbourNodes[oppositeSideOrdinal] = aPreviousNode; + tConsumeNode.mNodePaths[oppositeSideOrdinal] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); final Lock lock = new Lock(); - tConsumeNode.mNodePaths[tSideOp].lock = lock; - aPreviousNode.returnValues.mReturnPath = tConsumeNode.mNodePaths[tSideOp]; + tConsumeNode.mNodePaths[oppositeSideOrdinal].lock = lock; + aPreviousNode.returnValues.mReturnPath = tConsumeNode.mNodePaths[oppositeSideOrdinal]; aPreviousNode.returnValues.returnLock = lock; tThisNode = tConsumeNode; } @@ -129,7 +133,7 @@ public abstract class GenerateNodeMap { } // go over the pipes until we see a valid tile entity that needs a node - protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList<MetaPipeEntity> aPipes, byte aSide, + protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList<MetaPipeEntity> aPipes, ForgeDirection side, HashSet<Node> aNodeMap) { if (isPipe(aTileEntity)) { final BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; @@ -140,23 +144,23 @@ public abstract class GenerateNodeMap { } final int tConnections = getNumberOfConnections(tMetaPipe); if (tConnections == 2) { - final byte tSideOp = getOppositeSide(aSide); - for (byte i : ALL_VALID_SIDES) { - if (i == tSideOp || !(tMetaPipe.isConnectedAtSide(i))) continue; - final TileEntity tNewTileEntity = tPipe.getTileEntityAtSide(i); + final ForgeDirection tSideOp = side.getOpposite(); + for (final ForgeDirection s : ForgeDirection.VALID_DIRECTIONS) { + if (s == tSideOp || !(tMetaPipe.isConnectedAtSide(s))) continue; + final TileEntity tNewTileEntity = tPipe.getTileEntityAtSide(s); if (tNewTileEntity == null) continue; if (isPipe(tNewTileEntity)) { aPipes.add(tMetaPipe); - return getNextValidTileEntity(tNewTileEntity, aPipes, i, aNodeMap); + return getNextValidTileEntity(tNewTileEntity, aPipes, s, aNodeMap); } else { - return new Pair(aTileEntity, i); + return new Pair(aTileEntity, s); } } } else { - return new Pair(aTileEntity, aSide); + return new Pair(aTileEntity, side); } } else { - return new Pair(aTileEntity, aSide); + return new Pair(aTileEntity, side); } return null; } @@ -167,31 +171,32 @@ public abstract class GenerateNodeMap { } // checks if the tile entity is a consumer and add to the list - protected abstract boolean addConsumer(TileEntity aTileEntity, byte aSide, int aNodeValue, + protected abstract boolean addConsumer(TileEntity aTileEntity, ForgeDirection side, int aNodeValue, ArrayList<ConsumerNode> aConsumers); // get correct pathClass that you need for your node network protected abstract NodePath getNewPath(MetaPipeEntity[] aPipes); // used for if you need to use dead ends for something can be null - protected Node getEmptyNode(int aNodeValue, byte aSide, TileEntity aTileEntity, + protected Node getEmptyNode(int aNodeValue, ForgeDirection side, TileEntity aTileEntity, ArrayList<ConsumerNode> aConsumers) { return null; } // get correct node type you need for your network - protected Node getPipeNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList<ConsumerNode> aConsumers) { + protected Node getPipeNode(int aNodeValue, ForgeDirection side, TileEntity aTileEntity, + ArrayList<ConsumerNode> aConsumers) { return new Node(aNodeValue, aTileEntity, aConsumers); } private static class Pair { - public byte mSide; + public ForgeDirection mSide; public TileEntity mTileEntity; - public Pair(TileEntity aTileEntity, byte aSide) { + public Pair(TileEntity aTileEntity, ForgeDirection side) { this.mTileEntity = aTileEntity; - this.mSide = aSide; + this.mSide = side; } } } diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java index f2a2e95df8..95f9aee32d 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java @@ -27,7 +27,7 @@ import ic2.api.energy.tile.IEnergySink; public class GenerateNodeMapPower extends GenerateNodeMap { public GenerateNodeMapPower(BaseMetaPipeEntity aTileEntity) { - generateNode(aTileEntity, null, 1, null, -1, new ArrayList<>(), new HashSet<>()); + generateNode(aTileEntity, null, 1, null, ForgeDirection.UNKNOWN, new ArrayList<>(), new HashSet<>()); } @Override @@ -37,27 +37,27 @@ public class GenerateNodeMapPower extends GenerateNodeMap { } @Override - protected boolean addConsumer(TileEntity aTileEntity, byte aSide, int aNodeValue, + protected boolean addConsumer(TileEntity aTileEntity, ForgeDirection side, int aNodeValue, ArrayList<ConsumerNode> aConsumers) { if (aTileEntity instanceof BaseMetaTileEntity tBaseTileEntity) { - if (tBaseTileEntity.inputEnergyFrom(aSide, false)) { - ConsumerNode tConsumerNode = new NodeGTBaseMetaTile(aNodeValue, tBaseTileEntity, aSide, aConsumers); + if (tBaseTileEntity.inputEnergyFrom(side, false)) { + ConsumerNode tConsumerNode = new NodeGTBaseMetaTile(aNodeValue, tBaseTileEntity, side, aConsumers); aConsumers.add(tConsumerNode); return true; } } else if (aTileEntity instanceof IEnergyConnected tTileEntity) { - if (tTileEntity.inputEnergyFrom(aSide, false)) { - ConsumerNode tConsumerNode = new NodeEnergyConnected(aNodeValue, tTileEntity, aSide, aConsumers); + if (tTileEntity.inputEnergyFrom(side, false)) { + ConsumerNode tConsumerNode = new NodeEnergyConnected(aNodeValue, tTileEntity, side, aConsumers); aConsumers.add(tConsumerNode); return true; } - } else if (aTileEntity instanceof IEnergySink) { + } else if (aTileEntity instanceof IEnergySink sink) { // ic2 wants the tilentity next to it of that side not going to add a bunch of arguments just for ic2 // crossborder checks to not load chuncks just to make sure - int dX = aTileEntity.xCoord + ForgeDirection.getOrientation(aSide).offsetX; - int dY = aTileEntity.yCoord + ForgeDirection.getOrientation(aSide).offsetY; - int dZ = aTileEntity.zCoord + ForgeDirection.getOrientation(aSide).offsetZ; + int dX = aTileEntity.xCoord + side.offsetX; + int dY = aTileEntity.yCoord + side.offsetY; + int dZ = aTileEntity.zCoord + side.offsetZ; boolean crossesChuncks = dX >> 4 != aTileEntity.xCoord >> 4 || dZ >> 4 != aTileEntity.zCoord >> 4; TileEntity tNextTo = null; if (!crossesChuncks || !aTileEntity.getWorldObj() @@ -65,21 +65,17 @@ public class GenerateNodeMapPower extends GenerateNodeMap { tNextTo = aTileEntity.getWorldObj() .getTileEntity(dX, dY, dZ); - if (((IEnergySink) aTileEntity).acceptsEnergyFrom(tNextTo, ForgeDirection.getOrientation(aSide))) { + if (sink.acceptsEnergyFrom(tNextTo, side)) { ConsumerNode tConsumerNode = new NodeEnergySink( aNodeValue, (IEnergySink) aTileEntity, - aSide, + side, aConsumers); aConsumers.add(tConsumerNode); return true; } - } else if (GregTech_API.mOutputRF && aTileEntity instanceof IEnergyReceiver) { - ConsumerNode tConsumerNode = new NodeEnergyReceiver( - aNodeValue, - (IEnergyReceiver) aTileEntity, - aSide, - aConsumers); + } else if (GregTech_API.mOutputRF && aTileEntity instanceof IEnergyReceiver receiver) { + ConsumerNode tConsumerNode = new NodeEnergyReceiver(aNodeValue, receiver, side, aConsumers); aConsumers.add(tConsumerNode); return true; } @@ -93,15 +89,16 @@ public class GenerateNodeMapPower extends GenerateNodeMap { // used to apply voltage on dead ends @Override - protected Node getEmptyNode(int aNodeValue, byte aSide, TileEntity aTileEntity, + protected Node getEmptyNode(int aNodeValue, ForgeDirection side, TileEntity aTileEntity, ArrayList<ConsumerNode> aConsumers) { - ConsumerNode tNode = new EmptyPowerConsumer(aNodeValue, aTileEntity, aSide, aConsumers); + ConsumerNode tNode = new EmptyPowerConsumer(aNodeValue, aTileEntity, side, aConsumers); aConsumers.add(tNode); return tNode; } @Override - protected Node getPipeNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList<ConsumerNode> aConsumers) { + protected Node getPipeNode(int aNodeValue, ForgeDirection side, TileEntity aTileEntity, + ArrayList<ConsumerNode> aConsumers) { return new PowerNode(aNodeValue, aTileEntity, aConsumers); } } diff --git a/src/main/java/gregtech/api/graphs/PowerNodes.java b/src/main/java/gregtech/api/graphs/PowerNodes.java index be94d2312a..98d35e2971 100644 --- a/src/main/java/gregtech/api/graphs/PowerNodes.java +++ b/src/main/java/gregtech/api/graphs/PowerNodes.java @@ -120,13 +120,13 @@ public class PowerNodes { return tAmpsUsed; } - protected static long processNextNode(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int aSide, + protected static long processNextNode(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int ordinalSide, long aMaxAmps, long aVoltage) { - if (aCurrentNode.locks[aSide].isLocked()) { + if (aCurrentNode.locks[ordinalSide].isLocked()) { aConsumers.getNextNode(); return 0; } - final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[aSide]; + final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[ordinalSide]; final PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; long tVoltLoss = 0; if (tSelfPath != null) { @@ -141,13 +141,13 @@ public class PowerNodes { return tAmps; } - protected static long processNextNodeAbove(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int aSide, + protected static long processNextNodeAbove(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int ordinalSide, long aMaxAmps, long aVoltage) { - if (aCurrentNode.locks[aSide].isLocked()) { + if (aCurrentNode.locks[ordinalSide].isLocked()) { aConsumers.getNextNode(); return 0; } - final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[aSide]; + final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[ordinalSide]; final PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; long tVoltLoss = 0; if (tSelfPath != null) { @@ -162,10 +162,10 @@ public class PowerNodes { return tAmps; } - protected static long processNodeInject(Node aCurrentNode, ConsumerNode aConsumer, int aSide, long aMaxAmps, + protected static long processNodeInject(Node aCurrentNode, ConsumerNode aConsumer, int ordinalSide, long aMaxAmps, long aVoltage) { - if (aCurrentNode.locks[aSide].isLocked()) return 0; - final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[aSide]; + if (aCurrentNode.locks[ordinalSide].isLocked()) return 0; + final PowerNodePath tPath = (PowerNodePath) aCurrentNode.mNodePaths[ordinalSide]; final PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; long tVoltLoss = 0; if (tSelfPath != null) { diff --git a/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java b/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java index f82798f09b..04d7ebbe5a 100644 --- a/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java +++ b/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java @@ -3,17 +3,19 @@ package gregtech.api.graphs.consumers; import java.util.ArrayList; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.graphs.Node; // node attached to a tile entity that can consume stuff from the network public class ConsumerNode extends Node { - public byte mSide; + public ForgeDirection mSide; - public ConsumerNode(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList<ConsumerNode> aConsumers) { + public ConsumerNode(int aNodeValue, TileEntity aTileEntity, ForgeDirection side, + ArrayList<ConsumerNode> aConsumers) { super(aNodeValue, aTileEntity, aConsumers); - this.mSide = aSide; + this.mSide = side; } public boolean needsEnergy() { diff --git a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java index 6507d0f8e4..48cf330bdb 100644 --- a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java +++ b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java @@ -3,6 +3,7 @@ package gregtech.api.graphs.consumers; import java.util.ArrayList; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.graphs.paths.PowerNodePath; import gregtech.api.metatileentity.BaseMetaPipeEntity; @@ -10,8 +11,9 @@ import gregtech.api.metatileentity.BaseMetaPipeEntity; // this is here to apply voltage to dead ends public class EmptyPowerConsumer extends ConsumerNode { - public EmptyPowerConsumer(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList<ConsumerNode> aConsumers) { - super(aNodeValue, aTileEntity, aSide, aConsumers); + public EmptyPowerConsumer(int aNodeValue, TileEntity aTileEntity, ForgeDirection side, + ArrayList<ConsumerNode> aConsumers) { + super(aNodeValue, aTileEntity, side, aConsumers); } @Override diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyConnected.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyConnected.java index 65dd50f9df..6daeae8c9c 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyConnected.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyConnected.java @@ -3,14 +3,15 @@ package gregtech.api.graphs.consumers; import java.util.ArrayList; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.interfaces.tileentity.IEnergyConnected; public class NodeEnergyConnected extends ConsumerNode { - public NodeEnergyConnected(int aNodeValue, IEnergyConnected aTileEntity, byte aSide, + public NodeEnergyConnected(int aNodeValue, IEnergyConnected aTileEntity, ForgeDirection side, ArrayList<ConsumerNode> aConsumers) { - super(aNodeValue, (TileEntity) aTileEntity, aSide, aConsumers); + super(aNodeValue, (TileEntity) aTileEntity, side, aConsumers); } @Override diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java index 4e84b04e2a..4f35922029 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java @@ -21,14 +21,14 @@ public class NodeEnergyReceiver extends ConsumerNode { int mRestRF = 0; - public NodeEnergyReceiver(int aNodeValue, IEnergyReceiver aTileEntity, byte aSide, + public NodeEnergyReceiver(int aNodeValue, IEnergyReceiver aTileEntity, ForgeDirection side, ArrayList<ConsumerNode> aConsumers) { - super(aNodeValue, (TileEntity) aTileEntity, aSide, aConsumers); + super(aNodeValue, (TileEntity) aTileEntity, side, aConsumers); } @Override public int injectEnergy(long aVoltage, long aMaxAmps) { - ForgeDirection tDirection = ForgeDirection.getOrientation(mSide); + ForgeDirection tDirection = mSide; int rfOut = GT_Utility.safeInt(aVoltage * GregTech_API.mEUtoRF / 100); int ampsUsed = 0; if (mRestRF < rfOut) { diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java index d978a99d0b..44fb88e5e8 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java @@ -10,7 +10,8 @@ import ic2.api.energy.tile.IEnergySink; // consumer for IC2 machines public class NodeEnergySink extends ConsumerNode { - public NodeEnergySink(int nodeValue, IEnergySink tileEntity, byte side, ArrayList<ConsumerNode> consumers) { + public NodeEnergySink(int nodeValue, IEnergySink tileEntity, ForgeDirection side, + ArrayList<ConsumerNode> consumers) { super(nodeValue, (TileEntity) tileEntity, side, consumers); } @@ -23,9 +24,7 @@ public class NodeEnergySink extends ConsumerNode { public int injectEnergy(long aVoltage, long aMaxAmps) { int tUsedAmps = 0; while (aMaxAmps > tUsedAmps && ((IEnergySink) mTileEntity).getDemandedEnergy() > 0 - && ((IEnergySink) mTileEntity).injectEnergy(ForgeDirection.getOrientation(mSide), aVoltage, aVoltage) - < aVoltage) - tUsedAmps++; + && ((IEnergySink) mTileEntity).injectEnergy(mSide, aVoltage, aVoltage) < aVoltage) tUsedAmps++; return tUsedAmps; } } diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java b/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java index ec75468db5..e8d8304eb3 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java @@ -2,15 +2,17 @@ package gregtech.api.graphs.consumers; import java.util.ArrayList; +import net.minecraftforge.common.util.ForgeDirection; + import gregtech.api.interfaces.tileentity.IEnergyConnected; import gregtech.api.metatileentity.BaseMetaTileEntity; // consumer for gt machines public class NodeGTBaseMetaTile extends ConsumerNode { - public NodeGTBaseMetaTile(int aNodeValue, BaseMetaTileEntity aTileEntity, byte aSide, + public NodeGTBaseMetaTile(int aNodeValue, BaseMetaTileEntity aTileEntity, ForgeDirection side, ArrayList<ConsumerNode> aConsumers) { - super(aNodeValue, aTileEntity, aSide, aConsumers); + super(aNodeValue, aTileEntity, side, aConsumers); } @Override diff --git a/src/main/java/gregtech/api/gui/modularui/GT_CoverUIBuildContext.java b/src/main/java/gregtech/api/gui/modularui/GT_CoverUIBuildContext.java index 62a933cfa6..20586b9c48 100644 --- a/src/main/java/gregtech/api/gui/modularui/GT_CoverUIBuildContext.java +++ b/src/main/java/gregtech/api/gui/modularui/GT_CoverUIBuildContext.java @@ -1,6 +1,7 @@ package gregtech.api.gui.modularui; import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; import gregtech.api.interfaces.tileentity.ICoverable; @@ -9,7 +10,7 @@ public class GT_CoverUIBuildContext extends UIBuildContext { // cover data is not synced to client, while ID is private final int coverID; - private final byte side; + private final ForgeDirection side; private final ICoverable tile; private final boolean anotherWindow; private final int guiColorization; @@ -22,8 +23,8 @@ public class GT_CoverUIBuildContext extends UIBuildContext { * @param anotherWindow If cover UI is shown on top of another window * @param guiColorization The color used to render machine's GUI */ - public GT_CoverUIBuildContext(EntityPlayer player, int coverID, byte side, ICoverable tile, boolean anotherWindow, - int guiColorization) { + public GT_CoverUIBuildContext(EntityPlayer player, int coverID, ForgeDirection side, ICoverable tile, + boolean anotherWindow, int guiColorization) { super(player); this.coverID = coverID; this.side = side; @@ -39,7 +40,8 @@ public class GT_CoverUIBuildContext extends UIBuildContext { * @param tile Tile this cover is attached to * @param anotherWindow If cover GUI is shown in opened on top of another window */ - public GT_CoverUIBuildContext(EntityPlayer player, int coverID, byte side, ICoverable tile, boolean anotherWindow) { + public GT_CoverUIBuildContext(EntityPlayer player, int coverID, ForgeDirection side, ICoverable tile, + boolean anotherWindow) { this(player, coverID, side, tile, anotherWindow, tile.getGUIColorization()); } @@ -47,7 +49,7 @@ public class GT_CoverUIBuildContext extends UIBuildContext { return coverID; } - public byte getCoverSide() { + public ForgeDirection getCoverSide() { return side; } diff --git a/src/main/java/gregtech/api/gui/modularui/GT_UIInfos.java b/src/main/java/gregtech/api/gui/modularui/GT_UIInfos.java index b132f33d63..afa60e5583 100644 --- a/src/main/java/gregtech/api/gui/modularui/GT_UIInfos.java +++ b/src/main/java/gregtech/api/gui/modularui/GT_UIInfos.java @@ -40,23 +40,16 @@ public class GT_UIInfos { .of() .container((player, world, x, y, z) -> { TileEntity te = world.getTileEntity(x, y, z); - if (te instanceof ITileWithModularUI) { - return createTileEntityContainer( - player, - ((ITileWithModularUI) te)::createWindow, - te::markDirty, - containerConstructor); + if (te instanceof ITileWithModularUI mui) { + return createTileEntityContainer(player, mui::createWindow, te::markDirty, containerConstructor); } return null; }) .gui(((player, world, x, y, z) -> { if (!world.isRemote) return null; TileEntity te = world.getTileEntity(x, y, z); - if (te instanceof ITileWithModularUI) { - return createTileEntityGuiContainer( - player, - ((ITileWithModularUI) te)::createWindow, - containerConstructor); + if (te instanceof ITileWithModularUI mui) { + return createTileEntityGuiContainer(player, mui::createWindow, containerConstructor); } return null; })) @@ -64,18 +57,17 @@ public class GT_UIInfos { private static final UIInfo<?, ?> GTTileEntityDefaultUI = GTTileEntityUIFactory.apply(ModularUIContainer::new); - private static final Map<Byte, UIInfo<?, ?>> coverUI = new HashMap<>(); + private static final Map<ForgeDirection, UIInfo<?, ?>> coverUI = new HashMap<>(); static { - for (byte i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { - final byte side = i; + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { coverUI.put( side, UIBuilder.of() .container((player, world, x, y, z) -> { final TileEntity te = world.getTileEntity(x, y, z); if (!(te instanceof ICoverable gtTileEntity)) return null; - GT_CoverBehaviorBase<?> cover = gtTileEntity.getCoverBehaviorAtSideNew(side); + final GT_CoverBehaviorBase<?> cover = gtTileEntity.getCoverBehaviorAtSideNew(side); return createCoverContainer( player, cover::createWindow, @@ -116,7 +108,7 @@ public class GT_UIInfos { /** * Opens cover UI, created by {@link GT_CoverBehaviorBase#createWindow}. */ - public static void openCoverUI(ICoverable tileEntity, EntityPlayer player, byte side) { + public static void openCoverUI(ICoverable tileEntity, EntityPlayer player, ForgeDirection side) { if (tileEntity.isClientSide()) return; GT_Values.NW.sendToPlayer( @@ -167,8 +159,8 @@ public class GT_UIInfos { } private static ModularUIContainer createCoverContainer(EntityPlayer player, - Function<GT_CoverUIBuildContext, ModularWindow> windowCreator, Runnable onWidgetUpdate, int coverID, byte side, - ICoverable tile) { + Function<GT_CoverUIBuildContext, ModularWindow> windowCreator, Runnable onWidgetUpdate, int coverID, + ForgeDirection side, ICoverable tile) { final GT_CoverUIBuildContext buildContext = new GT_CoverUIBuildContext(player, coverID, side, tile, false); final ModularWindow window = windowCreator.apply(buildContext); if (window == null) return null; @@ -177,7 +169,8 @@ public class GT_UIInfos { @SideOnly(Side.CLIENT) private static ModularGui createCoverGuiContainer(EntityPlayer player, - Function<GT_CoverUIBuildContext, ModularWindow> windowCreator, int coverID, byte side, ICoverable tile) { + Function<GT_CoverUIBuildContext, ModularWindow> windowCreator, int coverID, ForgeDirection side, + ICoverable tile) { final ModularUIContainer container = createCoverContainer(player, windowCreator, null, coverID, side, tile); if (container == null) { return null; diff --git a/src/main/java/gregtech/api/gui/widgets/GT_GuiCoverTabLine.java b/src/main/java/gregtech/api/gui/widgets/GT_GuiCoverTabLine.java index 9694316bee..890e6298c9 100644 --- a/src/main/java/gregtech/api/gui/widgets/GT_GuiCoverTabLine.java +++ b/src/main/java/gregtech/api/gui/widgets/GT_GuiCoverTabLine.java @@ -8,6 +8,7 @@ import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.StatCollector; +import net.minecraftforge.common.util.ForgeDirection; import org.lwjgl.opengl.GL11; @@ -66,10 +67,10 @@ public class GT_GuiCoverTabLine extends GT_GuiTabLine { * Add a tab for each existing cover on this IGregTechTileEntity at creation time */ private void setupTabs() { - for (byte tSide = 0; tSide < 6; tSide++) { - final ItemStack cover = tile.getCoverItemAtSide(tSide); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final ItemStack cover = tile.getCoverItemAtSide(side); if (cover != null) { - addCoverToTabs(tSide, cover); + addCoverToTabs(side, cover); } } } @@ -101,26 +102,27 @@ public class GT_GuiCoverTabLine extends GT_GuiTabLine { /** * Add the cover on this side of the IGregTechTileEntity to the tabs - * + * * @param side * @param cover */ - private void addCoverToTabs(byte side, ItemStack cover) { + private void addCoverToTabs(ForgeDirection side, ItemStack cover) { final boolean enabled = this.tile.getCoverBehaviorAtSideNew(side) .hasCoverGUI(); - this.setTab(side, cover, null, getTooltipForCoverTab(side, cover, enabled)); - this.setTabEnabled(side, enabled); + final int ordinalSide = side.ordinal(); + this.setTab(ordinalSide, cover, null, getTooltipForCoverTab(side, cover, enabled)); + this.setTabEnabled(ordinalSide, enabled); } /** * Decorate the cover's tooltips according to the side it's on and on whether the tab is enabled or not - * + * * @param side * @param cover * @param enabled * @return This cover tab's tooltip */ - private String[] getTooltipForCoverTab(byte side, ItemStack cover, boolean enabled) { + private String[] getTooltipForCoverTab(ForgeDirection side, ItemStack cover, boolean enabled) { final List<String> tooltip = cover.getTooltip(Minecraft.getMinecraft().thePlayer, true); tooltip.set( 0, @@ -132,16 +134,17 @@ public class GT_GuiCoverTabLine extends GT_GuiTabLine { /** * Get the translated name for a side of the IGregTechTileEntity - * + * * @param side * @return translated name for a side of the IGregTechTileEntity */ - private String getSideDescription(byte side) { - if (side < SIDES.length) { - if (this.translatedSides[side] == null) { - this.translatedSides[side] = StatCollector.translateToLocal(SIDES[side]); + private String getSideDescription(ForgeDirection side) { + final int ordinalSide = side.ordinal(); + if (ordinalSide < SIDES.length) { + if (this.translatedSides[ordinalSide] == null) { + this.translatedSides[ordinalSide] = StatCollector.translateToLocal(SIDES[ordinalSide]); } - return this.translatedSides[side]; + return this.translatedSides[ordinalSide]; } return null; } diff --git a/src/main/java/gregtech/api/interfaces/IItemBehaviour.java b/src/main/java/gregtech/api/interfaces/IItemBehaviour.java index 1f67b9c1a8..67bb505c6b 100644 --- a/src/main/java/gregtech/api/interfaces/IItemBehaviour.java +++ b/src/main/java/gregtech/api/interfaces/IItemBehaviour.java @@ -10,6 +10,7 @@ import net.minecraft.entity.projectile.EntityArrow; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.SubTag; import gregtech.api.items.GT_MetaBase_Item; @@ -18,11 +19,11 @@ public interface IItemBehaviour<E extends Item> { boolean onLeftClickEntity(E aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity); - boolean onItemUse(E aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, - float hitX, float hitY, float hitZ); + boolean onItemUse(E aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + int ordinalSide, float hitX, float hitY, float hitZ); boolean onItemUseFirst(E aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ); + ForgeDirection side, float hitX, float hitY, float hitZ); ItemStack onItemRightClick(E aItem, ItemStack aStack, World aWorld, EntityPlayer aPlayer); diff --git a/src/main/java/gregtech/api/interfaces/IRedstoneCircuitBlock.java b/src/main/java/gregtech/api/interfaces/IRedstoneCircuitBlock.java index 91219368b7..0eea6ca3a4 100644 --- a/src/main/java/gregtech/api/interfaces/IRedstoneCircuitBlock.java +++ b/src/main/java/gregtech/api/interfaces/IRedstoneCircuitBlock.java @@ -2,6 +2,7 @@ package gregtech.api.interfaces; import net.minecraft.block.Block; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.interfaces.tileentity.ICoverable; import gregtech.api.util.GT_CoverBehavior; @@ -14,47 +15,47 @@ public interface IRedstoneCircuitBlock { /** * The Output Direction the Circuit Block is Facing */ - byte getOutputFacing(); + ForgeDirection getOutputFacing(); /** * sets Output Redstone State at Side */ - boolean setRedstone(byte aStrength, byte aSide); + boolean setRedstone(byte aStrength, ForgeDirection side); /** * returns Output Redstone State at Side Note that setRedstone checks if there is a Difference between the old and * the new Setting before consuming any Energy */ - byte getOutputRedstone(byte aSide); + byte getOutputRedstone(ForgeDirection side); /** * returns Input Redstone Signal at Side */ - byte getInputRedstone(byte aSide); + byte getInputRedstone(ForgeDirection side); /** * If this Side is Covered up and therefor not doing any Redstone */ - GT_CoverBehavior getCover(byte aSide); + GT_CoverBehavior getCover(ForgeDirection side); - int getCoverID(byte aSide); + int getCoverID(ForgeDirection side); - int getCoverVariable(byte aSide); + int getCoverVariable(ForgeDirection side); /** * returns whatever Block-ID is adjacent to the Redstone Circuit Block */ - Block getBlockAtSide(byte aSide); + Block getBlockAtSide(ForgeDirection side); /** * returns whatever Meta-Value is adjacent to the Redstone Circuit Block */ - byte getMetaIDAtSide(byte aSide); + byte getMetaIDAtSide(ForgeDirection side); /** * returns whatever TileEntity is adjacent to the Redstone Circuit Block */ - TileEntity getTileEntityAtSide(byte aSide); + TileEntity getTileEntityAtSide(ForgeDirection side); /** * returns whatever TileEntity is used by the Redstone Circuit Block diff --git a/src/main/java/gregtech/api/interfaces/covers/IControlsWorkCover.java b/src/main/java/gregtech/api/interfaces/covers/IControlsWorkCover.java index cef20ac3b7..d4cd1e9ec2 100644 --- a/src/main/java/gregtech/api/interfaces/covers/IControlsWorkCover.java +++ b/src/main/java/gregtech/api/interfaces/covers/IControlsWorkCover.java @@ -1,6 +1,6 @@ package gregtech.api.interfaces.covers; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.interfaces.tileentity.ICoverable; import gregtech.api.interfaces.tileentity.IMachineProgress; @@ -16,10 +16,11 @@ public interface IControlsWorkCover { * * @return true if the cover is the first (side) one **/ - static boolean makeSureOnlyOne(byte aMySide, ICoverable aTileEntity) { - for (byte tSide : ALL_VALID_SIDES) { - if (aTileEntity.getCoverBehaviorAtSideNew(tSide) instanceof IControlsWorkCover && tSide < aMySide) { - aTileEntity.dropCover(tSide, tSide, true); + static boolean makeSureOnlyOne(ForgeDirection aMySide, ICoverable aTileEntity) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (aTileEntity.getCoverBehaviorAtSideNew(side) instanceof IControlsWorkCover + && side.ordinal() < aMySide.ordinal()) { + aTileEntity.dropCover(side, side, true); aTileEntity.markDirty(); return false; } diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IConnectable.java b/src/main/java/gregtech/api/interfaces/metatileentity/IConnectable.java index 76d8d082ef..0ca519d40b 100644 --- a/src/main/java/gregtech/api/interfaces/metatileentity/IConnectable.java +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IConnectable.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.metatileentity; +import net.minecraftforge.common.util.ForgeDirection; + /** * For pipes, wires, and other MetaTiles which need to be decided whether they should connect to the block at each side. */ @@ -21,12 +23,12 @@ public interface IConnectable { * Try to connect to the Block at the specified side returns the connection state. Non-positive values for failed, * others for succeeded. */ - int connect(byte aSide); + int connect(ForgeDirection side); /** * Try to disconnect to the Block at the specified side */ - void disconnect(byte aSide); + void disconnect(ForgeDirection side); - boolean isConnectedAtSide(int aSide); + boolean isConnectedAtSide(ForgeDirection side); } diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java index a24e05f1a2..c9377d10be 100644 --- a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntity.java @@ -16,6 +16,7 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.AxisAlignedBB; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.IFluidHandler; import net.minecraftforge.fluids.IFluidTank; @@ -125,28 +126,30 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand * If a Cover of that Type can be placed on this Side. Also Called when the Facing of the Block Changes and a Cover * is on said Side. */ - boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack); + boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aStack); /** * When a Player rightclicks the Facing with a Screwdriver. */ - void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ); + void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ); /** - * When a Player rightclicks the Facing with a Wrench. + * When a Player right-clicks the Facing with a Wrench. */ - boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ); + boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, float aX, + float aY, float aZ); /** - * When a Player rightclicks the Facing with a wire cutter. + * When a Player right-clicks the Facing with a wire cutter. */ - boolean onWireCutterRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ); + boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ); /** - * When a Player rightclicks the Facing with a soldering iron. + * When a Player right-clicks the Facing with a soldering iron. */ - boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ); + boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ); /** * Called right before this Machine explodes @@ -181,10 +184,10 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand void onRemoval(); /** - * @param aFacing + * @param facing * @return if aFacing would be a valid Facing for this Device. Used for wrenching. */ - boolean isFacingValid(byte aFacing); + boolean isFacingValid(ForgeDirection facing); /** * @return the Server Side Container @@ -214,12 +217,12 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand /** * From new ISidedInventory */ - boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack); + boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack); /** * From new ISidedInventory */ - boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack); + boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack); /** * @return if aIndex is a valid Slot. false for things like HoloSlots. Is used for determining if an Item is dropped @@ -243,12 +246,12 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand /** * If this Side can connect to inputting pipes */ - boolean isLiquidInput(byte aSide); + boolean isLiquidInput(ForgeDirection side); /** * If this Side can connect to outputting pipes */ - boolean isLiquidOutput(byte aSide); + boolean isLiquidOutput(ForgeDirection side); /** * Just an Accessor for the Name variable. @@ -261,12 +264,12 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand boolean isAccessAllowed(EntityPlayer aPlayer); /** - * a Player rightclicks the Machine Sneaky rightclicks are not getting passed to this! + * a Player right-clicks the Machine Sneaky right clicks are not getting passed to this! * * @return */ - boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, - float aZ); + boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, float aX, + float aY, float aZ); /** * a Player leftclicks the Machine Sneaky leftclicks are getting passed to this unlike with the rightclicks. @@ -364,22 +367,17 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand /** * Icon of the Texture. If this returns null then it falls back to getTextureIndex. * - * @param aSide is the Side of the Block - * @param aFacing is the direction the Block is facing (or a Bitmask of all Connections in case of Pipes) - * @param aColorIndex The Minecraft Color the Block is having - * @param aActive if the Machine is currently active (use this instead of calling - * mBaseMetaTileEntity.mActive!!!). Note: In case of Pipes this means if this Side is connected - * to something or not. - * @param aRedstone if the Machine is currently outputting a RedstoneSignal (use this instead of calling - * mBaseMetaTileEntity.mRedstone!!!) + * @param side is the Side of the Block + * @param facing is the direction the Block is facing + * @param colorIndex The Minecraft Color the Block is having + * @param active if the Machine is currently active (use this instead of calling + * {@code mBaseMetaTileEntity.mActive)}. Note: In case of Pipes this means if this Side is + * connected to something or not. + * @param redstoneLevel if the Machine is currently outputting a RedstoneSignal (use this instead of calling + * {@code mBaseMetaTileEntity.mRedstone} !!!) */ - ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone); - - /** - * The Textures used for the Item rendering. Return null if you want the regular 3D Block Rendering. - */ - // public ITexture[] getItemTexture(ItemStack aStack); + ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean active, boolean redstoneLevel); /** * Register Icons here. This gets called when the Icons get initialized by the Base Block Best is you put your Icons @@ -405,9 +403,9 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand /** * Gets the Output for the comparator on the given Side */ - byte getComparatorValue(byte aSide); + byte getComparatorValue(ForgeDirection side); - float getExplosionResistance(byte aSide); + float getExplosionResistance(ForgeDirection side); String[] getInfoData(); @@ -415,7 +413,7 @@ public interface IMetaTileEntity extends ISidedInventory, IFluidTank, IFluidHand ItemStack[] getRealInventory(); - boolean connectsToItemPipe(byte aSide); + boolean connectsToItemPipe(ForgeDirection side); void onColorChangeServer(byte aColor); diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityCable.java b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityCable.java index 3f7bc73383..a2d672e765 100644 --- a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityCable.java +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityCable.java @@ -4,14 +4,16 @@ import java.util.ArrayList; import java.util.HashSet; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; -public interface IMetaTileEntityCable extends IMetaTileEntity { +public interface IMetaTileEntityCable extends IMetaTileEntityPipe { @Deprecated - long transferElectricity(byte aSide, long aVoltage, long aAmperage, + long transferElectricity(ForgeDirection side, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList); - default long transferElectricity(byte aSide, long aVoltage, long aAmperage, HashSet<TileEntity> aAlreadyPassedSet) { - return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList<>(aAlreadyPassedSet)); + default long transferElectricity(ForgeDirection side, long aVoltage, long aAmperage, + HashSet<TileEntity> aAlreadyPassedSet) { + return transferElectricity(side, aVoltage, aAmperage, new ArrayList<>(aAlreadyPassedSet)); } } diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityItemPipe.java b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityItemPipe.java index 76d3f56e74..0c2c5ebf28 100644 --- a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityItemPipe.java +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityItemPipe.java @@ -1,14 +1,13 @@ package gregtech.api.interfaces.metatileentity; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; - import java.util.Map; +import net.minecraftforge.common.util.ForgeDirection; + import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.metatileentity.BaseMetaPipeEntity; -import gregtech.api.util.GT_Utility; -public interface IMetaTileEntityItemPipe extends IMetaTileEntity { +public interface IMetaTileEntityItemPipe extends IMetaTileEntityPipe { /** * @return if this Pipe can still be used. @@ -32,10 +31,10 @@ public interface IMetaTileEntityItemPipe extends IMetaTileEntity { * Executes the Sending Code for inserting Stacks into the TileEntities. * * @param aSender the BaseMetaTileEntity sending the Stack. - * @param aSide the Side of the PIPE facing the TileEntity. + * @param side the Side of the PIPE facing the TileEntity. * @return if this Side was allowed to Output into the Block. */ - boolean insertItemStackIntoTileEntity(Object aSender, byte aSide); + boolean insertItemStackIntoTileEntity(Object aSender, ForgeDirection side); /** * Can be used to make flow control Pipes, like Redpowers Restriction Tubes. Every normal Pipe returns a Value of @@ -59,11 +58,10 @@ public interface IMetaTileEntityItemPipe extends IMetaTileEntity { if (aMap.get(aMetaTileEntity) == null || aMap.get(aMetaTileEntity) > aStep) { final IGregTechTileEntity aBaseMetaTileEntity = aMetaTileEntity.getBaseMetaTileEntity(); aMap.put(aMetaTileEntity, aStep); - byte oppositeSide; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (aMetaTileEntity instanceof IConnectable && !((IConnectable) aMetaTileEntity).isConnectedAtSide(side)) continue; - oppositeSide = GT_Utility.getOppositeSide(side); + final ForgeDirection oppositeSide = side.getOpposite(); if (aSuckItems) { if (aBaseMetaTileEntity.getCoverInfoAtSide(side) .letsItemsIn(-2)) { diff --git a/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityPipe.java b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityPipe.java new file mode 100644 index 0000000000..0ac29b2e45 --- /dev/null +++ b/src/main/java/gregtech/api/interfaces/metatileentity/IMetaTileEntityPipe.java @@ -0,0 +1,24 @@ +package gregtech.api.interfaces.metatileentity; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public interface IMetaTileEntityPipe extends IMetaTileEntity { + + /** + * Icon of the Texture. If this returns null then it falls back to getTextureIndex. + * + * @param side is the Side of the Block + * @param facingBitMask is the Bitmask of all Connections + * @param colorIndex The Minecraft Color the Block is having + * @param active if the Machine is currently active (use this instead of calling + * mBaseMetaTileEntity.mActive!!!). Note: In case of Pipes this means if this Side is connected + * to something or not. + * @param redstoneLevel if the Machine is currently outputting a RedstoneSignal (use this instead of calling + * mBaseMetaTileEntity.mRedstone!!!) + */ + ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, int facingBitMask, + int colorIndex, boolean active, boolean redstoneLevel); +} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java index 4e64742db0..37d62894bb 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IBasicEnergyContainer.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + /** * Interface for internal Code, which is mainly used for independent Energy conversion. */ @@ -57,7 +59,7 @@ public interface IBasicEnergyContainer extends IEnergyConnected, IHasWorldObject /** * Drain Energy Call for Electricity. */ - boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage); + boolean drainEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage); /** * returns the amount of Electricity, accepted by this Block the last 5 ticks as Average. diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java index d3186258ef..112a7035d7 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/ICoverable.java @@ -2,6 +2,7 @@ package gregtech.api.interfaces.tileentity; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.util.GT_CoverBehavior; import gregtech.api.util.GT_CoverBehaviorBase; @@ -10,80 +11,81 @@ import gregtech.common.covers.CoverInfo; public interface ICoverable extends IRedstoneTileEntity, IHasInventory, IBasicEnergyContainer { - boolean canPlaceCoverIDAtSide(byte aSide, int aID); + boolean canPlaceCoverIDAtSide(ForgeDirection side, int aID); - boolean canPlaceCoverItemAtSide(byte aSide, ItemStack aCover); + boolean canPlaceCoverItemAtSide(ForgeDirection side, ItemStack aCover); - boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced); + boolean dropCover(ForgeDirection side, ForgeDirection droppedSide, boolean aForced); @Deprecated - void setCoverDataAtSide(byte aSide, int aData); + void setCoverDataAtSide(ForgeDirection side, int aData); - default void setCoverDataAtSide(byte aSide, ISerializableObject aData) { + default void setCoverDataAtSide(ForgeDirection side, ISerializableObject aData) { if (aData instanceof ISerializableObject.LegacyCoverData) - setCoverDataAtSide(aSide, ((ISerializableObject.LegacyCoverData) aData).get()); + setCoverDataAtSide(side, ((ISerializableObject.LegacyCoverData) aData).get()); } - void setCoverIdAndDataAtSide(byte aSide, int aId, ISerializableObject aData); + void setCoverIdAndDataAtSide(ForgeDirection side, int aId, ISerializableObject aData); - void setCoverIDAtSide(byte aSide, int aID); + void setCoverIDAtSide(ForgeDirection side, int aID); - boolean setCoverIDAtSideNoUpdate(byte aSide, int aID); + boolean setCoverIDAtSideNoUpdate(ForgeDirection side, int aID); - void setCoverItemAtSide(byte aSide, ItemStack aCover); + void setCoverItemAtSide(ForgeDirection side, ItemStack aCover); @Deprecated - int getCoverDataAtSide(byte aSide); + int getCoverDataAtSide(ForgeDirection side); - default CoverInfo getCoverInfoAtSide(byte aSide) { + default CoverInfo getCoverInfoAtSide(ForgeDirection side) { return null; } - default ISerializableObject getComplexCoverDataAtSide(byte aSide) { - return new ISerializableObject.LegacyCoverData(getCoverDataAtSide(aSide)); + default ISerializableObject getComplexCoverDataAtSide(ForgeDirection side) { + return new ISerializableObject.LegacyCoverData(getCoverDataAtSide(side)); } - int getCoverIDAtSide(byte aSide); + int getCoverIDAtSide(ForgeDirection side); - ItemStack getCoverItemAtSide(byte aSide); + ItemStack getCoverItemAtSide(ForgeDirection side); @Deprecated - GT_CoverBehavior getCoverBehaviorAtSide(byte aSide); + GT_CoverBehavior getCoverBehaviorAtSide(ForgeDirection side); - default GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(byte aSide) { - return getCoverBehaviorAtSide(aSide); + default GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(ForgeDirection side) { + return getCoverBehaviorAtSide(side); } /** * For use by the regular MetaTileEntities. Returns the Cover Manipulated input Redstone. Don't use this if you are * a Cover Behavior. Only for MetaTileEntities. */ - byte getInternalInputRedstoneSignal(byte aSide); + byte getInternalInputRedstoneSignal(ForgeDirection side); /** * For use by the regular MetaTileEntities. This makes it not conflict with Cover based Redstone Signals. Don't use * this if you are a Cover Behavior. Only for MetaTileEntities. */ - void setInternalOutputRedstoneSignal(byte aSide, byte aStrength); + void setInternalOutputRedstoneSignal(ForgeDirection side, byte aStrength); /** * Causes a general Cover Texture update. Sends 6 Integers to Client + causes @issueTextureUpdate() */ - void issueCoverUpdate(byte aSide); + void issueCoverUpdate(ForgeDirection side); /** * Receiving a packet with cover data. */ - void receiveCoverData(byte coverSide, int coverID, int coverData); + void receiveCoverData(ForgeDirection coverSide, int coverID, int coverData); /** * Receiving a packet with cover data. - * - * @param aPlayer the player who made the change + * + * @param coverSide + * @param aPlayer the player who made the change */ - default void receiveCoverData(byte aCoverSide, int aCoverID, ISerializableObject aCoverData, + default void receiveCoverData(ForgeDirection coverSide, int aCoverID, ISerializableObject aCoverData, EntityPlayerMP aPlayer) { if (aCoverData instanceof ISerializableObject.LegacyCoverData) - receiveCoverData(aCoverSide, aCoverID, ((ISerializableObject.LegacyCoverData) aCoverData).get()); + receiveCoverData(coverSide, aCoverID, ((ISerializableObject.LegacyCoverData) aCoverData).get()); } } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java index 55de2db088..f866092d38 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IEnergyConnected.java @@ -24,28 +24,28 @@ public interface IEnergyConnected extends IColoredTileEntity { * <p/> * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself. * - * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do - * Side checks for this Side) + * @param side 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do + * Side checks for this Side) * @return amount of used Amperes. 0 if not accepted anything. */ - long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage); + long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage); /** * Sided Energy Input */ - boolean inputEnergyFrom(byte aSide); + boolean inputEnergyFrom(ForgeDirection side); - default boolean inputEnergyFrom(byte aSide, boolean waitForActive) { - return inputEnergyFrom(aSide); + default boolean inputEnergyFrom(ForgeDirection side, boolean waitForActive) { + return inputEnergyFrom(side); } /** * Sided Energy Output */ - boolean outputsEnergyTo(byte aSide); + boolean outputsEnergyTo(ForgeDirection side); - default boolean outputsEnergyTo(byte aSide, boolean waitForActive) { - return outputsEnergyTo(aSide); + default boolean outputsEnergyTo(ForgeDirection side, boolean waitForActive) { + return outputsEnergyTo(side); } /** @@ -64,43 +64,38 @@ public interface IEnergyConnected extends IColoredTileEntity { return 0; } - for (byte i = 0, j = 0; i < 6 && aAmperage > rUsedAmperes; i++) { - if (!aEmitter.outputsEnergyTo(i)) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (rUsedAmperes > aAmperage) break; + if (!aEmitter.outputsEnergyTo(side)) { continue; } - j = GT_Utility.getOppositeSide(i); - final TileEntity tTileEntity = emitterTile.getTileEntityAtSide(i); + final ForgeDirection oppositeSide = side.getOpposite(); + final TileEntity tTileEntity = emitterTile.getTileEntityAtSide(side); if (tTileEntity instanceof PowerLogicHost host) { - PowerLogic logic = host.getPowerLogic(ForgeDirection.getOrientation(j)); + final PowerLogic logic = host.getPowerLogic(oppositeSide); if (logic == null || logic.isEnergyReceiver()) { continue; } rUsedAmperes += logic.injectEnergy(aVoltage, aAmperage - rUsedAmperes); - } else if (tTileEntity instanceof IEnergyConnected) { + } else if (tTileEntity instanceof IEnergyConnected energyConnected) { if (aEmitter.getColorization() >= 0) { - final byte tColor = ((IEnergyConnected) tTileEntity).getColorization(); + final byte tColor = energyConnected.getColorization(); if (tColor >= 0 && tColor != aEmitter.getColorization()) continue; } - rUsedAmperes += ((IEnergyConnected) tTileEntity) - .injectEnergyUnits(j, aVoltage, aAmperage - rUsedAmperes); + rUsedAmperes += energyConnected.injectEnergyUnits(oppositeSide, aVoltage, aAmperage - rUsedAmperes); - } else if (tTileEntity instanceof IEnergySink) { - if (((IEnergySink) tTileEntity) - .acceptsEnergyFrom((TileEntity) aEmitter, ForgeDirection.getOrientation(j))) { - while (aAmperage > rUsedAmperes && ((IEnergySink) tTileEntity).getDemandedEnergy() > 0 - && ((IEnergySink) tTileEntity) - .injectEnergy(ForgeDirection.getOrientation(j), aVoltage, aVoltage) < aVoltage) - rUsedAmperes++; + } else if (tTileEntity instanceof IEnergySink sink) { + if (sink.acceptsEnergyFrom((TileEntity) aEmitter, oppositeSide)) { + while (aAmperage > rUsedAmperes && sink.getDemandedEnergy() > 0 + && sink.injectEnergy(oppositeSide, aVoltage, aVoltage) < aVoltage) rUsedAmperes++; } - } else if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver) { - final ForgeDirection tDirection = ForgeDirection.getOrientation(i) - .getOpposite(); + } else if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver receiver) { final int rfOut = GT_Utility.safeInt(aVoltage * GregTech_API.mEUtoRF / 100); - if (((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, true) == rfOut) { - ((IEnergyReceiver) tTileEntity).receiveEnergy(tDirection, rfOut, false); + if (receiver.receiveEnergy(oppositeSide, rfOut, true) == rfOut) { + receiver.receiveEnergy(oppositeSide, rfOut, false); rUsedAmperes++; } } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java deleted file mode 100644 index aa1b9a11c6..0000000000 --- a/src/main/java/gregtech/api/interfaces/tileentity/IExperimentalEnergyTileEntity.java +++ /dev/null @@ -1,112 +0,0 @@ -package gregtech.api.interfaces.tileentity; - -import net.minecraft.tileentity.TileEntity; -import net.minecraftforge.common.util.ForgeDirection; - -import cofh.api.energy.IEnergyReceiver; -import gregtech.api.enums.SubTag; -import gregtech.api.util.GT_Utility; -import ic2.api.energy.tile.IEnergySink; - -/** - * THIS IS GOING TO BE USED IN 1.8 - * <p/> - * Interface for getting Connected to the GregTech Energy Network. - * <p/> - * This is all you need to connect to the GT Network. IColoredTileEntity is needed for not connecting differently - * coloured Blocks to each other. IHasWorldObjectAndCoords is needed for the InWorld related Stuff. @BaseTileEntity does - * implement most of that Interface. - */ -public interface IExperimentalEnergyTileEntity extends IColoredTileEntity, IHasWorldObjectAndCoords { - - /** - * Inject Energy Call for Electricity. Gets called by EnergyEmitters to inject Energy into your Block - * <p/> - * Note: you have to check for @inputEnergyFrom because the Network won't check for that by itself. - * - * @param aSide 0 - 5 = Vanilla Directions of YOUR Block the Energy gets inserted to. 6 = No specific Side (don't do - * Side checks for this Side) - * @return amount of used Amperes. 0 if not accepted anything. - */ - long injectEnergy(SubTag aEnergyType, byte aSide, long aPrimary, long aSecondary); - - /** - * Sided Energy Input - */ - boolean inputEnergyFrom(SubTag aEnergyType, byte aSide); - - /** - * Sided Energy Output - */ - boolean outputsEnergyTo(SubTag aEnergyType, byte aSide); - - /** - * Utility for the Network - */ - class Util { - - public static int RF_PER_EU = 4; - private static boolean RF_ENERGY = false, IC_ENERGY = false, CHECK_ALL = true; - - private static void checkAvailabilities() { - if (CHECK_ALL) { - try { - Class<IEnergyReceiver> tClass = cofh.api.energy.IEnergyReceiver.class; - tClass.getCanonicalName(); - RF_ENERGY = true; - } catch (Throwable e) { - /**/ - } - try { - Class<IEnergySink> tClass = ic2.api.energy.tile.IEnergySink.class; - tClass.getCanonicalName(); - IC_ENERGY = true; - } catch (Throwable e) { - /**/ - } - CHECK_ALL = false; - } - } - - /** - * Emits Energy to the adjacent Blocks. Also compatible with adjacent IC2 TileEntities when electric and RF - * TileEntities when RedstoneFlux. - * - * @return the amount of used secondary value. - */ - public static final long emitEnergyToNetwork(SubTag aEnergyType, long aPrimary, long aSecondary, - IExperimentalEnergyTileEntity aEmitter) { - long rUsedSecondary = 0; - checkAvailabilities(); - for (byte i = 0, j = 0; i < 6 && aSecondary > rUsedSecondary; i++) - if (aEmitter.outputsEnergyTo(aEnergyType, i)) { - j = GT_Utility.getOppositeSide(i); - TileEntity tTileEntity = aEmitter.getTileEntityAtSide(i); - if (tTileEntity instanceof IExperimentalEnergyTileEntity) { - if (aEmitter.getColorization() >= 0) { - byte tColor = ((IExperimentalEnergyTileEntity) tTileEntity).getColorization(); - if (tColor >= 0 && tColor != aEmitter.getColorization()) continue; - } - rUsedSecondary += ((IExperimentalEnergyTileEntity) tTileEntity) - .injectEnergy(aEnergyType, j, aPrimary, aSecondary - rUsedSecondary); - } else if (IC_ENERGY && aEnergyType == SubTag.ENERGY_ELECTRICITY - && tTileEntity instanceof IEnergySink) { - if (((IEnergySink) tTileEntity) - .acceptsEnergyFrom((TileEntity) aEmitter, ForgeDirection.getOrientation(j))) { - while (aSecondary > rUsedSecondary - && ((IEnergySink) tTileEntity).getDemandedEnergy() > 0 - && ((IEnergySink) tTileEntity) - .injectEnergy(ForgeDirection.getOrientation(j), aPrimary, aPrimary) < aPrimary) - rUsedSecondary++; - } - } else if (RF_ENERGY && aEnergyType == SubTag.ENERGY_REDSTONE_FLUX - && tTileEntity instanceof IEnergyReceiver - && ((IEnergyReceiver) tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))) { - rUsedSecondary += ((IEnergyReceiver) tTileEntity) - .receiveEnergy(ForgeDirection.getOrientation(j), (int) aSecondary, false); - } - } - return rUsedSecondary; - } - } -} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java index a301c21a76..2f7f26e723 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IFibreConnected.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + /** * This File has just internal Information about the Fibre Redstone State of a TileEntity */ @@ -8,25 +10,25 @@ public interface IFibreConnected extends IColoredTileEntity, IHasWorldObjectAndC /** * If this Blocks accepts Fibre from this Side */ - void inputFibreFrom(byte aSide); + void inputFibreFrom(ForgeDirection side); /** * If this Blocks emits Fibre to this Side */ - void outputsFibreTo(byte aSide); + void outputsFibreTo(ForgeDirection side); /** * Sets the Signal this Blocks outputs to this Fibre Color */ - void setFibreOutput(byte aSide, byte aColor, byte aRedstoneStrength); + void setFibreOutput(ForgeDirection side, byte aColor, byte aRedstoneStrength); /** * Gets the Signal this Blocks outputs to this Fibre Color */ - byte getFibreOutput(byte aSide, byte aColor); + byte getFibreOutput(ForgeDirection side, byte aColor); /** * Gets the Signal this Blocks receives from this Fibre Color */ - byte getFibreInput(byte aSide, byte aColor); + byte getFibreInput(ForgeDirection side, byte aColor); } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java index 31e9b51719..eefcbcb5ac 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IGearEnergyTileEntity.java @@ -1,18 +1,21 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + public interface IGearEnergyTileEntity { /** * If Rotation Energy can be accepted on this Side. This means that the Gear/Axle will connect to this Side, and can * cause the Gear/Axle to stop if the Energy isn't accepted. */ - boolean acceptsRotationalEnergy(byte aSide); + boolean acceptsRotationalEnergy(ForgeDirection side); /** * Inject Energy Call for Rotational Energy. Rotation Energy can't be stored, this is just for things like internal * Dynamos, which convert it into Energy, or into Progress. * + * @param side * @param aSpeed Positive = Clockwise, Negative = Counterclockwise */ - boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy); + boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy); } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java index 23e4d662c9..5062f0fce5 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IGregTechTileEntity.java @@ -10,6 +10,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.AxisAlignedBB; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.IFluidHandler; import cpw.mods.fml.relauncher.Side; @@ -128,9 +129,9 @@ public interface IGregTechTileEntity extends ITexturedTileEntity, IGearEnergyTil /** * Called when rightclicking the TileEntity */ - boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ); + boolean onRightclick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ); - float getBlastResistance(byte aSide); + float getBlastResistance(ForgeDirection side); default void onBlockDestroyed() {} diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java index f02672365e..64d206aff7 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IHasWorldObjectAndCoords.java @@ -8,6 +8,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; import net.minecraft.world.World; import net.minecraft.world.biome.BiomeGenBase; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.IFluidHandler; /** @@ -43,91 +44,91 @@ public interface IHasWorldObjectAndCoords { TileEntity getTileEntityOffset(int aX, int aY, int aZ); - TileEntity getTileEntityAtSide(byte aSide); + TileEntity getTileEntityAtSide(ForgeDirection side); - TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance); + TileEntity getTileEntityAtSideAndDistance(ForgeDirection side, int aDistance); IInventory getIInventory(int aX, int aY, int aZ); IInventory getIInventoryOffset(int aX, int aY, int aZ); - IInventory getIInventoryAtSide(byte aSide); + IInventory getIInventoryAtSide(ForgeDirection side); - IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance); + IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int aDistance); IFluidHandler getITankContainer(int aX, int aY, int aZ); IFluidHandler getITankContainerOffset(int aX, int aY, int aZ); - IFluidHandler getITankContainerAtSide(byte aSide); + IFluidHandler getITankContainerAtSide(ForgeDirection side); - IFluidHandler getITankContainerAtSideAndDistance(byte aSide, int aDistance); + IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int aDistance); IGregTechTileEntity getIGregTechTileEntity(int aX, int aY, int aZ); IGregTechTileEntity getIGregTechTileEntityOffset(int aX, int aY, int aZ); - IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide); + IGregTechTileEntity getIGregTechTileEntityAtSide(ForgeDirection side); - IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte aSide, int aDistance); + IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int aDistance); Block getBlock(int aX, int aY, int aZ); Block getBlockOffset(int aX, int aY, int aZ); - Block getBlockAtSide(byte aSide); + Block getBlockAtSide(ForgeDirection side); - Block getBlockAtSideAndDistance(byte aSide, int aDistance); + Block getBlockAtSideAndDistance(ForgeDirection side, int aDistance); byte getMetaID(int aX, int aY, int aZ); byte getMetaIDOffset(int aX, int aY, int aZ); - byte getMetaIDAtSide(byte aSide); + byte getMetaIDAtSide(ForgeDirection side); - byte getMetaIDAtSideAndDistance(byte aSide, int aDistance); + byte getMetaIDAtSideAndDistance(ForgeDirection side, int aDistance); byte getLightLevel(int aX, int aY, int aZ); byte getLightLevelOffset(int aX, int aY, int aZ); - byte getLightLevelAtSide(byte aSide); + byte getLightLevelAtSide(ForgeDirection side); - byte getLightLevelAtSideAndDistance(byte aSide, int aDistance); + byte getLightLevelAtSideAndDistance(ForgeDirection side, int aDistance); boolean getOpacity(int aX, int aY, int aZ); boolean getOpacityOffset(int aX, int aY, int aZ); - boolean getOpacityAtSide(byte aSide); + boolean getOpacityAtSide(ForgeDirection side); - boolean getOpacityAtSideAndDistance(byte aSide, int aDistance); + boolean getOpacityAtSideAndDistance(ForgeDirection side, int aDistance); boolean getSky(int aX, int aY, int aZ); boolean getSkyOffset(int aX, int aY, int aZ); - boolean getSkyAtSide(byte aSide); + boolean getSkyAtSide(ForgeDirection side); - boolean getSkyAtSideAndDistance(byte aSide, int aDistance); + boolean getSkyAtSideAndDistance(ForgeDirection side, int aDistance); boolean getAir(int aX, int aY, int aZ); boolean getAirOffset(int aX, int aY, int aZ); - boolean getAirAtSide(byte aSide); + boolean getAirAtSide(ForgeDirection side); - boolean getAirAtSideAndDistance(byte aSide, int aDistance); + boolean getAirAtSideAndDistance(ForgeDirection side, int aDistance); BiomeGenBase getBiome(); BiomeGenBase getBiome(int aX, int aZ); - int getOffsetX(byte aSide, int aMultiplier); + int getOffsetX(ForgeDirection side, int aMultiplier); - short getOffsetY(byte aSide, int aMultiplier); + short getOffsetY(ForgeDirection side, int aMultiplier); - int getOffsetZ(byte aSide, int aMultiplier); + int getOffsetZ(ForgeDirection side, int aMultiplier); /** * Checks if the TileEntity is Invalid or Unloaded. Stupid Minecraft cannot do that btw. @@ -168,7 +169,7 @@ public interface IHasWorldObjectAndCoords { /** * Opens the GUI with this ID of this MetaTileEntity - * + * * @deprecated Use ModularUI */ @Deprecated @@ -178,7 +179,7 @@ public interface IHasWorldObjectAndCoords { /** * Opens the GUI with the ID = 0 of this TileEntity - * + * * @deprecated Use ModularUI */ @Deprecated diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java index 3cc3c6404d..ab476449f0 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IPipeRenderedTileEntity.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + import gregtech.api.interfaces.ITexture; public interface IPipeRenderedTileEntity extends ICoverable, ITexturedTileEntity { @@ -8,9 +10,9 @@ public interface IPipeRenderedTileEntity extends ICoverable, ITexturedTileEntity byte getConnections(); - ITexture[] getTextureUncovered(byte aSide); + ITexture[] getTextureUncovered(ForgeDirection side); - default ITexture[] getTextureCovered(byte aSide) { - return getTextureUncovered(aSide); + default ITexture[] getTextureCovered(ForgeDirection side) { + return getTextureUncovered(side); } } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java index fba20ee79d..1b280184ce 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneEmitter.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + /** * This File has just internal Information about the Redstone State of a TileEntity */ @@ -7,8 +9,11 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords { /** * gets the Redstone Level the TileEntity should emit to the given Output Side + * + * @param side the {@link ForgeDirection} side + * @return the Redstone Level the TileEntity */ - byte getOutputRedstoneSignal(byte aSide); + byte getOutputRedstoneSignal(ForgeDirection side); /** * sets the Redstone Level the TileEntity should emit to the given Output Side @@ -17,12 +22,12 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords { * internal Output Redstone, so that it doesnt conflict with Cover Redstone. This sets the true Redstone Output * Signal. Only Cover Behaviors should use it, not MetaTileEntities. */ - void setOutputRedstoneSignal(byte aSide, byte aStrength); + void setOutputRedstoneSignal(ForgeDirection side, byte aStrength); /** * gets the Redstone Level the TileEntity should emit to the given Output Side */ - byte getStrongOutputRedstoneSignal(byte aSide); + byte getStrongOutputRedstoneSignal(ForgeDirection side); /** * sets the Redstone Level the TileEntity should emit to the given Output Side @@ -31,17 +36,17 @@ public interface IRedstoneEmitter extends IHasWorldObjectAndCoords { * internal Output Redstone, so that it doesnt conflict with Cover Redstone. This sets the true Redstone Output * Signal. Only Cover Behaviors should use it, not MetaTileEntities. */ - void setStrongOutputRedstoneSignal(byte aSide, byte aStrength); + void setStrongOutputRedstoneSignal(ForgeDirection side, byte aStrength); /** * Gets the Output for the comparator on the given Side */ - byte getComparatorValue(byte aSide); + byte getComparatorValue(ForgeDirection side); /** * Get the redstone output signal strength for a given side */ - default byte getGeneralRS(byte aSide) { + default byte getGeneralRS(ForgeDirection side) { return 0; } } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java index d5fb814c52..a41e9aaf7a 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/IRedstoneReceiver.java @@ -1,5 +1,7 @@ package gregtech.api.interfaces.tileentity; +import net.minecraftforge.common.util.ForgeDirection; + /** * This File has just internal Information about the Redstone State of a TileEntity */ @@ -12,7 +14,7 @@ public interface IRedstoneReceiver extends IHasWorldObjectAndCoords { * Input Redstone This returns the true incoming Redstone Signal. Only Cover Behaviors should check it, not * MetaTileEntities. */ - byte getInputRedstoneSignal(byte aSide); + byte getInputRedstoneSignal(ForgeDirection side); /** * gets the strongest Redstone Level the TileEntity receives @@ -27,5 +29,5 @@ public interface IRedstoneReceiver extends IHasWorldObjectAndCoords { /** * gets if the TileEntity receives Redstone at this Side */ - boolean getRedstone(byte aSide); + boolean getRedstone(ForgeDirection side); } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java index d6024b612e..379111b07e 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/ITexturedTileEntity.java @@ -1,6 +1,7 @@ package gregtech.api.interfaces.tileentity; import net.minecraft.block.Block; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.interfaces.ITexture; @@ -9,5 +10,5 @@ public interface ITexturedTileEntity { /** * @return the Textures rendered by the GT Rendering */ - ITexture[] getTexture(Block aBlock, byte aSide); + ITexture[] getTexture(Block aBlock, ForgeDirection side); } diff --git a/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java index e54a85090e..64cc8675ef 100644 --- a/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java +++ b/src/main/java/gregtech/api/interfaces/tileentity/ITurnable.java @@ -1,6 +1,6 @@ package gregtech.api.interfaces.tileentity; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; +import net.minecraftforge.common.util.ForgeDirection; /** * Implemented by all my Machines. However without any security checks, if the Players are even allowed to rotate it. @@ -12,34 +12,34 @@ public interface ITurnable { * * @return front Block facing */ - byte getFrontFacing(); + ForgeDirection getFrontFacing(); /** * Set the block's facing * - * @param aSide facing to set the block to + * @param side facing to set the block to */ - void setFrontFacing(byte aSide); + void setFrontFacing(ForgeDirection side); /** * Get the block's back facing. * * @return opposite Block facing */ - byte getBackFacing(); + ForgeDirection getBackFacing(); /** * Determine if the wrench can be used to set the block's facing. */ - boolean isValidFacing(byte aSide); + boolean isValidFacing(ForgeDirection side); /** * Get the list of valid facings */ default boolean[] getValidFacings() { final boolean[] validFacings = new boolean[6]; - for (byte facing : ALL_VALID_SIDES) { - validFacings[facing] = isValidFacing(facing); + for (final ForgeDirection facing : ForgeDirection.VALID_DIRECTIONS) { + validFacings[facing.ordinal()] = isValidFacing(facing); } return validFacings; } diff --git a/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java b/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java index dbd8ffecf6..31a44f3dbc 100644 --- a/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java +++ b/src/main/java/gregtech/api/items/GT_Block_LongDistancePipe.java @@ -90,7 +90,7 @@ public class GT_Block_LongDistancePipe extends GT_Generic_Block { } @Override - public IIcon getIcon(int aSide, int aMeta) { + public IIcon getIcon(int ordinalSide, int aMeta) { return mIcons[aMeta % mIcons.length].getIcon(); } diff --git a/src/main/java/gregtech/api/items/GT_MetaBase_Item.java b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java index f1646529ea..4b3c713f22 100644 --- a/src/main/java/gregtech/api/items/GT_MetaBase_Item.java +++ b/src/main/java/gregtech/api/items/GT_MetaBase_Item.java @@ -19,6 +19,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumChatFormatting; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidContainerItem; @@ -139,14 +140,14 @@ public abstract class GT_MetaBase_Item extends GT_Generic_Item } @Override - public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, - float hitX, float hitY, float hitZ) { + public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + int ordinalSide, float hitX, float hitY, float hitZ) { use(aStack, 0, aPlayer); isItemStackUsable(aStack); ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); try { if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) - if (tBehavior.onItemUse(this, aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ)) { + if (tBehavior.onItemUse(this, aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ)) { if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); return true; } @@ -162,13 +163,23 @@ public abstract class GT_MetaBase_Item extends GT_Generic_Item @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { + int ordinalSide, float hitX, float hitY, float hitZ) { use(aStack, 0, aPlayer); isItemStackUsable(aStack); ArrayList<IItemBehaviour<GT_MetaBase_Item>> tList = mItemBehaviors.get((short) getDamage(aStack)); try { - if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) - if (tBehavior.onItemUseFirst(this, aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ)) { + if (tList != null) for (IItemBehaviour<GT_MetaBase_Item> tBehavior : tList) if (tBehavior.onItemUseFirst( + this, + aStack, + aPlayer, + aWorld, + aX, + aY, + aZ, + ForgeDirection.getOrientation(ordinalSide), + hitX, + hitY, + hitZ)) { if (aStack.stackSize <= 0) aPlayer.destroyCurrentEquippedItem(); return true; } diff --git a/src/main/java/gregtech/api/items/GT_SolderingTool_Item.java b/src/main/java/gregtech/api/items/GT_SolderingTool_Item.java index 07a0c3bd9b..6ec06c91a5 100644 --- a/src/main/java/gregtech/api/items/GT_SolderingTool_Item.java +++ b/src/main/java/gregtech/api/items/GT_SolderingTool_Item.java @@ -46,8 +46,8 @@ public class GT_SolderingTool_Item extends GT_Tool_Item { @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); return false; } } diff --git a/src/main/java/gregtech/api/items/GT_Spray_Bug_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Bug_Item.java index 29df584326..0716ca9dc1 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Bug_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Bug_Item.java @@ -38,8 +38,8 @@ public class GT_Spray_Bug_Item extends GT_Tool_Item { */ @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aWorld.isRemote) { return false; } diff --git a/src/main/java/gregtech/api/items/GT_Spray_Foam_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Foam_Item.java index 0a68e222f8..6bdca0da1c 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Foam_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Foam_Item.java @@ -32,22 +32,10 @@ public class GT_Spray_Foam_Item extends GT_Tool_Item { */ } - /* - * @Override public ItemStack getEmptiedItem(ItemStack aStack) { return ItemList.Spray_Empty.get(1); } public void - * switchMode(ItemStack aStack, EntityPlayer aPlayer) { setMode(aStack, (getMode(aStack) + 1) % 3); switch - * (getMode(aStack)) { case 0: GT_Utility.sendChatToPlayer(aPlayer, "Single Block Mode"); break; case 1: - * GT_Utility.sendChatToPlayer(aPlayer, "4m Line Mode"); break; case 2: GT_Utility.sendChatToPlayer(aPlayer, - * "3mx3m Area Mode"); break; } } - * @Override public void addAdditionalToolTips(List aList, ItemStack aStack) { super.addAdditionalToolTips(aList, - * aStack); switch (getMode(aStack)) { case 0: aList.add("Single Block Mode"); break; case 1: - * aList.add("4m Line Mode"); break; case 2: aList.add("3mx3m Area Mode"); break; } } - * @Override public ItemStack onItemRightClick(ItemStack aStack, World aWorld, EntityPlayer aPlayer) { if - * (aPlayer.isSneaking()) switchMode(aStack, aPlayer); return super.onItemRightClick(aStack, aWorld, aPlayer); } - */ @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aPlayer.isSneaking()) return false; if (aWorld.isRemote) { return false; @@ -82,9 +70,9 @@ public class GT_Spray_Foam_Item extends GT_Tool_Item { return true; } - aX += ForgeDirection.getOrientation(aSide).offsetX; - aY += ForgeDirection.getOrientation(aSide).offsetY; - aZ += ForgeDirection.getOrientation(aSide).offsetZ; + aX += ForgeDirection.getOrientation(ordinalSide).offsetX; + aY += ForgeDirection.getOrientation(ordinalSide).offsetY; + aZ += ForgeDirection.getOrientation(ordinalSide).offsetZ; ItemStack tStack = GT_ModHandler.getIC2Item("constructionFoam", 1); if (tStack != null && tStack.getItem() instanceof ItemBlock) { diff --git a/src/main/java/gregtech/api/items/GT_Spray_Hardener_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Hardener_Item.java index 1f6d49e8da..2fecc77c14 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Hardener_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Hardener_Item.java @@ -32,8 +32,8 @@ public class GT_Spray_Hardener_Item extends GT_Tool_Item { @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aWorld.isRemote) { return false; } diff --git a/src/main/java/gregtech/api/items/GT_Spray_Hydration_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Hydration_Item.java index dd10b419d4..6589beb94c 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Hydration_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Hydration_Item.java @@ -28,8 +28,8 @@ public class GT_Spray_Hydration_Item extends GT_Tool_Item { @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aWorld.isRemote) { return false; } diff --git a/src/main/java/gregtech/api/items/GT_Spray_Ice_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Ice_Item.java index 402b655692..dab2515b72 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Ice_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Ice_Item.java @@ -52,14 +52,14 @@ public class GT_Spray_Ice_Item extends GT_Tool_Item { @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aWorld.isRemote) { return false; } - aX += ForgeDirection.getOrientation(aSide).offsetX; - aY += ForgeDirection.getOrientation(aSide).offsetY; - aZ += ForgeDirection.getOrientation(aSide).offsetZ; + aX += ForgeDirection.getOrientation(ordinalSide).offsetX; + aY += ForgeDirection.getOrientation(ordinalSide).offsetY; + aZ += ForgeDirection.getOrientation(ordinalSide).offsetZ; Block aBlock = aWorld.getBlock(aX, aY, aZ); if (aBlock == null) return false; byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ); diff --git a/src/main/java/gregtech/api/items/GT_Spray_Pepper_Item.java b/src/main/java/gregtech/api/items/GT_Spray_Pepper_Item.java index 1607ae7d5b..29f6348d82 100644 --- a/src/main/java/gregtech/api/items/GT_Spray_Pepper_Item.java +++ b/src/main/java/gregtech/api/items/GT_Spray_Pepper_Item.java @@ -46,8 +46,8 @@ public class GT_Spray_Pepper_Item extends GT_Tool_Item { @Override public boolean onItemUseFirst(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, - int aSide, float hitX, float hitY, float hitZ) { - super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, aSide, hitX, hitY, hitZ); + int ordinalSide, float hitX, float hitY, float hitZ) { + super.onItemUseFirst(aStack, aPlayer, aWorld, aX, aY, aZ, ordinalSide, hitX, hitY, hitZ); if (aWorld.isRemote) { return false; } diff --git a/src/main/java/gregtech/api/logic/interfaces/PowerLogicHost.java b/src/main/java/gregtech/api/logic/interfaces/PowerLogicHost.java index 1a66e5fe83..8604c160fb 100644 --- a/src/main/java/gregtech/api/logic/interfaces/PowerLogicHost.java +++ b/src/main/java/gregtech/api/logic/interfaces/PowerLogicHost.java @@ -6,7 +6,7 @@ import gregtech.api.logic.PowerLogic; public interface PowerLogicHost { - PowerLogic getPowerLogic(ForgeDirection facing); + PowerLogic getPowerLogic(ForgeDirection side); default boolean isEnergyReceiver() { return false; diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java index 36d4aadcd5..6ea66d4956 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java @@ -76,9 +76,9 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity this.nodePath = nodePath; } - public void addToLock(TileEntity tileEntity, int side) { + public void addToLock(TileEntity tileEntity, ForgeDirection side) { if (node != null) { - final Lock lock = node.locks[side]; + final Lock lock = node.locks[side.ordinal()]; if (lock != null) { lock.addTileEntity(tileEntity); } @@ -87,9 +87,9 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } } - public void removeFromLock(TileEntity tileEntity, int side) { + public void removeFromLock(TileEntity tileEntity, ForgeDirection side) { if (node != null) { - final Lock lock = node.locks[side]; + final Lock lock = node.locks[side.ordinal()]; if (lock != null) { lock.removeTileEntity(tileEntity); } @@ -288,12 +288,12 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity (short) yCoord, zCoord, mID, - getCoverInfoAtSide((byte) 0).getCoverID(), - getCoverInfoAtSide((byte) 1).getCoverID(), - getCoverInfoAtSide((byte) 2).getCoverID(), - getCoverInfoAtSide((byte) 3).getCoverID(), - getCoverInfoAtSide((byte) 4).getCoverID(), - getCoverInfoAtSide((byte) 5).getCoverID(), + getCoverInfoAtSide(ForgeDirection.DOWN).getCoverID(), + getCoverInfoAtSide(ForgeDirection.UP).getCoverID(), + getCoverInfoAtSide(ForgeDirection.NORTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.SOUTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.WEST).getCoverID(), + getCoverInfoAtSide(ForgeDirection.EAST).getCoverID(), oTextureData = mConnections, oUpdateData = hasValidMetaTileEntity() ? mMetaTileEntity.getUpdateData() : 0, oRedstoneData = (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) @@ -317,12 +317,12 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity createNewMetatileEntity(mID); } - setCoverIDAtSide((byte) 0, aCover0); - setCoverIDAtSide((byte) 1, aCover1); - setCoverIDAtSide((byte) 2, aCover2); - setCoverIDAtSide((byte) 3, aCover3); - setCoverIDAtSide((byte) 4, aCover4); - setCoverIDAtSide((byte) 5, aCover5); + setCoverIDAtSide(ForgeDirection.DOWN, aCover0); + setCoverIDAtSide(ForgeDirection.UP, aCover1); + setCoverIDAtSide(ForgeDirection.NORTH, aCover2); + setCoverIDAtSide(ForgeDirection.SOUTH, aCover3); + setCoverIDAtSide(ForgeDirection.WEST, aCover4); + setCoverIDAtSide(ForgeDirection.EAST, aCover5); receiveClientEvent(GregTechTileClientEvents.CHANGE_COMMON_DATA, aTextureData); receiveClientEvent(GregTechTileClientEvents.CHANGE_CUSTOM_DATA, aUpdateData); @@ -436,17 +436,17 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public byte getBackFacing() { - return GT_Utility.getOppositeSide(getFrontFacing()); + public ForgeDirection getBackFacing() { + return getFrontFacing().getOpposite(); } @Override - public byte getFrontFacing() { - return 6; + public ForgeDirection getFrontFacing() { + return ForgeDirection.UNKNOWN; } @Override - public void setFrontFacing(byte aFacing) { + public void setFrontFacing(ForgeDirection aFacing) { doEnetUpdate(); } @@ -640,22 +640,22 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public boolean inputEnergyFrom(byte aSide) { + public boolean inputEnergyFrom(ForgeDirection side) { return false; } @Override - public boolean inputEnergyFrom(byte aSide, boolean waitForActive) { + public boolean inputEnergyFrom(ForgeDirection side, boolean waitForActive) { return false; } @Override - public boolean outputsEnergyTo(byte aSide) { + public boolean outputsEnergyTo(ForgeDirection side) { return false; } @Override - public boolean outputsEnergyTo(byte aSide, boolean waitForActive) { + public boolean outputsEnergyTo(ForgeDirection side, boolean waitForActive) { return false; } @@ -700,16 +700,16 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public ITexture[] getTexture(Block aBlock, byte aSide) { - final ITexture rIcon = getCoverTexture(aSide); + public ITexture[] getTexture(Block aBlock, ForgeDirection side) { + final ITexture rIcon = getCoverTexture(side); if (rIcon != null) return new ITexture[] { rIcon }; - return getTextureUncovered(aSide); + return getTextureUncovered(side); } @Override - public ITexture[] getTextureCovered(byte aSide) { - final ITexture coverTexture = getCoverTexture(aSide); - final ITexture[] textureUncovered = getTextureUncovered(aSide); + public ITexture[] getTextureCovered(ForgeDirection side) { + final ITexture coverTexture = getCoverTexture(side); + final ITexture[] textureUncovered = getTextureUncovered(side); final ITexture[] textureCovered; if (coverTexture != null) { textureCovered = Arrays.copyOf(textureUncovered, textureUncovered.length + 1); @@ -721,24 +721,24 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public ITexture[] getTextureUncovered(byte aSide) { + public ITexture[] getTextureUncovered(ForgeDirection sideDirection) { if ((mConnections & IConnectable.HAS_FRESHFOAM) != 0) return Textures.BlockIcons.FRESHFOAM; if ((mConnections & IConnectable.HAS_HARDENEDFOAM) != 0) return Textures.BlockIcons.HARDENEDFOAMS[mColor]; if ((mConnections & IConnectable.HAS_FOAM) != 0) return Textures.BlockIcons.ERROR_RENDERING; - byte tConnections = mConnections; + int tConnections = mConnections; if (tConnections == IConnectable.CONNECTED_WEST || tConnections == IConnectable.CONNECTED_EAST) - tConnections = (byte) (IConnectable.CONNECTED_WEST | IConnectable.CONNECTED_EAST); + tConnections = IConnectable.CONNECTED_WEST | IConnectable.CONNECTED_EAST; else if (tConnections == IConnectable.CONNECTED_DOWN || tConnections == IConnectable.CONNECTED_UP) - tConnections = (byte) (IConnectable.CONNECTED_DOWN | IConnectable.CONNECTED_UP); + tConnections = IConnectable.CONNECTED_DOWN | IConnectable.CONNECTED_UP; else if (tConnections == IConnectable.CONNECTED_NORTH || tConnections == IConnectable.CONNECTED_SOUTH) - tConnections = (byte) (IConnectable.CONNECTED_NORTH | IConnectable.CONNECTED_SOUTH); + tConnections = IConnectable.CONNECTED_NORTH | IConnectable.CONNECTED_SOUTH; if (hasValidMetaTileEntity()) return mMetaTileEntity.getTexture( this, - aSide, + sideDirection, tConnections, - (byte) (mColor - 1), - tConnections == 0 || (tConnections & (1 << aSide)) != 0, - getOutputRedstoneSignal(aSide) > 0); + (int) (mColor - 1), + tConnections == 0 || (tConnections & (1 << sideDirection.ordinal())) != 0, + getOutputRedstoneSignal(sideDirection) > 0); return Textures.BlockIcons.ERROR_RENDERING; } @@ -775,14 +775,15 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) { + public boolean onRightclick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ) { if (isClientSide()) { // Configure Cover, sneak can also be: screwdriver, wrench, side cutter, soldering iron if (aPlayer.isSneaking()) { - final byte tSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) - : aSide; + final ForgeDirection tSide = (getCoverIDAtSide(side) == 0) + ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) + : side; return (getCoverInfoAtSide(tSide).hasCoverGUI()); - } else if (getCoverBehaviorAtSideNew(aSide).onCoverRightclickClient(aSide, this, aPlayer, aX, aY, aZ)) { + } else if (getCoverBehaviorAtSideNew(side).onCoverRightclickClient(side, this, aPlayer, aX, aY, aZ)) { return true; } } @@ -796,9 +797,9 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity setColorization((byte) -1); return true; } - final byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); + final ForgeDirection tSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWrenchList)) { - if (mMetaTileEntity.onWrenchRightClick(aSide, tSide, aPlayer, aX, aY, aZ)) { + if (mMetaTileEntity.onWrenchRightClick(side, tSide, aPlayer, aX, aY, aZ)) { mMetaTileEntity.markDirty(); GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer); GT_Utility.sendSoundToPlayers( @@ -813,7 +814,7 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity return true; } if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sScrewdriverList)) { - if (getCoverIDAtSide(aSide) == 0 && getCoverIDAtSide(tSide) != 0) { + if (getCoverIDAtSide(side) == 0 && getCoverIDAtSide(tSide) != 0) { if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 200, aPlayer)) { setCoverDataAtSide( tSide, @@ -832,9 +833,9 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } else { if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer)) { setCoverDataAtSide( - aSide, - getCoverInfoAtSide(aSide).onCoverScrewdriverClick(aPlayer, aX, aY, aZ)); - mMetaTileEntity.onScrewdriverRightClick(aSide, aPlayer, aX, aY, aZ); + side, + getCoverInfoAtSide(side).onCoverScrewdriverClick(aPlayer, aX, aY, aZ)); + mMetaTileEntity.onScrewdriverRightClick(side, aPlayer, aX, aY, aZ); mMetaTileEntity.markDirty(); GT_Utility.sendSoundToPlayers( worldObj, @@ -880,7 +881,7 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWireCutterList)) { - if (mMetaTileEntity.onWireCutterRightClick(aSide, tSide, aPlayer, aX, aY, aZ)) { + if (mMetaTileEntity.onWireCutterRightClick(side, tSide, aPlayer, aX, aY, aZ)) { mMetaTileEntity.markDirty(); // logic handled internally GT_Utility.sendSoundToPlayers( @@ -897,7 +898,7 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sSolderingToolList)) { - if (mMetaTileEntity.onSolderingToolRightClick(aSide, tSide, aPlayer, aX, aY, aZ)) { + if (mMetaTileEntity.onSolderingToolRightClick(side, tSide, aPlayer, aX, aY, aZ)) { mMetaTileEntity.markDirty(); // logic handled internally GT_Utility.sendSoundToPlayers( @@ -910,12 +911,12 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity zCoord); } else if (GT_ModHandler.useSolderingIron(tCurrentItem, aPlayer)) { mMetaTileEntity.markDirty(); - mStrongRedstone ^= (1 << tSide); + mStrongRedstone ^= (1 << tSide.ordinal()); GT_Utility.sendChatToPlayer( aPlayer, GT_Utility.trans("091", "Redstone Output at Side ") + tSide + GT_Utility.trans("092", " set to: ") - + ((mStrongRedstone & (1 << tSide)) != 0 ? GT_Utility.trans("093", "Strong") + + ((mStrongRedstone & (1 << tSide.ordinal())) != 0 ? GT_Utility.trans("093", "Strong") : GT_Utility.trans("094", "Weak"))); GT_Utility.sendSoundToPlayers( worldObj, @@ -931,8 +932,8 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity return true; } - byte coverSide = aSide; - if (getCoverIDAtSide(aSide) == 0) coverSide = tSide; + ForgeDirection coverSide = side; + if (getCoverIDAtSide(side) == 0) coverSide = tSide; final CoverInfo coverInfo = getCoverInfoAtSide(coverSide); @@ -966,26 +967,26 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity xCoord, yCoord, zCoord); - dropCover(coverSide, aSide, false); + dropCover(coverSide, side, false); mMetaTileEntity.markDirty(); } return true; } } } else if (aPlayer.isSneaking()) { // Sneak click, no tool -> open cover config or turn back. - aSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) : aSide; - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + side = (getCoverIDAtSide(side) == 0) ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) : side; + final CoverInfo coverInfo = getCoverInfoAtSide(side); return coverInfo.isValid() && coverInfo.onCoverShiftRightClick(aPlayer); } - if (getCoverInfoAtSide(aSide).onCoverRightClick(aPlayer, aX, aY, aZ)) return true; + if (getCoverInfoAtSide(side).onCoverRightClick(aPlayer, aX, aY, aZ)) return true; } - if (!getCoverInfoAtSide(aSide).isGUIClickable()) return false; + if (!getCoverInfoAtSide(side).isGUIClickable()) return false; try { if (!aPlayer.isSneaking() && hasValidMetaTileEntity()) { - final boolean handled = mMetaTileEntity.onRightclick(this, aPlayer, aSide, aX, aY, aZ); + final boolean handled = mMetaTileEntity.onRightclick(this, aPlayer, side, aX, aY, aZ); if (handled) { mMetaTileEntity.markDirty(); } @@ -1040,10 +1041,10 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity * following two Functions. */ @Override - public int[] getAccessibleSlotsFromSide(int aSide) { - final CoverInfo coverInfo = getCoverInfoAtSide((byte) aSide); + public int[] getAccessibleSlotsFromSide(int ordinalSide) { + final CoverInfo coverInfo = getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)); if (canAccessData() && (coverInfo.letsItemsOut(-1) || coverInfo.letsItemsIn(-1))) - return mMetaTileEntity.getAccessibleSlotsFromSide(aSide); + return mMetaTileEntity.getAccessibleSlotsFromSide(ordinalSide); return GT_Values.emptyIntArray; } @@ -1051,22 +1052,21 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity * Can put aStack into Slot at Side */ @Override - public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) { - return canAccessData() && getCoverInfoAtSide((byte) aSide).letsItemsIn(aIndex) - && mMetaTileEntity.canInsertItem(aIndex, aStack, aSide); + public boolean canInsertItem(int aIndex, ItemStack aStack, int ordinalSide) { + return canAccessData() && getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)).letsItemsIn(aIndex) + && mMetaTileEntity.canInsertItem(aIndex, aStack, ordinalSide); } /** * Can pull aStack out of Slot from Side */ @Override - public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) { - return canAccessData() && getCoverBehaviorAtSideNew((byte) aSide).letsItemsOut( - (byte) aSide, - getCoverIDAtSide((byte) aSide), - getComplexCoverDataAtSide((byte) aSide), - aIndex, - this) && mMetaTileEntity.canExtractItem(aIndex, aStack, aSide); + public boolean canExtractItem(int aIndex, ItemStack aStack, int ordinalSide) { + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + return canAccessData() + && getCoverBehaviorAtSideNew(side) + .letsItemsOut(side, getCoverIDAtSide(side), getComplexCoverDataAtSide(side), aIndex, this) + && mMetaTileEntity.canExtractItem(aIndex, aStack, ordinalSide); } @Override @@ -1152,8 +1152,8 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity public void setOwnerUuid(UUID uuid) {} @Override - public byte getComparatorValue(byte aSide) { - return canAccessData() ? mMetaTileEntity.getComparatorValue(aSide) : 0; + public byte getComparatorValue(ForgeDirection side) { + return canAccessData() ? mMetaTileEntity.getComparatorValue(side) : 0; } @Override @@ -1166,96 +1166,92 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity } @Override - public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { - if (canAccessData()) return mMetaTileEntity.injectEnergyUnits(aSide, aVoltage, aAmperage); + public long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { + if (canAccessData()) return mMetaTileEntity.injectEnergyUnits(side, aVoltage, aAmperage); return 0; } @Override - public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public boolean drainEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { return false; } @Override - public boolean acceptsRotationalEnergy(byte aSide) { - if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false; - return mMetaTileEntity.acceptsRotationalEnergy(aSide); + public boolean acceptsRotationalEnergy(ForgeDirection side) { + if (!canAccessData() || getCoverIDAtSide(side) != 0) return false; + return mMetaTileEntity.acceptsRotationalEnergy(side); } @Override - public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) { - if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false; - return mMetaTileEntity.injectRotationalEnergy(aSide, aSpeed, aEnergy); + public boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy) { + if (!canAccessData() || getCoverIDAtSide(side) != 0) return false; + return mMetaTileEntity.injectRotationalEnergy(side, aSpeed, aEnergy); } - private boolean canMoveFluidOnSide(ForgeDirection aSide, Fluid aFluid, boolean isFill) { - if (aSide == ForgeDirection.UNKNOWN) return true; + private boolean canMoveFluidOnSide(ForgeDirection side, Fluid fluid, boolean isFill) { + if (side == ForgeDirection.UNKNOWN) return true; - final IFluidHandler tTileEntity = getITankContainerAtSide((byte) aSide.ordinal()); + final IFluidHandler tTileEntity = getITankContainerAtSide(side); // Only require a connection if there's something to connect to - Allows fluid cells & buckets to interact with // the pipe - if (tTileEntity != null && !mMetaTileEntity.isConnectedAtSide((byte) aSide.ordinal())) return false; + if (tTileEntity != null && !mMetaTileEntity.isConnectedAtSide(side)) return false; - if (isFill && mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidIn(aFluid)) return true; + if (isFill && mMetaTileEntity.isLiquidInput(side) && getCoverInfoAtSide(side).letsFluidIn(fluid)) return true; - if (!isFill && mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidOut(aFluid)) return true; - - return false; + return !isFill && mMetaTileEntity.isLiquidOutput(side) && getCoverInfoAtSide(side).letsFluidOut(fluid); } @Override - public int fill(ForgeDirection aSide, FluidStack aFluidStack, boolean doFill) { + public int fill(ForgeDirection side, FluidStack aFluidStack, boolean doFill) { if (mTickTimer > 5 && canAccessData() - && canMoveFluidOnSide(aSide, aFluidStack == null ? null : aFluidStack.getFluid(), true)) - return mMetaTileEntity.fill(aSide, aFluidStack, doFill); + && canMoveFluidOnSide(side, aFluidStack == null ? null : aFluidStack.getFluid(), true)) + return mMetaTileEntity.fill(side, aFluidStack, doFill); return 0; } @Override - public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) { + public FluidStack drain(ForgeDirection side, int maxDrain, boolean doDrain) { if (mTickTimer > 5 && canAccessData() && canMoveFluidOnSide( - aSide, + side, mMetaTileEntity.getFluid() == null ? null : mMetaTileEntity.getFluid() .getFluid(), false)) - return mMetaTileEntity.drain(aSide, maxDrain, doDrain); + return mMetaTileEntity.drain(side, maxDrain, doDrain); return null; } @Override - public FluidStack drain(ForgeDirection aSide, FluidStack aFluidStack, boolean doDrain) { + public FluidStack drain(ForgeDirection side, FluidStack aFluidStack, boolean doDrain) { if (mTickTimer > 5 && canAccessData() - && canMoveFluidOnSide(aSide, aFluidStack == null ? null : aFluidStack.getFluid(), false)) - return mMetaTileEntity.drain(aSide, aFluidStack, doDrain); + && canMoveFluidOnSide(side, aFluidStack == null ? null : aFluidStack.getFluid(), false)) + return mMetaTileEntity.drain(side, aFluidStack, doDrain); return null; } @Override - public boolean canFill(ForgeDirection aSide, Fluid aFluid) { - if (mTickTimer > 5 && canAccessData() && canMoveFluidOnSide(aSide, aFluid, true)) - return mMetaTileEntity.canFill(aSide, aFluid); + public boolean canFill(ForgeDirection side, Fluid aFluid) { + if (mTickTimer > 5 && canAccessData() && canMoveFluidOnSide(side, aFluid, true)) + return mMetaTileEntity.canFill(side, aFluid); return false; } @Override - public boolean canDrain(ForgeDirection aSide, Fluid aFluid) { - if (mTickTimer > 5 && canAccessData() && canMoveFluidOnSide(aSide, aFluid, false)) - return mMetaTileEntity.canDrain(aSide, aFluid); + public boolean canDrain(ForgeDirection side, Fluid aFluid) { + if (mTickTimer > 5 && canAccessData() && canMoveFluidOnSide(side, aFluid, false)) + return mMetaTileEntity.canDrain(side, aFluid); return false; } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { - final CoverInfo coverInfo = getCoverInfoAtSide((byte) aSide.ordinal()); - if (canAccessData() && (aSide == ForgeDirection.UNKNOWN - || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) && coverInfo.letsFluidIn(null)) - || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) && coverInfo.letsFluidOut(null)) - // Doesn't need to be connected to get Tank Info -- otherwise things can't connect - )) return mMetaTileEntity.getTankInfo(aSide); + public FluidTankInfo[] getTankInfo(ForgeDirection side) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); + if (canAccessData() + && (side == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput(side) && coverInfo.letsFluidIn(null)) + || (mMetaTileEntity.isLiquidOutput(side) && coverInfo.letsFluidOut(null)) + // Doesn't need to be connected to get Tank Info -- otherwise things can't connect + )) return mMetaTileEntity.getTankInfo(side); return new FluidTankInfo[] {}; } @@ -1302,13 +1298,13 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity return 1.0F; } - public boolean renderInside(byte aSide) { - if (canAccessData()) return mMetaTileEntity.renderInside(aSide); + public boolean renderInside(ForgeDirection side) { + if (canAccessData()) return mMetaTileEntity.renderInside(side); return false; } @Override - public float getBlastResistance(byte aSide) { + public float getBlastResistance(ForgeDirection side) { return (mConnections & IConnectable.HAS_FOAM) != 0 ? 50.0F : 5.0F; } @@ -1339,10 +1335,8 @@ public class BaseMetaPipeEntity extends CommonMetaTileEntity @Override public String[] getInfoData() { - { - if (canAccessData()) return getMetaTileEntity().getInfoData(); - return new String[] {}; - } + if (canAccessData()) return getMetaTileEntity().getInfoData(); + return new String[] {}; } @Override diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index 55be6c6d92..b994826d87 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -1,7 +1,6 @@ package gregtech.api.metatileentity; import static gregtech.GT_Mod.GT_FML_LOGGER; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.NW; import static gregtech.api.enums.GT_Values.V; import static gregtech.api.objects.XSTR.XSTR_INSTANCE; @@ -100,8 +99,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec private boolean oRedstone = false; private byte mColor = 0, oColor = 0, oStrongRedstone = 0, oRedstoneData = 63, oTextureData = 0, oUpdateData = 0, oTexturePage = 0; - private byte oLightValueClient = 0, oLightValue = -1, mLightValue = 0, mOtherUpgrades = 0, mFacing = 0, oFacing = 0, - mWorkData = 0; + private byte oLightValueClient = 0, oLightValue = -1, mLightValue = 0, mOtherUpgrades = 0, mWorkData = 0; + private ForgeDirection mFacing, oFacing; private int mDisplayErrorCode = 0, oX = 0, oY = 0, oZ = 0, mTimeStatisticsIndex = 0, mLagWarningCount = 0; private long oOutput = 0, mAcceptedAmperes = Long.MAX_VALUE; private long mLastCheckTick = 0; @@ -128,7 +127,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec aNBT.setByte("mLightValue", mLightValue); aNBT.setByte("mOtherUpgrades", mOtherUpgrades); aNBT.setByte("mWorkData", mWorkData); - aNBT.setShort("mFacing", mFacing); + aNBT.setShort("mFacing", (short) mFacing.ordinal()); aNBT.setString("mOwnerName", mOwnerName); aNBT.setString("mOwnerUuid", mOwnerUuid == null ? "" : mOwnerUuid.toString()); aNBT.setBoolean("mLockUpgrade", mLockUpgrade); @@ -168,7 +167,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec mColor = aNBT.getByte("mColor"); mLightValue = aNBT.getByte("mLightValue"); mWorkData = aNBT.getByte("mWorkData"); - mFacing = oFacing = (byte) aNBT.getShort("mFacing"); + mFacing = oFacing = ForgeDirection.getOrientation(aNBT.getShort("mFacing")); mOwnerName = aNBT.getString("mOwnerName"); try { mOwnerUuid = UUID.fromString(aNBT.getString("mOwnerUuid")); @@ -252,14 +251,15 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec final int precipitationHeightAtSide3 = worldObj.getPrecipitationHeight(xCoord, zCoord + 1); final int precipitationHeightAtSide4 = worldObj.getPrecipitationHeight(xCoord - 1, zCoord); final int precipitationHeightAtSide5 = worldObj.getPrecipitationHeight(xCoord + 1, zCoord); - return (getCoverIDAtSide((byte) 1) == 0 && worldObj.getPrecipitationHeight(xCoord, zCoord) - 2 < yCoord) - || (getCoverIDAtSide((byte) 2) == 0 && precipitationHeightAtSide2 - 1 < yCoord + return (getCoverIDAtSide(ForgeDirection.UP) == 0 + && worldObj.getPrecipitationHeight(xCoord, zCoord) - 2 < yCoord) + || (getCoverIDAtSide(ForgeDirection.NORTH) == 0 && precipitationHeightAtSide2 - 1 < yCoord && precipitationHeightAtSide2 > -1) - || (getCoverIDAtSide((byte) 3) == 0 && precipitationHeightAtSide3 - 1 < yCoord + || (getCoverIDAtSide(ForgeDirection.SOUTH) == 0 && precipitationHeightAtSide3 - 1 < yCoord && precipitationHeightAtSide3 > -1) - || (getCoverIDAtSide((byte) 4) == 0 && precipitationHeightAtSide4 - 1 < yCoord + || (getCoverIDAtSide(ForgeDirection.WEST) == 0 && precipitationHeightAtSide4 - 1 < yCoord && precipitationHeightAtSide4 > -1) - || (getCoverIDAtSide((byte) 5) == 0 && precipitationHeightAtSide5 - 1 < yCoord + || (getCoverIDAtSide(ForgeDirection.EAST) == 0 && precipitationHeightAtSide5 - 1 < yCoord && precipitationHeightAtSide5 > -1); } @@ -370,14 +370,15 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } if (mMetaTileEntity.isEnetOutput() || mMetaTileEntity.isEnetInput()) { - for (byte i : ALL_VALID_SIDES) { - boolean temp = isEnergyInputSide(i); - if (temp != mActiveEUInputs[i]) { - mActiveEUInputs[i] = temp; + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final int ordinalSide = side.ordinal(); + boolean temp = isEnergyInputSide(side); + if (temp != mActiveEUInputs[ordinalSide]) { + mActiveEUInputs[ordinalSide] = temp; } - temp = isEnergyOutputSide(i); - if (temp != mActiveEUOutputs[i]) { - mActiveEUOutputs[i] = temp; + temp = isEnergyOutputSide(side); + if (temp != mActiveEUOutputs[ordinalSide]) { + mActiveEUOutputs[ordinalSide] = temp; } } } @@ -397,7 +398,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } if (getEUCapacity() > 0) { if (GregTech_API.sMachineFireExplosions && getRandomNumber(1000) == 0) { - final Block tBlock = getBlockAtSide((byte) getRandomNumber(6)); + final Block tBlock = getBlockAtSide(ForgeDirection.getOrientation(getRandomNumber(6))); if (tBlock instanceof BlockFire) doEnergyExplosion(); } @@ -536,7 +537,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } if (mTickTimer > 10) { - byte tData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) + byte tData = (byte) ((mFacing.ordinal() & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0) | (mWorks ? 64 : 0) @@ -613,12 +614,12 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, + public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { if (hasValidMetaTileEntity()) { - getMetaTileEntity().getWailaBody(itemStack, currenttip, accessor, config); + getMetaTileEntity().getWailaBody(itemStack, currentTip, accessor, config); } - super.getWailaBody(itemStack, currenttip, accessor, config); + super.getWailaBody(itemStack, currentTip, accessor, config); } @Override @@ -639,13 +640,13 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec (short) yCoord, zCoord, mID, - getCoverInfoAtSide((byte) 0).getCoverID(), - getCoverInfoAtSide((byte) 1).getCoverID(), - getCoverInfoAtSide((byte) 2).getCoverID(), - getCoverInfoAtSide((byte) 3).getCoverID(), - getCoverInfoAtSide((byte) 4).getCoverID(), - getCoverInfoAtSide((byte) 5).getCoverID(), - oTextureData = (byte) ((mFacing & 7) | (mActive ? 8 : 0) + getCoverInfoAtSide(ForgeDirection.DOWN).getCoverID(), + getCoverInfoAtSide(ForgeDirection.UP).getCoverID(), + getCoverInfoAtSide(ForgeDirection.NORTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.SOUTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.WEST).getCoverID(), + getCoverInfoAtSide(ForgeDirection.EAST).getCoverID(), + oTextureData = (byte) ((mFacing.ordinal() & 7) | (mActive ? 8 : 0) | (mRedstone ? 16 : 0) | (mLockUpgrade ? 32 : 0) | (mWorks ? 64 : 0)), @@ -675,12 +676,12 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec createNewMetatileEntity(mID); } - setCoverIDAtSide((byte) 0, aCover0); - setCoverIDAtSide((byte) 1, aCover1); - setCoverIDAtSide((byte) 2, aCover2); - setCoverIDAtSide((byte) 3, aCover3); - setCoverIDAtSide((byte) 4, aCover4); - setCoverIDAtSide((byte) 5, aCover5); + setCoverIDAtSide(ForgeDirection.DOWN, aCover0); + setCoverIDAtSide(ForgeDirection.UP, aCover1); + setCoverIDAtSide(ForgeDirection.NORTH, aCover2); + setCoverIDAtSide(ForgeDirection.SOUTH, aCover3); + setCoverIDAtSide(ForgeDirection.WEST, aCover4); + setCoverIDAtSide(ForgeDirection.EAST, aCover5); receiveClientEvent(GregTechTileClientEvents.CHANGE_COMMON_DATA, aTextureData); receiveClientEvent(GregTechTileClientEvents.CHANGE_CUSTOM_DATA, aUpdateData & 0x7F); @@ -725,7 +726,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec issueTextureUpdate(); switch (aEventID) { case GregTechTileClientEvents.CHANGE_COMMON_DATA -> { - mFacing = (byte) (aValue & 7); + mFacing = ForgeDirection.getOrientation((byte) (aValue & 7)); mActive = ((aValue & 8) != 0); mRedstone = ((aValue & 16) != 0); // mLockUpgrade = ((aValue&32) != 0); @@ -844,17 +845,17 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public byte getBackFacing() { - return GT_Utility.getOppositeSide(mFacing); + public ForgeDirection getBackFacing() { + return mFacing.getOpposite(); } @Override - public byte getFrontFacing() { + public ForgeDirection getFrontFacing() { return mFacing; } @Override - public void setFrontFacing(byte aFacing) { + public void setFrontFacing(ForgeDirection aFacing) { if (isValidFacing(aFacing)) { mFacing = aFacing; mMetaTileEntity.onFacingChange(); @@ -1075,29 +1076,27 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public boolean inputEnergyFrom(byte aSide) { - return inputEnergyFrom(aSide, true); + public boolean inputEnergyFrom(ForgeDirection side) { + return inputEnergyFrom(side, true); } @Override - public boolean inputEnergyFrom(byte aSide, boolean waitForActive) { - if (aSide == 6) return true; - if (isServerSide() && waitForActive) - return ((aSide >= 0 && aSide < 6) && mActiveEUInputs[aSide]) && !mReleaseEnergy; - return isEnergyInputSide(aSide); + public boolean inputEnergyFrom(ForgeDirection side, boolean waitForActive) { + if (side == ForgeDirection.UNKNOWN) return true; + if (isServerSide() && waitForActive) return mActiveEUInputs[side.ordinal()] && !mReleaseEnergy; + return isEnergyInputSide(side); } @Override - public boolean outputsEnergyTo(byte aSide) { - return outputsEnergyTo(aSide, true); + public boolean outputsEnergyTo(ForgeDirection side) { + return outputsEnergyTo(side, true); } @Override - public boolean outputsEnergyTo(byte aSide, boolean waitForActive) { - if (aSide == 6) return true; - if (isServerSide() && waitForActive) - return ((aSide >= 0 && aSide < 6) && mActiveEUOutputs[aSide]) || mReleaseEnergy; - return isEnergyOutputSide(aSide); + public boolean outputsEnergyTo(ForgeDirection side, boolean waitForActive) { + if (side == ForgeDirection.UNKNOWN) return true; + if (isServerSide() && waitForActive) return (mActiveEUOutputs[side.ordinal()]) || mReleaseEnergy; + return isEnergyOutputSide(side); } @Override @@ -1114,9 +1113,9 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec if (isServerSide() && (isEnetInput() || isEnetOutput())) { final int time = MinecraftServer.getServer() .getTickCounter(); - for (byte i : ALL_VALID_SIDES) { - if (outputsEnergyTo(i, false) || inputEnergyFrom(i, false)) { - final IGregTechTileEntity TE = getIGregTechTileEntityAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (outputsEnergyTo(side, false) || inputEnergyFrom(side, false)) { + final IGregTechTileEntity TE = getIGregTechTileEntityAtSide(side); if (TE instanceof BaseMetaPipeEntity) { final Node node = ((BaseMetaPipeEntity) TE).getNode(); if (node == null) { @@ -1201,11 +1200,11 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public ITexture[] getTexture(Block aBlock, byte aSide) { - final ITexture coverTexture = getCoverTexture(aSide); + public ITexture[] getTexture(Block aBlock, ForgeDirection side) { + final ITexture coverTexture = getCoverTexture(side); final ITexture[] textureUncovered = hasValidMetaTileEntity() ? mMetaTileEntity - .getTexture(this, aSide, mFacing, (byte) (mColor - 1), mActive, getOutputRedstoneSignal(aSide) > 0) + .getTexture(this, side, mFacing, (byte) (mColor - 1), mActive, getOutputRedstoneSignal(side) > 0) : Textures.BlockIcons.ERROR_RENDERING; final ITexture[] textureCovered; if (coverTexture != null) { @@ -1217,22 +1216,22 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } } - private boolean isEnergyInputSide(byte aSide) { - if (aSide >= 0 && aSide < 6) { - if (!getCoverInfoAtSide(aSide).letsEnergyIn()) return false; + private boolean isEnergyInputSide(ForgeDirection side) { + if (side != ForgeDirection.UNKNOWN) { + if (!getCoverInfoAtSide(side).letsEnergyIn()) return false; if (isInvalid() || mReleaseEnergy) return false; if (canAccessData() && mMetaTileEntity.isElectric() && mMetaTileEntity.isEnetInput()) - return mMetaTileEntity.isInputFacing(aSide); + return mMetaTileEntity.isInputFacing(side); } return false; } - private boolean isEnergyOutputSide(byte aSide) { - if (aSide >= 0 && aSide < 6) { - if (!getCoverInfoAtSide(aSide).letsEnergyOut()) return false; + private boolean isEnergyOutputSide(ForgeDirection side) { + if (side != ForgeDirection.UNKNOWN) { + if (!getCoverInfoAtSide(side).letsEnergyOut()) return false; if (isInvalid() || mReleaseEnergy) return mReleaseEnergy; if (canAccessData() && mMetaTileEntity.isElectric() && mMetaTileEntity.isEnetOutput()) - return mMetaTileEntity.isOutputFacing(aSide); + return mMetaTileEntity.isOutputFacing(side); } return false; } @@ -1414,18 +1413,19 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public boolean onRightclick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) { + public boolean onRightclick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ) { if (isClientSide()) { // Configure Cover, sneak can also be: screwdriver, wrench, side cutter, soldering iron if (aPlayer.isSneaking()) { - final byte tSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) - : aSide; + final ForgeDirection tSide = (getCoverIDAtSide(side) == 0) + ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) + : side; return (getCoverBehaviorAtSideNew(tSide).hasCoverGUI()); - } else if (getCoverBehaviorAtSideNew(aSide).onCoverRightclickClient(aSide, this, aPlayer, aX, aY, aZ)) { + } else if (getCoverBehaviorAtSideNew(side).onCoverRightclickClient(side, this, aPlayer, aX, aY, aZ)) { return true; } - if (!getCoverInfoAtSide(aSide).isGUIClickable()) return false; + if (!getCoverInfoAtSide(side).isGUIClickable()) return false; } if (isServerSide()) { @@ -1442,7 +1442,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWrenchList)) { if (aPlayer.isSneaking() && mMetaTileEntity instanceof GT_MetaTileEntity_BasicMachine && ((GT_MetaTileEntity_BasicMachine) mMetaTileEntity) - .setMainFacing(GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ))) { + .setMainFacing(GT_Utility.determineWrenchingSide(side, aX, aY, aZ))) { GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer); GT_Utility.sendSoundToPlayers( worldObj, @@ -1454,8 +1454,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec zCoord); cableUpdateDelay = 10; } else if (mMetaTileEntity.onWrenchRightClick( - aSide, - GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ), + side, + GT_Utility.determineWrenchingSide(side, aX, aY, aZ), aPlayer, aX, aY, @@ -1477,17 +1477,17 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sScrewdriverList)) { if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 200, aPlayer)) { setCoverDataAtSide( - aSide, - getCoverBehaviorAtSideNew(aSide).onCoverScrewdriverClick( - aSide, - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + side, + getCoverBehaviorAtSideNew(side).onCoverScrewdriverClick( + side, + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this, aPlayer, aX, aY, aZ)); - mMetaTileEntity.onScrewdriverRightClick(aSide, aPlayer, aX, aY, aZ); + mMetaTileEntity.onScrewdriverRightClick(side, aPlayer, aX, aY, aZ); GT_Utility.sendSoundToPlayers( worldObj, SoundResource.IC2_TOOLS_WRENCH, @@ -1548,8 +1548,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sSolderingToolList)) { - final byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); - if (mMetaTileEntity.onSolderingToolRightClick(aSide, tSide, aPlayer, aX, aY, aZ)) { + final ForgeDirection tSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); + if (mMetaTileEntity.onSolderingToolRightClick(side, tSide, aPlayer, aX, aY, aZ)) { // logic handled internally GT_Utility.sendSoundToPlayers( worldObj, @@ -1560,12 +1560,13 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec yCoord, zCoord); } else if (GT_ModHandler.useSolderingIron(tCurrentItem, aPlayer)) { - mStrongRedstone ^= (1 << tSide); + mStrongRedstone ^= (1 << tSide.ordinal()); GT_Utility.sendChatToPlayer( aPlayer, GT_Utility.trans("091", "Redstone Output at Side ") + tSide + GT_Utility.trans("092", " set to: ") - + ((mStrongRedstone & (1 << tSide)) != 0 ? GT_Utility.trans("093", "Strong") + + ((mStrongRedstone & (1 << tSide.ordinal())) != 0 + ? GT_Utility.trans("093", "Strong") : GT_Utility.trans("094", "Weak"))); GT_Utility.sendSoundToPlayers( worldObj, @@ -1583,8 +1584,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWireCutterList)) { - final byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); - if (mMetaTileEntity.onWireCutterRightClick(aSide, tSide, aPlayer, aX, aY, aZ)) { + final ForgeDirection tSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); + if (mMetaTileEntity.onWireCutterRightClick(side, tSide, aPlayer, aX, aY, aZ)) { // logic handled internally GT_Utility.sendSoundToPlayers( worldObj, @@ -1600,8 +1601,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec return true; } - byte coverSide = aSide; - if (getCoverIDAtSide(aSide) == 0) coverSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); + ForgeDirection coverSide = side; + if (getCoverIDAtSide(side) == 0) coverSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); if (getCoverIDAtSide(coverSide) == 0) { if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sCovers.keySet())) { @@ -1633,34 +1634,33 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec xCoord, yCoord, zCoord); - dropCover(coverSide, aSide, false); + dropCover(coverSide, side, false); } return true; } } // End item != null } else if (aPlayer.isSneaking()) { // Sneak click, no tool -> open cover config if possible. - aSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) - : aSide; - return getCoverIDAtSide(aSide) > 0 && getCoverBehaviorAtSideNew(aSide).onCoverShiftRightClick( - aSide, - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + side = (getCoverIDAtSide(side) == 0) ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) : side; + return getCoverIDAtSide(side) > 0 && getCoverBehaviorAtSideNew(side).onCoverShiftRightClick( + side, + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this, aPlayer); } - if (getCoverBehaviorAtSideNew(aSide).onCoverRightClick( - aSide, - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + if (getCoverBehaviorAtSideNew(side).onCoverRightClick( + side, + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this, aPlayer, aX, aY, aZ)) return true; - if (!getCoverInfoAtSide(aSide).isGUIClickable()) return false; + if (!getCoverInfoAtSide(side).isGUIClickable()) return false; if (isUpgradable() && tCurrentItem != null) { if (ItemList.Upgrade_Muffler.isStackEqual(aPlayer.inventory.getCurrentItem())) { @@ -1700,7 +1700,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec try { if (!aPlayer.isSneaking() && hasValidMetaTileEntity()) - return mMetaTileEntity.onRightclick(this, aPlayer, aSide, aX, aY, aZ); + return mMetaTileEntity.onRightclick(this, aPlayer, side, aX, aY, aZ); } catch (Throwable e) { GT_Log.err.println( "Encountered Exception while rightclicking TileEntity, the Game should've crashed now, but I prevented that. Please report immediately to GregTech Intergalactical!!!"); @@ -1758,10 +1758,10 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec * following two Functions. */ @Override - public int[] getAccessibleSlotsFromSide(int aSide) { - final CoverInfo coverInfo = getCoverInfoAtSide((byte) aSide); + public int[] getAccessibleSlotsFromSide(int ordinalSide) { + final CoverInfo coverInfo = getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)); if (canAccessData() && (coverInfo.letsItemsOut(-1) || coverInfo.letsItemsIn(-1))) - return mMetaTileEntity.getAccessibleSlotsFromSide(aSide); + return mMetaTileEntity.getAccessibleSlotsFromSide(ordinalSide); return GT_Values.emptyIntArray; } @@ -1769,25 +1769,22 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec * Can put aStack into Slot at Side */ @Override - public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) { + public boolean canInsertItem(int slotIndex, ItemStack stack, int ordinalSide) { return canAccessData() && (mRunningThroughTick || !mInputDisabled) - && getCoverInfoAtSide((byte) aSide).letsItemsIn(aIndex) - && mMetaTileEntity.canInsertItem(aIndex, aStack, aSide); + && getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)).letsItemsIn(slotIndex) + && mMetaTileEntity.canInsertItem(slotIndex, stack, ordinalSide); } /** - * Can pull aStack out of Slot from Side + * Can pull stack out of Slot from Side */ @Override - public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) { + public boolean canExtractItem(int slotIndex, ItemStack stack, int ordinalSide) { + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); return canAccessData() && (mRunningThroughTick || !mOutputDisabled) - && getCoverBehaviorAtSideNew((byte) aSide).letsItemsOut( - (byte) aSide, - getCoverIDAtSide((byte) aSide), - getComplexCoverDataAtSide((byte) aSide), - aIndex, - this) - && mMetaTileEntity.canExtractItem(aIndex, aStack, aSide); + && getCoverBehaviorAtSideNew(side) + .letsItemsOut(side, getCoverIDAtSide(side), getComplexCoverDataAtSide(side), slotIndex, this) + && mMetaTileEntity.canExtractItem(slotIndex, stack, ordinalSide); } @Override @@ -1796,9 +1793,9 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public byte getGeneralRS(byte aSide) { + public byte getGeneralRS(ForgeDirection side) { if (mMetaTileEntity == null) return 0; - return mMetaTileEntity.allowGeneralRedstoneOutput() ? mSidedRedstone[aSide] : 0; + return mMetaTileEntity.allowGeneralRedstoneOutput() ? mSidedRedstone[side.ordinal()] : 0; } @Override @@ -1894,11 +1891,11 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - protected void updateOutputRedstoneSignal(byte aSide) { + protected void updateOutputRedstoneSignal(ForgeDirection side) { if (mMetaTileEntity.hasSidedRedstoneOutputBehavior()) { - setOutputRedstoneSignal(aSide, (byte) 0); + setOutputRedstoneSignal(side, (byte) 0); } else { - setOutputRedstoneSignal(aSide, (byte) 15); + setOutputRedstoneSignal(side, (byte) 15); } } @@ -1925,8 +1922,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public byte getComparatorValue(byte aSide) { - return canAccessData() ? mMetaTileEntity.getComparatorValue(aSide) : 0; + public byte getComparatorValue(ForgeDirection side) { + return canAccessData() ? mMetaTileEntity.getComparatorValue(side) : 0; } @Override @@ -1939,9 +1936,9 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { if (!canAccessData() || !mMetaTileEntity.isElectric() - || !inputEnergyFrom(aSide) + || !inputEnergyFrom(side) || aAmperage <= 0 || aVoltage <= 0 || getStoredEU() >= getEUCapacity() @@ -1967,9 +1964,9 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public boolean drainEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { if (!canAccessData() || !mMetaTileEntity.isElectric() - || !outputsEnergyTo(aSide) + || !outputsEnergyTo(side) || getStoredEU() - (aVoltage * aAmperage) < mMetaTileEntity.getMinimumStoredEU()) return false; if (decreaseStoredEU(aVoltage * aAmperage, false)) { mAverageEUOutput[mAverageEUOutputIndex] += aVoltage * aAmperage; @@ -1979,78 +1976,76 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public boolean acceptsRotationalEnergy(byte aSide) { - if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false; - return mMetaTileEntity.acceptsRotationalEnergy(aSide); + public boolean acceptsRotationalEnergy(ForgeDirection side) { + if (!canAccessData() || getCoverIDAtSide(side) != 0) return false; + return mMetaTileEntity.acceptsRotationalEnergy(side); } @Override - public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) { - if (!canAccessData() || getCoverIDAtSide(aSide) != 0) return false; - return mMetaTileEntity.injectRotationalEnergy(aSide, aSpeed, aEnergy); + public boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy) { + if (!canAccessData() || getCoverIDAtSide(side) != 0) return false; + return mMetaTileEntity.injectRotationalEnergy(side, aSpeed, aEnergy); } @Override - public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { + public int fill(ForgeDirection side, FluidStack aFluid, boolean doFill) { if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) - && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidIn(aFluid == null ? null : aFluid.getFluid())))) - return mMetaTileEntity.fill(aSide, aFluid, doFill); + && (side == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput(side) + && getCoverInfoAtSide(side).letsFluidIn(aFluid == null ? null : aFluid.getFluid())))) + return mMetaTileEntity.fill(side, aFluid, doFill); return 0; } @Override - public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) { + public FluidStack drain(ForgeDirection side, int maxDrain, boolean doDrain) { if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) - && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidOut( + && (side == ForgeDirection.UNKNOWN + || (mMetaTileEntity.isLiquidOutput(side) && getCoverInfoAtSide(side).letsFluidOut( mMetaTileEntity.getFluid() == null ? null : mMetaTileEntity.getFluid() .getFluid())))) - return mMetaTileEntity.drain(aSide, maxDrain, doDrain); + return mMetaTileEntity.drain(side, maxDrain, doDrain); return null; } @Override - public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) { + public FluidStack drain(ForgeDirection side, FluidStack aFluid, boolean doDrain) { if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) - && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidOut(aFluid == null ? null : aFluid.getFluid())))) - return mMetaTileEntity.drain(aSide, aFluid, doDrain); + && (side == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput(side) + && getCoverInfoAtSide(side).letsFluidOut(aFluid == null ? null : aFluid.getFluid())))) + return mMetaTileEntity.drain(side, aFluid, doDrain); return null; } @Override - public boolean canFill(ForgeDirection aSide, Fluid aFluid) { + public boolean canFill(ForgeDirection side, Fluid aFluid) { if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mInputDisabled) - && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidInput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidIn(aFluid)))) - return mMetaTileEntity.canFill(aSide, aFluid); + && (side == ForgeDirection.UNKNOWN + || (mMetaTileEntity.isLiquidInput(side) && getCoverInfoAtSide(side).letsFluidIn(aFluid)))) + return mMetaTileEntity.canFill(side, aFluid); return false; } @Override - public boolean canDrain(ForgeDirection aSide, Fluid aFluid) { + public boolean canDrain(ForgeDirection side, Fluid aFluid) { if (mTickTimer > 5 && canAccessData() && (mRunningThroughTick || !mOutputDisabled) - && (aSide == ForgeDirection.UNKNOWN || (mMetaTileEntity.isLiquidOutput((byte) aSide.ordinal()) - && getCoverInfoAtSide((byte) aSide.ordinal()).letsFluidOut(aFluid)))) - return mMetaTileEntity.canDrain(aSide, aFluid); + && (side == ForgeDirection.UNKNOWN + || (mMetaTileEntity.isLiquidOutput(side) && getCoverInfoAtSide(side).letsFluidOut(aFluid)))) + return mMetaTileEntity.canDrain(side, aFluid); return false; } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { - final byte tSide = (byte) aSide.ordinal(); - - if (canAccessData() && (aSide == ForgeDirection.UNKNOWN - || (mMetaTileEntity.isLiquidInput(tSide) && getCoverInfoAtSide(tSide).letsFluidIn(null)) - || (mMetaTileEntity.isLiquidOutput(tSide) && getCoverInfoAtSide(tSide).letsFluidOut(null)))) - return mMetaTileEntity.getTankInfo(aSide); + public FluidTankInfo[] getTankInfo(ForgeDirection side) { + if (canAccessData() && (side == ForgeDirection.UNKNOWN + || (mMetaTileEntity.isLiquidInput(side) && getCoverInfoAtSide(side).letsFluidIn(null)) + || (mMetaTileEntity.isLiquidOutput(side) && getCoverInfoAtSide(side).letsFluidOut(null)))) + return mMetaTileEntity.getTankInfo(side); return new FluidTankInfo[] {}; } @@ -2058,7 +2053,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec return oOutput; } - public boolean isTeleporterCompatible(ForgeDirection aSide) { + public boolean isTeleporterCompatible(ForgeDirection side) { return canAccessData() && mMetaTileEntity.isTeleporterCompatible(); } @@ -2068,15 +2063,15 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } public double injectEnergyUnits(ForgeDirection aDirection, double aAmount) { - return injectEnergyUnits((byte) aDirection.ordinal(), (int) aAmount, 1) > 0 ? 0 : aAmount; + return injectEnergyUnits(aDirection, (int) aAmount, 1) > 0 ? 0 : aAmount; } public boolean acceptsEnergyFrom(TileEntity aEmitter, ForgeDirection aDirection) { - return inputEnergyFrom((byte) aDirection.ordinal()); + return inputEnergyFrom(aDirection); } public boolean emitsEnergyTo(TileEntity aReceiver, ForgeDirection aDirection) { - return outputsEnergyTo((byte) aDirection.ordinal()); + return outputsEnergyTo(aDirection); } public double getOfferedEnergy() { @@ -2091,7 +2086,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } public int injectEnergy(ForgeDirection aForgeDirection, int aAmount) { - return injectEnergyUnits((byte) aForgeDirection.ordinal(), aAmount, 1) > 0 ? 0 : aAmount; + return injectEnergyUnits(aForgeDirection, aAmount, 1) > 0 ? 0 : aAmount; } public int addEnergy(int aEnergy) { @@ -2136,34 +2131,34 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } public int injectEnergy(Direction aDirection, int aAmount) { - return injectEnergyUnits((byte) aDirection.toSideValue(), aAmount, 1) > 0 ? 0 : aAmount; + return injectEnergyUnits(aDirection.toForgeDirection(), aAmount, 1) > 0 ? 0 : aAmount; } - public boolean isTeleporterCompatible(Direction aSide) { + public boolean isTeleporterCompatible(Direction ignoredDirection) { return canAccessData() && mMetaTileEntity.isTeleporterCompatible(); } - public boolean acceptsEnergyFrom(TileEntity aReceiver, Direction aDirection) { - return inputEnergyFrom((byte) aDirection.toSideValue()); + public boolean acceptsEnergyFrom(TileEntity ignoredTileEntity, Direction aDirection) { + return inputEnergyFrom(aDirection.toForgeDirection()); } - public boolean emitsEnergyTo(TileEntity aReceiver, Direction aDirection) { - return outputsEnergyTo((byte) aDirection.toSideValue()); + public boolean emitsEnergyTo(TileEntity ignoredTileEntity, Direction aDirection) { + return outputsEnergyTo(aDirection.toForgeDirection()); } @Override - public boolean addStackToSlot(int aIndex, ItemStack aStack) { - if (GT_Utility.isStackInvalid(aStack)) return true; - if (aIndex < 0 || aIndex >= getSizeInventory()) return false; - final ItemStack tStack = getStackInSlot(aIndex); - if (GT_Utility.isStackInvalid(tStack)) { - setInventorySlotContents(aIndex, aStack); + public boolean addStackToSlot(int slotIndex, ItemStack stack) { + if (GT_Utility.isStackInvalid(stack)) return true; + if (slotIndex < 0 || slotIndex >= getSizeInventory()) return false; + final ItemStack toStack = getStackInSlot(slotIndex); + if (GT_Utility.isStackInvalid(toStack)) { + setInventorySlotContents(slotIndex, stack); return true; } - aStack = GT_OreDictUnificator.get(aStack); - if (GT_Utility.areStacksEqual(tStack, aStack) - && tStack.stackSize + aStack.stackSize <= Math.min(aStack.getMaxStackSize(), getInventoryStackLimit())) { - tStack.stackSize += aStack.stackSize; + final ItemStack fromStack = GT_OreDictUnificator.get(stack); + if (GT_Utility.areStacksEqual(toStack, fromStack) && toStack.stackSize + fromStack.stackSize + <= Math.min(fromStack.getMaxStackSize(), getInventoryStackLimit())) { + toStack.stackSize += fromStack.stackSize; markDirty(); return true; } @@ -2189,8 +2184,8 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec } @Override - public float getBlastResistance(byte aSide) { - return canAccessData() ? Math.max(0, getMetaTileEntity().getExplosionResistance(aSide)) : 10.0F; + public float getBlastResistance(ForgeDirection side) { + return canAccessData() ? Math.max(0, getMetaTileEntity().getExplosionResistance(side)) : 10.0F; } @Override @@ -2332,7 +2327,7 @@ public class BaseMetaTileEntity extends CommonMetaTileEntity implements IGregTec @Override public IGridNode getGridNode(ForgeDirection forgeDirection) { - if (mFacing != forgeDirection.ordinal()) return null; + if (mFacing != forgeDirection) return null; final AENetworkProxy gp = getProxy(); return gp != null ? gp.getNode() : null; } diff --git a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java index 2b9894a616..618dc9b662 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseTileEntity.java @@ -1,6 +1,5 @@ package gregtech.api.metatileentity; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.COMPASS_DIRECTIONS; import static gregtech.api.enums.GT_Values.GT; import static gregtech.api.enums.GT_Values.NW; @@ -103,16 +102,17 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje private final ChunkCoordinates mReturnedCoordinates = new ChunkCoordinates(); - public static byte getSideForPlayerPlacing(Entity aPlayer, byte aDefaultFacing, boolean[] aAllowedFacings) { + public static ForgeDirection getSideForPlayerPlacing(Entity aPlayer, ForgeDirection defaultFacing, + boolean[] aAllowedFacings) { if (aPlayer != null) { - if (aPlayer.rotationPitch >= 65 && aAllowedFacings[SIDE_UP]) return SIDE_UP; - if (aPlayer.rotationPitch <= -65 && aAllowedFacings[SIDE_DOWN]) return SIDE_DOWN; + 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 rFacing; + if (aAllowedFacings[rFacing]) return ForgeDirection.getOrientation(rFacing); } - for (final byte tSide : ALL_VALID_SIDES) if (aAllowedFacings[tSide]) return tSide; - return aDefaultFacing; + for (final ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) if (aAllowedFacings[dir.ordinal()]) return dir; + return defaultFacing; } private void clearNullMarkersFromTileEntityBuffer() { @@ -156,18 +156,18 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final int getOffsetX(byte aSide, int aMultiplier) { - return xCoord + ForgeDirection.getOrientation(aSide).offsetX * aMultiplier; + public final int getOffsetX(ForgeDirection side, int aMultiplier) { + return xCoord + side.offsetX * aMultiplier; } @Override - public final short getOffsetY(byte aSide, int aMultiplier) { - return (short) (yCoord + ForgeDirection.getOrientation(aSide).offsetY * aMultiplier); + public final short getOffsetY(ForgeDirection side, int aMultiplier) { + return (short) (yCoord + side.offsetY * aMultiplier); } @Override - public final int getOffsetZ(byte aSide, int aMultiplier) { - return zCoord + ForgeDirection.getOrientation(aSide).offsetZ * aMultiplier; + public final int getOffsetZ(ForgeDirection side, int aMultiplier) { + return zCoord + side.offsetZ * aMultiplier; } @Override @@ -224,13 +224,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final Block getBlockAtSide(byte aSide) { - return getBlockAtSideAndDistance(aSide, 1); + public final Block getBlockAtSide(ForgeDirection side) { + return getBlockAtSideAndDistance(side, 1); } @Override - public final Block getBlockAtSideAndDistance(byte aSide, int aDistance) { - return getBlock(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final Block getBlockAtSideAndDistance(ForgeDirection side, int aDistance) { + return getBlock(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -239,13 +239,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final byte getMetaIDAtSide(byte aSide) { - return getMetaIDAtSideAndDistance(aSide, 1); + public final byte getMetaIDAtSide(ForgeDirection side) { + return getMetaIDAtSideAndDistance(side, 1); } @Override - public final byte getMetaIDAtSideAndDistance(byte aSide, int aDistance) { - return getMetaID(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final byte getMetaIDAtSideAndDistance(ForgeDirection side, int aDistance) { + return getMetaID(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -254,13 +254,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final byte getLightLevelAtSide(byte aSide) { - return getLightLevelAtSideAndDistance(aSide, 1); + public final byte getLightLevelAtSide(ForgeDirection side) { + return getLightLevelAtSideAndDistance(side, 1); } @Override - public final byte getLightLevelAtSideAndDistance(byte aSide, int aDistance) { - return getLightLevel(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final byte getLightLevelAtSideAndDistance(ForgeDirection side, int aDistance) { + return getLightLevel(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -269,13 +269,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getOpacityAtSide(byte aSide) { - return getOpacityAtSideAndDistance(aSide, 1); + public final boolean getOpacityAtSide(ForgeDirection side) { + return getOpacityAtSideAndDistance(side, 1); } @Override - public final boolean getOpacityAtSideAndDistance(byte aSide, int aDistance) { - return getOpacity(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final boolean getOpacityAtSideAndDistance(ForgeDirection side, int aDistance) { + return getOpacity(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -284,13 +284,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getSkyAtSide(byte aSide) { - return getSkyAtSideAndDistance(aSide, 1); + public final boolean getSkyAtSide(ForgeDirection side) { + return getSkyAtSideAndDistance(side, 1); } @Override - public final boolean getSkyAtSideAndDistance(byte aSide, int aDistance) { - return getSky(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final boolean getSkyAtSideAndDistance(ForgeDirection side, int aDistance) { + return getSky(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -299,13 +299,13 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final boolean getAirAtSide(byte aSide) { - return getAirAtSideAndDistance(aSide, 1); + public final boolean getAirAtSide(ForgeDirection side) { + return getAirAtSideAndDistance(side, 1); } @Override - public final boolean getAirAtSideAndDistance(byte aSide, int aDistance) { - return getAir(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + public final boolean getAirAtSideAndDistance(ForgeDirection side, int aDistance) { + return getAir(getOffsetX(side, aDistance), getOffsetY(side, aDistance), getOffsetZ(side, aDistance)); } @Override @@ -314,9 +314,9 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final TileEntity getTileEntityAtSideAndDistance(byte aSide, int aDistance) { - if (aDistance == 1) return getTileEntityAtSide(aSide); - return getTileEntity(getOffsetX(aSide, aDistance), getOffsetY(aSide, aDistance), getOffsetZ(aSide, aDistance)); + 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)); } @Override @@ -334,15 +334,15 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IInventory getIInventoryAtSide(byte aSide) { - final TileEntity tTileEntity = getTileEntityAtSide(aSide); + public final IInventory getIInventoryAtSide(ForgeDirection side) { + final TileEntity tTileEntity = getTileEntityAtSide(side); if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity; return null; } @Override - public final IInventory getIInventoryAtSideAndDistance(byte aSide, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(aSide, aDistance); + public final IInventory getIInventoryAtSideAndDistance(ForgeDirection side, int aDistance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); if (tTileEntity instanceof IInventory) return (IInventory) tTileEntity; return null; } @@ -362,15 +362,15 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IFluidHandler getITankContainerAtSide(byte aSide) { - final TileEntity tTileEntity = getTileEntityAtSide(aSide); + public final IFluidHandler getITankContainerAtSide(ForgeDirection side) { + final TileEntity tTileEntity = getTileEntityAtSide(side); if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity; return null; } @Override - public final IFluidHandler getITankContainerAtSideAndDistance(byte aSide, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(aSide, aDistance); + public final IFluidHandler getITankContainerAtSideAndDistance(ForgeDirection side, int aDistance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); if (tTileEntity instanceof IFluidHandler) return (IFluidHandler) tTileEntity; return null; } @@ -390,15 +390,15 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final IGregTechTileEntity getIGregTechTileEntityAtSide(byte aSide) { - final TileEntity tTileEntity = getTileEntityAtSide(aSide); + public final IGregTechTileEntity getIGregTechTileEntityAtSide(ForgeDirection side) { + final TileEntity tTileEntity = getTileEntityAtSide(side); if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity; return null; } @Override - public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte aSide, int aDistance) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(aSide, aDistance); + public final IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(ForgeDirection side, int aDistance) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, aDistance); if (tTileEntity instanceof IGregTechTileEntity) return (IGregTechTileEntity) tTileEntity; return null; } @@ -453,30 +453,31 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje } @Override - public final TileEntity getTileEntityAtSide(byte aSide) { - if (aSide < 0 || aSide >= 6 || mBufferedTileEntities[aSide] == this) return null; - final int tX = getOffsetX(aSide, 1); - final int tY = getOffsetY(aSide, 1); - final int tZ = getOffsetZ(aSide, 1); + public final TileEntity getTileEntityAtSide(ForgeDirection side) { + final int ordinalSide = side.ordinal(); + if (side == ForgeDirection.UNKNOWN || mBufferedTileEntities[ordinalSide] == this) return null; + final int tX = getOffsetX(side, 1); + final int tY = getOffsetY(side, 1); + final int tZ = getOffsetZ(side, 1); if (crossedChunkBorder(tX, tZ)) { - mBufferedTileEntities[aSide] = null; + mBufferedTileEntities[ordinalSide] = null; if (ignoreUnloadedChunks && !worldObj.blockExists(tX, tY, tZ)) return null; } - if (mBufferedTileEntities[aSide] == null) { - mBufferedTileEntities[aSide] = worldObj.getTileEntity(tX, tY, tZ); - if (mBufferedTileEntities[aSide] == null) { - mBufferedTileEntities[aSide] = this; + if (mBufferedTileEntities[ordinalSide] == null) { + mBufferedTileEntities[ordinalSide] = worldObj.getTileEntity(tX, tY, tZ); + if (mBufferedTileEntities[ordinalSide] == null) { + mBufferedTileEntities[ordinalSide] = this; return null; } - return mBufferedTileEntities[aSide]; + return mBufferedTileEntities[ordinalSide]; } - if (mBufferedTileEntities[aSide].isInvalid()) { - mBufferedTileEntities[aSide] = null; - return getTileEntityAtSide(aSide); + if (mBufferedTileEntities[ordinalSide].isInvalid()) { + mBufferedTileEntities[ordinalSide] = null; + return getTileEntityAtSide(side); } - if (mBufferedTileEntities[aSide].xCoord == tX && mBufferedTileEntities[aSide].yCoord == tY - && mBufferedTileEntities[aSide].zCoord == tZ) { - return mBufferedTileEntities[aSide]; + if (mBufferedTileEntities[ordinalSide].xCoord == tX && mBufferedTileEntities[ordinalSide].yCoord == tY + && mBufferedTileEntities[ordinalSide].zCoord == tZ) { + return mBufferedTileEntities[ordinalSide]; } return null; } @@ -518,7 +519,7 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje isDead = false; } - public final void onAdjacentBlockChange(int aX, int aY, int aZ) { + public final void onAdjacentBlockChange(int ignoredAX, int ignoredAY, int ignoredAZ) { clearNullMarkersFromTileEntityBuffer(); } @@ -709,7 +710,6 @@ public abstract class BaseTileEntity extends TileEntity implements IHasWorldObje int titleWidth = 0, titleHeight = 0; if (NetworkUtils.isClient()) { final FontRenderer fontRenderer = Minecraft.getMinecraft().fontRenderer; - // noinspection unchecked final List<String> titleLines = fontRenderer .listFormattedStringToWidth(title, getGUIWidth() - (TAB_PADDING + TITLE_PADDING) * 2); titleWidth = titleLines.size() > 1 ? getGUIWidth() - (TAB_PADDING + TITLE_PADDING) * 2 diff --git a/src/main/java/gregtech/api/metatileentity/CommonMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/CommonMetaTileEntity.java index 5fa9cbfaee..157bef793c 100644 --- a/src/main/java/gregtech/api/metatileentity/CommonMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/CommonMetaTileEntity.java @@ -6,6 +6,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.network.Packet; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; import com.gtnewhorizons.modularui.api.screen.ModularWindow; @@ -140,8 +141,8 @@ public abstract class CommonMetaTileEntity extends CoverableTileEntity implement } @Override - public boolean isValidFacing(byte aSide) { - if (canAccessData()) return getMetaTileEntity().isFacingValid(aSide); + public boolean isValidFacing(ForgeDirection side) { + if (canAccessData()) return getMetaTileEntity().isFacingValid(side); return false; } @@ -163,13 +164,13 @@ public abstract class CommonMetaTileEntity extends CoverableTileEntity implement } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { - return hasValidMetaTileEntity() && getMetaTileEntity().allowCoverOnSide(aSide, aCoverID); + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { + return hasValidMetaTileEntity() && getMetaTileEntity().allowCoverOnSide(side, aCoverID); } @Override - public void issueCoverUpdate(byte aSide) { - super.issueCoverUpdate(aSide); + public void issueCoverUpdate(ForgeDirection side) { + super.issueCoverUpdate(side); issueClientUpdate(); } diff --git a/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java b/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java index f2cd7e3019..0370965f61 100644 --- a/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/CoverableTileEntity.java @@ -1,6 +1,5 @@ package gregtech.api.metatileentity; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.E; import static gregtech.api.enums.GT_Values.NW; import static gregtech.api.util.GT_LanguageManager.FACES; @@ -9,9 +8,9 @@ import static gregtech.api.util.GT_LanguageManager.getTranslation; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; +import java.util.Comparator; import java.util.List; import java.util.Objects; -import java.util.stream.IntStream; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; @@ -98,14 +97,14 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final NBTTagList tList = new NBTTagList(); final int[] coverSides = new int[] { 0, 0, 0, 0, 0, 0 }; - for (byte i = 0; i < coverInfos.length; i++) { - final CoverInfo coverInfo = getCoverInfoAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (!coverInfo.isValid()) continue; // Backwards compat, in case of a revert... for now tList.appendTag(coverInfo.writeToNBT(new NBTTagCompound())); aNBT.setTag( - COVER_DATA_NBT_KEYS[i], + COVER_DATA_NBT_KEYS[side.ordinal()], coverInfo.getCoverData() .saveDataToNBT()); } @@ -142,7 +141,7 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final NBTTagCompound tNBT = tList.getCompoundTagAt(i); final CoverInfo coverInfo = new CoverInfo(this, tNBT); this.setCoverInfoAtSide(coverInfo.getSide(), coverInfo); - if (coverInfo.isDataNeededOnClient()) issueCoverUpdate(i); + if (coverInfo.isDataNeededOnClient()) issueCoverUpdate(ForgeDirection.getOrientation(i)); } } @@ -152,58 +151,60 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final boolean hasOldCoverData = (aNBT.hasKey("mCoverData", 11) && aNBT.getIntArray("mCoverData").length == 6); final int[] tOldData = hasOldCoverData ? aNBT.getIntArray("mCoverData") : new int[] {}; - for (byte i : ALL_VALID_SIDES) { - if (coverIDs[i] == 0) continue; + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final int ordinalSide = side.ordinal(); + if (coverIDs[ordinalSide] == 0) continue; - final CoverInfo coverInfo = new CoverInfo(i, coverIDs[i], this, null); + final CoverInfo coverInfo = new CoverInfo(side, coverIDs[ordinalSide], this, null); final GT_CoverBehaviorBase<?> coverBehavior = coverInfo.getCoverBehavior(); if (coverBehavior == GregTech_API.sNoBehavior) continue; ISerializableObject coverData = null; if (hasOldCoverData) { if (coverBehavior instanceof GT_Cover_Fluidfilter) { - final String filterKey = String.format("fluidFilter%d", i); + final String filterKey = String.format("fluidFilter%d", ordinalSide); if (aNBT.hasKey(filterKey)) { coverData = coverInfo.getCoverBehavior() .createDataObject( - (tOldData[i] & 7) | (FluidRegistry.getFluidID(aNBT.getString(filterKey)) << 3)); + (tOldData[ordinalSide] & 7) + | (FluidRegistry.getFluidID(aNBT.getString(filterKey)) << 3)); } } else { - coverData = coverBehavior.createDataObject(tOldData[i]); + coverData = coverBehavior.createDataObject(tOldData[ordinalSide]); } } else { - if (aNBT.hasKey(COVER_DATA_NBT_KEYS[i])) - coverData = coverBehavior.createDataObject(aNBT.getTag(COVER_DATA_NBT_KEYS[i])); + if (aNBT.hasKey(COVER_DATA_NBT_KEYS[ordinalSide])) + coverData = coverBehavior.createDataObject(aNBT.getTag(COVER_DATA_NBT_KEYS[ordinalSide])); } if (coverData != null) coverInfo.setCoverData(coverData); - setCoverInfoAtSide(i, coverInfo); - if (coverInfo.isDataNeededOnClient()) issueCoverUpdate(i); + setCoverInfoAtSide(side, coverInfo); + if (coverInfo.isDataNeededOnClient()) issueCoverUpdate(side); } } public abstract boolean isStillValid(); protected boolean doCoverThings() { - for (byte i : ALL_VALID_SIDES) { - if (!tickCoverAtSide(i)) return false; + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (!tickCoverAtSide(side)) return false; } return true; } - public boolean tickCoverAtSide(byte aSide) { - return tickCoverAtSide(aSide, mTickTimer); + public boolean tickCoverAtSide(ForgeDirection side) { + return tickCoverAtSide(side, mTickTimer); } /** * Returns false if the tile is no longer valid after ticking the cover */ - public boolean tickCoverAtSide(byte aSide, long aTickTimer) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + public boolean tickCoverAtSide(ForgeDirection side, long aTickTimer) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (!coverInfo.isValid()) return true; final int tCoverTickRate = coverInfo.getTickRate(); if (tCoverTickRate > 0 && aTickTimer % tCoverTickRate == 0) { - final byte tRedstone = coverInfo.isRedstoneSensitive(aTickTimer) ? getInputRedstoneSignal(aSide) : 0; + final byte tRedstone = coverInfo.isRedstoneSensitive(aTickTimer) ? getInputRedstoneSignal(side) : 0; coverInfo.setCoverData(coverInfo.doCoverThings(aTickTimer, tRedstone)); return isStillValid(); } @@ -211,33 +212,33 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov return true; } - public abstract boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID); + public abstract boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID); protected void checkDropCover() { - for (byte i : ALL_VALID_SIDES) { - final int coverId = getCoverIDAtSide(i); - if (coverId != 0) if (!allowCoverOnSide(i, new GT_ItemStack(coverId))) dropCover(i, i, true); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final int coverId = getCoverIDAtSide(side); + if (coverId != 0 && !allowCoverOnSide(side, new GT_ItemStack(coverId))) dropCover(side, side, true); } } protected void updateCoverBehavior() { - for (byte i : ALL_VALID_SIDES) { - final CoverInfo coverInfo = getCoverInfoAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid()) coverInfo.updateCoverBehavior(); } } @Override - public void issueCoverUpdate(byte aSide) { + public void issueCoverUpdate(ForgeDirection side) { // If we've got a null worldObj we're getting called as a part of readingNBT from a non tickable MultiTileEntity // on chunk load before the world is set // so we'll want to send a cover update. - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (worldObj == null || (isServerSide() && coverInfo.isDataNeededOnClient())) coverInfo.setNeedsUpdate(true); } - public final ITexture getCoverTexture(byte aSide) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + public final ITexture getCoverTexture(ForgeDirection side) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (!coverInfo.isValid()) return null; if (GT_Mod.instance.isClientSide() && (GT_Client.hideValue & 0x1) != 0) { return Textures.BlockIcons.HIDDEN_TEXTURE[0]; // See through @@ -245,41 +246,40 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final ITexture coverTexture = (!(this instanceof BaseMetaPipeEntity)) ? coverInfo.getSpecialCoverFGTexture() : coverInfo.getSpecialCoverTexture(); - return coverTexture != null ? coverTexture - : GregTech_API.sCovers.get(new GT_ItemStack(getCoverIDAtSide(aSide))); + return coverTexture != null ? coverTexture : GregTech_API.sCovers.get(new GT_ItemStack(getCoverIDAtSide(side))); } protected void requestCoverDataIfNeeded() { if (worldObj == null || !worldObj.isRemote) return; - for (byte i : ALL_VALID_SIDES) { - final CoverInfo coverInfo = getCoverInfoAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isDataNeededOnClient()) NW.sendToServer(new GT_Packet_RequestCoverData(coverInfo, this)); } } @Override - public void setCoverIdAndDataAtSide(byte aSide, int aId, ISerializableObject aData) { - if (setCoverIDAtSideNoUpdate(aSide, aId, aData)) { - issueCoverUpdate(aSide); + public void setCoverIdAndDataAtSide(ForgeDirection side, int aId, ISerializableObject aData) { + if (setCoverIDAtSideNoUpdate(side, aId, aData)) { + issueCoverUpdate(side); issueBlockUpdate(); } } @Override - public void setCoverIDAtSide(byte aSide, int aID) { - setCoverIdAndDataAtSide(aSide, aID, null); + public void setCoverIDAtSide(ForgeDirection side, int aID) { + setCoverIdAndDataAtSide(side, aID, null); } @Override - public boolean setCoverIDAtSideNoUpdate(byte aSide, int aID) { - return setCoverIDAtSideNoUpdate(aSide, aID, null); + public boolean setCoverIDAtSideNoUpdate(ForgeDirection side, int aID) { + return setCoverIDAtSideNoUpdate(side, aID, null); } - public boolean setCoverIDAtSideNoUpdate(byte aSide, int aID, ISerializableObject aData) { - final CoverInfo oldCoverInfo = getCoverInfoAtSide(aSide); - if (aSide >= 0 && aSide < 6 && oldCoverInfo.getCoverID() != aID) { + public boolean setCoverIDAtSideNoUpdate(ForgeDirection side, int aID, ISerializableObject aData) { + final CoverInfo oldCoverInfo = getCoverInfoAtSide(side); + if (side != ForgeDirection.UNKNOWN && oldCoverInfo.getCoverID() != aID) { if (aID == 0 && isClientSide()) oldCoverInfo.onDropped(); - setCoverInfoAtSide(aSide, new CoverInfo(aSide, aID, this, aData)); + setCoverInfoAtSide(side, new CoverInfo(side, aID, this, aData)); return true; } return false; @@ -287,57 +287,57 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov @Override @Deprecated - public void setCoverDataAtSide(byte aSide, int aData) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + public void setCoverDataAtSide(ForgeDirection side, int aData) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid() && coverInfo.getCoverData() instanceof ISerializableObject.LegacyCoverData) coverInfo.setCoverData(new ISerializableObject.LegacyCoverData(aData)); } @Override - public void setCoverDataAtSide(byte aSide, ISerializableObject aData) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + public void setCoverDataAtSide(ForgeDirection side, ISerializableObject aData) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid() && coverInfo.getCoverBehavior() .cast(aData) != null) coverInfo.setCoverData(aData); } @Override @Deprecated - public GT_CoverBehavior getCoverBehaviorAtSide(byte aSide) { - final GT_CoverBehaviorBase<?> behavior = getCoverInfoAtSide(aSide).getCoverBehavior(); + public GT_CoverBehavior getCoverBehaviorAtSide(ForgeDirection side) { + final GT_CoverBehaviorBase<?> behavior = getCoverInfoAtSide(side).getCoverBehavior(); if (behavior instanceof GT_CoverBehavior) return (GT_CoverBehavior) behavior; return GregTech_API.sNoBehavior; } @Override - public void setCoverItemAtSide(byte aSide, ItemStack aCover) { + public void setCoverItemAtSide(ForgeDirection side, ItemStack aCover) { GregTech_API.getCoverBehaviorNew(aCover) - .placeCover(aSide, aCover, this); + .placeCover(side, aCover, this); } @Override - public int getCoverIDAtSide(byte aSide) { - return getCoverInfoAtSide(aSide).getCoverID(); + public int getCoverIDAtSide(ForgeDirection side) { + return getCoverInfoAtSide(side).getCoverID(); } @Override - public ItemStack getCoverItemAtSide(byte aSide) { - return getCoverInfoAtSide(aSide).getDisplayStack(); + public ItemStack getCoverItemAtSide(ForgeDirection side) { + return getCoverInfoAtSide(side).getDisplayStack(); } @Override - public boolean canPlaceCoverIDAtSide(byte aSide, int aID) { - return getCoverIDAtSide(aSide) == 0; + public boolean canPlaceCoverIDAtSide(ForgeDirection side, int aID) { + return getCoverIDAtSide(side) == 0; } @Override - public boolean canPlaceCoverItemAtSide(byte aSide, ItemStack aCover) { - return getCoverIDAtSide(aSide) == 0; + public boolean canPlaceCoverItemAtSide(ForgeDirection side, ItemStack aCover) { + return getCoverIDAtSide(side) == 0; } @Override @Deprecated - public int getCoverDataAtSide(byte aSide) { - final ISerializableObject coverData = getCoverInfoAtSide(aSide).getCoverData(); + public int getCoverDataAtSide(ForgeDirection side) { + final ISerializableObject coverData = getCoverInfoAtSide(side).getCoverData(); if (coverData instanceof ISerializableObject.LegacyCoverData) { return ((ISerializableObject.LegacyCoverData) coverData).get(); } @@ -345,37 +345,38 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov } @Override - public ISerializableObject getComplexCoverDataAtSide(byte aSide) { - return getCoverInfoAtSide(aSide).getCoverData(); + public ISerializableObject getComplexCoverDataAtSide(ForgeDirection side) { + return getCoverInfoAtSide(side).getCoverData(); } @Override - public GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(byte aSide) { - return getCoverInfoAtSide(aSide).getCoverBehavior(); + public GT_CoverBehaviorBase<?> getCoverBehaviorAtSideNew(ForgeDirection side) { + return getCoverInfoAtSide(side).getCoverBehavior(); } - public void setCoverInfoAtSide(byte aSide, CoverInfo coverInfo) { - if (aSide >= 0 && aSide < 6) coverInfos[aSide] = coverInfo; + public void setCoverInfoAtSide(ForgeDirection side, CoverInfo coverInfo) { + if (side != ForgeDirection.UNKNOWN) coverInfos[side.ordinal()] = coverInfo; } @Override - public CoverInfo getCoverInfoAtSide(byte aSide) { - if (aSide >= 0 && aSide < 6) { - if (coverInfos[aSide] == null) coverInfos[aSide] = new CoverInfo(aSide, this); - return coverInfos[aSide]; + public CoverInfo getCoverInfoAtSide(ForgeDirection side) { + final int ordinalSide = side.ordinal(); + if (side != ForgeDirection.UNKNOWN) { + if (coverInfos[ordinalSide] == null) coverInfos[ordinalSide] = new CoverInfo(side, this); + return coverInfos[side.ordinal()]; } return CoverInfo.EMPTY_INFO; } - public void clearCoverInfoAtSide(byte aSide) { - if (aSide >= 0 && aSide < 6) { - setCoverIDAtSide(aSide, 0); + public void clearCoverInfoAtSide(ForgeDirection side) { + if (side != ForgeDirection.UNKNOWN) { + setCoverIDAtSide(side, 0); } } @Override - public boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + public boolean dropCover(ForgeDirection side, ForgeDirection droppedSide, boolean aForced) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (!coverInfo.isValid()) return false; if (!coverInfo.onCoverRemoval(aForced) && !aForced) return false; final ItemStack tStack = coverInfo.getDrop(); @@ -383,84 +384,88 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov coverInfo.onDropped(); final EntityItem tEntity = new EntityItem( worldObj, - getOffsetX(aDroppedSide, 1) + 0.5, - getOffsetY(aDroppedSide, 1) + 0.5, - getOffsetZ(aDroppedSide, 1) + 0.5, + getOffsetX(droppedSide, 1) + 0.5, + getOffsetY(droppedSide, 1) + 0.5, + getOffsetZ(droppedSide, 1) + 0.5, tStack); tEntity.motionX = 0; tEntity.motionY = 0; tEntity.motionZ = 0; worldObj.spawnEntityInWorld(tEntity); } - clearCoverInfoAtSide(aSide); - updateOutputRedstoneSignal(aSide); + clearCoverInfoAtSide(side); + updateOutputRedstoneSignal(side); return true; } protected void onBaseTEDestroyed() { - for (byte side : ALL_VALID_SIDES) { + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid()) coverInfo.onBaseTEDestroyed(); } } @Override - public void setOutputRedstoneSignal(byte aSide, byte aStrength) { - aStrength = (byte) Math.min(Math.max(0, aStrength), 15); - if (aSide < 0 || aSide >= 6) return; + public void setOutputRedstoneSignal(ForgeDirection side, byte strength) { + final byte cappedStrength = (byte) Math.min(Math.max(0, strength), 15); + if (side == ForgeDirection.UNKNOWN) return; - if (mSidedRedstone[aSide] != aStrength || (mStrongRedstone & (1 << aSide)) > 0) { - if ((mStrongRedstone & (1 << aSide)) > 0) { - mStrongRedstone ^= (1 << aSide); + final int ordinalSide = side.ordinal(); + if (mSidedRedstone[ordinalSide] != cappedStrength || (mStrongRedstone & (1 << ordinalSide)) > 0) { + if ((mStrongRedstone & (1 << ordinalSide)) > 0) { + mStrongRedstone ^= (1 << ordinalSide); issueBlockUpdate(); } - mSidedRedstone[aSide] = aStrength; + mSidedRedstone[ordinalSide] = cappedStrength; issueBlockUpdate(); } } @Override - public void setStrongOutputRedstoneSignal(byte aSide, byte aStrength) { - aStrength = (byte) Math.min(Math.max(0, aStrength), 15); - if (aSide < 0 || aSide >= 6) return; + public void setStrongOutputRedstoneSignal(ForgeDirection side, byte strength) { + final byte cappedStrength = (byte) Math.min(Math.max(0, strength), 15); + if (side == ForgeDirection.UNKNOWN) return; - if (mSidedRedstone[aSide] != aStrength || (mStrongRedstone & (1 << aSide)) == 0) { - mStrongRedstone |= (1 << aSide); - mSidedRedstone[aSide] = aStrength; + final int ordinalSide = side.ordinal(); + if (mSidedRedstone[ordinalSide] != cappedStrength || (mStrongRedstone & (1 << ordinalSide)) == 0) { + mStrongRedstone |= (1 << ordinalSide); + mSidedRedstone[ordinalSide] = cappedStrength; issueBlockUpdate(); } } @Override - public void setInternalOutputRedstoneSignal(byte aSide, byte aStrength) { - if (!getCoverBehaviorAtSideNew(aSide) - .manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getComplexCoverDataAtSide(aSide), this)) - setOutputRedstoneSignal(aSide, aStrength); + public void setInternalOutputRedstoneSignal(ForgeDirection side, byte aStrength) { + if (!getCoverBehaviorAtSideNew(side) + .manipulatesSidedRedstoneOutput(side, getCoverIDAtSide(side), getComplexCoverDataAtSide(side), this)) + setOutputRedstoneSignal(side, aStrength); } @Override public boolean getRedstone() { - return IntStream.range(1, 6) - .anyMatch(i -> getRedstone((byte) i)); + return Arrays.stream(ForgeDirection.VALID_DIRECTIONS) + .anyMatch(this::getRedstone); } @Override - public boolean getRedstone(byte aSide) { - return getInternalInputRedstoneSignal(aSide) > 0; + public boolean getRedstone(ForgeDirection side) { + return getInternalInputRedstoneSignal(side) > 0; } @Override public byte getStrongestRedstone() { - return (byte) IntStream.range(1, 6) - .map(i -> getInternalInputRedstoneSignal((byte) i)) - .max() - .orElse(0); + return Arrays.stream(ForgeDirection.VALID_DIRECTIONS) + .map(this::getInternalInputRedstoneSignal) + .max(Comparator.comparing(Byte::valueOf)) + .orElse((byte) 0); } @Override - public byte getStrongOutputRedstoneSignal(byte aSide) { - return aSide >= 0 && aSide < 6 && (mStrongRedstone & (1 << aSide)) != 0 ? (byte) (mSidedRedstone[aSide] & 15) + public byte getStrongOutputRedstoneSignal(ForgeDirection side) { + final int ordinalSide = side.ordinal(); + return side != ForgeDirection.UNKNOWN && (mStrongRedstone & (1 << ordinalSide)) != 0 + ? (byte) (mSidedRedstone[ordinalSide] & 15) : 0; } @@ -470,64 +475,65 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov } @Override - public byte getInternalInputRedstoneSignal(byte aSide) { - return (byte) (getCoverBehaviorAtSideNew(aSide).getRedstoneInput( - aSide, - getInputRedstoneSignal(aSide), - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + public byte getInternalInputRedstoneSignal(ForgeDirection side) { + return (byte) (getCoverBehaviorAtSideNew(side).getRedstoneInput( + side, + getInputRedstoneSignal(side), + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this) & 15); } @Override - public byte getInputRedstoneSignal(byte aSide) { + public byte getInputRedstoneSignal(ForgeDirection side) { return (byte) (worldObj - .getIndirectPowerLevelTo(getOffsetX(aSide, 1), getOffsetY(aSide, 1), getOffsetZ(aSide, 1), aSide) & 15); + .getIndirectPowerLevelTo(getOffsetX(side, 1), getOffsetY(side, 1), getOffsetZ(side, 1), side.ordinal()) + & 15); } @Override - public byte getOutputRedstoneSignal(byte aSide) { - return getCoverBehaviorAtSideNew(aSide) - .manipulatesSidedRedstoneOutput(aSide, getCoverIDAtSide(aSide), getComplexCoverDataAtSide(aSide), this) - ? mSidedRedstone[aSide] - : getGeneralRS(aSide); + public byte getOutputRedstoneSignal(ForgeDirection side) { + return getCoverBehaviorAtSideNew(side) + .manipulatesSidedRedstoneOutput(side, getCoverIDAtSide(side), getComplexCoverDataAtSide(side), this) + ? mSidedRedstone[side.ordinal()] + : getGeneralRS(side); } - protected void updateOutputRedstoneSignal(byte aSide) { - setOutputRedstoneSignal(aSide, (byte) 0); + protected void updateOutputRedstoneSignal(ForgeDirection side) { + setOutputRedstoneSignal(side, (byte) 0); } @Override - public void receiveCoverData(byte aCoverSide, int aCoverID, int aCoverData) { - if (aCoverSide < 0 || aCoverSide >= 6) return; - final CoverInfo oldCoverInfo = getCoverInfoAtSide(aCoverSide); + public void receiveCoverData(ForgeDirection coverSide, int aCoverID, int aCoverData) { + if (coverSide != ForgeDirection.UNKNOWN) return; + final CoverInfo oldCoverInfo = getCoverInfoAtSide(coverSide); if (!oldCoverInfo.isValid()) return; - setCoverIDAtSideNoUpdate(aCoverSide, aCoverID); - setCoverDataAtSide(aCoverSide, aCoverData); + setCoverIDAtSideNoUpdate(coverSide, aCoverID); + setCoverDataAtSide(coverSide, aCoverData); } @Override - public void receiveCoverData(byte aCoverSide, int aCoverID, ISerializableObject aCoverData, + public void receiveCoverData(ForgeDirection coverSide, int aCoverID, ISerializableObject aCoverData, EntityPlayerMP aPlayer) { - if (aCoverSide < 0 || aCoverSide >= 6) return; + if (coverSide != ForgeDirection.UNKNOWN) return; - final CoverInfo oldCoverInfo = getCoverInfoAtSide(aCoverSide); + final CoverInfo oldCoverInfo = getCoverInfoAtSide(coverSide); if (!oldCoverInfo.isValid()) return; oldCoverInfo.preDataChanged(aCoverID, aCoverData); - setCoverIDAtSideNoUpdate(aCoverSide, aCoverID, aCoverData); - setCoverDataAtSide(aCoverSide, aCoverData); + setCoverIDAtSideNoUpdate(coverSide, aCoverID, aCoverData); + setCoverDataAtSide(coverSide, aCoverData); if (isClientSide()) { - getCoverInfoAtSide(aCoverSide).onDataChanged(); + getCoverInfoAtSide(coverSide).onDataChanged(); } } protected void sendCoverDataIfNeeded() { if (worldObj == null || worldObj.isRemote) return; - for (byte i : ALL_VALID_SIDES) { - final CoverInfo coverInfo = getCoverInfoAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.needsUpdate()) { NW.sendPacketToAllPlayersInRange( worldObj, @@ -540,11 +546,10 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov } @Override - public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, + public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { final NBTTagCompound tag = accessor.getNBTData(); - final byte currentFacing = (byte) accessor.getSide() - .ordinal(); + final ForgeDirection currentFacing = accessor.getSide(); final NBTTagList tList = tag.getTagList(GT_Values.NBT.COVERS, 10); for (byte i = 0; i < tList.tagCount(); i++) { @@ -554,18 +559,18 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final ItemStack coverStack = coverInfo.getDisplayStack(); if (coverStack != null) { - currenttip.add( + currentTip.add( StatCollector.translateToLocalFormatted( "GT5U.waila.cover", currentFacing == coverInfo.getSide() ? StatCollector.translateToLocal("GT5U.waila.cover.current_facing") : StatCollector.translateToLocal( - "GT5U.interface.coverTabs." + ForgeDirection.getOrientation(coverInfo.getSide()) + "GT5U.interface.coverTabs." + coverInfo.getSide() .toString() .toLowerCase()), coverStack.getDisplayName())); final String behaviorDesc = coverInfo.getBehaviorDescription(); - if (!Objects.equals(behaviorDesc, E)) currenttip.add(behaviorDesc); + if (!Objects.equals(behaviorDesc, E)) currentTip.add(behaviorDesc); } } @@ -602,7 +607,9 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov aList.add( String.format( "Cover on %s side: %s", - getTranslation(FACES[coverInfo.getSide()]), + getTranslation( + FACES[coverInfo.getSide() + .ordinal()]), coverStack.getDisplayName())); } } @@ -610,28 +617,27 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov if (aNBT.hasKey("mCoverSides")) { final int[] mCoverSides = aNBT.getIntArray("mCoverSides"); if (mCoverSides != null && mCoverSides.length == 6) { - for (byte tSide : ALL_VALID_SIDES) { - final int coverId = mCoverSides[tSide]; + for (final ForgeDirection tSide : ForgeDirection.VALID_DIRECTIONS) { + final int i = tSide.ordinal(); + final int coverId = mCoverSides[i]; if (coverId == 0) continue; final GT_CoverBehaviorBase<?> behavior = GregTech_API.getCoverBehaviorNew(coverId); if (behavior == null || behavior == GregTech_API.sNoBehavior) continue; - if (!aNBT.hasKey(CoverableTileEntity.COVER_DATA_NBT_KEYS[tSide])) continue; + if (!aNBT.hasKey(CoverableTileEntity.COVER_DATA_NBT_KEYS[i])) continue; final ISerializableObject dataObject = behavior - .createDataObject(aNBT.getTag(CoverableTileEntity.COVER_DATA_NBT_KEYS[tSide])); + .createDataObject(aNBT.getTag(CoverableTileEntity.COVER_DATA_NBT_KEYS[i])); final ItemStack coverStack = behavior.getDisplayStack(coverId, dataObject); if (coverStack != null) { aList.add( - String.format( - "Cover on %s side: %s", - getTranslation(FACES[tSide]), - coverStack.getDisplayName())); + String + .format("Cover on %s side: %s", getTranslation(FACES[i]), coverStack.getDisplayName())); } } } } } - protected ModularWindow createCoverWindow(EntityPlayer player, byte side) { + protected ModularWindow createCoverWindow(EntityPlayer player, ForgeDirection side) { return getCoverInfoAtSide(side).createWindow(player); } @@ -659,8 +665,9 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov .setSpace(COVER_TAB_SPACING); for (ForgeDirection direction : ForgeDirection.VALID_DIRECTIONS) { - final byte side = (byte) direction.ordinal(); - buildContext.addSyncedWindow(side + COVER_WINDOW_ID_START, player -> createCoverWindow(player, side)); + buildContext.addSyncedWindow( + direction.ordinal() + COVER_WINDOW_ID_START, + player -> createCoverWindow(player, direction)); columnWidget.addChild(new MultiChildWidget().addChild(new ButtonWidget() { @Override @@ -668,7 +675,7 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov final List<IDrawable> backgrounds = new ArrayList<>(); final GUITextureSet tabIconSet = getGUITextureSet(); - if (getCoverBehaviorAtSideNew(side).hasCoverGUI()) { + if (getCoverBehaviorAtSideNew(direction).hasCoverGUI()) { if (isHovering()) { backgrounds.add( flipHorizontally ? tabIconSet.getCoverTabHighlightFlipped() @@ -685,20 +692,20 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov } return backgrounds.toArray(new IDrawable[] {}); } - }.setOnClick((clickData, widget) -> onTabClicked(clickData, widget, side)) - .dynamicTooltip(() -> getCoverTabTooltip(side)) + }.setOnClick((clickData, widget) -> onTabClicked(clickData, widget, direction)) + .dynamicTooltip(() -> getCoverTabTooltip(direction)) .setSize(COVER_TAB_WIDTH, COVER_TAB_HEIGHT)) .addChild( - new ItemDrawable(() -> getCoverItemAtSide(side)).asWidget() + new ItemDrawable(() -> getCoverItemAtSide(direction)).asWidget() .setPos( (COVER_TAB_WIDTH - ICON_SIZE) / 2 + (flipHorizontally ? -1 : 1), (COVER_TAB_HEIGHT - ICON_SIZE) / 2)) - .setEnabled(widget -> getCoverItemAtSide(side) != null)); + .setEnabled(widget -> getCoverItemAtSide(direction) != null)); } } @SideOnly(Side.CLIENT) - protected List<String> getCoverTabTooltip(byte side) { + protected List<String> getCoverTabTooltip(ForgeDirection side) { final String[] SIDE_TOOLTIPS = new String[] { "GT5U.interface.coverTabs.down", "GT5U.interface.coverTabs.up", "GT5U.interface.coverTabs.north", "GT5U.interface.coverTabs.south", "GT5U.interface.coverTabs.west", "GT5U.interface.coverTabs.east" }; @@ -707,14 +714,13 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov if (coverItem == null) return Collections.emptyList(); final boolean coverHasGUI = coverInfo.hasCoverGUI(); - // noinspection unchecked final List<String> tooltip = coverItem.getTooltip(Minecraft.getMinecraft().thePlayer, true); for (int i = 0; i < tooltip.size(); i++) { if (i == 0) { tooltip.set( 0, (coverHasGUI ? EnumChatFormatting.UNDERLINE : EnumChatFormatting.DARK_GRAY) - + StatCollector.translateToLocal(SIDE_TOOLTIPS[side]) + + StatCollector.translateToLocal(SIDE_TOOLTIPS[side.ordinal()]) + (coverHasGUI ? EnumChatFormatting.RESET + ": " : ": " + EnumChatFormatting.RESET) + tooltip.get(0)); } else { @@ -724,12 +730,12 @@ public abstract class CoverableTileEntity extends BaseTileEntity implements ICov return tooltip; } - protected void onTabClicked(Widget.ClickData clickData, Widget widget, byte side) { + protected void onTabClicked(Widget.ClickData ignoredClickData, Widget widget, ForgeDirection side) { if (isClientSide()) return; final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.useModularUI()) { widget.getContext() - .openSyncedWindow(side + COVER_WINDOW_ID_START); + .openSyncedWindow(side.ordinal() + COVER_WINDOW_ID_START); } else { final GT_Packet_TileEntityCoverGUI packet = new GT_Packet_TileEntityCoverGUI( coverInfo, diff --git a/src/main/java/gregtech/api/metatileentity/MetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/MetaPipeEntity.java index c8657fbcff..2ecdd7f2ca 100644 --- a/src/main/java/gregtech/api/metatileentity/MetaPipeEntity.java +++ b/src/main/java/gregtech/api/metatileentity/MetaPipeEntity.java @@ -6,6 +6,7 @@ import java.io.File; import java.util.ArrayList; import java.util.List; import java.util.Locale; +import java.util.Objects; import net.minecraft.block.Block; import net.minecraft.client.renderer.RenderBlocks; @@ -33,13 +34,22 @@ import gnu.trove.list.array.TIntArrayList; import gregtech.api.GregTech_API; import gregtech.api.enums.Dyes; import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IConnectable; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IColoredTileEntity; import gregtech.api.interfaces.tileentity.ICoverable; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.objects.GT_ItemStack; -import gregtech.api.util.*; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_CoverBehaviorBase; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Util; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; +import gregtech.api.util.WorldSpawnedEventBuilder; import gregtech.common.GT_Client; import gregtech.common.covers.CoverInfo; @@ -114,7 +124,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { if (!GT.isClientSide()) return; ItemStack tStack = new ItemStack(GregTech_API.sBlockMachines, 1, aID); - tStack.getItem() + Objects.requireNonNull(tStack.getItem()) .addInformation(tStack, null, new ArrayList<>(), true); } @@ -134,13 +144,24 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { /** * For Pipe Rendering */ - public abstract boolean renderInside(byte aSide); + public abstract boolean renderInside(ForgeDirection side); public boolean isDisplaySecondaryDescription() { return false; } @Override + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean active, boolean redstoneLevel) { + return Textures.BlockIcons.ERROR_RENDERING; + } + + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, int connections, + int colorIndex, boolean active, boolean redstoneLevel) { + return Textures.BlockIcons.ERROR_RENDERING; + } + + @Override public IGregTechTileEntity getBaseMetaTileEntity() { return mBaseMetaTileEntity; } @@ -164,33 +185,33 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } public boolean isCoverOnSide(BaseMetaPipeEntity aPipe, EntityLivingBase aEntity) { - byte aSide = 6; + ForgeDirection side = ForgeDirection.UNKNOWN; double difference = aEntity.posY - (double) aPipe.yCoord; if (difference > 0.6 && difference < 0.99) { - aSide = 1; + side = ForgeDirection.UP; } if (difference < -1.5 && difference > -1.99) { - aSide = 0; + side = ForgeDirection.DOWN; } difference = aEntity.posZ - (double) aPipe.zCoord; if (difference < -0.05 && difference > -0.4) { - aSide = 2; + side = ForgeDirection.NORTH; } if (difference > 1.05 && difference < 1.4) { - aSide = 3; + side = ForgeDirection.SOUTH; } difference = aEntity.posX - (double) aPipe.xCoord; if (difference < -0.05 && difference > -0.4) { - aSide = 4; + side = ForgeDirection.WEST; } if (difference > 1.05 && difference < 1.4) { - aSide = 5; + side = ForgeDirection.EAST; } boolean tCovered = false; - if (aSide < 6 && mBaseMetaTileEntity.getCoverIDAtSide(aSide) > 0) { + if (side != ForgeDirection.UNKNOWN && mBaseMetaTileEntity.getCoverIDAtSide(side) > 0) { tCovered = true; } - if (isConnectedAtSide(aSide)) { + if (isConnectedAtSide(side)) { tCovered = true; } // GT_FML_LOGGER.info("Cover: "+mBaseMetaTileEntity.getCoverIDAtSide(aSide)); @@ -230,30 +251,30 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { return true; } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { /* Do nothing */ } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { return false; } @Override - public boolean onWireCutterRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { return false; } @Override - public boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { return false; } @@ -317,8 +338,8 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { * a Player rightclicks the Machine Sneaky rightclicks are not getting passed to this! */ @Override - public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, - float aY, float aZ) { + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, + float aX, float aY, float aZ) { return false; } @@ -371,7 +392,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @@ -402,12 +423,12 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public boolean isLiquidInput(byte aSide) { + public boolean isLiquidInput(ForgeDirection side) { return false; } @Override - public boolean isLiquidOutput(byte aSide) { + public boolean isLiquidOutput(ForgeDirection side) { return false; } @@ -487,17 +508,17 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public byte getComparatorValue(byte aSide) { + public byte getComparatorValue(ForgeDirection side) { return 0; } @Override - public boolean acceptsRotationalEnergy(byte aSide) { + public boolean acceptsRotationalEnergy(ForgeDirection side) { return false; } @Override - public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) { + public boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy) { return false; } @@ -538,8 +559,8 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public ItemStack getStackInSlot(int aIndex) { - if (aIndex >= 0 && aIndex < mInventory.length) return mInventory[aIndex]; + public ItemStack getStackInSlot(int slotIndex) { + if (slotIndex >= 0 && slotIndex < mInventory.length) return mInventory[slotIndex]; return null; } @@ -582,10 +603,10 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public int[] getAccessibleSlotsFromSide(int aSide) { + public int[] getAccessibleSlotsFromSide(int ordinalSide) { final TIntList tList = new TIntArrayList(); final IGregTechTileEntity tTileEntity = getBaseMetaTileEntity(); - final CoverInfo tileCoverInfo = tTileEntity.getCoverInfoAtSide((byte) aSide); + final CoverInfo tileCoverInfo = tTileEntity.getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)); final boolean tSkip = tileCoverInfo.letsItemsIn(-2) || tileCoverInfo.letsItemsOut(-2); for (int i = 0; i < getSizeInventory(); i++) { if (isValidSlot(i) && (tSkip || tileCoverInfo.letsItemsOut(i) || tileCoverInfo.letsItemsIn(i))) { @@ -596,54 +617,58 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) { - return isValidSlot(aIndex) && aStack != null - && aIndex < mInventory.length - && (mInventory[aIndex] == null || GT_Utility.areStacksEqual(aStack, mInventory[aIndex])) - && allowPutStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + public boolean canInsertItem(int slotIndex, ItemStack itemStack, int ordinalSide) { + return isValidSlot(slotIndex) && itemStack != null + && slotIndex < mInventory.length + && (mInventory[slotIndex] == null || GT_Utility.areStacksEqual(itemStack, mInventory[slotIndex])) + && allowPutStack(getBaseMetaTileEntity(), slotIndex, ForgeDirection.getOrientation(ordinalSide), itemStack); } @Override - public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) { - return isValidSlot(aIndex) && aStack != null - && aIndex < mInventory.length - && allowPullStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + public boolean canExtractItem(int slotIndex, ItemStack itemStack, int ordinalSide) { + return isValidSlot(slotIndex) && itemStack != null + && slotIndex < mInventory.length + && allowPullStack( + getBaseMetaTileEntity(), + slotIndex, + ForgeDirection.getOrientation(ordinalSide), + itemStack); } @Override - public boolean canFill(ForgeDirection aSide, Fluid aFluid) { - return fill(aSide, new FluidStack(aFluid, 1), false) == 1; + public boolean canFill(ForgeDirection side, Fluid aFluid) { + return fill(side, new FluidStack(aFluid, 1), false) == 1; } @Override - public boolean canDrain(ForgeDirection aSide, Fluid aFluid) { - return drain(aSide, new FluidStack(aFluid, 1), false) != null; + public boolean canDrain(ForgeDirection side, Fluid aFluid) { + return drain(side, new FluidStack(aFluid, 1), false) != null; } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { + public FluidTankInfo[] getTankInfo(ForgeDirection side) { if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[] {}; return new FluidTankInfo[] { getInfo() }; } - public int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { + public int fill_default(ForgeDirection side, FluidStack aFluid, boolean doFill) { return fill(aFluid, doFill); } @Override - public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { - return fill_default(aSide, aFluid, doFill); + public int fill(ForgeDirection side, FluidStack aFluid, boolean doFill) { + return fill_default(side, aFluid, doFill); } @Override - public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) { + public FluidStack drain(ForgeDirection side, FluidStack aFluid, boolean doDrain) { if (getFluid() != null && aFluid != null && getFluid().isFluidEqual(aFluid)) return drain(aFluid.amount, doDrain); return null; } @Override - public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) { + public FluidStack drain(ForgeDirection side, int maxDrain, boolean doDrain) { return drain(maxDrain, doDrain); } @@ -678,7 +703,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public boolean connectsToItemPipe(byte aSide) { + public boolean connectsToItemPipe(ForgeDirection side) { return false; } @@ -703,7 +728,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public float getExplosionResistance(byte aSide) { + public float getExplosionResistance(ForgeDirection side) { return 10.0F; } @@ -736,7 +761,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { mCheckConnections = true; } - public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { return 0; } @@ -822,7 +847,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { if (tTileEntity instanceof IColoredTileEntity) { if (getBaseMetaTileEntity().getColorization() >= 0) { final byte tColor = ((IColoredTileEntity) tTileEntity).getColorization(); - if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) return false; + return tColor < 0 || tColor == getBaseMetaTileEntity().getColorization(); } } @@ -830,21 +855,21 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { } @Override - public int connect(byte aSide) { - if (aSide >= 6) return 0; + public int connect(ForgeDirection side) { + if (side == ForgeDirection.UNKNOWN) return 0; - final byte tSide = GT_Utility.getOppositeSide(aSide); + final ForgeDirection oppositeSide = side.getOpposite(); final IGregTechTileEntity baseMetaTile = getBaseMetaTileEntity(); if (baseMetaTile == null || !baseMetaTile.isServerSide()) return 0; - final CoverInfo coverInfo = baseMetaTile.getCoverInfoAtSide(aSide); + final CoverInfo coverInfo = baseMetaTile.getCoverInfoAtSide(side); final boolean alwaysLookConnected = coverInfo.alwaysLookConnected(); final boolean letsIn = letsIn(coverInfo); final boolean letsOut = letsOut(coverInfo); // Careful - tTileEntity might be null, and that's ok -- so handle it - final TileEntity tTileEntity = baseMetaTile.getTileEntityAtSide(aSide); + final TileEntity tTileEntity = baseMetaTile.getTileEntityAtSide(side); if (!connectableColor(tTileEntity)) return 0; if ((alwaysLookConnected || letsIn || letsOut)) { @@ -854,23 +879,21 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { : null; if (getClass().isInstance(tPipe) || (tPipe != null && tPipe.getClass() .isInstance(this))) { - connectAtSide(aSide); - if (!((MetaPipeEntity) tPipe).isConnectedAtSide(tSide)) { + connectAtSide(side); + if (!((IConnectable) tPipe).isConnectedAtSide(oppositeSide)) { // Make sure pipes all get together -- connect back to us if we're connecting to a pipe - ((MetaPipeEntity) tPipe).connect(tSide); + ((IConnectable) tPipe).connect(oppositeSide); } return 1; - } else - if ((getGT6StyleConnection() && baseMetaTile.getAirAtSide(aSide)) || canConnect(aSide, tTileEntity)) { - // Allow open connections to Air, if the GT6 style pipe/cables are enabled, so that it'll connect to - // the - // next block placed down next to it - connectAtSide(aSide); - return 1; - } + } else if ((getGT6StyleConnection() && baseMetaTile.getAirAtSide(side)) || canConnect(side, tTileEntity)) { + // Allow open connections to Air, if the GT6 style pipe/cables are enabled, so that it'll connect to + // the next block placed down next to it + connectAtSide(side); + return 1; + } if (!baseMetaTile.getWorld() .getChunkProvider() - .chunkExists(baseMetaTile.getOffsetX(aSide, 1) >> 4, baseMetaTile.getOffsetZ(aSide, 1) >> 4)) { + .chunkExists(baseMetaTile.getOffsetX(side, 1) >> 4, baseMetaTile.getOffsetZ(side, 1) >> 4)) { // Target chunk unloaded return -1; } @@ -881,38 +904,40 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { protected void checkConnections() { // Verify connections around us. If GT6 style cables are not enabled then revert to old behavior and try // connecting to everything around us - for (byte aSide = 0; aSide < 6; aSide++) { - if ((!getGT6StyleConnection() || isConnectedAtSide(aSide)) && connect(aSide) == 0) { - disconnect(aSide); + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if ((!getGT6StyleConnection() || isConnectedAtSide(side)) && connect(side) == 0) { + disconnect(side); } } mCheckConnections = false; } - private void connectAtSide(byte aSide) { - mConnections |= (1 << aSide); + private void connectAtSide(ForgeDirection side) { + mConnections |= (1 << side.ordinal()); } @Override - public void disconnect(byte aSide) { - if (aSide >= 6) return; - mConnections &= ~(1 << aSide); - byte tSide = GT_Utility.getOppositeSide(aSide); - IGregTechTileEntity tTileEntity = getBaseMetaTileEntity().getIGregTechTileEntityAtSide(aSide); + public void disconnect(ForgeDirection side) { + if (side == ForgeDirection.UNKNOWN) return; + mConnections &= ~(1 << side.ordinal()); + final ForgeDirection oppositeSide = side.getOpposite(); + IGregTechTileEntity tTileEntity = getBaseMetaTileEntity().getIGregTechTileEntityAtSide(side); IMetaTileEntity tPipe = tTileEntity == null ? null : tTileEntity.getMetaTileEntity(); if ((this.getClass() .isInstance(tPipe) || (tPipe != null && tPipe.getClass() .isInstance(this))) - && ((MetaPipeEntity) tPipe).isConnectedAtSide(tSide)) ((MetaPipeEntity) tPipe).disconnect(tSide); + && ((IConnectable) tPipe).isConnectedAtSide(oppositeSide)) { + ((IConnectable) tPipe).disconnect(oppositeSide); + } } @Override - public boolean isConnectedAtSide(int aSide) { - return (mConnections & (1 << aSide)) != 0; + public boolean isConnectedAtSide(ForgeDirection sideDirection) { + return (mConnections & (1 << sideDirection.ordinal())) != 0; } - public boolean letsIn(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsIn(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } @@ -921,7 +946,7 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { return false; } - public boolean letsOut(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsOut(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } @@ -930,17 +955,17 @@ public abstract class MetaPipeEntity implements IMetaTileEntity, IConnectable { return false; } - public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { return false; } - public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { return false; } - public boolean canConnect(byte aSide, TileEntity tTileEntity) { + public boolean canConnect(ForgeDirection side, TileEntity tTileEntity) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java index 3acbb2ce2d..f6cba8a849 100644 --- a/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java @@ -217,51 +217,51 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) { + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aStack) { return true; } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { /* Do nothing */ } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { - if (getBaseMetaTileEntity().isValidFacing(aWrenchingSide)) { - getBaseMetaTileEntity().setFrontFacing(aWrenchingSide); + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { + if (getBaseMetaTileEntity().isValidFacing(wrenchingSide)) { + getBaseMetaTileEntity().setFrontFacing(wrenchingSide); return true; } return false; } @Override - public boolean onWireCutterRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { if (!aPlayer.isSneaking()) return false; - byte tSide = GT_Utility.getOppositeSide(aWrenchingSide); - TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(aWrenchingSide); - if ((tTileEntity instanceof IGregTechTileEntity) - && (((IGregTechTileEntity) tTileEntity).getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable)) { + final ForgeDirection oppositeSide = wrenchingSide.getOpposite(); + final TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(wrenchingSide); + if ((tTileEntity instanceof IGregTechTileEntity gtTE) + && (gtTE.getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable)) { // The tile entity we're facing is a cable, let's try to connect to it - return ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() - .onWireCutterRightClick(aWrenchingSide, tSide, aPlayer, aX, aY, aZ); + return gtTE.getMetaTileEntity() + .onWireCutterRightClick(wrenchingSide, oppositeSide, aPlayer, aX, aY, aZ); } return false; } @Override - public boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { if (!aPlayer.isSneaking()) return false; - byte tSide = GT_Utility.getOppositeSide(aWrenchingSide); - TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(aWrenchingSide); - if ((tTileEntity instanceof IGregTechTileEntity) - && (((IGregTechTileEntity) tTileEntity).getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable)) { + final ForgeDirection oppositeSide = wrenchingSide.getOpposite(); + TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(wrenchingSide); + if ((tTileEntity instanceof IGregTechTileEntity gtTE) + && (gtTE.getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable)) { // The tile entity we're facing is a cable, let's try to connect to it - return ((IGregTechTileEntity) tTileEntity).getMetaTileEntity() - .onSolderingToolRightClick(aWrenchingSide, tSide, aPlayer, aX, aY, aZ); + return gtTE.getMetaTileEntity() + .onSolderingToolRightClick(wrenchingSide, oppositeSide, aPlayer, aX, aY, aZ); } return false; } @@ -342,8 +342,8 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, - float aY, float aZ) { + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, + float aX, float aY, float aZ) { return onRightclick(aBaseMetaTileEntity, aPlayer); } @@ -492,14 +492,14 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac /** * @return true if that Side is an Output. */ - public boolean isOutputFacing(byte aSide) { + public boolean isOutputFacing(ForgeDirection side) { return false; } /** * @return true if that Side is an Input. */ - public boolean isInputFacing(byte aSide) { + public boolean isInputFacing(ForgeDirection side) { return false; } @@ -511,7 +511,7 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @@ -640,12 +640,12 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean isLiquidInput(byte aSide) { + public boolean isLiquidInput(ForgeDirection side) { return true; } @Override - public boolean isLiquidOutput(byte aSide) { + public boolean isLiquidOutput(ForgeDirection side) { return true; } @@ -774,17 +774,17 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac * Gets the Output for the comparator on the given Side */ @Override - public byte getComparatorValue(byte aSide) { + public byte getComparatorValue(ForgeDirection side) { return 0; } @Override - public boolean acceptsRotationalEnergy(byte aSide) { + public boolean acceptsRotationalEnergy(ForgeDirection side) { return false; } @Override - public boolean injectRotationalEnergy(byte aSide, long aSpeed, long aEnergy) { + public boolean injectRotationalEnergy(ForgeDirection side, long aSpeed, long aEnergy) { return false; } @@ -879,10 +879,10 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public int[] getAccessibleSlotsFromSide(int aSide) { + public int[] getAccessibleSlotsFromSide(int ordinalSide) { final TIntList tList = new TIntArrayList(); final IGregTechTileEntity tTileEntity = getBaseMetaTileEntity(); - final CoverInfo tileCoverInfo = tTileEntity.getCoverInfoAtSide((byte) aSide); + final CoverInfo tileCoverInfo = tTileEntity.getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)); final boolean tSkip = tileCoverInfo.letsItemsIn(-2) || tileCoverInfo.letsItemsOut(-2); for (int i = 0; i < getSizeInventory(); i++) { if (isValidSlot(i) && (tSkip || tileCoverInfo.letsItemsOut(i) || tileCoverInfo.letsItemsIn(i))) { @@ -893,43 +893,43 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) { + public boolean canInsertItem(int aIndex, ItemStack aStack, int ordinalSide) { return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length && (mInventory[aIndex] == null || GT_Utility.areStacksEqual(aStack, mInventory[aIndex])) - && allowPutStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + && allowPutStack(getBaseMetaTileEntity(), aIndex, ForgeDirection.getOrientation(ordinalSide), aStack); } @Override - public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) { + public boolean canExtractItem(int aIndex, ItemStack aStack, int ordinalSide) { return isValidSlot(aIndex) && aStack != null && aIndex < mInventory.length - && allowPullStack(getBaseMetaTileEntity(), aIndex, (byte) aSide, aStack); + && allowPullStack(getBaseMetaTileEntity(), aIndex, ForgeDirection.getOrientation(ordinalSide), aStack); } @Override - public boolean canFill(ForgeDirection aSide, Fluid aFluid) { - return fill(aSide, new FluidStack(aFluid, 1), false) == 1; + public boolean canFill(ForgeDirection side, Fluid aFluid) { + return fill(side, new FluidStack(aFluid, 1), false) == 1; } @Override - public boolean canDrain(ForgeDirection aSide, Fluid aFluid) { - return drain(aSide, new FluidStack(aFluid, 1), false) != null; + public boolean canDrain(ForgeDirection side, Fluid aFluid) { + return drain(side, new FluidStack(aFluid, 1), false) != null; } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { + public FluidTankInfo[] getTankInfo(ForgeDirection side) { if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[] {}; return new FluidTankInfo[] { getInfo() }; } - public int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { + public int fill_default(ForgeDirection side, FluidStack aFluid, boolean doFill) { markDirty(); return fill(aFluid, doFill); } @Override - public int fill(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { + public int fill(ForgeDirection side, FluidStack aFluid, boolean doFill) { if (getBaseMetaTileEntity().hasSteamEngineUpgrade() && GT_ModHandler.isSteam(aFluid) && aFluid.amount > 1) { int tSteam = (int) Math.min( Integer.MAX_VALUE, @@ -942,20 +942,20 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac return tSteam * 2; } } else { - return fill_default(aSide, aFluid, doFill); + return fill_default(side, aFluid, doFill); } return 0; } @Override - public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) { + public FluidStack drain(ForgeDirection side, FluidStack aFluid, boolean doDrain) { if (getFluid() != null && aFluid != null && getFluid().isFluidEqual(aFluid)) return drain(aFluid.amount, doDrain); return null; } @Override - public FluidStack drain(ForgeDirection aSide, int maxDrain, boolean doDrain) { + public FluidStack drain(ForgeDirection side, int maxDrain, boolean doDrain) { return drain(maxDrain, doDrain); } @@ -1030,12 +1030,12 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac } @Override - public boolean connectsToItemPipe(byte aSide) { + public boolean connectsToItemPipe(ForgeDirection side) { return false; } @Override - public float getExplosionResistance(byte aSide) { + public float getExplosionResistance(ForgeDirection side) { return 10.0F; } @@ -1048,11 +1048,11 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac public void onColorChangeServer(byte aColor) { final IGregTechTileEntity meta = getBaseMetaTileEntity(); final int aX = meta.getXCoord(), aY = meta.getYCoord(), aZ = meta.getZCoord(); - for (byte aSide = 0; aSide < 6; aSide++) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { // Flag surrounding pipes/cables to revaluate their connection with us if we got painted - final TileEntity tTileEntity = meta.getTileEntityAtSide(aSide); - if ((tTileEntity instanceof BaseMetaPipeEntity)) { - ((BaseMetaPipeEntity) tTileEntity).onNeighborBlockChange(aX, aY, aZ); + final TileEntity tTileEntity = meta.getTileEntityAtSide(side); + if (tTileEntity instanceof BaseMetaPipeEntity pipe) { + pipe.onNeighborBlockChange(aX, aY, aZ); } } } @@ -1163,12 +1163,12 @@ public abstract class MetaTileEntity implements IMetaTileEntity, IMachineCallbac currenttip.add( String.format( "Facing: %s", - ForgeDirection.getOrientation(mBaseMetaTileEntity.getFrontFacing()) + mBaseMetaTileEntity.getFrontFacing() .name())); if (this instanceof IPowerChannelState state) { // adapted from PowerStateWailaDataProvider - NBTTagCompound tag = accessor.getNBTData(); + final NBTTagCompound tag = accessor.getNBTData(); final boolean isActive = tag.getBoolean("isActive"); final boolean isPowered = tag.getBoolean("isPowered"); final boolean isBooting = tag.getBoolean("isBooting"); diff --git a/src/main/java/gregtech/api/metatileentity/TileIC2EnergySink.java b/src/main/java/gregtech/api/metatileentity/TileIC2EnergySink.java index da86635fea..91b6d5a117 100644 --- a/src/main/java/gregtech/api/metatileentity/TileIC2EnergySink.java +++ b/src/main/java/gregtech/api/metatileentity/TileIC2EnergySink.java @@ -59,7 +59,7 @@ public class TileIC2EnergySink extends TileEntity implements IEnergySink { /** * Determine the tier of this energy sink. 1 = LV, 2 = MV, 3 = HV, 4 = EV etc. - * + * * @note Return Integer.MAX_VALUE to allow any voltage. * * @return tier of this energy sink @@ -92,13 +92,12 @@ public class TileIC2EnergySink extends TileEntity implements IEnergySink { final long usedAmps; if (cableMeta != null) { usedAmps = ((IMetaTileEntityCable) metaTile).transferElectricity( - (byte) directionFrom.ordinal(), + directionFrom, Math.min(euPerAmp, cableMeta.mVoltage), amps, Sets.newHashSet((TileEntity) myMeta)); - } else usedAmps = myMeta - .injectEnergyUnits((byte) directionFrom.ordinal(), Math.min(euPerAmp, myMeta.getInputVoltage()), amps); + } else usedAmps = myMeta.injectEnergyUnits(directionFrom, Math.min(euPerAmp, myMeta.getInputVoltage()), amps); return amount - (usedAmps * euPerAmp); // transferElectricity for cables @@ -116,8 +115,9 @@ public class TileIC2EnergySink extends TileEntity implements IEnergySink { @Override public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) { final IMetaTileEntity metaTile = myMeta.getMetaTileEntity(); - if (metaTile instanceof IMetaTileEntityCable && (direction == ForgeDirection.UNKNOWN - || ((IConnectable) metaTile).isConnectedAtSide(direction.ordinal()))) return true; - else return myMeta.inputEnergyFrom((byte) direction.ordinal(), false); + if (metaTile instanceof IMetaTileEntityCable + && (direction == ForgeDirection.UNKNOWN || ((IConnectable) metaTile).isConnectedAtSide(direction))) + return true; + else return myMeta.inputEnergyFrom(direction, false); } } diff --git a/src/main/java/gregtech/api/metatileentity/examples/GT_MetaTileEntity_E_Furnace.java b/src/main/java/gregtech/api/metatileentity/examples/GT_MetaTileEntity_E_Furnace.java index 83cebbb08d..83c6174438 100644 --- a/src/main/java/gregtech/api/metatileentity/examples/GT_MetaTileEntity_E_Furnace.java +++ b/src/main/java/gregtech/api/metatileentity/examples/GT_MetaTileEntity_E_Furnace.java @@ -3,6 +3,7 @@ package gregtech.api.metatileentity.examples; import static gregtech.api.enums.Textures.BlockIcons.*; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.SoundResource; import gregtech.api.interfaces.ITexture; @@ -107,9 +108,9 @@ public class GT_MetaTileEntity_E_Furnace extends GT_MetaTileEntity_BasicMachine } @Override - protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, + protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack) { - return super.allowPutStackValidated(aBaseMetaTileEntity, aIndex, aSide, aStack) + return super.allowPutStackValidated(aBaseMetaTileEntity, aIndex, side, aStack) && GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(64, aStack), false, null) != null; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Cable.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Cable.java index 122a5f5128..699b0d5797 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Cable.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Cable.java @@ -1,7 +1,7 @@ package gregtech.api.metatileentity.implementations; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.Mods.GalacticraftCore; +import static net.minecraftforge.common.util.ForgeDirection.DOWN; import java.util.ArrayList; import java.util.HashSet; @@ -111,54 +111,52 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, - byte aColorIndex, boolean aConnected, boolean aRedstone) { - if (!mInsulated) return new ITexture[] { TextureFactory.of( - mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], - Dyes.getModulation(aColorIndex, mMaterial.mRGBa)) }; - if (aConnected) { + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, + int facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + if (!mInsulated) return new ITexture[] { TextureFactory + .of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], Dyes.getModulation(colorIndex, mMaterial.mRGBa)) }; + if (active) { float tThickNess = getThickNess(); - if (tThickNess < 0.124F) return new ITexture[] { TextureFactory.of( - Textures.BlockIcons.INSULATION_FULL, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + if (tThickNess < 0.124F) return new ITexture[] { TextureFactory + .of(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; if (tThickNess < 0.374F) // 0.375 x1 return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_TINY, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; if (tThickNess < 0.499F) // 0.500 x2 return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_SMALL, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; if (tThickNess < 0.624F) // 0.625 x4 return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_MEDIUM, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; if (tThickNess < 0.749F) // 0.750 x8 return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_MEDIUM_PLUS, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; if (tThickNess < 0.874F) // 0.825 x12 return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_LARGE, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; return new ITexture[] { TextureFactory.of(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), TextureFactory.of( Textures.BlockIcons.INSULATION_HUGE, - Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; } return new ITexture[] { TextureFactory - .of(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; + .of(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(colorIndex, Dyes.CABLE_INSULATION.mRGBa)) }; } @Override @@ -178,7 +176,7 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @@ -188,7 +186,7 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public final boolean renderInside(byte aSide) { + public final boolean renderInside(ForgeDirection side) { return false; } @@ -203,42 +201,40 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { - if (!isConnectedAtSide(aSide) && aSide != 6) return 0; - if (!getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + public long injectEnergyUnits(ForgeDirection side, long voltage, long amperage) { + if (!isConnectedAtSide(side) && side != ForgeDirection.UNKNOWN) return 0; + if (!getBaseMetaTileEntity().getCoverInfoAtSide(side) .letsEnergyIn()) return 0; - final HashSet<TileEntity> nul = null; - return transferElectricity(aSide, aVoltage, aAmperage, nul); + return transferElectricity(side, voltage, amperage, (HashSet<TileEntity>) null); } @Override @Deprecated - public long transferElectricity(byte aSide, long aVoltage, long aAmperage, + public long transferElectricity(ForgeDirection side, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList) { - return transferElectricity(aSide, aVoltage, aAmperage, new HashSet<>(aAlreadyPassedTileEntityList)); + return transferElectricity(side, aVoltage, aAmperage, new HashSet<>(aAlreadyPassedTileEntityList)); } @Override - public long transferElectricity(byte aSide, long aVoltage, long aAmperage, HashSet<TileEntity> aAlreadyPassedSet) { - if (!getBaseMetaTileEntity().isServerSide() || !isConnectedAtSide(aSide) && aSide != 6) return 0; + public long transferElectricity(ForgeDirection side, long voltage, long amperage, + HashSet<TileEntity> alreadyPassedSet) { + if (!getBaseMetaTileEntity().isServerSide() || !isConnectedAtSide(side) && side != ForgeDirection.UNKNOWN) + return 0; final BaseMetaPipeEntity tBase = (BaseMetaPipeEntity) getBaseMetaTileEntity(); if (!(tBase.getNode() instanceof PowerNode tNode)) return 0; - if (tNode != null) { - int tPlace = 0; - final Node[] tToPower = new Node[tNode.mConsumers.size()]; - if (tNode.mHadVoltage) { - for (ConsumerNode consumer : tNode.mConsumers) { - if (consumer.needsEnergy()) tToPower[tPlace++] = consumer; - } - } else { - tNode.mHadVoltage = true; - for (ConsumerNode consumer : tNode.mConsumers) { - tToPower[tPlace++] = consumer; - } + int tPlace = 0; + final Node[] tToPower = new Node[tNode.mConsumers.size()]; + if (tNode.mHadVoltage) { + for (ConsumerNode consumer : tNode.mConsumers) { + if (consumer.needsEnergy()) tToPower[tPlace++] = consumer; + } + } else { + tNode.mHadVoltage = true; + for (ConsumerNode consumer : tNode.mConsumers) { + tToPower[tPlace++] = consumer; } - return PowerNodes.powerNode(tNode, null, new NodeList(tToPower), (int) aVoltage, (int) aAmperage); } - return 0; + return PowerNodes.powerNode(tNode, null, new NodeList(tToPower), (int) voltage, (int) amperage); } @Override @@ -262,15 +258,15 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean onWireCutterRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { if (GT_Mod.gregtechproxy.gt6Cable && GT_ModHandler.damageOrDechargeItem(aPlayer.inventory.getCurrentItem(), 1, 500, aPlayer)) { - if (isConnectedAtSide(aWrenchingSide)) { - disconnect(aWrenchingSide); + if (isConnectedAtSide(wrenchingSide)) { + disconnect(wrenchingSide); GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("215", "Disconnected")); } else if (!GT_Mod.gregtechproxy.costlyCableConnection) { - if (connect(aWrenchingSide) > 0) + if (connect(wrenchingSide) > 0) GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("214", "Connected")); } return true; @@ -279,15 +275,15 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ) { if (GT_Mod.gregtechproxy.gt6Cable && GT_ModHandler.damageOrDechargeItem(aPlayer.inventory.getCurrentItem(), 1, 500, aPlayer)) { - if (isConnectedAtSide(aWrenchingSide)) { - disconnect(aWrenchingSide); + if (isConnectedAtSide(wrenchingSide)) { + disconnect(wrenchingSide); GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("215", "Disconnected")); } else if (!GT_Mod.gregtechproxy.costlyCableConnection || GT_ModHandler.consumeSolderingMaterial(aPlayer)) { - if (connect(aWrenchingSide) > 0) + if (connect(wrenchingSide) > 0) GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("214", "Connected")); } return true; @@ -296,27 +292,27 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean letsIn(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsIn(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsEnergyIn(aSide, aCoverID, aCoverVariable, aTileEntity); + return coverBehavior.letsEnergyIn(side, aCoverID, aCoverVariable, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsOut(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsEnergyOut(aSide, aCoverID, aCoverVariable, aTileEntity); + return coverBehavior.letsEnergyOut(side, aCoverID, aCoverVariable, aTileEntity); } @Override - public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsEnergyIn(aSide, aCoverID, aCoverVariable, aTileEntity); + return coverBehavior.letsEnergyIn(side, aCoverID, aCoverVariable, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsEnergyOut(aSide, aCoverID, aCoverVariable, aTileEntity); + return coverBehavior.letsEnergyOut(side, aCoverID, aCoverVariable, aTileEntity); } @Override @@ -330,18 +326,16 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean canConnect(byte aSide, TileEntity tTileEntity) { + public boolean canConnect(ForgeDirection side, TileEntity tileEntity) { final IGregTechTileEntity baseMetaTile = getBaseMetaTileEntity(); - final GT_CoverBehaviorBase<?> coverBehavior = baseMetaTile.getCoverBehaviorAtSideNew(aSide); - final byte tSide = GT_Utility.getOppositeSide(aSide); - final ForgeDirection tDir = ForgeDirection.getOrientation(tSide); + final GT_CoverBehaviorBase<?> coverBehavior = baseMetaTile.getCoverBehaviorAtSideNew(side); + final ForgeDirection oppositeSide = side.getOpposite(); // GT Machine handling - if ((tTileEntity instanceof PowerLogicHost - && ((PowerLogicHost) tTileEntity).getPowerLogic(ForgeDirection.getOrientation(aSide)) != null) - || ((tTileEntity instanceof IEnergyConnected) - && (((IEnergyConnected) tTileEntity).inputEnergyFrom(tSide, false) - || ((IEnergyConnected) tTileEntity).outputsEnergyTo(tSide, false)))) + if ((tileEntity instanceof PowerLogicHost powerLogic && powerLogic.getPowerLogic(side) != null) + || ((tileEntity instanceof IEnergyConnected energyConnected) + && (energyConnected.inputEnergyFrom(oppositeSide, false) + || energyConnected.outputsEnergyTo(oppositeSide, false)))) return true; // Solar Panel Compat @@ -349,47 +343,43 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile // ((tIsGregTechTileEntity && tIsTileEntityCable) && (tAlwaysLookConnected || tLetEnergyIn || tLetEnergyOut) ) // --> Not needed - if (GalacticraftCore.isModLoaded() && GT_GC_Compat.canConnect(tTileEntity, tDir)) return true; + if (GalacticraftCore.isModLoaded() && GT_GC_Compat.canConnect(tileEntity, oppositeSide)) return true; // AE2-p2p Compat if (GT_Mod.gregtechproxy.mAE2Integration) { - if (tTileEntity instanceof appeng.tile.powersink.IC2 - && ((appeng.tile.powersink.IC2) tTileEntity).acceptsEnergyFrom((TileEntity) baseMetaTile, tDir)) - return true; + if (tileEntity instanceof appeng.tile.powersink.IC2 ic2sink + && ic2sink.acceptsEnergyFrom((TileEntity) baseMetaTile, oppositeSide)) return true; } // IC2 Compat { final TileEntity ic2Energy; - if (tTileEntity instanceof IReactorChamber) - ic2Energy = (TileEntity) ((IReactorChamber) tTileEntity).getReactor(); - else ic2Energy = (tTileEntity == null || tTileEntity instanceof IEnergyTile || EnergyNet.instance == null) - ? tTileEntity - : EnergyNet.instance.getTileEntity( - tTileEntity.getWorldObj(), - tTileEntity.xCoord, - tTileEntity.yCoord, - tTileEntity.zCoord); + if (tileEntity instanceof IReactorChamber) + ic2Energy = (TileEntity) ((IReactorChamber) tileEntity).getReactor(); + else ic2Energy = (tileEntity == null || tileEntity instanceof IEnergyTile || EnergyNet.instance == null) + ? tileEntity + : EnergyNet.instance + .getTileEntity(tileEntity.getWorldObj(), tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); // IC2 Sink Compat if ((ic2Energy instanceof IEnergySink) - && ((IEnergySink) ic2Energy).acceptsEnergyFrom((TileEntity) baseMetaTile, tDir)) return true; + && ((IEnergySink) ic2Energy).acceptsEnergyFrom((TileEntity) baseMetaTile, oppositeSide)) return true; // IC2 Source Compat if (GT_Mod.gregtechproxy.ic2EnergySourceCompat && (ic2Energy instanceof IEnergySource)) { - if (((IEnergySource) ic2Energy).emitsEnergyTo((TileEntity) baseMetaTile, tDir)) { + if (((IEnergySource) ic2Energy).emitsEnergyTo((TileEntity) baseMetaTile, oppositeSide)) { return true; } } } // RF Output Compat - if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver - && ((IEnergyReceiver) tTileEntity).canConnectEnergy(tDir)) return true; + if (GregTech_API.mOutputRF && tileEntity instanceof IEnergyReceiver + && ((IEnergyReceiver) tileEntity).canConnectEnergy(oppositeSide)) return true; // RF Input Compat - return GregTech_API.mInputRF && (tTileEntity instanceof IEnergyEmitter - && ((IEnergyEmitter) tTileEntity).emitsEnergyTo((TileEntity) baseMetaTile, tDir)); + return GregTech_API.mInputRF && (tileEntity instanceof IEnergyEmitter + && ((IEnergyEmitter) tileEntity).emitsEnergyTo((TileEntity) baseMetaTile, oppositeSide)); } @Override @@ -399,12 +389,14 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @@ -508,48 +500,53 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile private AxisAlignedBB getActualCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { float tSpace = (1f - mThickNess) / 2; - float tSide0 = tSpace; - float tSide1 = 1f - tSpace; - float tSide2 = tSpace; - float tSide3 = 1f - tSpace; - float tSide4 = tSpace; - float tSide5 = 1f - tSpace; - - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 0) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide3 = tSide5 = 1; + float spaceDown = tSpace; + float spaceUp = 1f - tSpace; + float spaceNorth = tSpace; + float spaceSouth = 1f - tSpace; + float spaceWest = tSpace; + float spaceEast = 1f - tSpace; + + if (getBaseMetaTileEntity().getCoverIDAtSide(DOWN) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 1) != 0) { - tSide2 = tSide4 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) { + spaceNorth = spaceWest = 0; + spaceUp = spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 2) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide1 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceUp = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 3) != 0) { - tSide0 = tSide4 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) { + spaceDown = spaceWest = 0; + spaceUp = spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 4) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide1 = tSide3 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceUp = spaceSouth = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 5) != 0) { - tSide0 = tSide2 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) { + spaceDown = spaceNorth = 0; + spaceUp = spaceSouth = spaceEast = 1; } byte tConn = ((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections; - if ((tConn & (1 << ForgeDirection.DOWN.ordinal())) != 0) tSide0 = 0f; - if ((tConn & (1 << ForgeDirection.UP.ordinal())) != 0) tSide1 = 1f; - if ((tConn & (1 << ForgeDirection.NORTH.ordinal())) != 0) tSide2 = 0f; - if ((tConn & (1 << ForgeDirection.SOUTH.ordinal())) != 0) tSide3 = 1f; - if ((tConn & (1 << ForgeDirection.WEST.ordinal())) != 0) tSide4 = 0f; - if ((tConn & (1 << ForgeDirection.EAST.ordinal())) != 0) tSide5 = 1f; + if ((tConn & (1 << DOWN.ordinal())) != 0) spaceDown = 0f; + if ((tConn & (1 << ForgeDirection.UP.ordinal())) != 0) spaceUp = 1f; + if ((tConn & (1 << ForgeDirection.NORTH.ordinal())) != 0) spaceNorth = 0f; + if ((tConn & (1 << ForgeDirection.SOUTH.ordinal())) != 0) spaceSouth = 1f; + if ((tConn & (1 << ForgeDirection.WEST.ordinal())) != 0) spaceWest = 0f; + if ((tConn & (1 << ForgeDirection.EAST.ordinal())) != 0) spaceEast = 1f; - return AxisAlignedBB - .getBoundingBox(aX + tSide4, aY + tSide0, aZ + tSide2, aX + tSide5, aY + tSide1, aZ + tSide3); + return AxisAlignedBB.getBoundingBox( + aX + spaceWest, + aY + spaceDown, + aZ + spaceNorth, + aX + spaceEast, + aY + spaceUp, + aZ + spaceSouth); } @Override @@ -568,18 +565,20 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile if (mConnections != 0) { final IGregTechTileEntity baseMeta = getBaseMetaTileEntity(); - for (byte aSide = 0; aSide < 6; aSide++) if (isConnectedAtSide(aSide)) { - final TileEntity tTileEntity = baseMeta.getTileEntityAtSide(aSide); - final TileEntity tEmitter = (tTileEntity == null || tTileEntity instanceof IEnergyTile - || EnergyNet.instance == null) - ? tTileEntity - : EnergyNet.instance.getTileEntity( - tTileEntity.getWorldObj(), - tTileEntity.xCoord, - tTileEntity.yCoord, - tTileEntity.zCoord); - - if (tEmitter instanceof IEnergyEmitter) return true; + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (isConnectedAtSide(side)) { + final TileEntity tTileEntity = baseMeta.getTileEntityAtSide(side); + final TileEntity tEmitter = (tTileEntity == null || tTileEntity instanceof IEnergyTile + || EnergyNet.instance == null) + ? tTileEntity + : EnergyNet.instance.getTileEntity( + tTileEntity.getWorldObj(), + tTileEntity.xCoord, + tTileEntity.yCoord, + tTileEntity.zCoord); + + if (tEmitter instanceof IEnergyEmitter) return true; + } } } return false; @@ -589,22 +588,22 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile public void reloadLocks() { final BaseMetaPipeEntity pipe = (BaseMetaPipeEntity) getBaseMetaTileEntity(); if (pipe.getNode() != null) { - for (byte tSide : ALL_VALID_SIDES) { - if (isConnectedAtSide(tSide)) { - final CoverInfo coverInfo = pipe.getCoverInfoAtSide(tSide); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (isConnectedAtSide(side)) { + final CoverInfo coverInfo = pipe.getCoverInfoAtSide(side); if (coverInfo.getCoverBehavior() instanceof GT_Cover_None) continue; if (!letsIn(coverInfo) || !letsOut(coverInfo)) { - pipe.addToLock(pipe, tSide); + pipe.addToLock(pipe, side); } else { - pipe.removeFromLock(pipe, tSide); + pipe.removeFromLock(pipe, side); } } } } else { boolean dontAllow = false; - for (byte tSide : ALL_VALID_SIDES) { - if (isConnectedAtSide(tSide)) { - final CoverInfo coverInfo = pipe.getCoverInfoAtSide(tSide); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (isConnectedAtSide(side)) { + final CoverInfo coverInfo = pipe.getCoverInfoAtSide(side); if (coverInfo.getCoverBehavior() instanceof GT_Cover_None) continue; if (!letsIn(coverInfo) || !letsOut(coverInfo)) { @@ -613,9 +612,9 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } } if (dontAllow) { - pipe.addToLock(pipe, 0); + pipe.addToLock(pipe, DOWN); } else { - pipe.removeFromLock(pipe, 0); + pipe.removeFromLock(pipe, DOWN); } } } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Fluid.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Fluid.java index 76c7f418e9..e19d6574c3 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Fluid.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Fluid.java @@ -1,5 +1,6 @@ package gregtech.api.metatileentity.implementations; +import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.D1; import static gregtech.api.objects.XSTR.XSTR_INSTANCE; @@ -108,54 +109,57 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, - byte aColorIndex, boolean aConnected, boolean aRedstone) { + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, int aConnections, + int colorIndex, boolean aConnected, boolean redstoneLevel) { + final int ordinalSide = side.ordinal(); final float tThickNess = getThickNess(); if (mDisableInput == 0) - return new ITexture[] { aConnected ? getBaseTexture(tThickNess, mPipeAmount, mMaterial, aColorIndex) + return new ITexture[] { aConnected ? getBaseTexture(tThickNess, mPipeAmount, mMaterial, colorIndex) : TextureFactory.of( mMaterial.mIconSet.mTextures[OrePrefixes.pipe.mTextureIndex], - Dyes.getModulation(aColorIndex, mMaterial.mRGBa)) }; + Dyes.getModulation(colorIndex, mMaterial.mRGBa)) }; byte tMask = 0; final byte[][] sRestrictionArray = { { 2, 3, 5, 4 }, { 2, 3, 4, 5 }, { 1, 0, 4, 5 }, { 1, 0, 4, 5 }, { 1, 0, 2, 3 }, { 1, 0, 2, 3 } }; - if (aSide >= 0 && aSide < 6) { - for (byte i = 0; i < 4; i++) if (isInputDisabledAtSide(sRestrictionArray[aSide][i])) tMask |= 1 << i; + if (side != ForgeDirection.UNKNOWN) { + for (byte i = 0; i < 4; i++) + if (isInputDisabledAtSide(ForgeDirection.getOrientation(sRestrictionArray[ordinalSide][i]))) + tMask |= 1 << i; // Full block size renderer flips side 5 and 2 textures, flip restrictor textures to compensate - if (aSide == 5 || aSide == 2) if (tMask > 3 && tMask < 12) tMask = (byte) (tMask ^ 12); + if (ordinalSide == 5 || ordinalSide == 2) if (tMask > 3 && tMask < 12) tMask = (byte) (tMask ^ 12); } - return new ITexture[] { aConnected ? getBaseTexture(tThickNess, mPipeAmount, mMaterial, aColorIndex) + return new ITexture[] { aConnected ? getBaseTexture(tThickNess, mPipeAmount, mMaterial, colorIndex) : TextureFactory.of( mMaterial.mIconSet.mTextures[OrePrefixes.pipe.mTextureIndex], - Dyes.getModulation(aColorIndex, mMaterial.mRGBa)), + Dyes.getModulation(colorIndex, mMaterial.mRGBa)), getRestrictorTexture(tMask) }; } - protected static ITexture getBaseTexture(float aThickNess, int aPipeAmount, Materials aMaterial, byte aColorIndex) { + protected static ITexture getBaseTexture(float aThickNess, int aPipeAmount, Materials aMaterial, int colorIndex) { if (aPipeAmount >= 9) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeNonuple.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aPipeAmount >= 4) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeQuadruple.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aThickNess < 0.124F) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipe.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aThickNess < 0.374F) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeTiny.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aThickNess < 0.499F) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeSmall.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aThickNess < 0.749F) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeMedium.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); if (aThickNess < 0.874F) return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeLarge.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); return TextureFactory.of( aMaterial.mIconSet.mTextures[OrePrefixes.pipeHuge.mTextureIndex], - Dyes.getModulation(aColorIndex, aMaterial.mRGBa)); + Dyes.getModulation(colorIndex, aMaterial.mRGBa)); } protected static ITexture getRestrictorTexture(byte aMask) { @@ -195,7 +199,7 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @@ -205,7 +209,7 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public final boolean renderInside(byte aSide) { + public final boolean renderInside(ForgeDirection side) { return false; } @@ -376,22 +380,22 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { // Tank, From, Amount to receive final List<MutableTriple<IFluidHandler, ForgeDirection, Integer>> tTanks = new ArrayList<>(); final int amount = tFluid.amount; - - for (byte aSide, i = 0, j = (byte) aBaseMetaTileEntity.getRandomNumber(6); i < 6; i++) { + final byte tOffset = (byte) getBaseMetaTileEntity().getRandomNumber(6); + for (final byte i : ALL_VALID_SIDES) { // Get a list of tanks accepting fluids, and what side they're on - aSide = (byte) ((i + j) % 6); - final byte tSide = GT_Utility.getOppositeSide(aSide); - final IFluidHandler tTank = aBaseMetaTileEntity.getITankContainerAtSide(aSide); + final ForgeDirection side = ForgeDirection.getOrientation((i + tOffset) % 6); + final ForgeDirection oppositeSide = side.getOpposite(); + final IFluidHandler tTank = aBaseMetaTileEntity.getITankContainerAtSide(side); final IGregTechTileEntity gTank = tTank instanceof IGregTechTileEntity ? (IGregTechTileEntity) tTank : null; - if (isConnectedAtSide(aSide) && tTank != null - && (mLastReceivedFrom & (1 << aSide)) == 0 - && getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + if (isConnectedAtSide(side) && tTank != null + && (mLastReceivedFrom & (1 << side.ordinal())) == 0 + && getBaseMetaTileEntity().getCoverInfoAtSide(side) .letsFluidOut(tFluid.getFluid()) - && (gTank == null || gTank.getCoverInfoAtSide(tSide) + && (gTank == null || gTank.getCoverInfoAtSide(oppositeSide) .letsFluidIn(tFluid.getFluid()))) { - if (tTank.fill(ForgeDirection.getOrientation(tSide), tFluid, false) > 0) { - tTanks.add(new MutableTriple<>(tTank, ForgeDirection.getOrientation(tSide), 0)); + if (tTank.fill(oppositeSide, tFluid, false) > 0) { + tTanks.add(new MutableTriple<>(tTank, oppositeSide, 0)); } tFluid.amount = amount; // Because some mods do actually modify input fluid stack } @@ -399,19 +403,19 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { // How much of this fluid is available for distribution? final double tAmount = Math.max(1, Math.min(mCapacity * 10, tFluid.amount)); - final double tNumTanks = tTanks.size(); + final FluidStack maxFluid = tFluid.copy(); maxFluid.amount = Integer.MAX_VALUE; double availableCapacity = 0; // Calculate available capacity for distribution from all tanks - for (MutableTriple<IFluidHandler, ForgeDirection, Integer> tEntry : tTanks) { + for (final MutableTriple<IFluidHandler, ForgeDirection, Integer> tEntry : tTanks) { tEntry.right = tEntry.left.fill(tEntry.middle, maxFluid, false); availableCapacity += tEntry.right; } // Now distribute - for (MutableTriple<IFluidHandler, ForgeDirection, Integer> tEntry : tTanks) { + for (final MutableTriple<IFluidHandler, ForgeDirection, Integer> tEntry : tTanks) { // Distribue fluids based on percentage available space at destination if (availableCapacity > tAmount) tEntry.right = (int) Math.floor(tEntry.right * tAmount / availableCapacity); @@ -431,26 +435,27 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { if (GT_Mod.gregtechproxy.gt6Pipe) { - final byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); - final byte tMask = (byte) (1 << tSide); - if (aPlayer.isSneaking()) { + final ForgeDirection tSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); + final byte tMask = (byte) (1 << tSide.ordinal()); + if (entityPlayer.isSneaking()) { if (isInputDisabledAtSide(tSide)) { mDisableInput &= ~tMask; - GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("212", "Input enabled")); + GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("212", "Input enabled")); if (!isConnectedAtSide(tSide)) connect(tSide); } else { mDisableInput |= tMask; - GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("213", "Input disabled")); + GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("213", "Input disabled")); } } else { if (!isConnectedAtSide(tSide)) { - if (connect(tSide) > 0) GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("214", "Connected")); + if (connect(tSide) > 0) + GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("214", "Connected")); } else { disconnect(tSide); - GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("215", "Disconnected")); + GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("215", "Disconnected")); } } return true; @@ -459,27 +464,27 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean letsIn(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsIn(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsFluidIn(aSide, aCoverID, aCoverVariable, null, aTileEntity); + return coverBehavior.letsFluidIn(side, aCoverID, aCoverVariable, null, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsOut(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsFluidOut(aSide, aCoverID, aCoverVariable, null, aTileEntity); + return coverBehavior.letsFluidOut(side, aCoverID, aCoverVariable, null, aTileEntity); } @Override - public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsFluidIn(aSide, aCoverID, aCoverVariable, null, aTileEntity); + return coverBehavior.letsFluidIn(side, aCoverID, aCoverVariable, null, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsFluidOut(aSide, aCoverID, aCoverVariable, null, aTileEntity); + return coverBehavior.letsFluidOut(side, aCoverID, aCoverVariable, null, aTileEntity); } @Override @@ -493,29 +498,27 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean canConnect(byte aSide, TileEntity tTileEntity) { - if (tTileEntity == null) return false; + public boolean canConnect(ForgeDirection side, TileEntity tileEntity) { + if (tileEntity == null) return false; - final byte tSide = (byte) ForgeDirection.getOrientation(aSide) - .getOpposite() - .ordinal(); + final ForgeDirection tSide = side.getOpposite(); final IGregTechTileEntity baseMetaTile = getBaseMetaTileEntity(); if (baseMetaTile == null) return false; - final GT_CoverBehaviorBase<?> coverBehavior = baseMetaTile.getCoverBehaviorAtSideNew(aSide); - final IGregTechTileEntity gTileEntity = (tTileEntity instanceof IGregTechTileEntity) - ? (IGregTechTileEntity) tTileEntity + final GT_CoverBehaviorBase<?> coverBehavior = baseMetaTile.getCoverBehaviorAtSideNew(side); + final IGregTechTileEntity gTileEntity = (tileEntity instanceof IGregTechTileEntity) + ? (IGregTechTileEntity) tileEntity : null; - if (coverBehavior instanceof GT_Cover_Drain || (GregTech_API.mTConstruct && isTConstructFaucet(tTileEntity))) + if (coverBehavior instanceof GT_Cover_Drain || (GregTech_API.mTConstruct && isTConstructFaucet(tileEntity))) return true; - final IFluidHandler fTileEntity = (tTileEntity instanceof IFluidHandler) ? (IFluidHandler) tTileEntity : null; + final IFluidHandler fTileEntity = (tileEntity instanceof IFluidHandler) ? (IFluidHandler) tileEntity : null; if (fTileEntity != null) { - final FluidTankInfo[] tInfo = fTileEntity.getTankInfo(ForgeDirection.getOrientation(tSide)); + final FluidTankInfo[] tInfo = fTileEntity.getTankInfo(tSide); if (tInfo != null) { - return tInfo.length > 0 || (GregTech_API.mTranslocator && isTranslocator(tTileEntity)) + return tInfo.length > 0 || (GregTech_API.mTranslocator && isTranslocator(tileEntity)) || gTileEntity != null && gTileEntity.getCoverBehaviorAtSideNew(tSide) instanceof GT_Cover_FluidRegulator; } @@ -578,7 +581,7 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { + public FluidTankInfo[] getTankInfo(ForgeDirection side) { if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[] {}; ArrayList<FluidTankInfo> tList = new ArrayList<>(); for (FluidStack tFluid : mFluids) tList.add(new FluidTankInfo(tFluid, mCapacity * 20)); @@ -586,12 +589,14 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @@ -613,7 +618,7 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public final int fill_default(ForgeDirection aSide, FluidStack aFluid, boolean doFill) { + public final int fill_default(ForgeDirection side, FluidStack aFluid, boolean doFill) { if (aFluid == null || aFluid.getFluid() .getID() <= 0) return 0; @@ -628,26 +633,28 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } } - return fill_default_intoIndex(aSide, aFluid, doFill, index); + return fill_default_intoIndex(side, aFluid, doFill, index); } - private int fill_default_intoIndex(ForgeDirection aSide, FluidStack aFluid, boolean doFill, int index) { + private int fill_default_intoIndex(ForgeDirection side, FluidStack aFluid, boolean doFill, int index) { if (index < 0 || index >= mPipeAmount) return 0; if (aFluid == null || aFluid.getFluid() .getID() <= 0) return 0; + final int ordinalSide = side.ordinal(); + if (mFluids[index] == null || mFluids[index].getFluid() .getID() <= 0) { if (aFluid.amount * mPipeAmount <= getCapacity()) { if (doFill) { mFluids[index] = aFluid.copy(); - mLastReceivedFrom |= (1 << aSide.ordinal()); + mLastReceivedFrom |= (1 << ordinalSide); } return aFluid.amount; } if (doFill) { mFluids[index] = aFluid.copy(); - mLastReceivedFrom |= (1 << aSide.ordinal()); + mLastReceivedFrom |= (1 << ordinalSide); mFluids[index].amount = getCapacity() / mPipeAmount; } return getCapacity() / mPipeAmount; @@ -659,13 +666,13 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { if (aFluid.amount <= space) { if (doFill) { mFluids[index].amount += aFluid.amount; - mLastReceivedFrom |= (1 << aSide.ordinal()); + mLastReceivedFrom |= (1 << ordinalSide); } return aFluid.amount; } if (doFill) { mFluids[index].amount = getCapacity() / mPipeAmount; - mLastReceivedFrom |= (1 << aSide.ordinal()); + mLastReceivedFrom |= (1 << ordinalSide); } return space; } @@ -742,17 +749,17 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public boolean isLiquidInput(byte aSide) { - return !isInputDisabledAtSide(aSide); + public boolean isLiquidInput(ForgeDirection side) { + return !isInputDisabledAtSide(side); } @Override - public boolean isLiquidOutput(byte aSide) { + public boolean isLiquidOutput(ForgeDirection side) { return true; } - public boolean isInputDisabledAtSide(int aSide) { - return (mDisableInput & (1 << aSide)) != 0; + public boolean isInputDisabledAtSide(ForgeDirection side) { + return (mDisableInput & (1 << side.ordinal())) != 0; } @Override @@ -771,27 +778,27 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { float tSide4 = tSpace; float tSide5 = 1f - tSpace; - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 0) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.DOWN) != 0) { tSide0 = tSide2 = tSide4 = 0; tSide3 = tSide5 = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 1) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) { tSide2 = tSide4 = 0; tSide1 = tSide3 = tSide5 = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 2) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) { tSide0 = tSide2 = tSide4 = 0; tSide1 = tSide5 = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 3) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) { tSide0 = tSide4 = 0; tSide1 = tSide3 = tSide5 = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 4) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) { tSide0 = tSide2 = tSide4 = 0; tSide1 = tSide3 = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 5) != 0) { + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) { tSide0 = tSide2 = 0; tSide1 = tSide3 = tSide5 = 1; } @@ -819,7 +826,7 @@ public class GT_MetaPipeEntity_Fluid extends MetaPipeEntity { } @Override - public FluidStack drain(ForgeDirection aSide, FluidStack aFluid, boolean doDrain) { + public FluidStack drain(ForgeDirection side, FluidStack aFluid, boolean doDrain) { if (aFluid == null) return null; for (int i = 0; i < mFluids.length; ++i) { final FluidStack f = mFluids[i]; diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Frame.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Frame.java index 9ccb43e733..83e658cbfc 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Frame.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Frame.java @@ -5,6 +5,7 @@ import static gregtech.api.util.GT_Utility.calculateRecipeEU; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.*; import gregtech.api.interfaces.ITexture; @@ -62,11 +63,11 @@ public class GT_MetaPipeEntity_Frame extends MetaPipeEntity { } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, - byte aColorIndex, boolean aConnected, boolean aRedstone) { + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, int connections, + int colorIndex, boolean active, boolean redstoneLevel) { return new ITexture[] { TextureFactory.of( mMaterial.mIconSet.mTextures[OrePrefixes.frameGt.mTextureIndex], - Dyes.getModulation(aColorIndex, mMaterial.mRGBa)) }; + Dyes.getModulation(colorIndex, mMaterial.mRGBa)) }; } @Override @@ -80,7 +81,7 @@ public class GT_MetaPipeEntity_Frame extends MetaPipeEntity { } @Override - public final boolean isFacingValid(byte aFacing) { + public final boolean isFacingValid(ForgeDirection facing) { return false; } @@ -90,7 +91,7 @@ public class GT_MetaPipeEntity_Frame extends MetaPipeEntity { } @Override - public final boolean renderInside(byte aSide) { + public final boolean renderInside(ForgeDirection side) { return true; } @@ -110,24 +111,24 @@ public class GT_MetaPipeEntity_Frame extends MetaPipeEntity { } @Override - public final boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, + public final boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack) { return false; } @Override - public final boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, + public final boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack) { return false; } @Override - public int connect(byte aSide) { + public int connect(ForgeDirection side) { return 0; } @Override - public void disconnect(byte aSide) { + public void disconnect(ForgeDirection side) { /* Do nothing */ } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Item.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Item.java index f69170b83e..0a1fe6ae7a 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Item.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaPipeEntity_Item.java @@ -47,7 +47,7 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE public final int mStepSize; public final int mTickTime; public int mTransferredItems = 0; - public byte mLastReceivedFrom = 0, oLastReceivedFrom = 0; + public ForgeDirection mLastReceivedFrom = ForgeDirection.UNKNOWN, oLastReceivedFrom = ForgeDirection.UNKNOWN; public boolean mIsRestrictive = false; private int[] cacheSides; @@ -95,8 +95,8 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, - byte aColorIndex, boolean aConnected, boolean aRedstone) { + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, int aConnections, + int aColorIndex, boolean aConnected, boolean redstoneLevel) { if (mIsRestrictive) { if (aConnected) { float tThickNess = getThickNess(); @@ -163,17 +163,17 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @Override - public boolean isValidSlot(int aIndex) { + public boolean isValidSlot(int ignoredSlotIndex) { return true; } @Override - public final boolean renderInside(byte aSide) { + public final boolean renderInside(ForgeDirection side) { return false; } @@ -189,13 +189,13 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE @Override public void saveNBTData(NBTTagCompound aNBT) { - aNBT.setByte("mLastReceivedFrom", mLastReceivedFrom); + aNBT.setByte("mLastReceivedFrom", (byte) mLastReceivedFrom.ordinal()); if (GT_Mod.gregtechproxy.gt6Pipe) aNBT.setByte("mConnections", mConnections); } @Override public void loadNBTData(NBTTagCompound aNBT) { - mLastReceivedFrom = aNBT.getByte("mLastReceivedFrom"); + mLastReceivedFrom = ForgeDirection.getOrientation(aNBT.getByte("mLastReceivedFrom")); if (GT_Mod.gregtechproxy.gt6Pipe) { mConnections = aNBT.getByte("mConnections"); } @@ -230,21 +230,21 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } } - if (isInventoryEmpty()) mLastReceivedFrom = 6; + if (isInventoryEmpty()) mLastReceivedFrom = ForgeDirection.UNKNOWN; oLastReceivedFrom = mLastReceivedFrom; } } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { if (GT_Mod.gregtechproxy.gt6Pipe) { - final byte tSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); + final ForgeDirection tSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); if (isConnectedAtSide(tSide)) { disconnect(tSide); - GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("215", "Disconnected")); + GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("215", "Disconnected")); } else { - if (connect(tSide) > 0) GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("214", "Connected")); + if (connect(tSide) > 0) GT_Utility.sendChatToPlayer(entityPlayer, GT_Utility.trans("214", "Connected")); } return true; } @@ -252,27 +252,27 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean letsIn(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsIn(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsItemsIn(aSide, aCoverID, aCoverVariable, -1, aTileEntity); + return coverBehavior.letsItemsIn(side, aCoverID, aCoverVariable, -1, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehavior coverBehavior, byte aSide, int aCoverID, int aCoverVariable, + public boolean letsOut(GT_CoverBehavior coverBehavior, ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsItemsOut(aSide, aCoverID, aCoverVariable, -1, aTileEntity); + return coverBehavior.letsItemsOut(side, aCoverID, aCoverVariable, -1, aTileEntity); } @Override - public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsIn(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsItemsIn(aSide, aCoverID, aCoverVariable, -1, aTileEntity); + return coverBehavior.letsItemsIn(side, aCoverID, aCoverVariable, -1, aTileEntity); } @Override - public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, byte aSide, int aCoverID, + public boolean letsOut(GT_CoverBehaviorBase<?> coverBehavior, ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return coverBehavior.letsItemsOut(aSide, aCoverID, aCoverVariable, -1, aTileEntity); + return coverBehavior.letsItemsOut(side, aCoverID, aCoverVariable, -1, aTileEntity); } @Override @@ -286,28 +286,28 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean canConnect(byte aSide, TileEntity tTileEntity) { - if (tTileEntity == null) return false; + public boolean canConnect(ForgeDirection side, TileEntity tileEntity) { + if (tileEntity == null) return false; - final byte tSide = GT_Utility.getOppositeSide(aSide); - boolean connectable = GT_Utility.isConnectableNonInventoryPipe(tTileEntity, tSide); + final ForgeDirection oppositeSide = side.getOpposite(); + boolean connectable = GT_Utility.isConnectableNonInventoryPipe(tileEntity, oppositeSide); - final IGregTechTileEntity gTileEntity = (tTileEntity instanceof IGregTechTileEntity) - ? (IGregTechTileEntity) tTileEntity + final IGregTechTileEntity gTileEntity = (tileEntity instanceof IGregTechTileEntity) + ? (IGregTechTileEntity) tileEntity : null; if (gTileEntity != null) { if (gTileEntity.getMetaTileEntity() == null) return false; if (gTileEntity.getMetaTileEntity() - .connectsToItemPipe(tSide)) return true; + .connectsToItemPipe(oppositeSide)) return true; connectable = true; } - if (tTileEntity instanceof IInventory) { - if (((IInventory) tTileEntity).getSizeInventory() <= 0) return false; + if (tileEntity instanceof IInventory) { + if (((IInventory) tileEntity).getSizeInventory() <= 0) return false; connectable = true; } - if (tTileEntity instanceof ISidedInventory) { - final int[] tSlots = ((ISidedInventory) tTileEntity).getAccessibleSlotsFromSide(tSide); + if (tileEntity instanceof ISidedInventory) { + final int[] tSlots = ((ISidedInventory) tileEntity).getAccessibleSlotsFromSide(oppositeSide.ordinal()); if (tSlots == null || tSlots.length <= 0) return false; connectable = true; } @@ -331,9 +331,8 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE public boolean sendItemStack(Object aSender) { if (pipeCapacityCheck()) { final byte tOffset = (byte) getBaseMetaTileEntity().getRandomNumber(6); - byte tSide = 0; - for (byte i : ALL_VALID_SIDES) { - tSide = (byte) ((i + tOffset) % 6); + for (final byte i : ALL_VALID_SIDES) { + final ForgeDirection tSide = ForgeDirection.getOrientation((i + tOffset) % 6); if (isConnectedAtSide(tSide) && (isInventoryEmpty() || (tSide != mLastReceivedFrom || aSender != getBaseMetaTileEntity()))) { if (insertItemStackIntoTileEntity(aSender, tSide)) return true; @@ -344,18 +343,19 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean insertItemStackIntoTileEntity(Object aSender, byte aSide) { - if (getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + public boolean insertItemStackIntoTileEntity(Object aSender, ForgeDirection side) { + if (getBaseMetaTileEntity().getCoverInfoAtSide(side) .letsItemsOut(-1)) { - final TileEntity tInventory = getBaseMetaTileEntity().getTileEntityAtSide(aSide); + final TileEntity tInventory = getBaseMetaTileEntity().getTileEntityAtSide(side); if (tInventory != null && !(tInventory instanceof BaseMetaPipeEntity)) { if ((!(tInventory instanceof TileEntityHopper) && !(tInventory instanceof TileEntityDispenser)) - || getBaseMetaTileEntity().getMetaIDAtSide(aSide) != GT_Utility.getOppositeSide(aSide)) { + || getBaseMetaTileEntity().getMetaIDAtSide(side) != side.getOpposite() + .ordinal()) { return GT_Utility.moveMultipleItemStacks( aSender, tInventory, - (byte) 6, - GT_Utility.getOppositeSide(aSide), + ForgeDirection.UNKNOWN, + side.getOpposite(), null, false, (byte) 64, @@ -395,22 +395,23 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean canInsertItem(int aIndex, ItemStack aStack, int aSide) { - return isConnectedAtSide(aSide) && super.canInsertItem(aIndex, aStack, aSide); + public boolean canInsertItem(int aIndex, ItemStack aStack, int ordinalSide) { + return isConnectedAtSide(ForgeDirection.getOrientation(ordinalSide)) + && super.canInsertItem(aIndex, aStack, ordinalSide); } @Override - public boolean canExtractItem(int aIndex, ItemStack aStack, int aSide) { - return isConnectedAtSide(aSide); + public boolean canExtractItem(int aIndex, ItemStack aStack, int ordinalSide) { + return isConnectedAtSide(ForgeDirection.getOrientation(ordinalSide)); } @Override - public int[] getAccessibleSlotsFromSide(int aSide) { + public int[] getAccessibleSlotsFromSide(int ordinalSide) { final IGregTechTileEntity tTileEntity = getBaseMetaTileEntity(); - final CoverInfo coverInfo = tTileEntity.getCoverInfoAtSide((byte) aSide); + final CoverInfo coverInfo = tTileEntity.getCoverInfoAtSide(ForgeDirection.getOrientation(ordinalSide)); final boolean tAllow = coverInfo.letsItemsIn(-2) || coverInfo.letsItemsOut(-2); if (tAllow) { - if (cacheSides == null) cacheSides = super.getAccessibleSlotsFromSide(aSide); + if (cacheSides == null) cacheSides = super.getAccessibleSlotsFromSide(ordinalSide); return cacheSides; } else { return GT_Values.emptyIntArray; @@ -418,15 +419,17 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return isConnectedAtSide(aSide); + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return isConnectedAtSide(side); } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - if (!isConnectedAtSide(aSide)) return false; - if (isInventoryEmpty()) mLastReceivedFrom = aSide; - return mLastReceivedFrom == aSide && mInventory[aIndex] == null; + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + if (!isConnectedAtSide(side)) return false; + if (isInventoryEmpty()) mLastReceivedFrom = side; + return mLastReceivedFrom == side && mInventory[aIndex] == null; } @Override @@ -459,50 +462,55 @@ public class GT_MetaPipeEntity_Item extends MetaPipeEntity implements IMetaTileE else return getActualCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ); } - private AxisAlignedBB getActualCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { + private AxisAlignedBB getActualCollisionBoundingBoxFromPool(World ignoredAWorld, int aX, int aY, int aZ) { final float tSpace = (1f - mThickNess) / 2; - float tSide0 = tSpace; - float tSide1 = 1f - tSpace; - float tSide2 = tSpace; - float tSide3 = 1f - tSpace; - float tSide4 = tSpace; - float tSide5 = 1f - tSpace; - - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 0) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide3 = tSide5 = 1; + float spaceDown = tSpace; + float spaceUp = 1f - tSpace; + float spaceNorth = tSpace; + float spaceSouth = 1f - tSpace; + float spaceWest = tSpace; + float spaceEast = 1f - tSpace; + + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.DOWN) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 1) != 0) { - tSide2 = tSide4 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) { + spaceNorth = spaceWest = 0; + spaceUp = spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 2) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide1 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceUp = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 3) != 0) { - tSide0 = tSide4 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) { + spaceDown = spaceWest = 0; + spaceUp = spaceSouth = spaceEast = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 4) != 0) { - tSide0 = tSide2 = tSide4 = 0; - tSide1 = tSide3 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) { + spaceDown = spaceNorth = spaceWest = 0; + spaceUp = spaceSouth = 1; } - if (getBaseMetaTileEntity().getCoverIDAtSide((byte) 5) != 0) { - tSide0 = tSide2 = 0; - tSide1 = tSide3 = tSide5 = 1; + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) { + spaceDown = spaceNorth = 0; + spaceUp = spaceSouth = spaceEast = 1; } final byte tConn = ((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections; - if ((tConn & (1 << ForgeDirection.DOWN.ordinal())) != 0) tSide0 = 0f; - if ((tConn & (1 << ForgeDirection.UP.ordinal())) != 0) tSide1 = 1f; - if ((tConn & (1 << ForgeDirection.NORTH.ordinal())) != 0) tSide2 = 0f; - if ((tConn & (1 << ForgeDirection.SOUTH.ordinal())) != 0) tSide3 = 1f; - if ((tConn & (1 << ForgeDirection.WEST.ordinal())) != 0) tSide4 = 0f; - if ((tConn & (1 << ForgeDirection.EAST.ordinal())) != 0) tSide5 = 1f; - - return AxisAlignedBB - .getBoundingBox(aX + tSide4, aY + tSide0, aZ + tSide2, aX + tSide5, aY + tSide1, aZ + tSide3); + if ((tConn & (1 << ForgeDirection.DOWN.ordinal())) != 0) spaceDown = 0f; + if ((tConn & (1 << ForgeDirection.UP.ordinal())) != 0) spaceUp = 1f; + if ((tConn & (1 << ForgeDirection.NORTH.ordinal())) != 0) spaceNorth = 0f; + if ((tConn & (1 << ForgeDirection.SOUTH.ordinal())) != 0) spaceSouth = 1f; + if ((tConn & (1 << ForgeDirection.WEST.ordinal())) != 0) spaceWest = 0f; + if ((tConn & (1 << ForgeDirection.EAST.ordinal())) != 0) spaceEast = 1f; + + return AxisAlignedBB.getBoundingBox( + aX + spaceWest, + aY + spaceDown, + aZ + spaceNorth, + aX + spaceEast, + aY + spaceUp, + aZ + spaceSouth); } @Override diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicBatteryBuffer.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicBatteryBuffer.java index ad6a730863..a72ec19d79 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicBatteryBuffer.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicBatteryBuffer.java @@ -15,6 +15,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.StatCollector; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; @@ -84,9 +85,9 @@ public class GT_MetaTileEntity_BasicBatteryBuffer extends GT_MetaTileEntity_Tier } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { - return mTextures[aSide == aFacing ? 1 : 0][aColorIndex + 1]; + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing, + int colorIndex, boolean aActive, boolean redstoneLevel) { + return mTextures[side == aFacing ? 1 : 0][colorIndex + 1]; } @Override @@ -110,7 +111,7 @@ public class GT_MetaTileEntity_BasicBatteryBuffer extends GT_MetaTileEntity_Tier } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -125,13 +126,13 @@ public class GT_MetaTileEntity_BasicBatteryBuffer extends GT_MetaTileEntity_Tier } @Override - public boolean isInputFacing(byte aSide) { - return aSide != getBaseMetaTileEntity().getFrontFacing(); + public boolean isInputFacing(ForgeDirection side) { + return side != getBaseMetaTileEntity().getFrontFacing(); } @Override - public boolean isOutputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -236,7 +237,8 @@ public class GT_MetaTileEntity_BasicBatteryBuffer extends GT_MetaTileEntity_Tier } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { if (GT_ModHandler.isElectricItem(aStack) && aStack.getUnlocalizedName() .startsWith("gt.metaitem.01.")) { String name = aStack.getUnlocalizedName(); @@ -254,7 +256,8 @@ public class GT_MetaTileEntity_BasicBatteryBuffer extends GT_MetaTileEntity_Tier } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { if (!GT_Utility.isStackValid(aStack)) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java index ef7242b420..0a589d6919 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicGenerator.java @@ -5,6 +5,7 @@ import static gregtech.api.enums.GT_Values.V; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidContainerItem; import net.minecraftforge.fluids.IFluidHandler; @@ -61,10 +62,11 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { - return mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 - : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1]; + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + return mTextures[(active ? 5 : 0) + (side == facingDirection ? 0 + : side == facingDirection.getOpposite() ? 1 + : side == ForgeDirection.DOWN ? 2 : side == ForgeDirection.UP ? 3 : 4)][colorIndex + 1]; } @Override @@ -122,7 +124,7 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity } @Override - public boolean isFacingValid(byte aSide) { + public boolean isFacingValid(ForgeDirection side) { return true; } @@ -142,7 +144,7 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity } @Override - public boolean isOutputFacing(byte aSide) { + public boolean isOutputFacing(ForgeDirection side) { return true; } @@ -198,7 +200,7 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity } @Override - public boolean isLiquidOutput(byte aSide) { + public boolean isLiquidOutput(ForgeDirection side) { // return super.isLiquidOutput(aSide); return false; } @@ -330,8 +332,9 @@ public abstract class GT_MetaTileEntity_BasicGenerator extends GT_MetaTileEntity } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack) && (getFuelValue(aStack, true) > 0 + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return super.allowPutStack(aBaseMetaTileEntity, aIndex, side, aStack) && (getFuelValue(aStack, true) > 0 || getFuelValue(GT_Utility.getFluidForFilledItem(aStack, true), true) > 0); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull.java index ff1365a735..e5766eee39 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.V; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.Textures; import gregtech.api.interfaces.ITexture; @@ -58,13 +59,13 @@ public class GT_MetaTileEntity_BasicHull extends GT_MetaTileEntity_BasicTank { } @Override - public boolean isInputFacing(byte aSide) { - return !isOutputFacing(aSide); + public boolean isInputFacing(ForgeDirection side) { + return !isOutputFacing(side); } @Override - public boolean isOutputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -93,7 +94,7 @@ public class GT_MetaTileEntity_BasicHull extends GT_MetaTileEntity_BasicTank { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -103,19 +104,21 @@ public class GT_MetaTileEntity_BasicHull extends GT_MetaTileEntity_BasicTank { } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return true; } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return true; } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aConnected, boolean aRedstone) { - return mTextures[Math.min(2, aSide) + (aSide == aFacing ? 3 : 0)][aColorIndex + 1]; + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing, + int colorIndex, boolean aConnected, boolean redstoneLevel) { + return mTextures[Math.min(2, side.ordinal()) + (side == aFacing ? 3 : 0)][colorIndex + 1]; } @Override diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull_NonElectric.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull_NonElectric.java index c9b66e6baf..b6584b50ab 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull_NonElectric.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicHull_NonElectric.java @@ -1,5 +1,7 @@ package gregtech.api.metatileentity.implementations; +import net.minecraftforge.common.util.ForgeDirection; + import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; @@ -21,9 +23,9 @@ public abstract class GT_MetaTileEntity_BasicHull_NonElectric extends GT_MetaTil } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, - byte aColorIndex, boolean aConnected, boolean aRedstone) { - return mTextures[Math.min(2, aSide)][aColorIndex + 1]; + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + return mTextures[Math.min(2, sideDirection.ordinal())][colorIndex + 1]; } @Override @@ -42,12 +44,12 @@ public abstract class GT_MetaTileEntity_BasicHull_NonElectric extends GT_MetaTil } @Override - public boolean isInputFacing(byte aSide) { + public boolean isInputFacing(ForgeDirection side) { return false; } @Override - public boolean isOutputFacing(byte aSide) { + public boolean isOutputFacing(ForgeDirection side) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine.java index 4868200bf1..b798c8cfef 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine.java @@ -1,6 +1,5 @@ package gregtech.api.metatileentity.implementations; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.V; import static gregtech.api.enums.GT_Values.debugCleanroom; import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS; @@ -102,7 +101,8 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B mHasBeenUpdated = false, mStuttering = false, mCharge = false, mDecharge = false; public boolean mDisableFilter = true; public boolean mDisableMultiStack = true; - public int mMainFacing = -1, mProgresstime = 0, mMaxProgresstime = 0, mEUt = 0, mOutputBlocked = 0; + public int mProgresstime = 0, mMaxProgresstime = 0, mEUt = 0, mOutputBlocked = 0; + public ForgeDirection mMainFacing = ForgeDirection.UNKNOWN; public FluidStack mOutputFluid; public String mGUIName, mNEIName; protected final Power mPower; @@ -190,15 +190,15 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B return new BasicMachineEUPower(mTier, mAmperage); } - protected boolean isValidMainFacing(byte aSide) { - return aSide > 1; + protected boolean isValidMainFacing(ForgeDirection side) { + return side.offsetY == 0; // Neither DOWN nor UP } - public boolean setMainFacing(byte aSide) { - if (!isValidMainFacing(aSide)) return false; - mMainFacing = aSide; + public boolean setMainFacing(ForgeDirection side) { + if (!isValidMainFacing(side)) return false; + mMainFacing = side; if (getBaseMetaTileEntity().getFrontFacing() == mMainFacing) { - getBaseMetaTileEntity().setFrontFacing(GT_Utility.getOppositeSide(aSide)); + getBaseMetaTileEntity().setFrontFacing(side.getOpposite()); } onFacingChange(); onMachineBlockUpdate(); @@ -235,39 +235,39 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { final int textureIndex; - if (mMainFacing < 2) { - if (aSide == aFacing) { - textureIndex = aActive ? 2 : 3; + if (mMainFacing.offsetY != 0) { // UP or DOWN + if (sideDirection == facingDirection) { + textureIndex = active ? 2 : 3; } else { - textureIndex = switch (aSide) { - case 0 -> aActive ? 6 : 7; - case 1 -> aActive ? 4 : 5; - default -> aActive ? 0 : 1; + textureIndex = switch (sideDirection) { + case DOWN -> active ? 6 : 7; + case UP -> active ? 4 : 5; + default -> active ? 0 : 1; }; } } else { - if (aSide == mMainFacing) { - textureIndex = aActive ? 2 : 3; + if (sideDirection == mMainFacing) { + textureIndex = active ? 2 : 3; } else { - if (showPipeFacing() && aSide == aFacing) { - textureIndex = switch (aSide) { - case 0 -> aActive ? 8 : 9; - case 1 -> aActive ? 10 : 11; - default -> aActive ? 12 : 13; + if (showPipeFacing() && sideDirection == facingDirection) { + textureIndex = switch (sideDirection) { + case DOWN -> active ? 8 : 9; + case UP -> active ? 10 : 11; + default -> active ? 12 : 13; }; } else { - textureIndex = switch (aSide) { - case 0 -> aActive ? 6 : 7; - case 1 -> aActive ? 4 : 5; - default -> aActive ? 0 : 1; + textureIndex = switch (sideDirection) { + case DOWN -> active ? 6 : 7; + case UP -> active ? 4 : 5; + default -> active ? 0 : 1; }; } } } - return mTextures[textureIndex][aColorIndex + 1]; + return mTextures[textureIndex][colorIndex + 1]; } @Override @@ -298,8 +298,8 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public boolean isFacingValid(byte aFacing) { - return mMainFacing > 1 || aFacing > 1; + public boolean isFacingValid(ForgeDirection facing) { + return facing.offsetY == 0 || facing.offsetY == 0; } @Override @@ -308,12 +308,12 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public boolean isInputFacing(byte aSide) { - return aSide != mMainFacing; + public boolean isInputFacing(ForgeDirection side) { + return side != mMainFacing; } @Override - public boolean isOutputFacing(byte aSide) { + public boolean isOutputFacing(ForgeDirection side) { return false; } @@ -323,13 +323,13 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public boolean isLiquidInput(byte aSide) { - return aSide != mMainFacing && (mAllowInputFromOutputSide || aSide != getBaseMetaTileEntity().getFrontFacing()); + public boolean isLiquidInput(ForgeDirection side) { + return side != mMainFacing && (mAllowInputFromOutputSide || side != getBaseMetaTileEntity().getFrontFacing()); } @Override - public boolean isLiquidOutput(byte aSide) { - return aSide != mMainFacing; + public boolean isLiquidOutput(ForgeDirection side) { + return side != mMainFacing; } @Override @@ -490,8 +490,8 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } return true; } - for (byte tSide : ALL_VALID_SIDES) { - if (aBaseMetaTileEntity.getAirAtSide(tSide)) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (aBaseMetaTileEntity.getAirAtSide(side)) { if (useModularUI()) { GT_UIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); } else { @@ -524,7 +524,7 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B @Override public void initDefaultModes(NBTTagCompound aNBT) { - mMainFacing = -1; + mMainFacing = ForgeDirection.UNKNOWN; if (!getBaseMetaTileEntity().getWorld().isRemote) { GT_ClientPreference tPreference = GT_Mod.gregtechproxy .getClientPreference(getBaseMetaTileEntity().getOwnerUuid()); @@ -545,7 +545,7 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B aNBT.setBoolean("mDisableFilter", mDisableFilter); aNBT.setBoolean("mDisableMultiStack", mDisableMultiStack); aNBT.setInteger("mEUt", mEUt); - aNBT.setInteger("mMainFacing", mMainFacing); + aNBT.setInteger("mMainFacing", mMainFacing.ordinal()); aNBT.setInteger("mProgresstime", mProgresstime); aNBT.setInteger("mMaxProgresstime", mMaxProgresstime); if (mOutputFluid != null) aNBT.setTag("mOutputFluid", mOutputFluid.writeToNBT(new NBTTagCompound())); @@ -565,7 +565,7 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B mDisableFilter = aNBT.getBoolean("mDisableFilter"); mDisableMultiStack = aNBT.getBoolean("mDisableMultiStack"); mEUt = aNBT.getInteger("mEUt"); - mMainFacing = aNBT.getInteger("mMainFacing"); + mMainFacing = ForgeDirection.getOrientation(aNBT.getInteger("mMainFacing")); mProgresstime = aNBT.getInteger("mProgresstime"); mMaxProgresstime = aNBT.getInteger("mMaxProgresstime"); mOutputFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mOutputFluid")); @@ -634,12 +634,9 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B if (tTank != null) { FluidStack tDrained = drain(1000, false); if (tDrained != null) { - int tFilledAmount = tTank - .fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), tDrained, false); - if (tFilledAmount > 0) tTank.fill( - ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), - drain(tFilledAmount, true), - true); + final int tFilledAmount = tTank.fill(aBaseMetaTileEntity.getBackFacing(), tDrained, false); + if (tFilledAmount > 0) + tTank.fill(aBaseMetaTileEntity.getBackFacing(), drain(tFilledAmount, true), true); } } if (getDrainableStack() == null) tRemovedOutputFluid = true; @@ -726,10 +723,10 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } protected void doDisplayThings() { - if (mMainFacing < 2 && getBaseMetaTileEntity().getFrontFacing() > 1) { + if (mMainFacing.offsetY != 0 && getBaseMetaTileEntity().getFrontFacing().offsetY == 0) { mMainFacing = getBaseMetaTileEntity().getFrontFacing(); } - if (mMainFacing >= 2 && !mHasBeenUpdated) { + if (mMainFacing.offsetY == 0 && !mHasBeenUpdated) { mHasBeenUpdated = true; getBaseMetaTileEntity().setFrontFacing(getBaseMetaTileEntity().getBackFacing()); } @@ -852,12 +849,12 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B @Override public void onValueUpdate(byte aValue) { - mMainFacing = aValue; + mMainFacing = ForgeDirection.getOrientation(aValue); } @Override public byte getUpdateData() { - return (byte) mMainFacing; + return (byte) mMainFacing.ordinal(); } @Override @@ -955,8 +952,8 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { - if (aSide == getBaseMetaTileEntity().getFrontFacing() || aSide == mMainFacing) { + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (side == getBaseMetaTileEntity().getFrontFacing() || side == mMainFacing) { if (aPlayer.isSneaking()) { mDisableFilter = !mDisableFilter; GT_Utility.sendChatToPlayer( @@ -973,44 +970,46 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B } @Override - public boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { - if (!aPlayer.isSneaking()) return false; - boolean click = super.onSolderingToolRightClick(aSide, aWrenchingSide, aPlayer, aX, aY, aZ); + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, + EntityPlayer entityPlayer, float aX, float aY, float aZ) { + if (!entityPlayer.isSneaking()) return false; + final boolean click = super.onSolderingToolRightClick(side, wrenchingSide, entityPlayer, aX, aY, aZ); if (click) return true; - if (aWrenchingSide != mMainFacing) return false; + if (wrenchingSide != mMainFacing) return false; mDisableMultiStack = !mDisableMultiStack; GT_Utility.sendChatToPlayer( - aPlayer, + entityPlayer, StatCollector.translateToLocal("GT5U.hatch.disableMultiStack." + mDisableMultiStack)); return true; } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { - if (aSide != mMainFacing) return true; + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { + if (side != mMainFacing) return true; GT_CoverBehaviorBase<?> tBehavior = GregTech_API.getCoverBehaviorNew(aCoverID.toStack()); return tBehavior.isGUIClickable( - aSide, + side, GT_Utility.stackToInt(aCoverID.toStack()), tBehavior.createDataObject(), getBaseMetaTileEntity()); } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide != mMainFacing && aIndex >= getOutputSlot() && aIndex < getOutputSlot() + mOutputItems.length; + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side != mMainFacing && aIndex >= getOutputSlot() && aIndex < getOutputSlot() + mOutputItems.length; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - if (aSide == mMainFacing || aIndex < getInputSlot() + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + if (side == mMainFacing || aIndex < getInputSlot() || aIndex >= getInputSlot() + mInputSlotCount - || (!mAllowInputFromOutputSide && aSide == aBaseMetaTileEntity.getFrontFacing())) return false; + || (!mAllowInputFromOutputSide && side == aBaseMetaTileEntity.getFrontFacing())) return false; for (int i = getInputSlot(), j = i + mInputSlotCount; i < j; i++) if (GT_Utility.areStacksEqual(GT_OreDictUnificator.get(aStack), mInventory[i]) && mDisableMultiStack) return i == aIndex; - return mDisableFilter || allowPutStackValidated(aBaseMetaTileEntity, aIndex, aSide, aStack); + return mDisableFilter || allowPutStackValidated(aBaseMetaTileEntity, aIndex, side, aStack); } /** @@ -1018,7 +1017,7 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B * method it is ensured there is no such kind of item inside any input slots already. Otherwise, you don't need to * check for it anyway. */ - protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, + protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack) { return !mDisableMultiStack || mInventory[aIndex] == null; } @@ -1265,13 +1264,16 @@ public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_B tag.setInteger("progressSingleBlock", mProgresstime); tag.setInteger("maxProgressSingleBlock", mMaxProgresstime); - tag.setInteger("mainFacingSingleBlock", mMainFacing); + tag.setInteger("mainFacingSingleBlock", mMainFacing.ordinal()); tag.setBoolean("stutteringSingleBlock", mStuttering); - IGregTechTileEntity tileEntity = getBaseMetaTileEntity(); + final IGregTechTileEntity tileEntity = getBaseMetaTileEntity(); if (tileEntity != null) { tag.setBoolean("isActiveSingleBlock", tileEntity.isActive()); - tag.setInteger("outputFacingSingleBlock", tileEntity.getFrontFacing()); + tag.setInteger( + "outputFacingSingleBlock", + tileEntity.getFrontFacing() + .ordinal()); if (tileEntity.isActive()) tag.setInteger("eut", mEUt); } } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_Bronze.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_Bronze.java index 38fce53658..2ea4b25860 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_Bronze.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_Bronze.java @@ -100,7 +100,7 @@ public abstract class GT_MetaTileEntity_BasicMachine_Bronze extends GT_MetaTileE } @Override - public boolean isInputFacing(byte aSide) { + public boolean isInputFacing(ForgeDirection side) { return false; } @@ -130,8 +130,8 @@ public abstract class GT_MetaTileEntity_BasicMachine_Bronze extends GT_MetaTileE } @Override - public boolean isFacingValid(byte aFacing) { - return super.isFacingValid(aFacing) && aFacing != mMainFacing; + public boolean isFacingValid(ForgeDirection facing) { + return super.isFacingValid(facing) && facing != mMainFacing; } @Override @@ -145,13 +145,13 @@ public abstract class GT_MetaTileEntity_BasicMachine_Bronze extends GT_MetaTileE } @Override - public boolean isLiquidInput(byte aSide) { - return aSide != mMainFacing; + public boolean isLiquidInput(ForgeDirection side) { + return side != mMainFacing; } @Override - public boolean isLiquidOutput(byte aSide) { - return aSide != mMainFacing; + public boolean isLiquidOutput(ForgeDirection side) { + return side != mMainFacing; } @Override @@ -224,9 +224,9 @@ public abstract class GT_MetaTileEntity_BasicMachine_Bronze extends GT_MetaTileE new ParticleEventBuilder().setIdentifier(ParticleFX.CLOUD) .setWorld(getBaseMetaTileEntity().getWorld()) .setMotion( - ForgeDirection.getOrientation(getBaseMetaTileEntity().getFrontFacing()).offsetX / 5.0, - ForgeDirection.getOrientation(getBaseMetaTileEntity().getFrontFacing()).offsetY / 5.0, - ForgeDirection.getOrientation(getBaseMetaTileEntity().getFrontFacing()).offsetZ / 5.0) + getBaseMetaTileEntity().getFrontFacing().offsetX / 5.0, + getBaseMetaTileEntity().getFrontFacing().offsetY / 5.0, + getBaseMetaTileEntity().getFrontFacing().offsetZ / 5.0) .<ParticleEventBuilder>times( 8, x -> x @@ -244,9 +244,9 @@ public abstract class GT_MetaTileEntity_BasicMachine_Bronze extends GT_MetaTileE } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { return GregTech_API.getCoverBehaviorNew(aCoverID.toStack()) - .isSimpleCover() && super.allowCoverOnSide(aSide, aCoverID); + .isSimpleCover() && super.allowCoverOnSide(side, aCoverID); } public float getSteamDamage() { diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_GT_Recipe.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_GT_Recipe.java index a80e235a65..2d4b080093 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_GT_Recipe.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine_GT_Recipe.java @@ -7,6 +7,7 @@ import static gregtech.api.enums.GT_Values.ticksBetweenSounds; import static gregtech.api.enums.Mods.BartWorks; import static gregtech.api.enums.Mods.GregTech; import static gregtech.api.objects.XSTR.XSTR_INSTANCE; +import static net.minecraftforge.common.util.ForgeDirection.UP; import java.util.Locale; @@ -559,9 +560,9 @@ public class GT_MetaTileEntity_BasicMachine_GT_Recipe extends GT_MetaTileEntity_ } @Override - protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, + protected boolean allowPutStackValidated(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, ItemStack aStack) { - if (!super.allowPutStackValidated(aBaseMetaTileEntity, aIndex, aSide, aStack)) return false; + if (!super.allowPutStackValidated(aBaseMetaTileEntity, aIndex, side, aStack)) return false; switch (this.mInputSlotCount) { case 0 -> { return false; @@ -636,10 +637,8 @@ public class GT_MetaTileEntity_BasicMachine_GT_Recipe extends GT_MetaTileEntity_ // noinspection SwitchStatementWithTooFewBranches switch (this.mSpecialEffect) { case TOP_SMOKE -> { - final byte topFacing = (byte) ForgeDirection.UP.ordinal(); - if (aBaseMetaTileEntity.getFrontFacing() != topFacing - && aBaseMetaTileEntity.getCoverIDAtSide(topFacing) == 0 - && !aBaseMetaTileEntity.getOpacityAtSide(topFacing)) { + if (aBaseMetaTileEntity.getFrontFacing() != UP && aBaseMetaTileEntity.getCoverIDAtSide(UP) == 0 + && !aBaseMetaTileEntity.getOpacityAtSide(UP)) { new ParticleEventBuilder().setMotion(0.0D, 0.0D, 0.0D) .setIdentifier(ParticleFX.SMOKE) @@ -671,9 +670,9 @@ public class GT_MetaTileEntity_BasicMachine_GT_Recipe extends GT_MetaTileEntity_ // Random Sparkles at main face if (aBaseMetaTileEntity.isActive() && XSTR_INSTANCE.nextInt(3) == 0) { - final byte mainFacing = (byte) this.mMainFacing; + final ForgeDirection mainFacing = this.mMainFacing; - if (mainFacing > 1 && aBaseMetaTileEntity.getCoverIDAtSide(mainFacing) == 0 + if (mainFacing.ordinal() > 1 && aBaseMetaTileEntity.getCoverIDAtSide(mainFacing) == 0 && !aBaseMetaTileEntity.getOpacityAtSide(mainFacing)) { final double oX = aBaseMetaTileEntity.getXCoord(); @@ -686,17 +685,17 @@ public class GT_MetaTileEntity_BasicMachine_GT_Recipe extends GT_MetaTileEntity_ y = oY + XSTR_INSTANCE.nextFloat() * 10D / 16D + 5D / 16D; - if (mainFacing == ForgeDirection.WEST.ordinal()) { + if (mainFacing == ForgeDirection.WEST) { x = oX - offset; mX = -.05D; z = oZ + horizontal; mZ = 0D; - } else if (mainFacing == ForgeDirection.EAST.ordinal()) { + } else if (mainFacing == ForgeDirection.EAST) { x = oX + offset; mX = .05D; z = oZ + horizontal; mZ = 0D; - } else if (mainFacing == ForgeDirection.NORTH.ordinal()) { + } else if (mainFacing == ForgeDirection.NORTH) { x = oX + horizontal; mX = 0D; z = oZ - offset; diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicTank.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicTank.java index 7d4723d4f6..f3a0af38f5 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicTank.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicTank.java @@ -308,7 +308,7 @@ public abstract class GT_MetaTileEntity_BasicTank extends GT_MetaTileEntity_Tier } @Override - public FluidTankInfo[] getTankInfo(ForgeDirection aSide) { + public FluidTankInfo[] getTankInfo(ForgeDirection side) { if (getCapacity() <= 0 && !getBaseMetaTileEntity().hasSteamEngineUpgrade()) return new FluidTankInfo[] {}; if (isDrainableStackSeparate()) { return new FluidTankInfo[] { new FluidTankInfo(getFillableStack(), getCapacity()), @@ -319,12 +319,14 @@ public abstract class GT_MetaTileEntity_BasicTank extends GT_MetaTileEntity_Tier } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return aIndex == getOutputSlot(); } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return aIndex == getInputSlot(); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Buffer.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Buffer.java index f7f69ae924..cf1ba436e1 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Buffer.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Buffer.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.V; import static gregtech.api.enums.Textures.BlockIcons.*; import java.util.*; +import java.util.stream.IntStream; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; @@ -97,14 +98,12 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { - int colorIndex = aColorIndex + 1; - ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[aSide]; - ForgeDirection facing = ForgeDirection.VALID_DIRECTIONS[aFacing]; - if (side == facing) return mTextures[FRONT_INDEX][colorIndex]; - if (ForgeDirection.OPPOSITES[aSide] == aFacing) return mTextures[OUTPUT_INDEX][colorIndex]; - switch (facing) { + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + colorIndex = colorIndex + 1; + if (sideDirection == facingDirection) return mTextures[FRONT_INDEX][colorIndex]; + if (sideDirection.getOpposite() == facingDirection) return mTextures[OUTPUT_INDEX][colorIndex]; + switch (facingDirection) { case DOWN -> { return mTextures[ARROW_UP_INDEX][colorIndex]; // ARROW_UP } @@ -112,7 +111,7 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM return mTextures[ARROW_DOWN_INDEX][colorIndex]; // ARROW_DOWN } case NORTH -> { - switch (side) { + switch (sideDirection) { case DOWN, UP -> { return mTextures[ARROW_DOWN_INDEX][colorIndex]; // ARROW_DOWN } @@ -126,7 +125,7 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } } case SOUTH -> { - switch (side) { + switch (sideDirection) { case DOWN, UP -> { return mTextures[ARROW_UP_INDEX][colorIndex]; // ARROW_UP } @@ -140,7 +139,7 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } } case WEST -> { - switch (side) { + switch (sideDirection) { case UP, SOUTH -> { return mTextures[ARROW_RIGHT_INDEX][colorIndex]; // ARROW_RIGHT } @@ -151,7 +150,7 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } } case EAST -> { - switch (side) { + switch (sideDirection) { case UP, SOUTH -> { return mTextures[ARROW_LEFT_INDEX][colorIndex]; // ARROW_LEFT } @@ -177,7 +176,7 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -192,13 +191,13 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public boolean isInputFacing(byte aSide) { - return !isOutputFacing(aSide); + public boolean isInputFacing(ForgeDirection side) { + return !isOutputFacing(side); } @Override - public boolean isOutputFacing(byte aSide) { - return getBaseMetaTileEntity().getBackFacing() == aSide; + public boolean isOutputFacing(ForgeDirection side) { + return getBaseMetaTileEntity().getBackFacing() == side; } @Override @@ -281,8 +280,8 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { - if (aSide == getBaseMetaTileEntity().getBackFacing()) { + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (side == getBaseMetaTileEntity().getBackFacing()) { mTargetStackSize = (byte) ((mTargetStackSize + (aPlayer.isSneaking() ? -1 : 1)) % 65); if (mTargetStackSize < 0) { @@ -299,11 +298,11 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { - aWrenchingSide = GT_Utility.getOppositeSide(aWrenchingSide); - if (getBaseMetaTileEntity().isValidFacing(aWrenchingSide)) { - getBaseMetaTileEntity().setFrontFacing(aWrenchingSide); + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { + wrenchingSide = wrenchingSide.getOpposite(); + if (getBaseMetaTileEntity().isValidFacing(wrenchingSide)) { + getBaseMetaTileEntity().setFrontFacing(wrenchingSide); return true; } return false; @@ -311,18 +310,15 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM protected void handleRedstoneOutput(IGregTechTileEntity aBaseMetaTileEntity) { if (bRedstoneIfFull) { - boolean hasEmptySlots = false; - for (int i = 0; i < mInventory.length; i++) { - if (isValidSlot(i) && mInventory[i] == null) { - hasEmptySlots = true; - break; - } - } - if (bInvert) hasEmptySlots = !hasEmptySlots; - for (byte b = 0; b < 6; b++) - aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, hasEmptySlots ? (byte) 0 : (byte) 15); + final boolean hasEmptySlots = IntStream.range(0, mInventory.length) + .anyMatch(i -> isValidSlot(i) && mInventory[i] == null); + Arrays.stream(ForgeDirection.VALID_DIRECTIONS) + .forEach( + side -> aBaseMetaTileEntity + .setInternalOutputRedstoneSignal(side, (byte) (bInvert ^ hasEmptySlots ? 0 : 15))); } else { - for (byte b = 0; b < 6; b++) aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, (byte) 0); + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 0); } } @@ -341,14 +337,15 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM @Override public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { - for (byte b = 0; b < 6; b++) aBaseMetaTileEntity.setInternalOutputRedstoneSignal(b, (byte) 0); + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 0); } protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) { moveItems(aBaseMetaTileEntity, aTimer, 1); } - protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer, int stacks) { + protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long ignoredTimer, int stacks) { int tCost; if (bStockingMode) tCost = GT_Utility.moveMultipleItemStacks( aBaseMetaTileEntity, @@ -381,13 +378,15 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return true; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide != aBaseMetaTileEntity.getBackFacing(); + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side != aBaseMetaTileEntity.getBackFacing(); } @Override @@ -432,18 +431,18 @@ public abstract class GT_MetaTileEntity_Buffer extends GT_MetaTileEntity_TieredM } @Override - public boolean onSolderingToolRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { - if (aPlayer.isSneaking()) { + public boolean onSolderingToolRightClick(ForgeDirection side, ForgeDirection wrenchingSide, + EntityPlayer entityPlayer, float aX, float aY, float aZ) { + if (entityPlayer.isSneaking()) { // I was so proud of all this but I literally just copied code from OutputBus bSortStacks = !bSortStacks; GT_Utility.sendChatToPlayer( - aPlayer, + entityPlayer, GT_Utility.trans("200", "Sort mode: ") + (bSortStacks ? GT_Utility.trans("088", "Enabled") : GT_Utility.trans("087", "Disabled"))); return true; } - return super.onSolderingToolRightClick(aSide, aWrenchingSide, aPlayer, aX, aY, aZ); + return super.onSolderingToolRightClick(side, wrenchingSide, entityPlayer, aX, aY, aZ); } @Override diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_EnhancedMultiBlockBase.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_EnhancedMultiBlockBase.java index 6fdfa53a14..9fac4a880c 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_EnhancedMultiBlockBase.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_EnhancedMultiBlockBase.java @@ -76,16 +76,16 @@ public abstract class GT_MetaTileEntity_EnhancedMultiBlockBase<T extends GT_Meta } @Override - public final boolean isFacingValid(byte aFacing) { - return canSetToDirectionAny(ForgeDirection.getOrientation(aFacing)); + public final boolean isFacingValid(ForgeDirection facing) { + return canSetToDirectionAny(facing); } @Override - public boolean onWrenchRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, - float aZ) { - if (aWrenchingSide != getBaseMetaTileEntity().getFrontFacing()) - return super.onWrenchRightClick(aSide, aWrenchingSide, aPlayer, aX, aY, aZ); - if (aPlayer.isSneaking()) { + public boolean onWrenchRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer entityPlayer, + float aX, float aY, float aZ) { + if (wrenchingSide != getBaseMetaTileEntity().getFrontFacing()) + return super.onWrenchRightClick(side, wrenchingSide, entityPlayer, aX, aY, aZ); + if (entityPlayer.isSneaking()) { // we won't be allowing horizontal flips, as it can be perfectly emulated by rotating twice and flipping // horizontally // allowing an extra round of flip make it hard to draw meaningful flip markers in GT_Proxy#drawGrid @@ -98,7 +98,7 @@ public abstract class GT_MetaTileEntity_EnhancedMultiBlockBase<T extends GT_Meta @Override public void onFacingChange() { - toolSetDirection(ForgeDirection.getOrientation(getBaseMetaTileEntity().getFrontFacing())); + toolSetDirection(getBaseMetaTileEntity().getFrontFacing()); } @Override @@ -145,7 +145,7 @@ public abstract class GT_MetaTileEntity_EnhancedMultiBlockBase<T extends GT_Meta public void loadNBTData(NBTTagCompound aNBT) { super.loadNBTData(aNBT); mExtendedFacing = ExtendedFacing.of( - ForgeDirection.getOrientation(getBaseMetaTileEntity().getFrontFacing()), + getBaseMetaTileEntity().getFrontFacing(), Rotation.byIndex(aNBT.getByte("eRotation")), Flip.byIndex(aNBT.getByte("eFlip"))); } @@ -157,14 +157,14 @@ public abstract class GT_MetaTileEntity_EnhancedMultiBlockBase<T extends GT_Meta /** * Explanation of the world coordinate these offset means: - * + * <p> * Imagine you stand in front of the controller, with controller facing towards you not rotated or flipped. - * + * <p> * The horizontalOffset would be the number of blocks on the left side of the controller, not counting controller * itself. The verticalOffset would be the number of blocks on the top side of the controller, not counting * controller itself. The depthOffset would be the number of blocks between you and controller, not counting * controller itself. - * + * <p> * All these offsets can be negative. */ protected final boolean checkPiece(String piece, int horizontalOffset, int verticalOffset, int depthOffset) { diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch.java index f0ce474fd1..ec6d1fe11f 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch.java @@ -1,6 +1,7 @@ package gregtech.api.metatileentity.implementations; import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.GT_Values; import gregtech.api.enums.Textures; @@ -61,16 +62,16 @@ public abstract class GT_MetaTileEntity_Hatch extends GT_MetaTileEntity_BasicTan public abstract ITexture[] getTexturesInactive(ITexture aBaseTexture); @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing, + int colorIndex, boolean aActive, boolean redstoneLevel) { int texturePointer = (byte) (actualTexture & 0x7F); // just to be sure, from my testing the 8th bit cannot be // set clientside int textureIndex = texturePointer | (mTexturePage << 7); // Shift seven since one page is 128 textures! try { - if (aSide != aFacing) { + if (side != aFacing) { if (textureIndex > 0) return new ITexture[] { Textures.BlockIcons.casingTexturePages[mTexturePage][texturePointer] }; - else return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1] }; + else return new ITexture[] { Textures.BlockIcons.MACHINE_CASINGS[mTier][colorIndex + 1] }; } else { if (textureIndex > 0) { if (aActive) @@ -78,8 +79,8 @@ public abstract class GT_MetaTileEntity_Hatch extends GT_MetaTileEntity_BasicTan else return getTexturesInactive( Textures.BlockIcons.casingTexturePages[mTexturePage][texturePointer]); } else { - if (aActive) return getTexturesActive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1]); - else return getTexturesInactive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1]); + if (aActive) return getTexturesActive(Textures.BlockIcons.MACHINE_CASINGS[mTier][colorIndex + 1]); + else return getTexturesInactive(Textures.BlockIcons.MACHINE_CASINGS[mTier][colorIndex + 1]); } } } catch (NullPointerException npe) { @@ -108,7 +109,7 @@ public abstract class GT_MetaTileEntity_Hatch extends GT_MetaTileEntity_BasicTan /** * Sets texture with page and index, called on add to machine list - * + * * @param id (page<<7)+index of the texture */ public final void updateTexture(int id) { @@ -118,7 +119,7 @@ public abstract class GT_MetaTileEntity_Hatch extends GT_MetaTileEntity_BasicTan /** * Sets texture with page and index, rather unusable, but kept FFS - * + * * @param page page of texure * @param index index of texure */ diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java index 7617725d92..122dcfa746 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java @@ -5,6 +5,7 @@ import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_DATA_ACCESS; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; @@ -58,7 +59,7 @@ public class GT_MetaTileEntity_Hatch_DataAccess extends GT_MetaTileEntity_Hatch } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -84,12 +85,14 @@ public class GT_MetaTileEntity_Hatch_DataAccess extends GT_MetaTileEntity_Hatch } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return mTier >= 8 && !aBaseMetaTileEntity.isActive(); } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return mTier >= 8 && !aBaseMetaTileEntity.isActive(); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Dynamo.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Dynamo.java index cc1d0ac404..8e621434db 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Dynamo.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Dynamo.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.V; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.Textures; import gregtech.api.interfaces.ITexture; @@ -51,7 +52,7 @@ public class GT_MetaTileEntity_Hatch_Dynamo extends GT_MetaTileEntity_Hatch { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -66,8 +67,8 @@ public class GT_MetaTileEntity_Hatch_Dynamo extends GT_MetaTileEntity_Hatch { } @Override - public boolean isOutputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -96,12 +97,14 @@ public class GT_MetaTileEntity_Hatch_Dynamo extends GT_MetaTileEntity_Hatch { } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Energy.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Energy.java index 2ad670fae1..d9be12671d 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Energy.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Energy.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.V; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.Textures; import gregtech.api.interfaces.ITexture; @@ -61,7 +62,7 @@ public class GT_MetaTileEntity_Hatch_Energy extends GT_MetaTileEntity_Hatch { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -76,8 +77,8 @@ public class GT_MetaTileEntity_Hatch_Energy extends GT_MetaTileEntity_Hatch { } @Override - public boolean isInputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -111,12 +112,14 @@ public class GT_MetaTileEntity_Hatch_Energy extends GT_MetaTileEntity_Hatch { } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java index 408e1eca14..e659fd10a9 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Input.java @@ -6,6 +6,7 @@ import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PIPE_IN; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.FluidStack; import gregtech.GT_Mod; @@ -77,7 +78,7 @@ public class GT_MetaTileEntity_Hatch_Input extends GT_MetaTileEntity_Hatch { } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -151,13 +152,15 @@ public class GT_MetaTileEntity_Hatch_Input extends GT_MetaTileEntity_Hatch { } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == aBaseMetaTileEntity.getFrontFacing() && aIndex == 1; + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing() && aIndex == 1; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == aBaseMetaTileEntity.getFrontFacing() && aIndex == 0 + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing() && aIndex == 0 && (mRecipeMap == null || mRecipeMap.containsInput(aStack) || mRecipeMap.containsInput(GT_Utility.getFluidForFilledItem(aStack, true))); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus.java index 4bbb98c1da..0a8144d620 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_InputBus.java @@ -10,6 +10,7 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.StatCollector; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; @@ -94,7 +95,7 @@ public class GT_MetaTileEntity_Hatch_InputBus extends GT_MetaTileEntity_Hatch } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -201,8 +202,8 @@ public class GT_MetaTileEntity_Hatch_InputBus extends GT_MetaTileEntity_Hatch } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { - if (!getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (!getBaseMetaTileEntity().getCoverInfoAtSide(side) .isGUIClickable()) return; if (aPlayer.isSneaking()) { if (disableSort) { @@ -227,14 +228,16 @@ public class GT_MetaTileEntity_Hatch_InputBus extends GT_MetaTileEntity_Hatch } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { if (aIndex == getCircuitSlot()) return false; - return aSide == getBaseMetaTileEntity().getFrontFacing(); + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == getBaseMetaTileEntity().getFrontFacing() && aIndex != getCircuitSlot() + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == getBaseMetaTileEntity().getFrontFacing() && aIndex != getCircuitSlot() && (mRecipeMap == null || disableFilter || mRecipeMap.containsInput(aStack)) && (disableLimited || limitedAllowPutStack(aIndex, aStack)); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Maintenance.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Maintenance.java index 12a55d097c..3b56a2dbbf 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Maintenance.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Maintenance.java @@ -14,6 +14,7 @@ import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.common.util.FakePlayer; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; @@ -125,7 +126,7 @@ public class GT_MetaTileEntity_Hatch_Maintenance extends GT_MetaTileEntity_Hatch } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -147,10 +148,10 @@ public class GT_MetaTileEntity_Hatch_Maintenance extends GT_MetaTileEntity_Hatch } @Override - public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, - float aY, float aZ) { + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, + float aX, float aY, float aZ) { if (aBaseMetaTileEntity.isClientSide()) return true; - if (aSide == aBaseMetaTileEntity.getFrontFacing()) { + if (side == aBaseMetaTileEntity.getFrontFacing()) { // only allow OC robot fake player if (aPlayer instanceof FakePlayer && !aPlayer.getGameProfile() .getName() @@ -294,12 +295,14 @@ public class GT_MetaTileEntity_Hatch_Maintenance extends GT_MetaTileEntity_Hatch } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return mAuto && GT_Mod.gregtechproxy.mAMHInteraction; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { if (mAuto && GT_Mod.gregtechproxy.mAMHInteraction) { for (int i = 0; i < getSizeInventory(); i++) if (GT_Utility.areStacksEqual( GT_OreDictUnificator.get(false, aStack), diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java index 1fdafd7f35..9cec94fe9b 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Muffler.java @@ -86,12 +86,14 @@ public class GT_MetaTileEntity_Hatch_Muffler extends GT_MetaTileEntity_Hatch { } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @@ -118,8 +120,8 @@ public class GT_MetaTileEntity_Hatch_Muffler extends GT_MetaTileEntity_Hatch { } @Override - public boolean isFacingValid(byte aFacing) { - return facings[aFacing]; + public boolean isFacingValid(ForgeDirection facing) { + return facings[facing.ordinal()]; } @Override @@ -144,18 +146,18 @@ public class GT_MetaTileEntity_Hatch_Muffler extends GT_MetaTileEntity_Hatch { chk2 = chk3 = false; } - IGregTechTileEntity aMuffler = this.getBaseMetaTileEntity(); - ForgeDirection aDir = ForgeDirection.getOrientation(aMuffler.getFrontFacing()); - float xPos = aDir.offsetX * 0.76F + aMuffler.getXCoord() + 0.25F; - float yPos = aDir.offsetY * 0.76F + aMuffler.getYCoord() + 0.25F; - float zPos = aDir.offsetZ * 0.76F + aMuffler.getZCoord() + 0.25F; + final IGregTechTileEntity aMuffler = this.getBaseMetaTileEntity(); + final ForgeDirection aDir = aMuffler.getFrontFacing(); + final float xPos = aDir.offsetX * 0.76F + aMuffler.getXCoord() + 0.25F; + final float yPos = aDir.offsetY * 0.76F + aMuffler.getYCoord() + 0.25F; + final float zPos = aDir.offsetZ * 0.76F + aMuffler.getZCoord() + 0.25F; - float ySpd = aDir.offsetY * 0.1F + 0.2F + 0.1F * XSTR_INSTANCE.nextFloat(); - float xSpd; - float zSpd; + final float ySpd = aDir.offsetY * 0.1F + 0.2F + 0.1F * XSTR_INSTANCE.nextFloat(); + final float xSpd; + final float zSpd; if (aDir.offsetY == -1) { - float temp = XSTR_INSTANCE.nextFloat() * 2 * (float) Math.PI; + final float temp = XSTR_INSTANCE.nextFloat() * 2 * (float) Math.PI; xSpd = (float) Math.sin(temp) * 0.1F; zSpd = (float) Math.cos(temp) * 0.1F; } else { @@ -163,7 +165,7 @@ public class GT_MetaTileEntity_Hatch_Muffler extends GT_MetaTileEntity_Hatch { zSpd = aDir.offsetZ * (0.1F + 0.2F * XSTR_INSTANCE.nextFloat()); } - WorldSpawnedEventBuilder.ParticleEventBuilder events = new WorldSpawnedEventBuilder.ParticleEventBuilder() + final WorldSpawnedEventBuilder.ParticleEventBuilder events = new WorldSpawnedEventBuilder.ParticleEventBuilder() .setIdentifier(name) .setWorld(aWorld) .setMotion(xSpd, ySpd, zSpd); diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Output.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Output.java index c3cc1edc9b..a967df47f3 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Output.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_Output.java @@ -92,7 +92,7 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -102,7 +102,7 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } @Override - public boolean isLiquidInput(byte aSide) { + public boolean isLiquidInput(ForgeDirection side) { return false; } @@ -124,20 +124,14 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl IFluidHandler tTileEntity = aBaseMetaTileEntity .getITankContainerAtSide(aBaseMetaTileEntity.getFrontFacing()); if (tTileEntity != null) { - FluidStack tDrained = aBaseMetaTileEntity.drain( - ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()), - Math.max(1, mFluid.amount), - false); + FluidStack tDrained = aBaseMetaTileEntity + .drain(aBaseMetaTileEntity.getFrontFacing(), Math.max(1, mFluid.amount), false); if (tDrained != null) { - int tFilledAmount = tTileEntity - .fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), tDrained, false); + int tFilledAmount = tTileEntity.fill(aBaseMetaTileEntity.getBackFacing(), tDrained, false); if (tFilledAmount > 0) { tTileEntity.fill( - ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), - aBaseMetaTileEntity.drain( - ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()), - tFilledAmount, - true), + aBaseMetaTileEntity.getBackFacing(), + aBaseMetaTileEntity.drain(aBaseMetaTileEntity.getFrontFacing(), tFilledAmount, true), true); } } @@ -222,13 +216,15 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == aBaseMetaTileEntity.getFrontFacing() && aIndex == 1; + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing() && aIndex == 1; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == aBaseMetaTileEntity.getFrontFacing() && aIndex == 0; + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing() && aIndex == 0; } @Override @@ -237,8 +233,8 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { - if (!getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (!getBaseMetaTileEntity().getCoverInfoAtSide(side) .isGUIClickable()) return; if (aPlayer.isSneaking()) { mMode = (byte) ((mMode + 9) % 10); @@ -323,8 +319,8 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } } - private boolean tryToLockHatch(EntityPlayer aPlayer, byte aSide) { - if (!getBaseMetaTileEntity().getCoverInfoAtSide(aSide) + private boolean tryToLockHatch(EntityPlayer aPlayer, ForgeDirection side) { + if (!getBaseMetaTileEntity().getCoverInfoAtSide(side) .isGUIClickable()) return false; if (!isFluidLocked()) return false; final ItemStack tCurrentItem = aPlayer.inventory.getCurrentItem(); @@ -371,10 +367,10 @@ public class GT_MetaTileEntity_Hatch_Output extends GT_MetaTileEntity_Hatch impl } @Override - public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, - float aY, float aZ) { - if (tryToLockHatch(aPlayer, aSide)) return true; - return super.onRightclick(aBaseMetaTileEntity, aPlayer, aSide, aX, aY, aZ); + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, + float aX, float aY, float aZ) { + if (tryToLockHatch(aPlayer, side)) return true; + return super.onRightclick(aBaseMetaTileEntity, aPlayer, side, aX, aY, aZ); } public boolean outputsSteam() { diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java index f04840d7d3..e3915d4854 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_OutputBus.java @@ -7,6 +7,7 @@ import static gregtech.api.util.GT_Utility.moveMultipleItemStacks; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.screen.ModularWindow; import com.gtnewhorizons.modularui.api.screen.UIBuildContext; @@ -85,7 +86,7 @@ public class GT_MetaTileEntity_Hatch_OutputBus extends GT_MetaTileEntity_Hatch i } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -147,12 +148,14 @@ public class GT_MetaTileEntity_Hatch_OutputBus extends GT_MetaTileEntity_Hatch i } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return aSide == aBaseMetaTileEntity.getFrontFacing(); + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing(); } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java index 7d37b6747f..e6ce7d14c2 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_MultiBlockBase.java @@ -136,8 +136,8 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { - return aSide != getBaseMetaTileEntity().getFrontFacing(); + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { + return side != getBaseMetaTileEntity().getFrontFacing(); } /** Override this if you are a multi-block that has added support for single recipe locking. */ @@ -146,7 +146,7 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity } @Override - public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { if (supportsSingleRecipeLocking()) { mLockedToSingleRecipe = !mLockedToSingleRecipe; if (mLockedToSingleRecipe) { @@ -166,7 +166,7 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -1314,12 +1314,14 @@ public abstract class GT_MetaTileEntity_MultiBlockBase extends MetaTileEntity } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SpecialFilter.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SpecialFilter.java index 9672c87f40..63b8160262 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SpecialFilter.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_SpecialFilter.java @@ -5,6 +5,7 @@ import java.util.List; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.drawable.Text; import com.gtnewhorizons.modularui.api.screen.ModularWindow; @@ -66,8 +67,9 @@ public abstract class GT_MetaTileEntity_SpecialFilter extends GT_MetaTileEntity_ } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { - return (super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return (super.allowPutStack(aBaseMetaTileEntity, aIndex, side, aStack)) && ((this.bNBTAllowed) || (!aStack.hasTagCompound())) && (this.isStackAllowed(aStack) != this.bInvertFilter); } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Transformer.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Transformer.java index ae70607416..4b8b59d9cb 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Transformer.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Transformer.java @@ -86,10 +86,10 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi } @Override - public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, - boolean aActive, boolean aRedstone) { - return mTextures[Math.min(2, aSide) + (aSide == aFacing ? 3 : 0) - + (aBaseMetaTileEntity.isAllowedToWork() ? 0 : 6)][aColorIndex + 1]; + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + return mTextures[Math.min(2, side.ordinal()) + (side == facingDirection ? 3 : 0) + + (baseMetaTileEntity.isAllowedToWork() ? 0 : 6)][colorIndex + 1]; } @Override @@ -108,7 +108,7 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -123,14 +123,14 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi } @Override - public boolean isInputFacing(byte aSide) { - return getBaseMetaTileEntity().isAllowedToWork() ? aSide == getBaseMetaTileEntity().getFrontFacing() - : aSide != getBaseMetaTileEntity().getFrontFacing(); + public boolean isInputFacing(ForgeDirection side) { + return getBaseMetaTileEntity().isAllowedToWork() ? side == getBaseMetaTileEntity().getFrontFacing() + : side != getBaseMetaTileEntity().getFrontFacing(); } @Override - public boolean isOutputFacing(byte aSide) { - return !isInputFacing(aSide); + public boolean isOutputFacing(ForgeDirection side) { + return !isInputFacing(side); } @Override @@ -172,50 +172,52 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { if (aBaseMetaTileEntity.isServerSide() && GregTech_API.mInputRF) { aBaseMetaTileEntity.setActive(aBaseMetaTileEntity.isAllowedToWork()); - for (byte i = 0; i < 6 && aBaseMetaTileEntity.getStoredEU() < aBaseMetaTileEntity.getEUCapacity(); i++) - if (aBaseMetaTileEntity.inputEnergyFrom(i)) { - TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i); - if (tTileEntity instanceof IEnergyProvider && ((IEnergyProvider) tTileEntity) - .extractEnergy(ForgeDirection.getOrientation(GT_Utility.getOppositeSide(i)), 1, true) == 1) { - long tEU = ((IEnergyProvider) tTileEntity).extractEnergy( - ForgeDirection.getOrientation(GT_Utility.getOppositeSide(i)), - GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU), - false); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (aBaseMetaTileEntity.getStoredEU() >= aBaseMetaTileEntity.getEUCapacity()) break; + if (!aBaseMetaTileEntity.inputEnergyFrom(side)) continue; + final TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(side); + if (tTileEntity instanceof IEnergyProvider energyProvider + && energyProvider.extractEnergy(side.getOpposite(), 1, true) == 1) { + long tEU = ((IEnergyProvider) tTileEntity).extractEnergy( + side.getOpposite(), + GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU), + false); + tEU = tEU * GregTech_API.mRFtoEU / 100; + aBaseMetaTileEntity.injectEnergyUnits(ForgeDirection.UNKNOWN, Math.min(tEU, maxEUInput()), 1); + } else if (tTileEntity instanceof IEnergyStorage energyStorage + && energyStorage.extractEnergy(1, true) == 1) { + long tEU = ((IEnergyStorage) tTileEntity) + .extractEnergy(GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU), false); tEU = tEU * GregTech_API.mRFtoEU / 100; - aBaseMetaTileEntity.injectEnergyUnits((byte) 6, Math.min(tEU, maxEUInput()), 1); - } else if (tTileEntity instanceof IEnergyStorage - && ((IEnergyStorage) tTileEntity).extractEnergy(1, true) == 1) { - long tEU = ((IEnergyStorage) tTileEntity) - .extractEnergy(GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU), false); - tEU = tEU * GregTech_API.mRFtoEU / 100; - aBaseMetaTileEntity.injectEnergyUnits((byte) 6, Math.min(tEU, maxEUInput()), 1); - } else if (GregTech_API.meIOLoaded && tTileEntity instanceof IPowerContainer - && ((IPowerContainer) tTileEntity).getEnergyStored() > 0) { - int storedRF = ((IPowerContainer) tTileEntity).getEnergyStored(); - int extractRF = GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU); - long tEU = 0; - if (tTileEntity instanceof TileCapBank) { - ICapBankNetwork network = ((TileCapBank) tTileEntity).getNetwork(); - if (network != null && network.getEnergyStoredL() > 0) { - tEU = Math.min( - (Math.min( - Math.min(network.getEnergyStoredL(), storedRF - extractRF), - network.getMaxOutput())) * (long) GregTech_API.mRFtoEU / 100L, - maxEUInput()); - network.addEnergy(GT_Utility.safeInt(-(tEU * 100 / GregTech_API.mRFtoEU))); - } + aBaseMetaTileEntity.injectEnergyUnits(ForgeDirection.UNKNOWN, Math.min(tEU, maxEUInput()), 1); + } else if (GregTech_API.meIOLoaded && tTileEntity instanceof IPowerContainer powerContainer + && powerContainer.getEnergyStored() > 0) { + final int storedRF = powerContainer.getEnergyStored(); + final int extractRF = GT_Utility.safeInt(maxEUInput() * 100L / GregTech_API.mRFtoEU); + long tEU = 0; + if (tTileEntity instanceof TileCapBank capBank) { + ICapBankNetwork network = capBank.getNetwork(); + if (network != null && network.getEnergyStoredL() > 0) { + tEU = Math.min( + (Math.min( + Math.min(network.getEnergyStoredL(), storedRF - extractRF), + network.getMaxOutput())) * (long) GregTech_API.mRFtoEU / 100L, + maxEUInput()); + network.addEnergy(GT_Utility.safeInt(-(tEU * 100 / GregTech_API.mRFtoEU))); + } + } else { + if (storedRF > extractRF) { + powerContainer.setEnergyStored(storedRF - extractRF); + tEU = maxEUInput(); } else { - if (storedRF > extractRF) { - ((IPowerContainer) tTileEntity).setEnergyStored(storedRF - extractRF); - tEU = maxEUInput(); - } else { - ((IPowerContainer) tTileEntity).setEnergyStored(0); - tEU = storedRF * (long) GregTech_API.mRFtoEU / 100L; - } + powerContainer.setEnergyStored(0); + tEU = storedRF * (long) GregTech_API.mRFtoEU / 100L; } - aBaseMetaTileEntity.injectEnergyUnits((byte) 6, Math.min(tEU, maxEUInput()), 1); } - } + aBaseMetaTileEntity + .injectEnergyUnits(ForgeDirection.UNKNOWN, Math.min(tEU, maxEUInput()), 1); + } + } } } @@ -230,12 +232,14 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @@ -265,10 +269,9 @@ public class GT_MetaTileEntity_Transformer extends GT_MetaTileEntity_TieredMachi @Override public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, IWailaConfigHandler config) { - final int facing = getBaseMetaTileEntity().getFrontFacing(); + final ForgeDirection facing = getBaseMetaTileEntity().getFrontFacing(); final NBTTagCompound tag = accessor.getNBTData(); - final int side = (byte) accessor.getSide() - .ordinal(); + final ForgeDirection side = accessor.getSide(); final boolean allowedToWork = tag.getBoolean("isAllowedToWork"); final byte inputTier = GT_Utility.getTier(tag.getLong("maxEUInput")); diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Dynamo.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Dynamo.java index 0e313a4c00..d677b76248 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Dynamo.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Dynamo.java @@ -5,6 +5,7 @@ import static gregtech.api.enums.GT_Values.*; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.Textures; import gregtech.api.interfaces.IGlobalWirelessEnergy; @@ -44,7 +45,7 @@ public class GT_MetaTileEntity_Wireless_Dynamo extends GT_MetaTileEntity_Hatch_D } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -59,8 +60,8 @@ public class GT_MetaTileEntity_Wireless_Dynamo extends GT_MetaTileEntity_Hatch_D } @Override - public boolean isInputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -106,12 +107,14 @@ public class GT_MetaTileEntity_Wireless_Dynamo extends GT_MetaTileEntity_Hatch_D } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Hatch.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Hatch.java index c363bb6eb0..4c1c7b4cb9 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Hatch.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Wireless_Hatch.java @@ -7,6 +7,7 @@ import java.math.BigInteger; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.enums.Textures; import gregtech.api.interfaces.IGlobalWirelessEnergy; @@ -56,7 +57,7 @@ public class GT_MetaTileEntity_Wireless_Hatch extends GT_MetaTileEntity_Hatch_En } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return true; } @@ -71,8 +72,8 @@ public class GT_MetaTileEntity_Wireless_Hatch extends GT_MetaTileEntity_Hatch_En } @Override - public boolean isInputFacing(byte aSide) { - return aSide == getBaseMetaTileEntity().getFrontFacing(); + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); } @Override @@ -111,12 +112,14 @@ public class GT_MetaTileEntity_Wireless_Hatch extends GT_MetaTileEntity_Hatch_En } @Override - public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } @Override - public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { return false; } diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java index b81961af95..7d1c74b1bc 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlock.java @@ -1,6 +1,5 @@ package gregtech.api.multitileentity; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.OFFX; import static gregtech.api.enums.GT_Values.OFFY; import static gregtech.api.enums.GT_Values.OFFZ; @@ -46,7 +45,6 @@ import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; import gregtech.api.GregTech_API; -import gregtech.api.enums.GT_Values; import gregtech.api.enums.ItemList; import gregtech.api.enums.Textures; import gregtech.api.interfaces.IDebugableBlock; @@ -66,7 +64,6 @@ import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_ShouldCheck import gregtech.api.objects.XSTR; import gregtech.api.util.GT_Log; import gregtech.api.util.GT_Util; -import gregtech.api.util.GT_Utility; import gregtech.common.covers.CoverInfo; import gregtech.common.render.GT_MultiTile_Renderer; @@ -229,13 +226,13 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil @SideOnly(Side.CLIENT) @Override - public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int aSide) { + public IIcon getIcon(IBlockAccess aIBlockAccess, int aX, int aY, int aZ, int ordinalSide) { return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); } @SideOnly(Side.CLIENT) @Override - public IIcon getIcon(int aSide, int aMeta) { + public IIcon getIcon(int ordinalSide, int aMeta) { return Textures.BlockIcons.MACHINE_LV_SIDE.getIcon(); } @@ -252,24 +249,22 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil @Override public final AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMultiTileEntity - ? ((IMultiTileEntity) aTileEntity).getCollisionBoundingBoxFromPool() + return aTileEntity instanceof IMultiTileEntity mte ? mte.getCollisionBoundingBoxFromPool() : aTileEntity == null ? null : super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ); } @Override public final AxisAlignedBB getSelectedBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMultiTileEntity - ? ((IMultiTileEntity) aTileEntity).getSelectedBoundingBoxFromPool() + return aTileEntity instanceof IMultiTileEntity mte ? mte.getSelectedBoundingBoxFromPool() : super.getSelectedBoundingBoxFromPool(aWorld, aX, aY, aZ); } @Override public void setBlockBoundsBasedOnState(IBlockAccess blockAccess, int aX, int aY, int aZ) { final TileEntity aTileEntity = blockAccess.getTileEntity(aX, aY, aZ); - if (aTileEntity instanceof IMultiTileEntity) { - ((IMultiTileEntity) aTileEntity).setBlockBoundsBasedOnState(this); + if (aTileEntity instanceof IMultiTileEntity mte) { + mte.setBlockBoundsBasedOnState(this); return; } super.setBlockBoundsBasedOnState(blockAccess, aX, aY, aZ); @@ -300,21 +295,20 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil if (aTileEntity instanceof BaseTileEntity) ((BaseTileEntity) aTileEntity).onAdjacentBlockChange(aX, aY, aZ); LOCK = false; } - if (aTileEntity instanceof IMTE_OnNeighborBlockChange) - ((IMTE_OnNeighborBlockChange) aTileEntity).onNeighborBlockChange(aWorld, aBlock); + if (aTileEntity instanceof IMTE_OnNeighborBlockChange change) change.onNeighborBlockChange(aWorld, aBlock); if (aTileEntity == null) aWorld.setBlockToAir(aX, aY, aZ); } @Override public final void onBlockAdded(World aWorld, int aX, int aY, int aZ) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - if (aTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) aTileEntity).onBlockAdded(); + if (aTileEntity 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 && ((IMultiTileEntity) aTileEntity).privateAccess() + return aTileEntity instanceof IMultiTileEntity mte && mte.privateAccess() && !((IMultiTileEntity) aTileEntity).playerOwnsThis(aPlayer, true) ? -1.0F : super.getPlayerRelativeBlockHardness(aPlayer, aWorld, aX, aY, aZ); } @@ -322,47 +316,47 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil @Override public final void onBlockClicked(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - if (aTileEntity instanceof IMultiTileEntity) ((IMultiTileEntity) aTileEntity).onLeftClick(aPlayer); + if (aTileEntity instanceof IMultiTileEntity mte) mte.onLeftClick(aPlayer); else super.onBlockClicked(aWorld, aX, aY, aZ, aPlayer); } @Override - public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int aSide, float aHitX, - float aHitY, float aHitZ) { + public boolean onBlockActivated(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer, int ordinalSide, + float aHitX, float aHitY, float aHitZ) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); if (aPlayer != null && ItemList.TC_Thaumometer.isStackEqual(aPlayer.getHeldItem(), true, true)) return false; - return aTileEntity instanceof IMultiTileEntity - && ((IMultiTileEntity) aTileEntity).onBlockActivated(aPlayer, (byte) aSide, aHitX, aHitY, aHitZ); + return aTileEntity 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 aSide) { + 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 - ? ((IMTE_IsProvidingWeakPower) aTileEntity).isProvidingWeakPower((byte) aSide) - : super.isProvidingWeakPower(aWorld, aX, aY, aZ, aSide); + return aTileEntity instanceof IMTE_IsProvidingWeakPower power + ? power.isProvidingWeakPower(ForgeDirection.getOrientation(ordinalSide)) + : super.isProvidingWeakPower(aWorld, aX, aY, aZ, ordinalSide); } @Override - public final int isProvidingStrongPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + 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 - ? ((IMTE_IsProvidingStrongPower) aTileEntity).isProvidingStrongPower((byte) aSide) - : super.isProvidingStrongPower(aWorld, aX, aY, aZ, aSide); + return aTileEntity instanceof IMTE_IsProvidingStrongPower power + ? power.isProvidingStrongPower(ForgeDirection.getOrientation(ordinalSide)) + : super.isProvidingStrongPower(aWorld, aX, aY, aZ, ordinalSide); } @Override - public final boolean shouldCheckWeakPower(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + 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 - ? ((IMTE_ShouldCheckWeakPower) aTileEntity).shouldCheckWeakPower((byte) aSide) + return aTileEntity instanceof IMTE_ShouldCheckWeakPower power + ? power.shouldCheckWeakPower(ForgeDirection.getOrientation(ordinalSide)) : isNormalCube(aWorld, aX, aY, aZ); } @Override public final boolean getWeakChanges(IBlockAccess aWorld, int aX, int aY, int aZ) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMTE_GetWeakChanges ? ((IMTE_GetWeakChanges) aTileEntity).getWeakChanges() + return aTileEntity instanceof IMTE_GetWeakChanges changes ? changes.getWeakChanges() : super.getWeakChanges(aWorld, aX, aY, aZ); } @@ -379,32 +373,33 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil final ArrayList<ItemStack> tList = ((IMultiTileEntity) aTileEntity).getDrops(aFortune, aSilkTouch); aChance = ForgeEventFactory .fireBlockHarvesting(tList, aWorld, this, aX, aY, aZ, aMeta, aFortune, aChance, aSilkTouch, aPlayer); - for (ItemStack tStack : tList) + for (final ItemStack tStack : tList) if (XSTR.XSTR_INSTANCE.nextFloat() <= aChance) dropBlockAsItem(aWorld, aX, aY, aZ, tStack); } } @Override - public final boolean shouldSideBeRendered(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { - final TileEntity aTileEntity = aWorld.getTileEntity(aX - OFFX[aSide], aY - OFFY[aSide], aZ - OFFZ[aSide]); + 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 - ? ((IMultiTileEntity) aTileEntity).shouldSideBeRendered((byte) aSide) - : super.shouldSideBeRendered(aWorld, aX, aY, aZ, aSide); + ? ((IMultiTileEntity) aTileEntity).shouldSideBeRendered(ForgeDirection.getOrientation(ordinalSide)) + : super.shouldSideBeRendered(aWorld, aX, aY, aZ, ordinalSide); } @Override - public Block getFacade(IBlockAccess aWorld, int aX, int aY, int aZ, int side) { + public Block getFacade(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); if (tTileEntity instanceof CoverableTileEntity tile) { - final byte aSide = (byte) side; - if (side != -1) { - final Block facadeBlock = tile.getCoverInfoAtSide(aSide) + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + if (ordinalSide != -1) { + final Block facadeBlock = tile.getCoverInfoAtSide(side) .getFacadeBlock(); if (facadeBlock != null) return facadeBlock; } else { // we do not allow more than one type of facade per block, so no need to check every side // see comment in gregtech.common.covers.GT_Cover_FacadeBase.isCoverPlaceable - for (byte tSide : ALL_VALID_SIDES) { + for (final ForgeDirection tSide : ForgeDirection.VALID_DIRECTIONS) { final Block facadeBlock = tile.getCoverInfoAtSide(tSide) .getFacadeBlock(); if (facadeBlock != null) { @@ -417,18 +412,18 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public int getFacadeMetadata(IBlockAccess aWorld, int aX, int aY, int aZ, int side) { + public int getFacadeMetadata(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); if (tTileEntity instanceof CoverableTileEntity tile) { - final byte aSide = (byte) side; - if (side != -1) { - final CoverInfo coverInfo = tile.getCoverInfoAtSide(aSide); + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + if (ordinalSide != -1) { + final CoverInfo coverInfo = tile.getCoverInfoAtSide(side); final Block facadeBlock = coverInfo.getFacadeBlock(); if (facadeBlock != null) return coverInfo.getFacadeMeta(); } else { // we do not allow more than one type of facade per block, so no need to check every side // see comment in gregtech.common.covers.GT_Cover_FacadeBase.isCoverPlaceable - for (byte tSide : ALL_VALID_SIDES) { + for (final ForgeDirection tSide : ForgeDirection.VALID_DIRECTIONS) { final CoverInfo coverInfo = tile.getCoverInfoAtSide(tSide); final Block facadeBlock = coverInfo.getFacadeBlock(); if (facadeBlock != null) { @@ -477,13 +472,14 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public final int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int aSide) { + public final int getComparatorInputOverride(World aWorld, int aX, int aY, int aZ, int ordinalSide) { final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); - return aTileEntity instanceof IMTE_GetComparatorInputOverride - ? ((IMTE_GetComparatorInputOverride) aTileEntity).getComparatorInputOverride((byte) aSide) - : aTileEntity instanceof IMTE_IsProvidingWeakPower - ? ((IMTE_IsProvidingWeakPower) aTileEntity).isProvidingWeakPower(GT_Utility.getOppositeSide(aSide)) - : super.getComparatorInputOverride(aWorld, aX, aY, aZ, aSide); + return aTileEntity instanceof IMTE_GetComparatorInputOverride override + ? override.getComparatorInputOverride(ForgeDirection.getOrientation(ordinalSide)) + : aTileEntity instanceof IMTE_IsProvidingWeakPower power ? power.isProvidingWeakPower( + ForgeDirection.getOrientation(ordinalSide) + .getOpposite()) + : super.getComparatorInputOverride(aWorld, aX, aY, aZ, ordinalSide); } @Override @@ -497,12 +493,9 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public final boolean isSideSolid(IBlockAccess aWorld, int aX, int aY, int aZ, ForgeDirection aSide) { + 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 - ? ((IMultiTileEntity) aTileEntity) - .isSideSolid((byte) (aSide != null ? aSide.ordinal() : GT_Values.SIDE_UNKNOWN)) - : mOpaque; + return aTileEntity instanceof IMultiTileEntity mte ? mte.isSideSolid(side) : mOpaque; } @Override @@ -566,15 +559,14 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil } @Override - public final boolean canConnectRedstone(IBlockAccess aWorld, int aX, int aY, int aZ, int aSide) { + public final boolean canConnectRedstone(IBlockAccess aWorld, int aX, int aY, int aZ, int ordinalSide) { return true; } @Override - public final boolean recolourBlock(World aWorld, int aX, int aY, int aZ, ForgeDirection aSide, int aColor) { + 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 - && ((IMultiTileEntity) aTileEntity).recolourBlock((byte) aSide.ordinal(), (byte) aColor); + return aTileEntity instanceof IMultiTileEntity mte && mte.recolourBlock(side, (byte) aColor); } @Override @@ -627,12 +619,12 @@ public class MultiTileEntityBlock extends Block implements IDebugableBlock, ITil public void receiveCoverData(IMultiTileEntity mte, int aCover0, int aCover1, int aCover2, int aCover3, int aCover4, int aCover5) { boolean updated; - updated = mte.setCoverIDAtSideNoUpdate((byte) 0, aCover0); - updated |= mte.setCoverIDAtSideNoUpdate((byte) 1, aCover1); - updated |= mte.setCoverIDAtSideNoUpdate((byte) 2, aCover2); - updated |= mte.setCoverIDAtSideNoUpdate((byte) 3, aCover3); - updated |= mte.setCoverIDAtSideNoUpdate((byte) 4, aCover4); - updated |= mte.setCoverIDAtSideNoUpdate((byte) 5, aCover5); + 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); if (updated) { mte.issueBlockUpdate(); diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java index a3637e4626..17e217ae7e 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityBlockInternal.java @@ -10,6 +10,7 @@ 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; @@ -45,8 +46,8 @@ public class MultiTileEntityBlockInternal extends Block { return StatCollector.translateToLocal(mMultiTileEntityRegistry.mNameInternal + ".name"); } - public boolean placeBlock(World aWorld, int aX, int aY, int aZ, byte aSide, short aMetaData, NBTTagCompound aNBT, - boolean aCauseBlockUpdates, boolean aForcePlacement) { + 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; diff --git a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java index a37fa9956e..07a9124df4 100644 --- a/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java +++ b/src/main/java/gregtech/api/multitileentity/MultiTileEntityItemInternal.java @@ -19,13 +19,13 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.AxisAlignedBB; 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.GregTech_API; -import gregtech.api.enums.GT_Values; import gregtech.api.metatileentity.CoverableTileEntity; import gregtech.api.multitileentity.interfaces.IItemUpdatable; import gregtech.api.multitileentity.interfaces.IMultiTileEntity; @@ -83,25 +83,27 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont } @Override - public boolean onItemUse(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide, - float aHitX, float aHitY, float aHitZ) { + 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; 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) { - aSide = SIDE_TOP; + ordinalSide = SIDE_TOP; + side = ForgeDirection.UP; } else if (tClickedBlock != Blocks.vine && tClickedBlock != Blocks.tallgrass && tClickedBlock != Blocks.deadbush && !tClickedBlock.isReplaceable(aWorld, aX, aY, aZ)) { - aX += GT_Values.OFFX[aSide]; - aY += GT_Values.OFFY[aSide]; - aZ += GT_Values.OFFZ[aSide]; + 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, aSide, aStack)) return false; - if (aStack.stackSize == 0 || (aPlayer != null && !aPlayer.canPlayerEdit(aX, aY, aZ, aSide, aStack))) + || !mBlock.canReplace(aWorld, aX, aY, aZ, ordinalSide, aStack)) return false; + if (aStack.stackSize == 0 || (aPlayer != null && !aPlayer.canPlayerEdit(aX, aY, aZ, ordinalSide, aStack))) return false; final MultiTileEntityContainer aMTEContainer = mBlock.mMultiTileEntityRegistry @@ -109,30 +111,29 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont if (aMTEContainer != null && (aPlayer == null || aPlayer.isSneaking() - || !(aMTEContainer.mTileEntity instanceof IMTE_OnlyPlaceableWhenSneaking) - || !((IMTE_OnlyPlaceableWhenSneaking) aMTEContainer.mTileEntity).onlyPlaceableWhenSneaking()) + || !(aMTEContainer.mTileEntity instanceof IMTE_OnlyPlaceableWhenSneaking mteSNeaking) + || !mteSNeaking.onlyPlaceableWhenSneaking()) && (aWorld.checkNoEntityCollision(AxisAlignedBB.getBoundingBox(aX, aY, aZ, aX + 1, aY + 1, aZ + 1)) - || (aMTEContainer.mTileEntity instanceof IMTE_IgnoreEntityCollisionWhenPlacing - && ((IMTE_IgnoreEntityCollisionWhenPlacing) aMTEContainer.mTileEntity) - .ignoreEntityCollisionWhenPlacing( - aStack, - aPlayer, - aWorld, - aX, - aY, - aZ, - (byte) aSide, - aHitX, - aHitY, - aHitZ))) - && (!(aMTEContainer.mTileEntity instanceof IMTE_CanPlace) || ((IMTE_CanPlace) aMTEContainer.mTileEntity) - .canPlace(aStack, aPlayer, aWorld, aX, aY, aZ, (byte) aSide, aHitX, aHitY, aHitZ)) + || (aMTEContainer.mTileEntity instanceof IMTE_IgnoreEntityCollisionWhenPlacing mteIgnoreCollision + && mteIgnoreCollision.ignoreEntityCollisionWhenPlacing( + aStack, + aPlayer, + aWorld, + aX, + aY, + aZ, + side, + aHitX, + aHitY, + aHitZ))) + && (!(aMTEContainer.mTileEntity instanceof IMTE_CanPlace mteCanPlace) + || mteCanPlace.canPlace(aStack, aPlayer, aWorld, aX, aY, aZ, side, aHitX, aHitY, aHitZ)) && aWorld.setBlock(aX, aY, aZ, aMTEContainer.mBlock, 15 - aMTEContainer.mBlockMetaData, 2)) { aMTEContainer.setMultiTile(aWorld, aX, aY, aZ); try { if (((IMultiTileEntity) aMTEContainer.mTileEntity) - .onPlaced(aStack, aPlayer, aWorld, aX, aY, aZ, (byte) aSide, aHitX, aHitY, aHitZ)) { + .onPlaced(aStack, aPlayer, aWorld, aX, aY, aZ, side, aHitX, aHitY, aHitZ)) { aWorld.playSoundEffect( aX + 0.5, aY + 0.5, @@ -145,9 +146,8 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont GT_FML_LOGGER.error("onPlaced", e); } try { - if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData - && (((IMTE_HasMultiBlockMachineRelevantData) aMTEContainer.mTileEntity) - .hasMultiBlockMachineRelevantData())) { + if (aMTEContainer.mTileEntity instanceof IMTE_HasMultiBlockMachineRelevantData mteData + && (mteData.hasMultiBlockMachineRelevantData())) { GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); } } catch (Throwable e) { @@ -187,8 +187,8 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont if (tContainer == null) return; final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable) { - ((IItemUpdatable) tTileEntityContainer.mTileEntity).updateItemStack(aStack); + if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable itemUpdatable) { + itemUpdatable.updateItemStack(aStack); } } @@ -198,8 +198,8 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont if (tContainer == null) return; final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable) { - ((IItemUpdatable) tTileEntityContainer.mTileEntity).updateItemStack(aStack, aWorld, aX, aY, aZ); + if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IItemUpdatable itemUpdatable) { + itemUpdatable.updateItemStack(aStack, aWorld, aX, aY, aZ); } } @@ -209,9 +209,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont if (tContainer == null) return 1; final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IMTE_GetMaxStackSize) { - return ((IMTE_GetMaxStackSize) tTileEntityContainer.mTileEntity) - .getMaxStackSize(aStack, tContainer.mStackSize); + if (tTileEntityContainer != null + && tTileEntityContainer.mTileEntity instanceof IMTE_GetMaxStackSize maxStackSize) { + return maxStackSize.getMaxStackSize(aStack, tContainer.mStackSize); } return tContainer.mStackSize; } @@ -225,8 +225,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont public FluidStack getFluid(ItemStack aStack) { final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) { - final FluidStack rFluid = ((IFluidContainerItem) tTileEntityContainer.mTileEntity).getFluid(aStack); + if (tTileEntityContainer != null + && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) { + final FluidStack rFluid = fluidContainerItem.getFluid(aStack); updateItemStack(aStack); return rFluid; } @@ -237,8 +238,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont public int getCapacity(ItemStack aStack) { final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) { - final int rCapacity = ((IFluidContainerItem) tTileEntityContainer.mTileEntity).getCapacity(aStack); + if (tTileEntityContainer != null + && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) { + final int rCapacity = fluidContainerItem.getCapacity(aStack); updateItemStack(aStack); return rCapacity; } @@ -249,8 +251,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont public int fill(ItemStack aStack, FluidStack aFluid, boolean aDoFill) { final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) { - final int tFilled = ((IFluidContainerItem) tTileEntityContainer.mTileEntity).fill(aStack, aFluid, aDoFill); + if (tTileEntityContainer != null + && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) { + final int tFilled = fluidContainerItem.fill(aStack, aFluid, aDoFill); updateItemStack(aStack); return tFilled; } @@ -261,9 +264,9 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont public FluidStack drain(ItemStack aStack, int aMaxDrain, boolean aDoDrain) { final MultiTileEntityContainer tTileEntityContainer = mBlock.mMultiTileEntityRegistry .getNewTileEntityContainer(aStack); - if (tTileEntityContainer != null && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem) { - final FluidStack rFluid = ((IFluidContainerItem) tTileEntityContainer.mTileEntity) - .drain(aStack, aMaxDrain, aDoDrain); + if (tTileEntityContainer != null + && tTileEntityContainer.mTileEntity instanceof IFluidContainerItem fluidContainerItem) { + final FluidStack rFluid = fluidContainerItem.drain(aStack, aMaxDrain, aDoDrain); updateItemStack(aStack); return rFluid; } @@ -271,7 +274,7 @@ public class MultiTileEntityItemInternal extends ItemBlock implements IFluidCont } @Override - public boolean func_150936_a /* canPlaceAtSide */(World aWorld, int aX, int aY, int aZ, int aSide, + public boolean func_150936_a /* canPlaceAtSide */(World aWorld, int aX, int aY, int aZ, int ordinalSide, EntityPlayer aPlayer, ItemStack aStack) { return true; } diff --git a/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java index 4312f99ce7..027d666a66 100644 --- a/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java +++ b/src/main/java/gregtech/api/multitileentity/base/MultiTileEntity.java @@ -1,7 +1,7 @@ package gregtech.api.multitileentity.base; import static gregtech.GT_Mod.GT_FML_LOGGER; -import static gregtech.api.enums.GT_Values.OPOS; +import static gregtech.api.enums.GT_Values.NBT; import static gregtech.api.enums.GT_Values.VALID_SIDES; import java.io.IOException; @@ -201,7 +201,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public ITexture[] getTexture(Block ignoredBlock, byte ignoredSide) { + public ITexture[] getTexture(Block ignoredBlock, ForgeDirection ignoredSide) { // We are not going to be using this return null; } @@ -361,34 +361,34 @@ public abstract class MultiTileEntity extends CoverableTileEntity public void doBlockUpdate() { final Block tBlock = getBlock(getCoords()); worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, tBlock); - if (this instanceof IMTE_IsProvidingStrongPower) for (byte tSide : GT_Values.ALL_VALID_SIDES) { - if (getBlockAtSide(tSide).isNormalCube( - worldObj, - xCoord + GT_Values.OFFX[tSide], - yCoord + GT_Values.OFFY[tSide], - zCoord + GT_Values.OFFZ[tSide])) { - worldObj.notifyBlocksOfNeighborChange( - xCoord + GT_Values.OFFX[tSide], - yCoord + GT_Values.OFFY[tSide], - zCoord + GT_Values.OFFZ[tSide], - tBlock, - OPOS[tSide]); + if (this instanceof IMTE_IsProvidingStrongPower) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (getBlockAtSide(side) + .isNormalCube(worldObj, xCoord + side.offsetX, yCoord + side.offsetY, zCoord + side.offsetZ)) { + worldObj.notifyBlocksOfNeighborChange( + xCoord + side.offsetX, + yCoord + side.offsetY, + zCoord + side.offsetZ, + tBlock, + side.getOpposite() + .ordinal()); + } } } needsBlockUpdate = false; } @Override - public boolean shouldSideBeRendered(byte aSide) { - final TileEntity tTileEntity = getTileEntityAtSideAndDistance(aSide, 1); + public boolean shouldSideBeRendered(ForgeDirection side) { + final TileEntity tTileEntity = getTileEntityAtSideAndDistance(side, 1); // TODO: check to an interface // if (getBlockAtSide(aSide) == Blocks.glass) return false; - return tTileEntity instanceof IMultiTileEntity ? !((IMultiTileEntity) tTileEntity).isSurfaceOpaque(OPOS[aSide]) - : !getBlockAtSide(aSide).isOpaqueCube(); + return tTileEntity instanceof IMultiTileEntity mte ? !mte.isSurfaceOpaque(side.getOpposite()) + : !getBlockAtSide(side).isOpaqueCube(); } @Override - public boolean isSurfaceOpaque(byte aSide) { + public boolean isSurfaceOpaque(ForgeDirection side) { return true; } @@ -430,13 +430,13 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean isFacingValid(byte aFacing) { + public boolean isFacingValid(ForgeDirection facing) { return false; } @Override - public byte getFrontFacing() { - return (byte) facing.ordinal(); + public ForgeDirection getFrontFacing() { + return facing; } /** @@ -445,9 +445,9 @@ public abstract class MultiTileEntity extends CoverableTileEntity * @return Whether the facing was changed */ @Override - public boolean setMainFacing(byte aSide) { - if (!isValidFacing(aSide)) return false; - facing = ForgeDirection.getOrientation(aSide); + public boolean setMainFacing(ForgeDirection side) { + if (!isValidFacing(side)) return false; + facing = side; issueClientUpdate(); issueBlockUpdate(); @@ -471,14 +471,13 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public byte getBackFacing() { - return (byte) facing.getOpposite() - .ordinal(); + public ForgeDirection getBackFacing() { + return facing.getOpposite(); } @Override - public boolean isValidFacing(byte aSide) { - return aSide >= 0 && aSide <= 6 && getValidFacings()[aSide]; + public boolean isValidFacing(ForgeDirection side) { + return side != ForgeDirection.UNKNOWN && getValidFacings()[side.ordinal()]; } @Override @@ -487,8 +486,8 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public void issueCoverUpdate(byte aSide) { - super.issueCoverUpdate(aSide); + public void issueCoverUpdate(ForgeDirection side) { + super.issueCoverUpdate(side); issueClientUpdate(); } @@ -643,7 +642,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { return true; } @@ -707,10 +706,9 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean onPlaced(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, byte aSide, - float aHitX, float aHitY, float aHitZ) { - facing = ForgeDirection - .getOrientation(getSideForPlayerPlacing(aPlayer, (byte) facing.ordinal(), getValidFacings())); + public boolean onPlaced(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + ForgeDirection side, float aHitX, float aHitY, float aHitZ) { + facing = getSideForPlayerPlacing(aPlayer, facing, getValidFacings()); onFacingChange(); return true; } @@ -725,9 +723,9 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean onBlockActivated(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) { + public boolean onBlockActivated(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ) { try { - return allowRightclick(aPlayer) && onRightClick(aPlayer, aSide, aX, aY, aZ); + return allowRightclick(aPlayer) && onRightClick(aPlayer, side, aX, aY, aZ); } catch (Throwable e) { GT_FML_LOGGER.error("onBlockActivated Failed", e); e.printStackTrace(GT_Log.err); @@ -736,24 +734,25 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean onRightClick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) { + public boolean onRightClick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ) { if (isClientSide()) { // Configure Cover, sneak can also be: screwdriver, wrench, side cutter, soldering iron if (aPlayer.isSneaking()) { - final byte tSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) - : aSide; + final ForgeDirection tSide = (getCoverIDAtSide(side) == 0) + ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) + : side; return (getCoverBehaviorAtSideNew(tSide).hasCoverGUI()); - } else if (getCoverBehaviorAtSideNew(aSide).onCoverRightclickClient(aSide, this, aPlayer, aX, aY, aZ)) { + } else if (getCoverBehaviorAtSideNew(side).onCoverRightclickClient(side, this, aPlayer, aX, aY, aZ)) { return true; } - if (!getCoverInfoAtSide(aSide).isGUIClickable()) return false; + if (!getCoverInfoAtSide(side).isGUIClickable()) return false; } if (isServerSide()) { if (!privateAccess() || aPlayer.getDisplayName() .equalsIgnoreCase(getOwnerName())) { final ItemStack tCurrentItem = aPlayer.inventory.getCurrentItem(); - final byte wrenchSide = GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ); + final ForgeDirection wrenchSide = GT_Utility.determineWrenchingSide(side, aX, aY, aZ); if (tCurrentItem != null) { if (getColorization() >= 0 @@ -773,7 +772,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sWireCutterList)) return onWireCutterRightClick(aPlayer, tCurrentItem, wrenchSide, aX, aY, aZ); - final byte coverSide = getCoverIDAtSide(aSide) == 0 ? wrenchSide : aSide; + final ForgeDirection coverSide = getCoverIDAtSide(side) == 0 ? wrenchSide : side; if (getCoverIDAtSide(coverSide) == 0) { if (GT_Utility.isStackInList(tCurrentItem, GregTech_API.sCovers.keySet())) { @@ -806,47 +805,46 @@ public abstract class MultiTileEntity extends CoverableTileEntity xCoord, yCoord, zCoord); - dropCover(coverSide, aSide, false); + dropCover(coverSide, side, false); } sendCoverDataIfNeeded(); return true; } } } else if (aPlayer.isSneaking()) { // Sneak click, no tool -> open cover config if possible. - aSide = (getCoverIDAtSide(aSide) == 0) ? GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ) - : aSide; - return getCoverIDAtSide(aSide) > 0 && getCoverBehaviorAtSideNew(aSide).onCoverShiftRightClick( - aSide, - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + side = (getCoverIDAtSide(side) == 0) ? GT_Utility.determineWrenchingSide(side, aX, aY, aZ) : side; + return getCoverIDAtSide(side) > 0 && getCoverBehaviorAtSideNew(side).onCoverShiftRightClick( + side, + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this, aPlayer); } - if (getCoverBehaviorAtSideNew(aSide).onCoverRightClick( - aSide, - getCoverIDAtSide(aSide), - getComplexCoverDataAtSide(aSide), + if (getCoverBehaviorAtSideNew(side).onCoverRightClick( + side, + getCoverIDAtSide(side), + getComplexCoverDataAtSide(side), this, aPlayer, aX, aY, aZ)) return true; - if (!getCoverInfoAtSide(aSide).isGUIClickable()) return false; + if (!getCoverInfoAtSide(side).isGUIClickable()) return false; - return openModularUi(aPlayer, aSide); + return openModularUi(aPlayer, side); } } return false; } - public boolean hasGui(byte aSide) { + public boolean hasGui(ForgeDirection side) { return false; } - boolean openModularUi(EntityPlayer aPlayer, byte aSide) { - if (!hasGui(aSide) || !isServerSide()) { + boolean openModularUi(EntityPlayer aPlayer, ForgeDirection side) { + if (!hasGui(side) || !isServerSide()) { System.out.println("No GUI or Not Serverside"); return false; } @@ -856,8 +854,8 @@ public abstract class MultiTileEntity extends CoverableTileEntity return true; } - public boolean onWrenchRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, float aY, - float aZ) { + public boolean onWrenchRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, + float aY, float aZ) { if (setMainFacing(wrenchSide)) { GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer); GT_Utility.sendSoundToPlayers(worldObj, SoundResource.IC2_TOOLS_WRENCH, 1.0F, -1, xCoord, yCoord, zCoord); @@ -865,8 +863,8 @@ public abstract class MultiTileEntity extends CoverableTileEntity return true; } - public boolean onScrewdriverRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, - float aY, float aZ) { + public boolean onScrewdriverRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, + float aX, float aY, float aZ) { if (GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 200, aPlayer)) { setCoverDataAtSide( wrenchSide, @@ -885,26 +883,26 @@ public abstract class MultiTileEntity extends CoverableTileEntity return true; } - public boolean onHammerRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, float aY, - float aZ) { + public boolean onHammerRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, + float aY, float aZ) { return true; } - public boolean onMalletRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, float aY, - float aZ) { + public boolean onMalletRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, + float aY, float aZ) { return true; } - public boolean onSolderingRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, - float aY, float aZ) { + public boolean onSolderingRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, + float aX, float aY, float aZ) { return true; } - public boolean onWireCutterRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, - float aY, float aZ) { + public boolean onWireCutterRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, + float aX, float aY, float aZ) { return true; } @@ -923,7 +921,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity public void onExploded(Explosion aExplosion) {} @Override - public boolean isSideSolid(byte aSide) { + public boolean isSideSolid(ForgeDirection side) { return true; } @@ -949,7 +947,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean recolourBlock(byte aSide, byte aColor) { + public boolean recolourBlock(ForgeDirection side, byte aColor) { // if (aColor > 15 || aColor < -1) aColor = -1; // if(paint((byte) (aColor + 1))) { //// updateClientData(); @@ -994,12 +992,12 @@ public abstract class MultiTileEntity extends CoverableTileEntity color); packet.setCoverData( - getCoverInfoAtSide((byte) 0).getCoverID(), - getCoverInfoAtSide((byte) 1).getCoverID(), - getCoverInfoAtSide((byte) 2).getCoverID(), - getCoverInfoAtSide((byte) 3).getCoverID(), - getCoverInfoAtSide((byte) 4).getCoverID(), - getCoverInfoAtSide((byte) 5).getCoverID()); + getCoverInfoAtSide(ForgeDirection.DOWN).getCoverID(), + getCoverInfoAtSide(ForgeDirection.UP).getCoverID(), + getCoverInfoAtSide(ForgeDirection.NORTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.SOUTH).getCoverID(), + getCoverInfoAtSide(ForgeDirection.WEST).getCoverID(), + getCoverInfoAtSide(ForgeDirection.EAST).getCoverID()); packet.setRedstoneData( (byte) (((mSidedRedstone[0] > 0) ? 1 : 0) | ((mSidedRedstone[1] > 0) ? 2 : 0) @@ -1077,14 +1075,10 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, + public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { - super.getWailaBody(itemStack, currenttip, accessor, config); - currenttip.add( - String.format( - "Facing: %s", - ForgeDirection.getOrientation(getFrontFacing()) - .name())); + super.getWailaBody(itemStack, currentTip, accessor, config); + currentTip.add(String.format("Facing: %s", getFrontFacing().name())); } @Override @@ -1125,37 +1119,37 @@ public abstract class MultiTileEntity extends CoverableTileEntity * Fluid - A Default implementation of the Fluid Tank behaviour, so that every TileEntity can use this to simplify * its Code. */ - protected IFluidTank getFluidTankFillable(byte aSide, FluidStack aFluidToFill) { + protected IFluidTank getFluidTankFillable(ForgeDirection side, FluidStack aFluidToFill) { return null; } - protected IFluidTank getFluidTankDrainable(byte aSide, FluidStack aFluidToDrain) { + protected IFluidTank getFluidTankDrainable(ForgeDirection side, FluidStack aFluidToDrain) { return null; } - protected IFluidTank[] getFluidTanks(byte aSide) { + protected IFluidTank[] getFluidTanks(ForgeDirection side) { return GT_Values.emptyFluidTank; } - public boolean isLiquidInput(byte aSide) { + public boolean isLiquidInput(ForgeDirection side) { return true; } - public boolean isLiquidOutput(byte aSide) { + public boolean isLiquidOutput(ForgeDirection side) { return true; } @Override public int fill(ForgeDirection aDirection, FluidStack aFluid, boolean aDoFill) { if (aFluid == null || aFluid.amount <= 0) return 0; - final IFluidTank tTank = getFluidTankFillable((byte) aDirection.ordinal(), aFluid); + final IFluidTank tTank = getFluidTankFillable(aDirection, aFluid); return (tTank == null) ? 0 : tTank.fill(aFluid, aDoFill); } @Override public FluidStack drain(ForgeDirection aDirection, FluidStack aFluid, boolean aDoDrain) { if (aFluid == null || aFluid.amount <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable((byte) aDirection.ordinal(), aFluid); + final IFluidTank tTank = getFluidTankDrainable(aDirection, aFluid); if (tTank == null || tTank.getFluid() == null || tTank.getFluidAmount() == 0 || !tTank.getFluid() @@ -1167,7 +1161,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity @Override public FluidStack drain(ForgeDirection aDirection, int aAmountToDrain, boolean aDoDrain) { if (aAmountToDrain <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable((byte) aDirection.ordinal(), null); + final IFluidTank tTank = getFluidTankDrainable(aDirection, null); if (tTank == null || tTank.getFluid() == null || tTank.getFluidAmount() == 0) return null; return tTank.drain(aAmountToDrain, aDoDrain); } @@ -1175,7 +1169,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity @Override public boolean canFill(ForgeDirection aDirection, Fluid aFluid) { if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankFillable((byte) aDirection.ordinal(), new FluidStack(aFluid, 0)); + final IFluidTank tTank = getFluidTankFillable(aDirection, new FluidStack(aFluid, 0)); return tTank != null && (tTank.getFluid() == null || tTank.getFluid() .getFluid() == aFluid); } @@ -1183,14 +1177,14 @@ public abstract class MultiTileEntity extends CoverableTileEntity @Override public boolean canDrain(ForgeDirection aDirection, Fluid aFluid) { if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankDrainable((byte) aDirection.ordinal(), new FluidStack(aFluid, 0)); + final IFluidTank tTank = getFluidTankDrainable(aDirection, new FluidStack(aFluid, 0)); return tTank != null && (tTank.getFluid() != null && tTank.getFluid() .getFluid() == aFluid); } @Override public FluidTankInfo[] getTankInfo(ForgeDirection aDirection) { - final IFluidTank[] tTanks = getFluidTanks((byte) aDirection.ordinal()); + final IFluidTank[] tTanks = getFluidTanks(aDirection); if (tTanks == null || tTanks.length <= 0) return GT_Values.emptyFluidTankInfo; final FluidTankInfo[] rInfo = new FluidTankInfo[tTanks.length]; for (int i = 0; i < tTanks.length; i++) rInfo[i] = new FluidTankInfo(tTanks[i]); @@ -1246,7 +1240,7 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public boolean drainEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public boolean drainEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { return false; } @@ -1271,17 +1265,17 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) { + public long injectEnergyUnits(ForgeDirection side, long aVoltage, long aAmperage) { return 0; } @Override - public boolean inputEnergyFrom(byte aSide) { + public boolean inputEnergyFrom(ForgeDirection side) { return false; } @Override - public boolean outputsEnergyTo(byte aSide) { + public boolean outputsEnergyTo(ForgeDirection side) { return false; } @@ -1321,17 +1315,17 @@ public abstract class MultiTileEntity extends CoverableTileEntity } @Override - public int[] getAccessibleSlotsFromSide(int aSide) { + public int[] getAccessibleSlotsFromSide(int ordinalSide) { return GT_Values.emptyIntArray; } @Override - public boolean canInsertItem(int aSlot, ItemStack aStack, int aSide) { + public boolean canInsertItem(int aSlot, ItemStack aStack, int ordinalSide) { return false; } @Override - public boolean canExtractItem(int aSlot, ItemStack aStack, int aSide) { + public boolean canExtractItem(int aSlot, ItemStack aStack, int ordinalSide) { return false; } @@ -1379,28 +1373,28 @@ public abstract class MultiTileEntity extends CoverableTileEntity * Cover Helpers */ - public boolean coverLetsFluidIn(byte aSide, Fluid aFluid) { - return getCoverInfoAtSide(aSide).letsFluidIn(aFluid); + public boolean coverLetsFluidIn(ForgeDirection side, Fluid aFluid) { + return getCoverInfoAtSide(side).letsFluidIn(aFluid); } - public boolean coverLetsFluidOut(byte aSide, Fluid aFluid) { - return getCoverInfoAtSide(aSide).letsFluidOut(aFluid); + public boolean coverLetsFluidOut(ForgeDirection side, Fluid aFluid) { + return getCoverInfoAtSide(side).letsFluidOut(aFluid); } - public boolean coverLetsEnergyIn(byte aSide) { - return getCoverInfoAtSide(aSide).letsEnergyIn(); + public boolean coverLetsEnergyIn(ForgeDirection side) { + return getCoverInfoAtSide(side).letsEnergyIn(); } - public boolean coverLetsEnergyOut(byte aSide) { - return getCoverInfoAtSide(aSide).letsEnergyOut(); + public boolean coverLetsEnergyOut(ForgeDirection side) { + return getCoverInfoAtSide(side).letsEnergyOut(); } - public boolean coverLetsItemsIn(byte aSide, int aSlot) { - return getCoverInfoAtSide(aSide).letsItemsIn(aSlot); + public boolean coverLetsItemsIn(ForgeDirection side, int aSlot) { + return getCoverInfoAtSide(side).letsItemsIn(aSlot); } - public boolean coverLetsItemsOut(byte aSide, int aSlot) { - return getCoverInfoAtSide(aSide).letsItemsOut(aSlot); + public boolean coverLetsItemsOut(ForgeDirection side, int aSlot) { + return getCoverInfoAtSide(side).letsItemsOut(aSlot); } @Override diff --git a/src/main/java/gregtech/api/multitileentity/base/NonTickableMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/NonTickableMultiTileEntity.java index 90c931239a..0ad4d9004e 100644 --- a/src/main/java/gregtech/api/multitileentity/base/NonTickableMultiTileEntity.java +++ b/src/main/java/gregtech/api/multitileentity/base/NonTickableMultiTileEntity.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.NW; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.network.Packet; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.net.GT_Packet_SendCoverData; import gregtech.api.util.ISerializableObject; @@ -34,13 +35,13 @@ public abstract class NonTickableMultiTileEntity extends MultiTileEntity { } @Override - public void issueCoverUpdate(byte aSide) { + public void issueCoverUpdate(ForgeDirection side) { if (!mConstructed) { // Queue these up and send them with the description packet - super.issueCoverUpdate(aSide); + super.issueCoverUpdate(side); } else { // Otherwise, send the data right away - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + final CoverInfo coverInfo = getCoverInfoAtSide(side); NW.sendPacketToAllPlayersInRange(worldObj, new GT_Packet_SendCoverData(coverInfo, this), xCoord, zCoord); // Just in case @@ -49,9 +50,9 @@ public abstract class NonTickableMultiTileEntity extends MultiTileEntity { } @Override - public void receiveCoverData(byte aCoverSide, int aCoverID, ISerializableObject aCoverData, + public void receiveCoverData(ForgeDirection coverSide, int aCoverID, ISerializableObject aCoverData, EntityPlayerMP aPlayer) { - super.receiveCoverData(aCoverSide, aCoverID, aCoverData, aPlayer); + super.receiveCoverData(coverSide, aCoverID, aCoverData, aPlayer); // We don't get ticked so issue the texture update right away issueTextureUpdate(); } diff --git a/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java index 4fa06ff6b4..d61f32813f 100644 --- a/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java +++ b/src/main/java/gregtech/api/multitileentity/base/TickableMultiTileEntity.java @@ -5,6 +5,7 @@ import static gregtech.GT_Mod.GT_FML_LOGGER; import net.minecraft.block.Block; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.multitileentity.interfaces.IMultiTileEntity.IMTE_OnNeighborBlockChange; import gregtech.api.util.GT_Log; @@ -106,7 +107,7 @@ public abstract class TickableMultiTileEntity extends MultiTileEntity implements } @Override - public byte getComparatorValue(byte aSide) { + public byte getComparatorValue(ForgeDirection side) { return 0; } } diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockController.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockController.java index 1168f8e7ce..6f508ab6f5 100644 --- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockController.java +++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockController.java @@ -19,17 +19,17 @@ public interface IMultiBlockController extends IMultiTileEntity, IMultiBlockFlui @Override ChunkCoordinates getCoords(); - FluidStack getDrainableFluid(byte aSide); + FluidStack getDrainableFluid(ForgeDirection side); - FluidStack getDrainableFluid(byte aSide, Fluid fluid); + FluidStack getDrainableFluid(ForgeDirection side, Fluid fluid); - boolean isLiquidInput(byte aSide); + boolean isLiquidInput(ForgeDirection side); - boolean isLiquidOutput(byte aSide); + boolean isLiquidOutput(ForgeDirection side); - void registerCoveredPartOnSide(final int aSide, IMultiBlockPart part); + void registerCoveredPartOnSide(final ForgeDirection side, IMultiBlockPart part); - void unregisterCoveredPartOnSide(final int aSide, IMultiBlockPart part); + void unregisterCoveredPartOnSide(final ForgeDirection side, IMultiBlockPart part); void registerInventory(String aName, String aID, int aInventorySize, int aType); diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockEnergy.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockEnergy.java index 598c057882..d6d8bf5310 100644 --- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockEnergy.java +++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockEnergy.java @@ -1,5 +1,7 @@ package gregtech.api.multitileentity.interfaces; +import net.minecraftforge.common.util.ForgeDirection; + import gregtech.api.multitileentity.multiblock.base.MultiBlockPart; interface IMultiBlockEnergy { @@ -22,9 +24,9 @@ interface IMultiBlockEnergy { boolean increaseStoredEnergyUnits(MultiBlockPart aPart, long aEnergy, boolean aIgnoreTooMuchEnergy); - boolean drainEnergyUnits(MultiBlockPart aPart, byte aSide, long aVoltage, long aAmperage); + boolean drainEnergyUnits(MultiBlockPart aPart, ForgeDirection side, long aVoltage, long aAmperage); - long injectEnergyUnits(MultiBlockPart aPart, byte aSide, long aVoltage, long aAmperage); + long injectEnergyUnits(MultiBlockPart aPart, ForgeDirection side, long aVoltage, long aAmperage); long getAverageElectricInput(MultiBlockPart aPart); @@ -34,7 +36,7 @@ interface IMultiBlockEnergy { long getEUCapacity(MultiBlockPart aPart); - boolean inputEnergyFrom(MultiBlockPart aPart, byte aSide); + boolean inputEnergyFrom(MultiBlockPart aPart, ForgeDirection side); - boolean outputsEnergyTo(MultiBlockPart aPart, byte aSide); + boolean outputsEnergyTo(MultiBlockPart aPart, ForgeDirection side); } diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockInventory.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockInventory.java index e095b739b7..b3473a3260 100644 --- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockInventory.java +++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockInventory.java @@ -4,6 +4,7 @@ import java.util.List; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable; import gregtech.api.multitileentity.multiblock.base.MultiBlockPart; @@ -18,11 +19,11 @@ public interface IMultiBlockInventory { boolean addStackToSlot(MultiBlockPart aPart, int aIndex, ItemStack aStack, int aAmount); - int[] getAccessibleSlotsFromSide(MultiBlockPart aPart, byte aSide); + int[] getAccessibleSlotsFromSide(MultiBlockPart aPart, ForgeDirection side); - boolean canInsertItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, byte aSide); + boolean canInsertItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side); - boolean canExtractItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, byte aSide); + boolean canExtractItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side); int getSizeInventory(MultiBlockPart aPart); diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java index dcee4ad9d9..017954f554 100644 --- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java +++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiBlockPart.java @@ -1,6 +1,7 @@ package gregtech.api.multitileentity.interfaces; import net.minecraft.util.ChunkCoordinates; +import net.minecraftforge.common.util.ForgeDirection; public interface IMultiBlockPart extends IMultiTileEntity { @@ -12,5 +13,5 @@ public interface IMultiBlockPart extends IMultiTileEntity { int getLockedInventoryIndex(); - boolean tickCoverAtSide(byte aSide, long aTickTimer); + boolean tickCoverAtSide(ForgeDirection side, long aTickTimer); } diff --git a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java index cafde57de5..a490e4275c 100644 --- a/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java +++ b/src/main/java/gregtech/api/multitileentity/interfaces/IMultiTileEntity.java @@ -16,6 +16,7 @@ import net.minecraft.util.AxisAlignedBB; import net.minecraft.util.MovingObjectPosition; import net.minecraft.world.Explosion; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.IFluidHandler; import cpw.mods.fml.common.Optional; @@ -130,19 +131,19 @@ public interface IMultiTileEntity int getPaint(); /** - * Sets the main facing to {aSide} and update as appropriately + * Sets the main facing to {side} and update as appropriately * * @return Whether the facing was changed */ - boolean setMainFacing(byte aSide); + boolean setMainFacing(ForgeDirection side); - boolean isFacingValid(byte aFacing); + boolean isFacingValid(ForgeDirection facing); void onFacingChange(); @Override - default void setFrontFacing(byte aSide) { - setMainFacing(aSide); + default void setFrontFacing(ForgeDirection side) { + setMainFacing(side); } boolean shouldTriggerBlockUpdate(); @@ -155,13 +156,13 @@ public interface IMultiTileEntity /* do nothing */ } - boolean onBlockActivated(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ); + boolean onBlockActivated(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ); - boolean onRightClick(EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ); + boolean onRightClick(EntityPlayer aPlayer, ForgeDirection side, float aX, float aY, float aZ); ArrayList<ItemStack> getDrops(int aFortune, boolean aSilkTouch); - boolean isSideSolid(byte aSide); + boolean isSideSolid(ForgeDirection side); float getExplosionResistance(Entity aExploder, double aExplosionX, double aExplosionY, double aExplosionZ); @@ -169,7 +170,7 @@ public interface IMultiTileEntity void onExploded(Explosion aExplosion); - boolean recolourBlock(byte aSide, byte aColor); + boolean recolourBlock(ForgeDirection side, byte aColor); /** Adds to the Creative Tab. return false to prevent it from being added. */ boolean getSubItems(MultiTileEntityBlockInternal aBlock, Item aItem, CreativeTabs aTab, List<ItemStack> aList, @@ -177,11 +178,11 @@ public interface IMultiTileEntity ItemStack getPickBlock(MovingObjectPosition aTarget); - boolean shouldSideBeRendered(byte aSide); + boolean shouldSideBeRendered(ForgeDirection side); - boolean isSurfaceOpaque(byte aSide); + boolean isSurfaceOpaque(ForgeDirection side); - boolean onPlaced(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, byte aSide, + boolean onPlaced(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, ForgeDirection side, float aHitX, float aHitY, float aHitZ); // ItemStack getPickBlock(MovingObjectPosition aTarget); @@ -198,18 +199,18 @@ public interface IMultiTileEntity interface IMTE_IsProvidingWeakPower extends IMultiTileEntity { /** Remember that it passes the opposite Side due to the way vanilla works! */ - int isProvidingWeakPower(byte aOppositeSide); + int isProvidingWeakPower(ForgeDirection oppositeSide); } interface IMTE_IsProvidingStrongPower extends IMultiTileEntity { /** Remember that it passes the opposite Side due to the way vanilla works! */ - int isProvidingStrongPower(byte aOppositeSide); + int isProvidingStrongPower(ForgeDirection oppositeSide); } interface IMTE_ShouldCheckWeakPower extends IMultiTileEntity { - boolean shouldCheckWeakPower(byte aSide); + boolean shouldCheckWeakPower(ForgeDirection side); } interface IMTE_GetWeakChanges extends IMultiTileEntity { @@ -219,7 +220,7 @@ public interface IMultiTileEntity interface IMTE_GetComparatorInputOverride extends IMultiTileEntity { - int getComparatorInputOverride(byte aSide); + int getComparatorInputOverride(ForgeDirection side); } interface IMTE_BreakBlock extends IMultiTileEntity { @@ -258,14 +259,14 @@ public interface IMultiTileEntity * pipes/wires. */ boolean ignoreEntityCollisionWhenPlacing(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, - int aZ, byte aSide, float aHitX, float aHitY, float aHitZ); + int aZ, ForgeDirection side, float aHitX, float aHitY, float aHitZ); } interface IMTE_CanPlace extends IMultiTileEntity { /** Return false if this TileEntity cannot be placed at that Location. */ - boolean canPlace(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, byte aSide, - float aHitX, float aHitY, float aHitZ); + boolean canPlace(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, + ForgeDirection side, float aHitX, float aHitY, float aHitZ); } interface IMTE_GetMaxStackSize extends IMultiTileEntity { diff --git a/src/main/java/gregtech/api/multitileentity/machine/MultiTileBasicMachine.java b/src/main/java/gregtech/api/multitileentity/machine/MultiTileBasicMachine.java index f3cc00692c..e36e7e60fb 100644 --- a/src/main/java/gregtech/api/multitileentity/machine/MultiTileBasicMachine.java +++ b/src/main/java/gregtech/api/multitileentity/machine/MultiTileBasicMachine.java @@ -309,7 +309,7 @@ public abstract class MultiTileBasicMachine extends TickableMultiTileEntity impl @Override public ITexture getTexture(ForgeDirection side) { - ITexture texture = super.getTexture(side); + final ITexture texture = super.getTexture(side); if (side == facing) { if (isActive()) { return TextureFactory.of(texture, activeOverlayTexture, activeOverlayGlowTexture); @@ -318,7 +318,7 @@ public abstract class MultiTileBasicMachine extends TickableMultiTileEntity impl return TextureFactory.of(texture, inactiveOverlayTexture, inactiveOverlayGlowTexture); } - return TextureFactory.of(texture, getCoverTexture((byte) side.ordinal())); + return TextureFactory.of(texture, getCoverTexture(side)); } @Override @@ -368,19 +368,19 @@ public abstract class MultiTileBasicMachine extends TickableMultiTileEntity impl } @Override - public boolean isLiquidInput(byte aSide) { - return facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0; + public boolean isLiquidInput(ForgeDirection side) { + return side != facing; } @Override - public boolean isLiquidOutput(byte aSide) { - return facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0; + public boolean isLiquidOutput(ForgeDirection side) { + return side != facing; } @Override - protected IFluidTank[] getFluidTanks(byte aSide) { - final boolean fluidInput = isLiquidInput(aSide); - final boolean fluidOutput = isLiquidOutput(aSide); + protected IFluidTank[] getFluidTanks(ForgeDirection side) { + final boolean fluidInput = isLiquidInput(side); + final boolean fluidOutput = isLiquidOutput(side); if (fluidInput && fluidOutput) { final IFluidTank[] rTanks = new IFluidTank[inputTanks.length + outputTanks.length]; @@ -396,13 +396,13 @@ public abstract class MultiTileBasicMachine extends TickableMultiTileEntity impl } @Override - public IFluidTank getFluidTankFillable(byte aSide, FluidStack aFluidToFill) { - return getFluidTankFillable((byte) facing.ordinal(), aSide, aFluidToFill); + public IFluidTank getFluidTankFillable(ForgeDirection side, FluidStack aFluidToFill) { + return getFluidTankFillable(facing, side, aFluidToFill); } - public IFluidTank getFluidTankFillable(byte sideSource, byte sideDestination, FluidStack fluidToFill) { - if (ForgeDirection.getOrientation(sideSource) - .compareTo(ForgeDirection.getOrientation(sideDestination)) != 0) return null; + public IFluidTank getFluidTankFillable(ForgeDirection sideSource, ForgeDirection sideDestination, + FluidStack fluidToFill) { + if (sideSource.compareTo(sideDestination) != 0) return null; for (FluidTankGT tankGT : inputTanks) if (tankGT.contains(fluidToFill)) return tankGT; // if (!mRecipes.containsInput(aFluidToFill, this, slot(mRecipes.mInputItemsCount + // mRecipes.mOutputItemsCount))) return null; @@ -411,13 +411,13 @@ public abstract class MultiTileBasicMachine extends TickableMultiTileEntity impl } @Override - protected IFluidTank getFluidTankDrainable(byte aSide, FluidStack aFluidToDrain) { - return getFluidTankDrainable((byte) facing.ordinal(), aSide, aFluidToDrain); + protected IFluidTank getFluidTankDrainable(ForgeDirection side, FluidStack aFluidToDrain) { + return getFluidTankDrainable(facing, side, aFluidToDrain); } - protected IFluidTank getFluidTankDrainable(byte sideSource, byte sideDestination, FluidStack fluidToDrain) { - if (ForgeDirection.getOrientation(sideSource) - .compareTo(ForgeDirection.getOrientation(sideDestination)) != 0) return null; + protected IFluidTank getFluidTankDrainable(ForgeDirection sideSource, ForgeDirection sideDestination, + FluidStack fluidToDrain) { + if (sideSource.compareTo(sideDestination) != 0) return null; for (FluidTankGT fluidTankGT : outputTanks) if (fluidToDrain == null ? fluidTankGT.has() : fluidTankGT.contains(fluidToDrain)) return fluidTankGT; diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java index 9fdac059da..a4fbb9f61e 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/Controller.java @@ -2,7 +2,6 @@ package gregtech.api.multitileentity.multiblock.base; import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; import static gregtech.GT_Mod.GT_FML_LOGGER; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.*; import static gregtech.loaders.preload.GT_Loader_MultiTileEntities.COMPONENT_CASING_REGISTRY; import static mcp.mobius.waila.api.SpecialChars.*; @@ -289,10 +288,8 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic if (outputTanks != null) registerFluidInventory("controller", "controller", outputTanks, Inventory.OUTPUT); structureOkay = nbt.getBoolean(NBT.STRUCTURE_OK); - extendedFacing = ExtendedFacing.of( - ForgeDirection.getOrientation(getFrontFacing()), - Rotation.byIndex(nbt.getByte(NBT.ROTATION)), - Flip.byIndex(nbt.getByte(NBT.FLIP))); + extendedFacing = ExtendedFacing + .of(getFrontFacing(), Rotation.byIndex(nbt.getByte(NBT.ROTATION)), Flip.byIndex(nbt.getByte(NBT.FLIP))); loadUpgradeInventoriesFromNBT(nbt); loadUpgradeTanksFromNBT(nbt); @@ -308,10 +305,10 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic .getTagList(NBT.UPGRADE_INVENTORIES_INPUT, Constants.NBT.TAG_COMPOUND); for (int i = 0; i < listInputInventories.tagCount(); i++) { final NBTTagCompound nbtInv = listInputInventories.getCompoundTagAt(i); - String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); - String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); - int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); - IItemHandlerModifiable inv = new ItemStackHandler(invSize); + final String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); + final String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); + final int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); + final IItemHandlerModifiable inv = new ItemStackHandler(invSize); loadInventory(nbtInv, inv, NBT.INV_INPUT_LIST); registerInventory(invName, invUUID, invSize, Inventory.INPUT); } @@ -320,9 +317,9 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic .getTagList(NBT.UPGRADE_INVENTORIES_OUTPUT, Constants.NBT.TAG_COMPOUND); for (int i = 0; i < listOutputInventories.tagCount(); i++) { final NBTTagCompound nbtInv = listOutputInventories.getCompoundTagAt(i); - String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); - String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); - int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); + final String invUUID = nbtInv.getString(NBT.UPGRADE_INVENTORY_UUID); + final String invName = nbtInv.getString(NBT.UPGRADE_INVENTORY_NAME); + final int invSize = nbtInv.getInteger(NBT.UPGRADE_INVENTORY_SIZE); IItemHandlerModifiable inv = new ItemStackHandler(invSize); loadInventory(nbtInv, inv, NBT.INV_OUTPUT_LIST); registerInventory(invName, invUUID, invSize, Inventory.OUTPUT); @@ -532,8 +529,8 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public boolean onWrenchRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, float aY, - float aZ) { + public boolean onWrenchRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, + float aY, float aZ) { if (wrenchSide != getFrontFacing()) return super.onWrenchRightClick(aPlayer, tCurrentItem, wrenchSide, aX, aY, aZ); if (aPlayer.isSneaking()) { @@ -548,19 +545,19 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public void registerCoveredPartOnSide(final int aSide, IMultiBlockPart part) { - if (aSide < 0 || aSide >= 6) return; + public void registerCoveredPartOnSide(final ForgeDirection side, IMultiBlockPart part) { + if (side == ForgeDirection.UNKNOWN) return; - final LinkedList<WeakReference<IMultiBlockPart>> registeredCovers = registeredCoveredParts.get(aSide); + final LinkedList<WeakReference<IMultiBlockPart>> registeredCovers = registeredCoveredParts.get(side.ordinal()); // TODO: Make sure that we're not already registered on this side registeredCovers.add(new WeakReference<>(part)); } @Override - public void unregisterCoveredPartOnSide(final int aSide, IMultiBlockPart aPart) { - if (aSide < 0 || aSide >= 6) return; + public void unregisterCoveredPartOnSide(final ForgeDirection side, IMultiBlockPart aPart) { + if (side == ForgeDirection.UNKNOWN) return; - final LinkedList<WeakReference<IMultiBlockPart>> coveredParts = registeredCoveredParts.get(aSide); + final LinkedList<WeakReference<IMultiBlockPart>> coveredParts = registeredCoveredParts.get(side.ordinal()); final Iterator<WeakReference<IMultiBlockPart>> it = coveredParts.iterator(); while (it.hasNext()) { final IMultiBlockPart part = (it.next()).get(); @@ -579,9 +576,10 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } private boolean tickCovers() { - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { // TODO: Tick controller covers, if any - final LinkedList<WeakReference<IMultiBlockPart>> coveredParts = this.registeredCoveredParts.get(side); + final LinkedList<WeakReference<IMultiBlockPart>> coveredParts = this.registeredCoveredParts + .get(side.ordinal()); final Iterator<WeakReference<IMultiBlockPart>> it = coveredParts.iterator(); while (it.hasNext()) { final IMultiBlockPart part = (it.next()).get(); @@ -626,19 +624,19 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public final boolean isFacingValid(byte aFacing) { - return canSetToDirectionAny(ForgeDirection.getOrientation(aFacing)); + public final boolean isFacingValid(ForgeDirection facing) { + return canSetToDirectionAny(facing); } @Override public void onFacingChange() { - toolSetDirection(ForgeDirection.getOrientation(getFrontFacing())); + toolSetDirection(getFrontFacing()); onStructureChange(); } @Override - public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) { - return facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0; + public boolean allowCoverOnSide(ForgeDirection side, GT_ItemStack aCoverID) { + return side != facing; } @Override @@ -672,14 +670,14 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public FluidStack getDrainableFluid(byte aSide) { - return getDrainableFluid(aSide, null); + public FluidStack getDrainableFluid(ForgeDirection side) { + return getDrainableFluid(side, null); } @Override - public FluidStack getDrainableFluid(byte aSide, Fluid fluidToDrain) { + public FluidStack getDrainableFluid(ForgeDirection side, Fluid fluidToDrain) { final IFluidTank tank = getFluidTankDrainable( - aSide, + side, fluidToDrain == null ? null : new FluidStack(fluidToDrain, 0)); return tank == null ? null : tank.getFluid(); } @@ -1054,22 +1052,22 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic return tanks.toArray(new FluidTankGT[0]); } - protected IFluidTank getFluidTankFillable(MultiBlockPart aPart, byte aSide, FluidStack aFluidToFill) { - return getFluidTankFillable(aPart.getFrontFacing(), aSide, aFluidToFill); + protected IFluidTank getFluidTankFillable(MultiBlockPart aPart, ForgeDirection side, FluidStack aFluidToFill) { + return getFluidTankFillable(side, aFluidToFill); } - protected IFluidTank getFluidTankDrainable(MultiBlockPart aPart, byte aSide, FluidStack aFluidToDrain) { - return getFluidTankDrainable(aPart.getFrontFacing(), aSide, aFluidToDrain); + protected IFluidTank getFluidTankDrainable(MultiBlockPart aPart, ForgeDirection side, FluidStack aFluidToDrain) { + return getFluidTankDrainable(side, aFluidToDrain); } - protected IFluidTank[] getFluidTanks(MultiBlockPart aPart, byte aSide) { - return getFluidTanks(aSide); + protected IFluidTank[] getFluidTanks(MultiBlockPart aPart, ForgeDirection side) { + return getFluidTanks(side); } @Override public int fill(MultiBlockPart aPart, ForgeDirection aDirection, FluidStack aFluid, boolean aDoFill) { if (aFluid == null || aFluid.amount <= 0) return 0; - final IFluidTank tTank = getFluidTankFillable(aPart, (byte) aDirection.ordinal(), aFluid); + final IFluidTank tTank = getFluidTankFillable(aPart, aDirection, aFluid); if (tTank == null) return 0; final int rFilledAmount = tTank.fill(aFluid, aDoFill); if (rFilledAmount > 0 && aDoFill) hasInventoryChanged = true; @@ -1079,7 +1077,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public FluidStack drain(MultiBlockPart aPart, ForgeDirection aDirection, FluidStack aFluid, boolean aDoDrain) { if (aFluid == null || aFluid.amount <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable(aPart, (byte) aDirection.ordinal(), aFluid); + final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, aFluid); if (tTank == null || tTank.getFluid() == null || tTank.getFluidAmount() == 0 || !tTank.getFluid() @@ -1093,7 +1091,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public FluidStack drain(MultiBlockPart aPart, ForgeDirection aDirection, int aAmountToDrain, boolean aDoDrain) { if (aAmountToDrain <= 0) return null; - final IFluidTank tTank = getFluidTankDrainable(aPart, (byte) aDirection.ordinal(), null); + final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, null); if (tTank == null || tTank.getFluid() == null || tTank.getFluidAmount() == 0) return null; final FluidStack rDrained = tTank.drain(aAmountToDrain, aDoDrain); if (rDrained != null && aDoDrain) markInventoryBeenModified(); @@ -1103,7 +1101,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public boolean canFill(MultiBlockPart aPart, ForgeDirection aDirection, Fluid aFluid) { if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankFillable(aPart, (byte) aDirection.ordinal(), new FluidStack(aFluid, 0)); + final IFluidTank tTank = getFluidTankFillable(aPart, aDirection, new FluidStack(aFluid, 0)); return tTank != null && (tTank.getFluid() == null || tTank.getFluid() .getFluid() == aFluid); } @@ -1111,14 +1109,14 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic @Override public boolean canDrain(MultiBlockPart aPart, ForgeDirection aDirection, Fluid aFluid) { if (aFluid == null) return false; - final IFluidTank tTank = getFluidTankDrainable(aPart, (byte) aDirection.ordinal(), new FluidStack(aFluid, 0)); + final IFluidTank tTank = getFluidTankDrainable(aPart, aDirection, new FluidStack(aFluid, 0)); return tTank != null && (tTank.getFluid() != null && tTank.getFluid() .getFluid() == aFluid); } @Override public FluidTankInfo[] getTankInfo(MultiBlockPart aPart, ForgeDirection aDirection) { - final IFluidTank[] tTanks = getFluidTanks(aPart, (byte) aDirection.ordinal()); + final IFluidTank[] tTanks = getFluidTanks(aPart, aDirection); if (tTanks == null || tTanks.length <= 0) return GT_Values.emptyFluidTankInfo; final FluidTankInfo[] rInfo = new FluidTankInfo[tTanks.length]; for (int i = 0; i < tTanks.length; i++) rInfo[i] = new FluidTankInfo(tTanks[i]); @@ -1143,15 +1141,15 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic // #region Energy @Override public PowerLogic getPowerLogic(IMultiBlockPart part, ForgeDirection side) { - if (!(this instanceof PowerLogicHost)) { + if (!(this instanceof PowerLogicHost powerLogicHost)) { return null; } - if (ForgeDirection.getOrientation(part.getFrontFacing()) != side) { + if (part.getFrontFacing() != side) { return null; } - return ((PowerLogicHost) this).getPowerLogic(side); + return powerLogicHost.getPowerLogic(side); } // #endregion Energy @@ -1294,7 +1292,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public int[] getAccessibleSlotsFromSide(MultiBlockPart aPart, byte aSide) { + public int[] getAccessibleSlotsFromSide(MultiBlockPart aPart, ForgeDirection side) { final TIntList tList = new TIntArrayList(); final Map<String, IItemHandlerModifiable> multiBlockInventory = getMultiBlockInventory(aPart); if (multiBlockInventory == null) return tList.toArray(); @@ -1318,7 +1316,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public boolean canInsertItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, byte aSide) { + public boolean canInsertItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side) { final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); if (tInv == null) return false; @@ -1334,7 +1332,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public boolean canExtractItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, byte aSide) { + public boolean canExtractItem(MultiBlockPart aPart, int aSlot, ItemStack aStack, ForgeDirection side) { final Pair<IItemHandlerModifiable, Integer> tInv = getInventory(aPart, aSlot); if (tInv == null) return false; @@ -1738,7 +1736,7 @@ public abstract class Controller<T extends Controller<T>> extends MultiTileBasic } @Override - public boolean hasGui(byte aSide) { + public boolean hasGui(ForgeDirection side) { return true; } diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java index d9d0ef4666..3b05c79f26 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/MultiBlockPart.java @@ -1,10 +1,8 @@ package gregtech.api.multitileentity.multiblock.base; import static com.google.common.math.LongMath.log2; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; import static gregtech.api.enums.GT_Values.B; import static gregtech.api.enums.GT_Values.NBT; -import static gregtech.api.enums.GT_Values.SIDE_UNKNOWN; import static gregtech.api.enums.Textures.BlockIcons.FLUID_IN_SIGN; import static gregtech.api.enums.Textures.BlockIcons.FLUID_OUT_SIGN; import static gregtech.api.enums.Textures.BlockIcons.ITEM_IN_SIGN; @@ -126,19 +124,19 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } @Override - public void getWailaBody(ItemStack itemStack, List<String> currenttip, IWailaDataAccessor accessor, + public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { - super.getWailaBody(itemStack, currenttip, accessor, config); - currenttip.add(String.format("Mode: %s", getModeName(mMode))); + super.getWailaBody(itemStack, currentTip, accessor, config); + currentTip.add(String.format("Mode: %s", getModeName(mMode))); if (modeSelected(FLUID_OUT)) { if (configurationTank != null && configurationTank.get() != null) { - currenttip.add( + currentTip.add( String.format( "Locked to: %s", configurationTank.get() .getLocalizedName())); } else { - currenttip.add("Locked to: Nothing"); + currentTip.add("Locked to: Nothing"); } } } @@ -164,41 +162,41 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } public void registerCovers(IMultiBlockController controller) { - for (byte i : ALL_VALID_SIDES) { - final CoverInfo coverInfo = getCoverInfoAtSide(i); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid() && coverInfo.getTickRate() > 0) { - controller.registerCoveredPartOnSide(i, this); + controller.registerCoveredPartOnSide(side, this); } } } @Override - public void setCoverItemAtSide(byte aSide, ItemStack aCover) { - super.setCoverItemAtSide(aSide, aCover); + public void setCoverItemAtSide(ForgeDirection side, ItemStack aCover) { + super.setCoverItemAtSide(side, aCover); // TODO: Filter on tickable covers final IMultiBlockController tTarget = getTarget(true); if (tTarget != null) { - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid() && coverInfo.getTickRate() > 0) { - tTarget.registerCoveredPartOnSide(aSide, this); + tTarget.registerCoveredPartOnSide(side, this); } } } public void unregisterCovers(IMultiBlockController controller) { - for (byte i : ALL_VALID_SIDES) { - if (getCoverInfoAtSide(i).isValid()) { - controller.unregisterCoveredPartOnSide(i, this); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (getCoverInfoAtSide(side).isValid()) { + controller.unregisterCoveredPartOnSide(side, this); } } } @Override - public boolean dropCover(byte aSide, byte aDroppedSide, boolean aForced) { - final boolean res = super.dropCover(aSide, aDroppedSide, aForced); + public boolean dropCover(ForgeDirection side, ForgeDirection droppedSide, boolean aForced) { + final boolean res = super.dropCover(side, droppedSide, aForced); final IMultiBlockController tTarget = getTarget(true); if (tTarget != null) { - tTarget.unregisterCoveredPartOnSide(aSide, this); + tTarget.unregisterCoveredPartOnSide(side, this); } return res; } @@ -327,13 +325,13 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public void onBlockAdded() { - for (byte tSide : ALL_VALID_SIDES) { - final TileEntity te = getTileEntityAtSide(tSide); - if (te instanceof MultiBlockPart) { - final IMultiBlockController tController = ((MultiBlockPart) te).getTarget(false); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final TileEntity te = getTileEntityAtSide(side); + if (te instanceof MultiBlockPart part) { + final IMultiBlockController tController = part.getTarget(false); if (tController != null) tController.onStructureChange(); - } else if (te instanceof IMultiBlockController) { - ((IMultiBlockController) te).onStructureChange(); + } else if (te instanceof IMultiBlockController controller) { + controller.onStructureChange(); } } } @@ -347,40 +345,38 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity texture, TextureFactory.of(OVERLAY_PIPE_IN), TextureFactory.of(ITEM_IN_SIGN), - getCoverTexture((byte) side.ordinal())); + getCoverTexture(side)); } if (mMode == getModeOrdinal(ITEM_OUT)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_OUT), TextureFactory.of(ITEM_OUT_SIGN), - getCoverTexture((byte) side.ordinal())); + getCoverTexture(side)); } if (mMode == getModeOrdinal(FLUID_IN)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_IN), TextureFactory.of(FLUID_IN_SIGN), - getCoverTexture((byte) side.ordinal())); + getCoverTexture(side)); } if (mMode == getModeOrdinal(FLUID_OUT)) { return TextureFactory.of( texture, TextureFactory.of(OVERLAY_PIPE_OUT), TextureFactory.of(FLUID_OUT_SIGN), - getCoverTexture((byte) side.ordinal())); + getCoverTexture(side)); } if (mMode == getModeOrdinal(ENERGY_IN)) { - return TextureFactory - .of(texture, TextureFactory.of(OVERLAY_ENERGY_IN_MULTI), getCoverTexture((byte) side.ordinal())); + return TextureFactory.of(texture, TextureFactory.of(OVERLAY_ENERGY_IN_MULTI), getCoverTexture(side)); } if (mMode == getModeOrdinal(ENERGY_OUT)) { - return TextureFactory - .of(texture, TextureFactory.of(OVERLAY_ENERGY_OUT_MULTI), getCoverTexture((byte) side.ordinal())); + return TextureFactory.of(texture, TextureFactory.of(OVERLAY_ENERGY_OUT_MULTI), getCoverTexture(side)); } } - return TextureFactory.of(texture, getCoverTexture((byte) side.ordinal())); + return TextureFactory.of(texture, getCoverTexture(side)); } @Override @@ -418,15 +414,15 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } @Override - public boolean onMalletRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, byte wrenchSide, float aX, float aY, - float aZ) { + public boolean onMalletRightClick(EntityPlayer aPlayer, ItemStack tCurrentItem, ForgeDirection wrenchSide, float aX, + float aY, float aZ) { if (mAllowedModes == NOTHING) return true; if (mMode == NOTHING) { - facing = ForgeDirection.getOrientation(wrenchSide); + facing = wrenchSide; } mMode = getNextAllowedMode(BASIC_MODES); if (aPlayer.isSneaking()) { - facing = ForgeDirection.getOrientation(wrenchSide); + facing = wrenchSide; } GT_Utility.sendChatToPlayer(aPlayer, "Mode set to `" + getModeName(mMode) + "' (" + mMode + ")"); sendClientData((EntityPlayerMP) aPlayer); @@ -437,7 +433,7 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity public void setLightValue(byte aLightValue) {} @Override - public byte getComparatorValue(byte aSide) { + public byte getComparatorValue(ForgeDirection side) { return 0; } @@ -457,10 +453,10 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public int fill(ForgeDirection aDirection, FluidStack aFluidStack, boolean aDoFill) { if (!modeSelected(FLUID_IN)) return 0; - final byte aSide = (byte) aDirection.ordinal(); + if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return 0; - if (aDirection != ForgeDirection.UNKNOWN && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 - || !coverLetsFluidIn(aSide, aFluidStack.getFluid()))) return 0; + if (aDirection != ForgeDirection.UNKNOWN + && (facing.compareTo(aDirection) != 0 || !coverLetsFluidIn(aDirection, aFluidStack.getFluid()))) return 0; final IMultiBlockController controller = getTarget(true); return controller == null ? 0 : controller.fill(this, aDirection, aFluidStack, aDoFill); } @@ -468,10 +464,10 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public FluidStack drain(ForgeDirection aDirection, FluidStack aFluidStack, boolean aDoDrain) { if (!modeSelected(FLUID_OUT)) return null; - final byte aSide = (byte) aDirection.ordinal(); if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return null; - if (aDirection != ForgeDirection.UNKNOWN && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 - || !coverLetsFluidOut(aSide, aFluidStack.getFluid()))) return null; + if (aDirection != ForgeDirection.UNKNOWN + && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluidStack.getFluid()))) + return null; final IMultiBlockController controller = getTarget(true); return controller == null ? null : controller.drain(this, aDirection, aFluidStack, aDoDrain); } @@ -479,28 +475,27 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public FluidStack drain(ForgeDirection aDirection, int aAmountToDrain, boolean aDoDrain) { if (!modeSelected(FLUID_OUT)) return null; - final byte aSide = (byte) aDirection.ordinal(); final IMultiBlockController controller = getTarget(true); if (controller == null) return null; FluidStack aFluidStack = null; if (getLockedFluid() != null) { - aFluidStack = controller.getDrainableFluid(aSide, getLockedFluid()); + aFluidStack = controller.getDrainableFluid(aDirection, getLockedFluid()); } else { - aFluidStack = controller.getDrainableFluid(aSide); + aFluidStack = controller.getDrainableFluid(aDirection); } if (aFluidStack == null || isWrongFluid(aFluidStack.getFluid())) return null; - if (aDirection != ForgeDirection.UNKNOWN && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 - || !coverLetsFluidOut(aSide, aFluidStack.getFluid()))) return null; + if (aDirection != ForgeDirection.UNKNOWN + && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluidStack.getFluid()))) + return null; return controller.drain(this, aDirection, aFluidStack, aDoDrain); } @Override public boolean canFill(ForgeDirection aDirection, Fluid aFluid) { if (!modeSelected(FLUID_IN)) return false; - final byte aSide = (byte) aDirection.ordinal(); + if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 || !coverLetsFluidIn(aSide, aFluid))) - return false; + && (facing.compareTo(aDirection) != 0 || !coverLetsFluidIn(aDirection, aFluid))) return false; if (isWrongFluid(aFluid)) return false; final IMultiBlockController controller = getTarget(true); return controller != null && controller.canFill(this, aDirection, aFluid); @@ -509,10 +504,8 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public boolean canDrain(ForgeDirection aDirection, Fluid aFluid) { if (!modeSelected(FLUID_OUT)) return false; - final byte aSide = (byte) aDirection.ordinal(); if (aDirection != ForgeDirection.UNKNOWN - && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 || !coverLetsFluidOut(aSide, aFluid))) - return false; + && (facing.compareTo(aDirection) != 0 || !coverLetsFluidOut(aDirection, aFluid))) return false; if (isWrongFluid(aFluid)) return false; final IMultiBlockController controller = getTarget(true); return controller != null && controller.canDrain(this, aDirection, aFluid); @@ -520,17 +513,16 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity @Override public FluidTankInfo[] getTankInfo(ForgeDirection aDirection) { - final byte aSide = (byte) aDirection.ordinal(); if (!modeSelected(FLUID_IN, FLUID_OUT) - || (aSide != SIDE_UNKNOWN && facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0)) + || (aDirection != ForgeDirection.UNKNOWN && facing.compareTo(aDirection) != 0)) return GT_Values.emptyFluidTankInfo; final IMultiBlockController controller = getTarget(true); if (controller == null) return GT_Values.emptyFluidTankInfo; - final CoverInfo coverInfo = getCoverInfoAtSide(aSide); + final CoverInfo coverInfo = getCoverInfoAtSide(aDirection); - if ((controller.isLiquidInput(aSide) && coverInfo.letsFluidIn(null, controller)) - || (controller.isLiquidOutput(aSide) && coverInfo.letsFluidOut(null, controller))) + if ((controller.isLiquidInput(aDirection) && coverInfo.letsFluidIn(null, controller)) + || (controller.isLiquidOutput(aDirection) && coverInfo.letsFluidOut(null, controller))) return controller.getTankInfo(this, aDirection); return GT_Values.emptyFluidTankInfo; @@ -597,31 +589,32 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } @Override - public int[] getAccessibleSlotsFromSide(int aSide) { - if (!modeSelected(ITEM_IN, ITEM_OUT) - || (facing != ForgeDirection.UNKNOWN && facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0)) + public int[] getAccessibleSlotsFromSide(int ordinalSide) { + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + if (!modeSelected(ITEM_IN, ITEM_OUT) || (facing != ForgeDirection.UNKNOWN && facing.compareTo(side) != 0)) return GT_Values.emptyIntArray; final IMultiBlockController controller = getTarget(true); - return controller != null ? controller.getAccessibleSlotsFromSide(this, (byte) aSide) : GT_Values.emptyIntArray; + return controller != null ? controller.getAccessibleSlotsFromSide(this, side) : GT_Values.emptyIntArray; } @Override - public boolean canInsertItem(int aSlot, ItemStack aStack, int aSide) { - if (!modeSelected(ITEM_IN, ITEM_OUT) || (facing != ForgeDirection.UNKNOWN - && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 || !coverLetsItemsIn((byte) aSide, aSlot)))) + public boolean canInsertItem(int aSlot, ItemStack aStack, int ordinalSide) { + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); + if (!modeSelected(ITEM_IN, ITEM_OUT) + || (facing != ForgeDirection.UNKNOWN && (facing.compareTo(side) != 0 || !coverLetsItemsIn(side, aSlot)))) return false; final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.canInsertItem(this, aSlot, aStack, (byte) aSide)); + return (controller != null && controller.canInsertItem(this, aSlot, aStack, side)); } @Override - public boolean canExtractItem(int aSlot, ItemStack aStack, int aSide) { + public boolean canExtractItem(int aSlot, ItemStack aStack, int ordinalSide) { + final ForgeDirection side = ForgeDirection.getOrientation(ordinalSide); if (!modeSelected(ITEM_IN, ITEM_OUT) - || (facing != ForgeDirection.UNKNOWN && (facing.compareTo(ForgeDirection.getOrientation(aSide)) != 0 - || !coverLetsItemsOut((byte) aSide, aSlot)))) + || (facing != ForgeDirection.UNKNOWN && (facing.compareTo(side) != 0 || !coverLetsItemsOut(side, aSlot)))) return false; final IMultiBlockController controller = getTarget(true); - return (controller != null && controller.canExtractItem(this, aSlot, aStack, (byte) aSide)); + return (controller != null && controller.canExtractItem(this, aSlot, aStack, side)); } @Override @@ -695,8 +688,8 @@ public abstract class MultiBlockPart extends NonTickableMultiTileEntity } @Override - public boolean hasGui(byte aSide) { - if (modeSelected(ENERGY_IN, ENERGY_OUT) && facing == ForgeDirection.getOrientation(aSide)) { + public boolean hasGui(ForgeDirection side) { + if (modeSelected(ENERGY_IN, ENERGY_OUT) && facing == side) { return false; } return getTarget(true) != null; diff --git a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java index a391f503dc..62beb64022 100644 --- a/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java +++ b/src/main/java/gregtech/api/multitileentity/multiblock/base/WallShareablePart.java @@ -1,12 +1,11 @@ package gregtech.api.multitileentity.multiblock.base; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; - import java.util.ArrayList; import java.util.List; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; +import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.multitileentity.interfaces.IMultiBlockController; @@ -67,7 +66,7 @@ public class WallShareablePart extends MultiBlockPart { @Override public boolean breakBlock() { - for (ChunkCoordinates coordinates : targetPositions) { + for (final ChunkCoordinates coordinates : targetPositions) { IMultiBlockController target = getTarget(coordinates, false); if (target == null) { continue; @@ -79,13 +78,13 @@ public class WallShareablePart extends MultiBlockPart { @Override public void onBlockAdded() { - for (byte tSide : ALL_VALID_SIDES) { - final TileEntity te = getTileEntityAtSide(tSide); - if (te instanceof MultiBlockPart) { - final IMultiBlockController tController = ((MultiBlockPart) te).getTarget(false); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + final TileEntity te = getTileEntityAtSide(side); + if (te instanceof MultiBlockPart part) { + final IMultiBlockController tController = part.getTarget(false); if (tController != null) tController.onStructureChange(); - } else if (te instanceof IMultiBlockController) { - ((IMultiBlockController) te).onStructureChange(); + } else if (te instanceof IMultiBlockController controller) { + controller.onStructureChange(); } } } diff --git a/src/main/java/gregtech/api/net/GT_Packet_GtTileEntityGuiRequest.java b/src/main/java/gregtech/api/net/GT_Packet_GtTileEntityGuiRequest.java index bccb4b2b76..dc2f88316d 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_GtTileEntityGuiRequest.java +++ b/src/main/java/gregtech/api/net/GT_Packet_GtTileEntityGuiRequest.java @@ -5,6 +5,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -88,7 +89,7 @@ public class GT_Packet_GtTileEntityGuiRequest extends GT_Packet_New { final World world = DimensionManager.getWorld(this.dimId); if (world == null) return; final TileEntity tile = world.getTileEntity(this.mX, this.mY, this.mZ); - if (!(tile instanceof BaseTileEntity baseTile) || ((BaseTileEntity) tile).isDead()) return; + if (!(tile instanceof BaseTileEntity baseTile) || baseTile.isDead()) return; final EntityPlayerMP player = (EntityPlayerMP) world.getEntityByID(playerId); final CoverableTileEntity coverableTile = (baseTile instanceof CoverableTileEntity) @@ -97,7 +98,8 @@ public class GT_Packet_GtTileEntityGuiRequest extends GT_Packet_New { // If the requested Gui ID corresponds to a cover, send the cover data to the client so they can open it. if (GT_Proxy.GUI_ID_COVER_SIDE_BASE <= guiId && guiId < GT_Proxy.GUI_ID_COVER_SIDE_BASE + 6 && coverableTile != null) { - final byte coverSide = (byte) (guiId - GT_Proxy.GUI_ID_COVER_SIDE_BASE); + final ForgeDirection coverSide = ForgeDirection + .getOrientation((byte) (guiId - GT_Proxy.GUI_ID_COVER_SIDE_BASE)); final GT_Packet_TileEntityCoverGUI packet = new GT_Packet_TileEntityCoverGUI( this.mX, this.mY, diff --git a/src/main/java/gregtech/api/net/GT_Packet_RequestCoverData.java b/src/main/java/gregtech/api/net/GT_Packet_RequestCoverData.java index 3f919dacd4..94ae86c2d9 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_RequestCoverData.java +++ b/src/main/java/gregtech/api/net/GT_Packet_RequestCoverData.java @@ -7,6 +7,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -24,7 +25,7 @@ public class GT_Packet_RequestCoverData extends GT_Packet_New { protected short mY; protected int mZ; - protected byte side; + protected ForgeDirection side; protected int coverID; protected EntityPlayerMP mPlayer; @@ -43,7 +44,7 @@ public class GT_Packet_RequestCoverData extends GT_Packet_New { this.coverID = info.getCoverID(); } - public GT_Packet_RequestCoverData(int mX, short mY, int mZ, byte coverSide, int coverID) { + public GT_Packet_RequestCoverData(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID) { super(false); this.mX = mX; this.mY = mY; @@ -53,7 +54,7 @@ public class GT_Packet_RequestCoverData extends GT_Packet_New { this.coverID = coverID; } - public GT_Packet_RequestCoverData(byte coverSide, int coverID, ICoverable tile) { + public GT_Packet_RequestCoverData(ForgeDirection coverSide, int coverID, ICoverable tile) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -74,7 +75,7 @@ public class GT_Packet_RequestCoverData extends GT_Packet_New { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); } @@ -84,7 +85,7 @@ public class GT_Packet_RequestCoverData extends GT_Packet_New { aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), aData.readInt()); } diff --git a/src/main/java/gregtech/api/net/GT_Packet_SendCoverData.java b/src/main/java/gregtech/api/net/GT_Packet_SendCoverData.java index b348cbb9e3..47f549b5b4 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_SendCoverData.java +++ b/src/main/java/gregtech/api/net/GT_Packet_SendCoverData.java @@ -2,6 +2,7 @@ package gregtech.api.net; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -21,7 +22,7 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { protected short mY; protected int mZ; - protected byte side; + protected ForgeDirection side; protected int coverID; protected ISerializableObject coverData; @@ -29,7 +30,7 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { super(true); } - public GT_Packet_SendCoverData(int mX, short mY, int mZ, byte coverSide, int coverID, + public GT_Packet_SendCoverData(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, ISerializableObject coverData) { super(false); this.mX = mX; @@ -52,7 +53,8 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { this.coverData = info.getCoverData(); } - public GT_Packet_SendCoverData(byte coverSide, int coverID, ISerializableObject coverData, ICoverable tile) { + public GT_Packet_SendCoverData(ForgeDirection coverSide, int coverID, ISerializableObject coverData, + ICoverable tile) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -74,7 +76,7 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); coverData.writeToByteBuf(aOut); } @@ -86,7 +88,7 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), coverId = aData.readInt(), GregTech_API.getCoverBehaviorNew(coverId) .createDataObject() @@ -97,8 +99,8 @@ public class GT_Packet_SendCoverData extends GT_Packet_New { public void process(IBlockAccess aWorld) { if (aWorld != null) { final TileEntity tile = aWorld.getTileEntity(mX, mY, mZ); - if (tile instanceof CoverableTileEntity && !((CoverableTileEntity) tile).isDead()) { - ((CoverableTileEntity) tile).receiveCoverData(side, coverID, coverData, null); + if (tile instanceof CoverableTileEntity coverable && !coverable.isDead()) { + coverable.receiveCoverData(side, coverID, coverData, null); } } } diff --git a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCover.java b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCover.java index 0e4bedc16e..d3642b62e8 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCover.java +++ b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCover.java @@ -4,6 +4,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -20,14 +21,15 @@ public class GT_Packet_TileEntityCover extends GT_Packet_New { protected short mY; protected int mZ; - protected byte side; + protected ForgeDirection side; protected int coverID, coverData, dimID; public GT_Packet_TileEntityCover() { super(true); } - public GT_Packet_TileEntityCover(int mX, short mY, int mZ, byte coverSide, int coverID, int coverData, int dimID) { + public GT_Packet_TileEntityCover(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, int coverData, + int dimID) { super(false); this.mX = mX; this.mY = mY; @@ -40,7 +42,7 @@ public class GT_Packet_TileEntityCover extends GT_Packet_New { this.dimID = dimID; } - public GT_Packet_TileEntityCover(byte coverSide, int coverID, int coverData, ICoverable tile) { + public GT_Packet_TileEntityCover(ForgeDirection coverSide, int coverID, int coverData, ICoverable tile) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -64,7 +66,7 @@ public class GT_Packet_TileEntityCover extends GT_Packet_New { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); aOut.writeInt(coverData); @@ -77,7 +79,7 @@ public class GT_Packet_TileEntityCover extends GT_Packet_New { aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), aData.readInt(), aData.readInt(), aData.readInt()); diff --git a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverGUI.java b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverGUI.java index 79156e4223..1b61f87541 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverGUI.java +++ b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverGUI.java @@ -7,6 +7,7 @@ import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -28,7 +29,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { protected short mY; protected int mZ; - protected byte side; + protected ForgeDirection side; protected int coverID, dimID, playerID; protected ISerializableObject coverData; @@ -38,8 +39,8 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { super(true); } - public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, byte coverSide, int coverID, int coverData, int dimID, - int playerID) { + public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, int coverData, + int dimID, int playerID) { super(false); this.mX = mX; this.mY = mY; @@ -54,7 +55,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { this.parentGuiId = -1; } - public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, byte coverSide, int coverID, + public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, ISerializableObject coverData, int dimID, int playerID) { super(false); this.mX = mX; @@ -85,7 +86,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { this.parentGuiId = parentGuiId; } - public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, byte coverSide, int coverID, + public GT_Packet_TileEntityCoverGUI(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, ISerializableObject coverData, int dimID, int playerID, int parentGuiId) { super(false); this.mX = mX; @@ -100,7 +101,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { this.parentGuiId = parentGuiId; } - public GT_Packet_TileEntityCoverGUI(byte side, int coverID, int coverData, ICoverable tile, + public GT_Packet_TileEntityCoverGUI(ForgeDirection side, int coverID, int coverData, ICoverable tile, EntityPlayerMP aPlayer) { super(false); @@ -117,7 +118,8 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { this.parentGuiId = -1; } - public GT_Packet_TileEntityCoverGUI(byte coverSide, int coverID, int coverData, IGregTechTileEntity tile) { + public GT_Packet_TileEntityCoverGUI(ForgeDirection coverSide, int coverID, int coverData, + IGregTechTileEntity tile) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -131,8 +133,8 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { this.parentGuiId = -1; } - public GT_Packet_TileEntityCoverGUI(byte side, int coverID, ISerializableObject coverData, ICoverable tile, - EntityPlayerMP aPlayer) { + public GT_Packet_TileEntityCoverGUI(ForgeDirection side, int coverID, ISerializableObject coverData, + ICoverable tile, EntityPlayerMP aPlayer) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -158,7 +160,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); coverData.writeToByteBuf(aOut); @@ -170,12 +172,12 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { @Override public GT_Packet_New decode(ByteArrayDataInput aData) { - int coverID; + final int coverID; return new GT_Packet_TileEntityCoverGUI( aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), coverID = aData.readInt(), GregTech_API.getCoverBehaviorNew(coverID) .createDataObject() @@ -191,7 +193,7 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { // Using EntityPlayer instead of EntityClientPlayerMP so both client and server can load this final EntityPlayer thePlayer = ((EntityPlayer) ((World) aWorld).getEntityByID(playerID)); final TileEntity tile = aWorld.getTileEntity(mX, mY, mZ); - if (tile instanceof IGregTechTileEntity gtTile && !((IGregTechTileEntity) tile).isDead()) { + if (tile instanceof IGregTechTileEntity gtTile && !gtTile.isDead()) { gtTile.setCoverDataAtSide(side, coverData); // Set it client side to read later. GT_CoverBehaviorBase<?> cover = gtTile.getCoverBehaviorAtSideNew(side); @@ -205,8 +207,8 @@ public class GT_Packet_TileEntityCoverGUI extends GT_Packet_New { thePlayer.worldObj); // If it's one of this mod's covers, tell it to exit to the GUI with the specified ID (-1 is // ignored) - if (gui instanceof GT_GUICover) { - ((GT_GUICover) gui).setParentGuiId(parentGuiId); + if (gui instanceof GT_GUICover guiCover) { + guiCover.setParentGuiId(parentGuiId); } Minecraft.getMinecraft() .displayGuiScreen(gui); diff --git a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverNew.java b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverNew.java index 89201710f3..8fd7348b24 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverNew.java +++ b/src/main/java/gregtech/api/net/GT_Packet_TileEntityCoverNew.java @@ -7,6 +7,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -25,7 +26,7 @@ public class GT_Packet_TileEntityCoverNew extends GT_Packet_New { protected short mY; protected int mZ; - protected byte side; + protected ForgeDirection side; protected int coverID, dimID; protected ISerializableObject coverData; @@ -35,7 +36,7 @@ public class GT_Packet_TileEntityCoverNew extends GT_Packet_New { super(true); } - public GT_Packet_TileEntityCoverNew(int mX, short mY, int mZ, byte coverSide, int coverID, + public GT_Packet_TileEntityCoverNew(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, ISerializableObject coverData, int dimID) { super(false); this.mX = mX; @@ -49,7 +50,8 @@ public class GT_Packet_TileEntityCoverNew extends GT_Packet_New { this.dimID = dimID; } - public GT_Packet_TileEntityCoverNew(byte coverSide, int coverID, ISerializableObject coverData, ICoverable tile) { + public GT_Packet_TileEntityCoverNew(ForgeDirection coverSide, int coverID, ISerializableObject coverData, + ICoverable tile) { super(false); this.mX = tile.getXCoord(); this.mY = tile.getYCoord(); @@ -80,7 +82,7 @@ public class GT_Packet_TileEntityCoverNew extends GT_Packet_New { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); coverData.writeToByteBuf(aOut); @@ -94,7 +96,7 @@ public class GT_Packet_TileEntityCoverNew extends GT_Packet_New { aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), coverId = aData.readInt(), GregTech_API.getCoverBehaviorNew(coverId) .createDataObject() diff --git a/src/main/java/gregtech/api/net/GT_Packet_WirelessRedstoneCover.java b/src/main/java/gregtech/api/net/GT_Packet_WirelessRedstoneCover.java index 5121ce03df..08628ace2b 100644 --- a/src/main/java/gregtech/api/net/GT_Packet_WirelessRedstoneCover.java +++ b/src/main/java/gregtech/api/net/GT_Packet_WirelessRedstoneCover.java @@ -7,6 +7,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.util.ForgeDirection; import com.google.common.io.ByteArrayDataInput; @@ -28,14 +29,14 @@ public class GT_Packet_WirelessRedstoneCover extends GT_Packet_TileEntityCover { super(); } - public GT_Packet_WirelessRedstoneCover(int mX, short mY, int mZ, byte coverSide, int coverID, int dimID, + public GT_Packet_WirelessRedstoneCover(int mX, short mY, int mZ, ForgeDirection coverSide, int coverID, int dimID, int publicChannel, int checkBoxValue) { super(mX, mY, mZ, coverSide, coverID, 0, dimID); mPublicChannel = publicChannel; mCheckBoxValue = checkBoxValue; } - public GT_Packet_WirelessRedstoneCover(byte coverSide, int coverID, ICoverable tile, int publicChannel, + public GT_Packet_WirelessRedstoneCover(ForgeDirection coverSide, int coverID, ICoverable tile, int publicChannel, int checkBoxValue) { super(coverSide, coverID, 0, tile); mPublicChannel = publicChannel; @@ -60,7 +61,7 @@ public class GT_Packet_WirelessRedstoneCover extends GT_Packet_TileEntityCover { aOut.writeShort(mY); aOut.writeInt(mZ); - aOut.writeByte(side); + aOut.writeByte(side.ordinal()); aOut.writeInt(coverID); aOut.writeInt(dimID); @@ -75,7 +76,7 @@ public class GT_Packet_WirelessRedstoneCover extends GT_Packet_TileEntityCover { aData.readInt(), aData.readShort(), aData.readInt(), - aData.readByte(), + ForgeDirection.getOrientation(aData.readByte()), aData.readInt(), aData.readInt(), aData.readInt(), diff --git a/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java index 8ea4ce008d..c5307b4803 100644 --- a/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java +++ b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java @@ -15,17 +15,17 @@ public class GT_CopiedBlockTexture extends gregtech.common.render.GT_CopiedBlock @Deprecated public short[] mRGBa; - public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta, short[] aRGBa, boolean aAllowAlpha) { - super(aBlock, aSide, aMeta, aRGBa, aAllowAlpha); + public GT_CopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta, short[] aRGBa, boolean aAllowAlpha) { + super(aBlock, ordinalSide, aMeta, aRGBa, aAllowAlpha); GT_CopiedBlockTexture.this.mRGBa = aRGBa; } - public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta, short[] aRGBa) { - this(aBlock, aSide, aMeta, aRGBa, true); + public GT_CopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta, short[] aRGBa) { + this(aBlock, ordinalSide, aMeta, aRGBa, true); } - public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta) { - this(aBlock, aSide, aMeta, Dyes._NULL.mRGBa); + public GT_CopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta) { + this(aBlock, ordinalSide, aMeta, Dyes._NULL.mRGBa); } @Override diff --git a/src/main/java/gregtech/api/objects/GT_Cover_Default.java b/src/main/java/gregtech/api/objects/GT_Cover_Default.java index b6259a9366..cc5f96eef3 100644 --- a/src/main/java/gregtech/api/objects/GT_Cover_Default.java +++ b/src/main/java/gregtech/api/objects/GT_Cover_Default.java @@ -1,6 +1,7 @@ package gregtech.api.objects; import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import gregtech.api.interfaces.tileentity.ICoverable; @@ -22,7 +23,7 @@ public class GT_Cover_Default extends GT_CoverBehavior { } @Override - public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { aCoverVariable = ((aCoverVariable + 1) & 15); GT_Utility.sendChatToPlayer( @@ -35,42 +36,46 @@ public class GT_Cover_Default extends GT_CoverBehavior { } @Override - public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return (aCoverVariable & 1) != 0; } @Override - public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return (aCoverVariable & 1) != 0; } @Override - public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return (aCoverVariable & 2) != 0; } @Override - public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return (aCoverVariable & 2) != 0; } @Override - public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return (aCoverVariable & 4) != 0; } @Override - public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return (aCoverVariable & 4) != 0; } @Override - public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return (aCoverVariable & 8) != 0; } @Override - public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return (aCoverVariable & 8) != 0; } } diff --git a/src/main/java/gregtech/api/objects/GT_Cover_None.java b/src/main/java/gregtech/api/objects/GT_Cover_None.java index e0b1adf66e..30a12d6354 100644 --- a/src/main/java/gregtech/api/objects/GT_Cover_None.java +++ b/src/main/java/gregtech/api/objects/GT_Cover_None.java @@ -4,6 +4,7 @@ import static gregtech.api.enums.GT_Values.E; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import gregtech.api.interfaces.tileentity.ICoverable; @@ -18,76 +19,80 @@ public class GT_Cover_None extends GT_CoverBehavior { public GT_Cover_None() {} @Override - public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public float getBlastProofLevel(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return 10.0F; } @Override - public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return true; } @Override - public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return true; } @Override - public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return true; } @Override - public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return true; } @Override - public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return true; } @Override - public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return true; } @Override - public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return true; } @Override - public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return true; } @Override - public boolean isGUIClickable(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean isGUIClickable(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return true; } @Override - public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, + public boolean manipulatesSidedRedstoneOutput(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } @Override - public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return false; } @Override - public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) { return true; } @Override - public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, - long aTimer) { + public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, + ICoverable aTileEntity, long aTimer) { return 0; } @@ -97,154 +102,142 @@ public class GT_Cover_None extends GT_CoverBehavior { } @Override - protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { return false; } @Override - protected ISerializableObject.LegacyCoverData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, - ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + protected ISerializableObject.LegacyCoverData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, + int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { return aCoverVariable; } @Override - protected boolean onCoverRightClickImpl(byte aSide, int aCoverID, + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return false; } @Override - protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(byte aSide, int aCoverID, + protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return aCoverVariable; } @Override - protected boolean onCoverShiftRightClickImpl(byte aSide, int aCoverID, + protected boolean onCoverShiftRightClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) { return false; } @Override - protected boolean onCoverRemovalImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity, boolean aForced) { + protected boolean onCoverRemovalImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, boolean aForced) { return true; } @Override - protected String getDescriptionImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected String getDescriptionImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return E; } @Override - protected float getBlastProofLevelImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected float getBlastProofLevelImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return 10.0F; } @Override - protected boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return true; - } - - @Override - protected boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, + protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return true; } @Override - protected boolean letsFibreGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return true; - } - - @Override - protected boolean letsFibreGoOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return true; } @Override - protected boolean letsEnergyInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return true; } @Override - protected boolean letsEnergyOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return true; } @Override - protected boolean letsFluidInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - Fluid aFluid, ICoverable aTileEntity) { + protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { return true; } @Override - protected boolean letsFluidOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - Fluid aFluid, ICoverable aTileEntity) { + protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { return true; } @Override - protected boolean letsItemsInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - int aSlot, ICoverable aTileEntity) { + protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { return true; } @Override - protected boolean letsItemsOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - int aSlot, ICoverable aTileEntity) { + protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { return true; } @Override - protected boolean isGUIClickableImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected boolean isGUIClickableImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return true; } @Override - protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return false; } @Override - protected boolean alwaysLookConnectedImpl(byte aSide, int aCoverID, + protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return false; } @Override - protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, + protected byte getRedstoneInputImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return aInputRedstone; } @Override - protected int getTickRateImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, + protected int getTickRateImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return 0; } @Override - protected byte getLensColorImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected byte getLensColorImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return -1; } @Override - protected ItemStack getDropImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { + protected ItemStack getDropImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { return null; } } diff --git a/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java b/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java index cc7410a481..d4b8d16da6 100644 --- a/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java +++ b/src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java @@ -12,7 +12,7 @@ import gregtech.api.util.LightingHelper; * This ITexture implementation extends the GT_RenderedTexture class to render with bottom side flipped as with dumb * blocks rendering. It is used in Ore blocks rendering so they better blends with dumb block ores from vanilla or other * mods, when seen from bottom. - * + * * @deprecated Replaced by the {@link gregtech.api.render.TextureFactory} API. */ @Deprecated @@ -36,10 +36,10 @@ public class GT_StdRenderedTexture extends GT_RenderedTexture { public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { LightingHelper lighting = new LightingHelper(aRenderer); lighting.setupLightingYNeg(aBlock, aX, aY, aZ) - .setupColor(ForgeDirection.DOWN.ordinal(), mRGBa); + .setupColor(ForgeDirection.DOWN, mRGBa); aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon()); if (mIconContainer.getOverlayIcon() != null) { - lighting.setupColor(ForgeDirection.DOWN.ordinal(), 0xffffff); + lighting.setupColor(ForgeDirection.DOWN, 0xffffff); aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); } } diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java b/src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java index c670307b5d..31c3c56aa8 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java @@ -1,7 +1,5 @@ package gregtech.api.threads; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; - import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; import net.minecraft.world.World; @@ -51,18 +49,16 @@ public class GT_Runnable_Cable_Update extends GT_Runnable_MachineBlockUpdate { // Now see if we should add the nearby blocks to the queue: // only add blocks the cable is connected to - if (tTileEntity instanceof BaseMetaPipeEntity - && ((BaseMetaPipeEntity) tTileEntity).getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable) { + if (tTileEntity instanceof BaseMetaPipeEntity metaPipe + && metaPipe.getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable cable) { ChunkCoordinates tCoords; - for (byte tSide : ALL_VALID_SIDES) { - if (((GT_MetaPipeEntity_Cable) ((BaseMetaPipeEntity) tTileEntity).getMetaTileEntity()) - .isConnectedAtSide(tSide)) { - final ForgeDirection offset = ForgeDirection.getOrientation(tSide); + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + if (cable.isConnectedAtSide(side)) { if (visited.add( tCoords = new ChunkCoordinates( - aCoords.posX + offset.offsetX, - aCoords.posY + offset.offsetY, - aCoords.posZ + offset.offsetZ))) + aCoords.posX + side.offsetX, + aCoords.posY + side.offsetY, + aCoords.posZ + side.offsetZ))) tQueue.add(tCoords); } } diff --git a/src/main/java/gregtech/api/util/GT_CircuitryBehavior.java b/src/main/java/gregtech/api/util/GT_CircuitryBehavior.java index b15627bb05..d5cd50049e 100644 --- a/src/main/java/gregtech/api/util/GT_CircuitryBehavior.java +++ b/src/main/java/gregtech/api/util/GT_CircuitryBehavior.java @@ -1,6 +1,6 @@ package gregtech.api.util; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; +import net.minecraftforge.common.util.ForgeDirection; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -35,7 +35,7 @@ public abstract class GT_CircuitryBehavior { * returns if there is Redstone applied to any of the valid Inputs (OR) */ public static boolean getAnyRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, @@ -54,7 +54,7 @@ public abstract class GT_CircuitryBehavior { * returns if there is Redstone applied to all the valid Inputs (AND) */ public static boolean getAllRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, @@ -74,7 +74,7 @@ public abstract class GT_CircuitryBehavior { */ public static boolean getOneRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { int tRedstoneAmount = 0; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, @@ -94,7 +94,7 @@ public abstract class GT_CircuitryBehavior { */ public static byte getStrongestRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { byte tRedstoneAmount = 0; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, @@ -117,7 +117,7 @@ public abstract class GT_CircuitryBehavior { public static byte getWeakestNonZeroRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { if (!getAnyRedstone(aRedstoneCircuitBlock)) return 0; byte tRedstoneAmount = 15; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, @@ -137,7 +137,7 @@ public abstract class GT_CircuitryBehavior { public static byte getWeakestRedstone(IRedstoneCircuitBlock aRedstoneCircuitBlock) { if (!getAnyRedstone(aRedstoneCircuitBlock)) return 0; byte tRedstoneAmount = 15; - for (byte side : ALL_VALID_SIDES) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { if (side != aRedstoneCircuitBlock.getOutputFacing() && aRedstoneCircuitBlock.getCover(side) .letsRedstoneGoIn( side, diff --git a/src/main/java/gregtech/api/util/GT_CoverBehavior.java b/src/main/java/gregtech/api/util/GT_CoverBehavior.java index 60196bd236..6441adb22b 100644 --- a/src/main/java/gregtech/api/util/GT_CoverBehavior.java +++ b/src/main/java/gregtech/api/util/GT_CoverBehavior.java @@ -6,6 +6,7 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.item.ItemStack; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import gregtech.api.enums.GT_Values; @@ -47,172 +48,161 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl } @Override - protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { - return isRedstoneSensitive(aSide, aCoverID, aCoverVariable.get(), aTileEntity, aTimer); + return isRedstoneSensitive(side, aCoverID, aCoverVariable.get(), aTileEntity, aTimer); } @Override - protected ISerializableObject.LegacyCoverData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, - ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + protected ISerializableObject.LegacyCoverData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, + int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { if (aCoverVariable == null) aCoverVariable = new ISerializableObject.LegacyCoverData(); - aCoverVariable.set(doCoverThings(aSide, aInputRedstone, aCoverID, aCoverVariable.get(), aTileEntity, aTimer)); + aCoverVariable.set(doCoverThings(side, aInputRedstone, aCoverID, aCoverVariable.get(), aTileEntity, aTimer)); return aCoverVariable; } @Override - protected boolean onCoverRightClickImpl(byte aSide, int aCoverID, + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { - return onCoverRightclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ); + return onCoverRightclick(side, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ); } @Override - protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(byte aSide, int aCoverID, + protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { if (aCoverVariable == null) aCoverVariable = new ISerializableObject.LegacyCoverData(); aCoverVariable - .set(onCoverScrewdriverclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ)); + .set(onCoverScrewdriverclick(side, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ)); return aCoverVariable; } @Override - protected boolean onCoverShiftRightClickImpl(byte aSide, int aCoverID, + protected boolean onCoverShiftRightClickImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) { - return onCoverShiftRightclick(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer); + return onCoverShiftRightclick(side, aCoverID, convert(aCoverVariable), aTileEntity, aPlayer); } @Deprecated @Override - protected Object getClientGUIImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) { - return getClientGUI(aSide, aCoverID, convert(aCoverVariable), aTileEntity); - } - - @Override - protected boolean onCoverRemovalImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity, boolean aForced) { - return onCoverRemoval(aSide, aCoverID, convert(aCoverVariable), aTileEntity, aForced); + protected Object getClientGUIImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, + World aWorld) { + return getClientGUI(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected String getDescriptionImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return getDescription(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean onCoverRemovalImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, boolean aForced) { + return onCoverRemoval(side, aCoverID, convert(aCoverVariable), aTileEntity, aForced); } @Override - protected float getBlastProofLevelImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return getBlastProofLevel(aSide, aCoverID, convert(aCoverVariable), aTileEntity); - } - - @Override - protected boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return letsRedstoneGoIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected String getDescriptionImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return getDescription(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, + protected float getBlastProofLevelImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { - return letsRedstoneGoOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + return getBlastProofLevel(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsFibreGoInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return letsFibreGoIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return letsRedstoneGoIn(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsFibreGoOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return letsFibreGoOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return letsRedstoneGoOut(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsEnergyInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return letsEnergyIn(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return letsEnergyIn(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsEnergyOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return letsEnergyOut(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return letsEnergyOut(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean letsFluidInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - Fluid aFluid, ICoverable aTileEntity) { - return letsFluidIn(aSide, aCoverID, convert(aCoverVariable), aFluid, aTileEntity); + protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return letsFluidIn(side, aCoverID, convert(aCoverVariable), aFluid, aTileEntity); } @Override - protected boolean letsFluidOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - Fluid aFluid, ICoverable aTileEntity) { - return letsFluidOut(aSide, aCoverID, convert(aCoverVariable), aFluid, aTileEntity); + protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return letsFluidOut(side, aCoverID, convert(aCoverVariable), aFluid, aTileEntity); } @Override - protected boolean letsItemsInImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - int aSlot, ICoverable aTileEntity) { - return letsItemsIn(aSide, aCoverID, convert(aCoverVariable), aSlot, aTileEntity); + protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return letsItemsIn(side, aCoverID, convert(aCoverVariable), aSlot, aTileEntity); } @Override - protected boolean letsItemsOutImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - int aSlot, ICoverable aTileEntity) { - return letsItemsOut(aSide, aCoverID, convert(aCoverVariable), aSlot, aTileEntity); + protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return letsItemsOut(side, aCoverID, convert(aCoverVariable), aSlot, aTileEntity); } @Override - protected boolean isGUIClickableImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return isGUIClickable(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected boolean isGUIClickableImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return isGUIClickable(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { - return manipulatesSidedRedstoneOutput(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + return manipulatesSidedRedstoneOutput(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected boolean alwaysLookConnectedImpl(byte aSide, int aCoverID, + protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { - return alwaysLookConnected(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + return alwaysLookConnected(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, + protected byte getRedstoneInputImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { - return getRedstoneInput(aSide, aInputRedstone, aCoverID, convert(aCoverVariable), aTileEntity); + return getRedstoneInput(side, aInputRedstone, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected int getTickRateImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, + protected int getTickRateImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { - return getTickRate(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + return getTickRate(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected byte getLensColorImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return getLensColor(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected byte getLensColorImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return getLensColor(side, aCoverID, convert(aCoverVariable), aTileEntity); } @Override - protected ItemStack getDropImpl(byte aSide, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, - ICoverable aTileEntity) { - return getDrop(aSide, aCoverID, convert(aCoverVariable), aTileEntity); + protected ItemStack getDropImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return getDrop(side, aCoverID, convert(aCoverVariable), aTileEntity); } // endregion - public boolean isRedstoneSensitive(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean isRedstoneSensitive(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { return true; } @@ -220,8 +210,8 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl /** * Called by updateEntity inside the covered TileEntity. aCoverVariable is the Value you returned last time. */ - public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, - long aTimer) { + public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, + ICoverable aTileEntity, long aTimer) { return aCoverVariable; } @@ -230,7 +220,7 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * <p/> * return true, if something actually happens. */ - public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return false; } @@ -240,7 +230,7 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * <p/> * return the new Value of the Cover Variable */ - public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return aCoverVariable; } @@ -248,17 +238,17 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl /** * Called when someone shift-rightclicks this Cover with no tool. Doesn't call @onCoverRightclick in this Case. */ - public boolean onCoverShiftRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean onCoverShiftRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) { if (hasCoverGUI() && aPlayer instanceof EntityPlayerMP) { lastPlayer = aPlayer; mPlayerNotified = false; if (useModularUI()) { - GT_UIInfos.openCoverUI(aTileEntity, aPlayer, aSide); + GT_UIInfos.openCoverUI(aTileEntity, aPlayer, side); } else { GT_Values.NW.sendToPlayer( new GT_Packet_TileEntityCoverGUI( - aSide, + side, aCoverID, aCoverVariable, aTileEntity, @@ -271,7 +261,7 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl } @Deprecated - public Object getClientGUI(byte aSide, int aCoverID, int coverData, ICoverable aTileEntity) { + public Object getClientGUI(ForgeDirection side, int aCoverID, int coverData, ICoverable aTileEntity) { return null; } @@ -279,7 +269,7 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * Removes the Cover if this returns true, or if aForced is true. Doesn't get called when the Machine Block is * getting broken, only if you break the Cover away from the Machine. */ - public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) { return true; } @@ -287,14 +277,14 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl /** * Gives a small Text for the status of the Cover. */ - public String getDescription(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public String getDescription(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return E; } /** * How Blast Proof the Cover is. 30 is normal. */ - public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public float getBlastProofLevel(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return 10.0F; } @@ -303,58 +293,44 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * <p/> * This is just Informative so that Machines know if their Redstone Input is blocked or not */ - public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets RS-Signals out of the Block */ - public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return false; - } - - /** - * If it lets Fibre-Signals into the Block - * <p/> - * This is just Informative so that Machines know if their Redstone Input is blocked or not - */ - public boolean letsFibreGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return false; - } - - /** - * If it lets Fibre-Signals out of the Block - */ - public boolean letsFibreGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets Energy into the Block */ - public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets Energy out of the Block */ - public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets Liquids into the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return false; } /** * If it lets Liquids out of the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { return false; } @@ -363,7 +339,8 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each * Slot). */ - public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return false; } @@ -372,21 +349,22 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each * Slot). */ - public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { return false; } /** * If it lets you rightclick the Machine normally */ - public boolean isGUIClickable(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean isGUIClickable(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } /** * Needs to return true for Covers, which have a Redstone Output on their Facing. */ - public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, + public boolean manipulatesSidedRedstoneOutput(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } @@ -394,7 +372,7 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl /** * if this Cover should let Pipe Connections look connected even if it is not the case. */ - public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public boolean alwaysLookConnected(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return false; } @@ -402,9 +380,9 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * Called to determine the incoming Redstone Signal of a Machine. Returns the original Redstone per default. The * Cover should @letsRedstoneGoIn or the aInputRedstone Parameter is always 0. */ - public byte getRedstoneInput(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, + public byte getRedstoneInput(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return letsRedstoneGoIn(aSide, aCoverID, aCoverVariable, aTileEntity) ? aInputRedstone : 0; + return letsRedstoneGoIn(side, aCoverID, aCoverVariable, aTileEntity) ? aInputRedstone : 0; } /** @@ -412,21 +390,21 @@ public abstract class GT_CoverBehavior extends GT_CoverBehaviorBase<ISerializabl * <p/> * 0 = No Ticks! Yes, 0 is Default, you have to override this */ - public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return 0; } /** * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then). */ - public byte getLensColor(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + public byte getLensColor(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { return -1; } /** * @return the ItemStack dropped by this Cover */ - public ItemStack getDrop(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { - return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(aSide)); + public ItemStack getDrop(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(side)); } } diff --git a/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java index 1757d0375a..8f65ae1553 100644 --- a/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java +++ b/src/main/java/gregtech/api/util/GT_CoverBehaviorBase.java @@ -13,6 +13,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTBase; import net.minecraft.nbt.NBTTagInt; import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import com.gtnewhorizons.modularui.api.ModularUITextures; @@ -89,23 +90,23 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * Get target facade block. Does not affect rendering of **this** block. It is only used as a hint for other block * in case of CTM - * + * * @return null if none, otherwise return facade target block */ - public final Block getFacadeBlock(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final Block getFacadeBlock(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getFacadeBlockImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getFacadeBlockImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Get target facade block. Does not affect rendering of **this** block. It is only used as a hint for other block * in case of CTM - * + * * @return 0 if none, otherwise return facade target meta */ - public final int getFacadeMeta(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final int getFacadeMeta(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getFacadeMetaImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getFacadeMetaImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** @@ -120,46 +121,46 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * passed to {@link gregtech.api.GregTech_API#registerCover(ItemStack, ITexture, GT_CoverBehaviorBase)} or its * overloads. */ - public final ITexture getSpecialCoverFGTexture(byte aSide, int aCoverID, ISerializableObject aCoverVariable, - ICoverable aTileEntity) { - return getSpecialCoverFGTextureImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + public final ITexture getSpecialCoverFGTexture(ForgeDirection side, int aCoverID, + ISerializableObject aCoverVariable, ICoverable aTileEntity) { + return getSpecialCoverFGTextureImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Get the special cover texture associated with this cover. Return null if one should use the texture passed to * {@link gregtech.api.GregTech_API#registerCover(ItemStack, ITexture, GT_CoverBehaviorBase)} or its overloads. */ - public final ITexture getSpecialCoverTexture(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final ITexture getSpecialCoverTexture(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getSpecialCoverTextureImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getSpecialCoverTextureImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Return whether cover data needs to be synced to client upon tile entity creation or cover placement. * * Note if you want to sync the data afterwards you will have to manually do it by calling - * {@link ICoverable#issueCoverUpdate(byte)} This option only affects the initial sync. + * {@link ICoverable#issueCoverUpdate(ForgeDirection)} This option only affects the initial sync. */ - public final boolean isDataNeededOnClient(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean isDataNeededOnClient(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return isDataNeededOnClientImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return isDataNeededOnClientImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Called upon receiving data from network. Use {@link ICoverable#isClientSide()} to determine the side. */ - public final void onDataChanged(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final void onDataChanged(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - onDataChangedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + onDataChangedImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Called before receiving data from network. Use {@link ICoverable#isClientSide()} to determine the side. */ - public final void preDataChanged(byte aSide, int aCoverID, int aNewCoverId, ISerializableObject aCoverVariable, - ISerializableObject aNewCoverVariable, ICoverable aTileEntity) { + public final void preDataChanged(ForgeDirection side, int aCoverID, int aNewCoverId, + ISerializableObject aCoverVariable, ISerializableObject aNewCoverVariable, ICoverable aTileEntity) { preDataChangedImpl( - aSide, + side, aCoverID, aNewCoverId, forceCast(aCoverVariable), @@ -170,21 +171,22 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * Called upon cover being removed. Called on both server and client. */ - public final void onDropped(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - onDroppedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + public final void onDropped(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, + ICoverable aTileEntity) { + onDroppedImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } - public final boolean isRedstoneSensitive(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean isRedstoneSensitive(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, long aTimer) { - return isRedstoneSensitiveImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer); + return isRedstoneSensitiveImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer); } /** * Called by updateEntity inside the covered TileEntity. aCoverVariable is the Value you returned last time. */ - public final T doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, ISerializableObject aCoverVariable, - ICoverable aTileEntity, long aTimer) { - return doCoverThingsImpl(aSide, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer); + public final T doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, + ISerializableObject aCoverVariable, ICoverable aTileEntity, long aTimer) { + return doCoverThingsImpl(side, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity, aTimer); } /** @@ -192,9 +194,9 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * return true, if something actually happens. */ - public final boolean onCoverRightClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean onCoverRightClick(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { - return onCoverRightClickImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ); + return onCoverRightClickImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ); } /** @@ -202,65 +204,57 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * return the new Value of the Cover Variable */ - public final T onCoverScrewdriverClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final T onCoverScrewdriverClick(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { - return onCoverScrewdriverClickImpl( - aSide, - aCoverID, - forceCast(aCoverVariable), - aTileEntity, - aPlayer, - aX, - aY, - aZ); + return onCoverScrewdriverClickImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aX, aY, aZ); } /** * Called when someone shift-rightclicks this Cover with no tool. Doesn't call @onCoverRightclick in this Case. */ - public final boolean onCoverShiftRightClick(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean onCoverShiftRightClick(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) { - return onCoverShiftRightClickImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer); + return onCoverShiftRightClickImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer); } @Deprecated - public final Object getClientGUI(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final Object getClientGUI(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) { - return getClientGUIImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aWorld); + return getClientGUIImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aPlayer, aWorld); } /** * Removes the Cover if this returns true, or if aForced is true. Doesn't get called when the Machine Block is * getting broken, only if you break the Cover away from the Machine. */ - public final boolean onCoverRemoval(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean onCoverRemoval(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity, boolean aForced) { - return onCoverRemovalImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity, aForced); + return onCoverRemovalImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity, aForced); } /** * Called upon Base TE being destroyed (once getDrops is called), thus getting called only when destroyed in * survival. */ - public final void onBaseTEDestroyed(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final void onBaseTEDestroyed(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - onBaseTEDestroyedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + onBaseTEDestroyedImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Gives a small Text for the status of the Cover. */ - public final String getDescription(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final String getDescription(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getDescriptionImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getDescriptionImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * How Blast Proof the Cover is. 30 is normal. */ - public final float getBlastProofLevel(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final float getBlastProofLevel(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getBlastProofLevelImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getBlastProofLevelImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** @@ -268,67 +262,49 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * This is just Informative so that Machines know if their Redstone Input is blocked or not */ - public final boolean letsRedstoneGoIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return letsRedstoneGoInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return letsRedstoneGoInImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * If it lets RS-Signals out of the Block */ - public final boolean letsRedstoneGoOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, - ICoverable aTileEntity) { - return letsRedstoneGoOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); - } - - /** - * If it lets Fibre-Signals into the Block - * <p/> - * This is just Informative so that Machines know if their Redstone Input is blocked or not - */ - public final boolean letsFibreGoIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, - ICoverable aTileEntity) { - return letsFibreGoInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); - } - - /** - * If it lets Fibre-Signals out of the Block - */ - public final boolean letsFibreGoOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return letsFibreGoOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return letsRedstoneGoOutImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * If it lets Energy into the Block */ - public final boolean letsEnergyIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean letsEnergyIn(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return letsEnergyInImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return letsEnergyInImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * If it lets Energy out of the Block */ - public final boolean letsEnergyOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean letsEnergyOut(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return letsEnergyOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return letsEnergyOutImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * If it lets Liquids into the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - public final boolean letsFluidIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, Fluid aFluid, - ICoverable aTileEntity) { - return letsFluidInImpl(aSide, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity); + public final boolean letsFluidIn(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, + Fluid aFluid, ICoverable aTileEntity) { + return letsFluidInImpl(side, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity); } /** * If it lets Liquids out of the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - public final boolean letsFluidOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, Fluid aFluid, - ICoverable aTileEntity) { - return letsFluidOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity); + public final boolean letsFluidOut(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, + Fluid aFluid, ICoverable aTileEntity) { + return letsFluidOutImpl(side, aCoverID, forceCast(aCoverVariable), aFluid, aTileEntity); } /** @@ -336,9 +312,9 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * reaction at all), aSlot = -2 means if it would accept for all Slots Impl(return true to skip the Checks for each * Slot). */ - public final boolean letsItemsIn(byte aSide, int aCoverID, ISerializableObject aCoverVariable, int aSlot, + public final boolean letsItemsIn(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, int aSlot, ICoverable aTileEntity) { - return letsItemsInImpl(aSide, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity); + return letsItemsInImpl(side, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity); } /** @@ -346,42 +322,42 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * reaction at all), aSlot = -2 means if it would accept for all Slots Impl(return true to skip the Checks for each * Slot). */ - public final boolean letsItemsOut(byte aSide, int aCoverID, ISerializableObject aCoverVariable, int aSlot, + public final boolean letsItemsOut(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, int aSlot, ICoverable aTileEntity) { - return letsItemsOutImpl(aSide, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity); + return letsItemsOutImpl(side, aCoverID, forceCast(aCoverVariable), aSlot, aTileEntity); } /** * If it lets you rightclick the Machine normally */ - public final boolean isGUIClickable(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean isGUIClickable(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return isGUIClickableImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return isGUIClickableImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Needs to return true for Covers, which have a Redstone Output on their Facing. */ - public final boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, ISerializableObject aCoverVariable, - ICoverable aTileEntity) { - return manipulatesSidedRedstoneOutputImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + public final boolean manipulatesSidedRedstoneOutput(ForgeDirection side, int aCoverID, + ISerializableObject aCoverVariable, ICoverable aTileEntity) { + return manipulatesSidedRedstoneOutputImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * if this Cover should let Pipe Connections look connected even if it is not the case. */ - public final boolean alwaysLookConnected(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final boolean alwaysLookConnected(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return alwaysLookConnectedImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return alwaysLookConnectedImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * Called to determine the incoming Redstone Signal of a Machine. Returns the original Redstone per default. The * Cover should @letsRedstoneGoIn or the aInputRedstone Parameter is always 0. */ - public final byte getRedstoneInput(byte aSide, byte aInputRedstone, int aCoverID, + public final byte getRedstoneInput(ForgeDirection side, byte aInputRedstone, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getRedstoneInputImpl(aSide, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getRedstoneInputImpl(side, aInputRedstone, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** @@ -389,24 +365,25 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * 0 = No Ticks! Yes, 0 is Default, you have to override this */ - public final int getTickRate(byte aSide, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getTickRateImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + public final int getTickRate(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, + ICoverable aTileEntity) { + return getTickRateImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then). */ - public final byte getLensColor(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final byte getLensColor(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getLensColorImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getLensColorImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } /** * @return the ItemStack dropped by this Cover */ - public final ItemStack getDrop(byte aSide, int aCoverID, ISerializableObject aCoverVariable, + public final ItemStack getDrop(ForgeDirection side, int aCoverID, ISerializableObject aCoverVariable, ICoverable aTileEntity) { - return getDropImpl(aSide, aCoverID, forceCast(aCoverVariable), aTileEntity); + return getDropImpl(side, aCoverID, forceCast(aCoverVariable), aTileEntity); } // endregion @@ -540,11 +517,11 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { // region impl - protected Block getFacadeBlockImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected Block getFacadeBlockImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return null; } - protected int getFacadeMetaImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected int getFacadeMetaImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return 0; } @@ -552,37 +529,39 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { return GT_Utility.intToStack(aCoverID); } - protected ITexture getSpecialCoverFGTextureImpl(byte aSide, int aCoverID, T aCoverVariable, + protected ITexture getSpecialCoverFGTextureImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return coverFGTexture; } - protected ITexture getSpecialCoverTextureImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected ITexture getSpecialCoverTextureImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return null; } - protected boolean isDataNeededOnClientImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean isDataNeededOnClientImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return false; } - protected void onDataChangedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} + protected void onDataChangedImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} - protected void preDataChangedImpl(byte aSide, int aCoverID, int aNewCoverId, T aCoverVariable, T aNewCoverVariable, - ICoverable aTileEntity) {} + protected void preDataChangedImpl(ForgeDirection side, int aCoverID, int aNewCoverId, T aCoverVariable, + T aNewCoverVariable, ICoverable aTileEntity) {} - protected void onDroppedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} + protected void onDroppedImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} - protected void onBaseTEDestroyedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} + protected void onBaseTEDestroyedImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) {} - protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, - long aTimer) { + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity, long aTimer) { return false; } /** * Called by updateEntity inside the covered TileEntity. aCoverVariable is the Value you returned last time. */ - protected T doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, T aCoverVariable, + protected T doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, T aCoverVariable, ICoverable aTileEntity, long aTimer) { return aCoverVariable; } @@ -592,7 +571,7 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * return true, if something actually happens. */ - protected boolean onCoverRightClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return false; } @@ -602,7 +581,7 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * return the new Value of the Cover Variable */ - protected T onCoverScrewdriverClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, + protected T onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { return aCoverVariable; } @@ -610,16 +589,16 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * Called when someone shift-rightclicks this Cover with no tool. Doesn't call @onCoverRightclick in this Case. */ - protected boolean onCoverShiftRightClickImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, - EntityPlayer aPlayer) { + protected boolean onCoverShiftRightClickImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity, EntityPlayer aPlayer) { if (hasCoverGUI() && aPlayer instanceof EntityPlayerMP) { lastPlayer = aPlayer; if (useModularUI()) { - GT_UIInfos.openCoverUI(aTileEntity, aPlayer, aSide); + GT_UIInfos.openCoverUI(aTileEntity, aPlayer, side); } else { GT_Values.NW.sendToPlayer( new GT_Packet_TileEntityCoverGUI( - aSide, + side, aCoverID, aCoverVariable, aTileEntity, @@ -632,7 +611,7 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { } @Deprecated - protected Object getClientGUIImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, + protected Object getClientGUIImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, World aWorld) { return null; } @@ -641,7 +620,7 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * Removes the Cover if this returns true, or if aForced is true. Doesn't get called when the Machine Block is * getting broken, only if you break the Cover away from the Machine. */ - protected boolean onCoverRemovalImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity, + protected boolean onCoverRemovalImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity, boolean aForced) { return true; } @@ -649,14 +628,15 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * Gives a small Text for the status of the Cover. */ - protected String getDescriptionImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected String getDescriptionImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return E; } /** * How Blast Proof the Cover is. 30 is normal. */ - protected float getBlastProofLevelImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected float getBlastProofLevelImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return 10.0F; } @@ -665,51 +645,37 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * This is just Informative so that Machines know if their Redstone Input is blocked or not */ - protected boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return false; } /** * If it lets RS-Signals out of the Block */ - protected boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { - return false; - } - - /** - * If it lets Fibre-Signals into the Block - * <p/> - * This is just Informative so that Machines know if their Redstone Input is blocked or not - */ - protected boolean letsFibreGoInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { - return false; - } - - /** - * If it lets Fibre-Signals out of the Block - */ - protected boolean letsFibreGoOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return false; } /** * If it lets Energy into the Block */ - protected boolean letsEnergyInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets Energy out of the Block */ - protected boolean letsEnergyOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return false; } /** * If it lets Liquids into the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - protected boolean letsFluidInImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, + protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { return false; } @@ -717,7 +683,7 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * If it lets Liquids out of the Block, aFluid can be null meaning if this is generally allowing Fluids or not. */ - protected boolean letsFluidOutImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, + protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { return false; } @@ -727,7 +693,8 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each * Slot). */ - protected boolean letsItemsInImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) { + protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, int aSlot, + ICoverable aTileEntity) { return false; } @@ -736,21 +703,22 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * Interaction at all), aSlot = -2 means if it would accept for all Slots (return true to skip the Checks for each * Slot). */ - protected boolean letsItemsOutImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) { + protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, int aSlot, + ICoverable aTileEntity) { return false; } /** * If it lets you rightclick the Machine normally */ - protected boolean isGUIClickableImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean isGUIClickableImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return false; } /** * Needs to return true for Covers, which have a Redstone Output on their Facing. */ - protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, T aCoverVariable, + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return false; } @@ -758,7 +726,8 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * if this Cover should let Pipe Connections look connected even if it is not the case. */ - protected boolean alwaysLookConnectedImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, T aCoverVariable, + ICoverable aTileEntity) { return false; } @@ -766,9 +735,9 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * Called to determine the incoming Redstone Signal of a Machine. Returns the original Redstone per default. The * Cover should @letsRedstoneGoIn or the aInputRedstone Parameter is always 0. */ - protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, T aCoverVariable, + protected byte getRedstoneInputImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { - return letsRedstoneGoIn(aSide, aCoverID, aCoverVariable, aTileEntity) ? aInputRedstone : 0; + return letsRedstoneGoIn(side, aCoverID, aCoverVariable, aTileEntity) ? aInputRedstone : 0; } /** @@ -776,22 +745,22 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * 0 = No Ticks! Yes, 0 is Default, you have to override this */ - protected int getTickRateImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected int getTickRateImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return 0; } /** * The MC Color of this Lens. -1 for no Color (meaning this isn't a Lens then). */ - protected byte getLensColorImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + protected byte getLensColorImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { return -1; } /** * @return the ItemStack dropped by this Cover */ - protected ItemStack getDropImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { - return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(aSide)); + protected ItemStack getDropImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return GT_OreDictUnificator.get(true, aTileEntity.getCoverItemAtSide(side)); } // endregion @@ -801,16 +770,16 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * Checks if the Cover can be placed on this. */ - public boolean isCoverPlaceable(byte aSide, ItemStack aStack, ICoverable aTileEntity) { - return isCoverPlaceable(aSide, new GT_ItemStack(aStack), aTileEntity); + public boolean isCoverPlaceable(ForgeDirection side, ItemStack aStack, ICoverable aTileEntity) { + return isCoverPlaceable(side, new GT_ItemStack(aStack), aTileEntity); } /** * Checks if the Cover can be placed on this. You will probably want to call - * {@link #isCoverPlaceable(byte, ItemStack, ICoverable)} instead. + * {@link #isCoverPlaceable(ForgeDirection, ItemStack, ICoverable)} instead. */ @Deprecated - public boolean isCoverPlaceable(byte aSide, GT_ItemStack aStack, ICoverable aTileEntity) { + public boolean isCoverPlaceable(ForgeDirection side, GT_ItemStack aStack, ICoverable aTileEntity) { return true; } @@ -823,8 +792,8 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { * <p/> * return true, if something actually happens. */ - public boolean onCoverRightclickClient(byte aSide, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, - float aZ) { + public boolean onCoverRightclickClient(ForgeDirection side, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, + float aY, float aZ) { return false; } @@ -838,8 +807,8 @@ public abstract class GT_CoverBehaviorBase<T extends ISerializableObject> { /** * sets the Cover upon placement. */ - public void placeCover(byte aSide, ItemStack aCover, ICoverable aTileEntity) { - aTileEntity.setCoverIDAtSide(aSide, GT_Utility.stackToInt(aCover)); + public void placeCover(ForgeDirection side, ItemStack aCover, ICoverable aTileEntity) { + aTileEntity.setCoverIDAtSide(side, GT_Utility.stackToInt(aCover)); } @Deprecated diff --git a/src/main/java/gregtech/api/util/GT_HatchElementBuilder.java b/src/main/java/gregtech/api/util/GT_HatchElementBuilder.java index ba9e3b9773..8565dc21f5 100644 --- a/src/main/java/gregtech/api/util/GT_HatchElementBuilder.java +++ b/src/main/java/gregtech/api/util/GT_HatchElementBuilder.java @@ -495,7 +495,7 @@ public class GT_HatchElementBuilder<T> { if (facing.offsetY == 0) break; } assert result != null; - ((IGregTechTileEntity) tileEntity).setFrontFacing((byte) result.ordinal()); + ((IGregTechTileEntity) tileEntity).setFrontFacing(result); } } return mNoStop ? PlaceResult.ACCEPT : PlaceResult.ACCEPT_STOP; diff --git a/src/main/java/gregtech/api/util/GT_Utility.java b/src/main/java/gregtech/api/util/GT_Utility.java index 91d5a90fe6..7420dc14f9 100644 --- a/src/main/java/gregtech/api/util/GT_Utility.java +++ b/src/main/java/gregtech/api/util/GT_Utility.java @@ -11,6 +11,13 @@ import static gregtech.api.enums.GT_Values.V; import static gregtech.api.enums.GT_Values.W; import static gregtech.api.enums.Materials.FLUID_MAP; import static gregtech.common.GT_UndergroundOil.undergroundOilReadInformation; +import static net.minecraftforge.common.util.ForgeDirection.DOWN; +import static net.minecraftforge.common.util.ForgeDirection.EAST; +import static net.minecraftforge.common.util.ForgeDirection.NORTH; +import static net.minecraftforge.common.util.ForgeDirection.SOUTH; +import static net.minecraftforge.common.util.ForgeDirection.UNKNOWN; +import static net.minecraftforge.common.util.ForgeDirection.UP; +import static net.minecraftforge.common.util.ForgeDirection.WEST; import java.lang.reflect.Constructor; import java.lang.reflect.Field; @@ -448,9 +455,8 @@ public class GT_Utility { return null; } - public static byte getOppositeSide(int aSide) { - return (byte) ForgeDirection.getOrientation(aSide) - .getOpposite() + public static byte getOppositeSide(ForgeDirection side) { + return (byte) side.getOpposite() .ordinal(); } @@ -501,14 +507,13 @@ public class GT_Utility { } } - public static boolean isConnectableNonInventoryPipe(Object aTileEntity, int aSide) { - if (aTileEntity == null) return false; + public static boolean isConnectableNonInventoryPipe(TileEntity tileEntity, ForgeDirection side) { + if (tileEntity == null) return false; checkAvailabilities(); - if (TE_CHECK && aTileEntity instanceof IItemDuct) return true; - if (BC_CHECK && aTileEntity instanceof buildcraft.api.transport.IPipeTile) - return ((buildcraft.api.transport.IPipeTile) aTileEntity) - .isPipeConnected(ForgeDirection.getOrientation(aSide)); - return GregTech_API.mTranslocator && aTileEntity instanceof codechicken.translocator.TileItemTranslocator; + if (TE_CHECK && tileEntity instanceof IItemDuct) return true; + if (BC_CHECK && tileEntity instanceof buildcraft.api.transport.IPipeTile pipeTile) + return pipeTile.isPipeConnected(side); + return GregTech_API.mTranslocator && tileEntity instanceof codechicken.translocator.TileItemTranslocator; } /** @@ -516,15 +521,15 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static byte moveStackIntoPipe(IInventory aTileEntity1, Object aTileEntity2, int[] aGrabSlots, int aGrabFrom, - int aPutTo, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { + public static byte moveStackIntoPipe(IInventory aTileEntity1, Object aTileEntity2, int[] aGrabSlots, + ForgeDirection fromSide, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, + byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { return moveStackIntoPipe( aTileEntity1, aTileEntity2, aGrabSlots, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -535,44 +540,44 @@ public class GT_Utility { } /** - * Moves Stack from Inv-Slot to Inv-Slot, without checking if its even allowed. + * Moves Stack from Inv-Slot to Inv-Slot, without checking if it is even allowed. * * @return the Amount of moved Items */ - public static byte moveStackIntoPipe(IInventory aTileEntity1, Object aTileEntity2, int[] aGrabSlots, int aGrabFrom, - int aPutTo, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, boolean dropItem) { - if (aTileEntity1 == null || aMaxTargetStackSize <= 0 + public static byte moveStackIntoPipe(IInventory fromInventory, Object toObject, int[] fromSlots, + ForgeDirection fromSide, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, + byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, + boolean dropItem) { + if (fromInventory == null || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMinTargetStackSize > aMaxTargetStackSize || aMaxMoveAtOnce <= 0 || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; - if (aTileEntity2 != null) { + if (toObject != null) { checkAvailabilities(); - if (TE_CHECK && aTileEntity2 instanceof IItemDuct) { - for (int aGrabSlot : aGrabSlots) { - if (listContainsItem(aFilter, aTileEntity1.getStackInSlot(aGrabSlot), true, aInvertFilter)) { + if (TE_CHECK && toObject instanceof IItemDuct itemDuct) { + for (final int aGrabSlot : fromSlots) { + if (listContainsItem(aFilter, fromInventory.getStackInSlot(aGrabSlot), true, aInvertFilter)) { if (isAllowedToTakeFromSlot( - aTileEntity1, + fromInventory, aGrabSlot, - (byte) aGrabFrom, - aTileEntity1.getStackInSlot(aGrabSlot))) { + fromSide, + fromInventory.getStackInSlot(aGrabSlot))) { if (Math.max(aMinMoveAtOnce, aMinTargetStackSize) - <= aTileEntity1.getStackInSlot(aGrabSlot).stackSize) { + <= fromInventory.getStackInSlot(aGrabSlot).stackSize) { ItemStack tStack = copyAmount( Math.min( - aTileEntity1.getStackInSlot(aGrabSlot).stackSize, + fromInventory.getStackInSlot(aGrabSlot).stackSize, Math.min(aMaxMoveAtOnce, aMaxTargetStackSize)), - aTileEntity1.getStackInSlot(aGrabSlot)); - ItemStack rStack = ((IItemDuct) aTileEntity2) - .insertItem(ForgeDirection.getOrientation(aPutTo), copyOrNull(tStack)); + fromInventory.getStackInSlot(aGrabSlot)); + ItemStack rStack = itemDuct.insertItem(putSide, copyOrNull(tStack)); byte tMovedItemCount = (byte) (tStack.stackSize - (rStack == null ? 0 : rStack.stackSize)); if (tMovedItemCount >= 1 /* Math.max(aMinMoveAtOnce, aMinTargetStackSize) */) { // ((cofh.api.transport.IItemConduit)aTileEntity2).insertItem(ForgeDirection.getOrientation(aPutTo), // copyAmount(tMovedItemCount, tStack), F); - aTileEntity1.decrStackSize(aGrabSlot, tMovedItemCount); - aTileEntity1.markDirty(); + fromInventory.decrStackSize(aGrabSlot, tMovedItemCount); + fromInventory.markDirty(); return tMovedItemCount; } } @@ -581,31 +586,27 @@ public class GT_Utility { } return 0; } - if (BC_CHECK && aTileEntity2 instanceof buildcraft.api.transport.IPipeTile) { - for (int aGrabSlot : aGrabSlots) { - if (listContainsItem(aFilter, aTileEntity1.getStackInSlot(aGrabSlot), true, aInvertFilter)) { + if (BC_CHECK && toObject instanceof buildcraft.api.transport.IPipeTile bcPipe) { + for (int fromSlot : fromSlots) { + if (listContainsItem(aFilter, fromInventory.getStackInSlot(fromSlot), true, aInvertFilter)) { if (isAllowedToTakeFromSlot( - aTileEntity1, - aGrabSlot, - (byte) aGrabFrom, - aTileEntity1.getStackInSlot(aGrabSlot))) { + fromInventory, + fromSlot, + fromSide, + fromInventory.getStackInSlot(fromSlot))) { if (Math.max(aMinMoveAtOnce, aMinTargetStackSize) - <= aTileEntity1.getStackInSlot(aGrabSlot).stackSize) { + <= fromInventory.getStackInSlot(fromSlot).stackSize) { ItemStack tStack = copyAmount( Math.min( - aTileEntity1.getStackInSlot(aGrabSlot).stackSize, + fromInventory.getStackInSlot(fromSlot).stackSize, Math.min(aMaxMoveAtOnce, aMaxTargetStackSize)), - aTileEntity1.getStackInSlot(aGrabSlot)); - byte tMovedItemCount = (byte) ((buildcraft.api.transport.IPipeTile) aTileEntity2) - .injectItem(copyOrNull(tStack), false, ForgeDirection.getOrientation(aPutTo)); + fromInventory.getStackInSlot(fromSlot)); + byte tMovedItemCount = (byte) bcPipe.injectItem(copyOrNull(tStack), false, putSide); if (tMovedItemCount >= Math.max(aMinMoveAtOnce, aMinTargetStackSize)) { - tMovedItemCount = (byte) (((buildcraft.api.transport.IPipeTile) aTileEntity2) - .injectItem( - copyAmount(tMovedItemCount, tStack), - true, - ForgeDirection.getOrientation(aPutTo))); - aTileEntity1.decrStackSize(aGrabSlot, tMovedItemCount); - aTileEntity1.markDirty(); + tMovedItemCount = (byte) (bcPipe + .injectItem(copyAmount(tMovedItemCount, tStack), true, putSide)); + fromInventory.decrStackSize(fromSlot, tMovedItemCount); + fromInventory.markDirty(); return tMovedItemCount; } } @@ -616,38 +617,37 @@ public class GT_Utility { } } - ForgeDirection tDirection = ForgeDirection.getOrientation(aGrabFrom); - if (aTileEntity1 instanceof TileEntity && tDirection != ForgeDirection.UNKNOWN - && tDirection.getOpposite() == ForgeDirection.getOrientation(aPutTo)) { - int tX = ((TileEntity) aTileEntity1).xCoord + tDirection.offsetX, - tY = ((TileEntity) aTileEntity1).yCoord + tDirection.offsetY, - tZ = ((TileEntity) aTileEntity1).zCoord + tDirection.offsetZ; - if (!hasBlockHitBox(((TileEntity) aTileEntity1).getWorldObj(), tX, tY, tZ) && dropItem) { - for (int aGrabSlot : aGrabSlots) { - if (listContainsItem(aFilter, aTileEntity1.getStackInSlot(aGrabSlot), true, aInvertFilter)) { + if (fromInventory instanceof TileEntity fromTileEntity && fromSide != ForgeDirection.UNKNOWN + && fromSide.getOpposite() == ForgeDirection.getOrientation(putSide.ordinal())) { + int tX = fromTileEntity.xCoord + fromSide.offsetX, tY = fromTileEntity.yCoord + fromSide.offsetY, + tZ = fromTileEntity.zCoord + fromSide.offsetZ; + if (!hasBlockHitBox(((TileEntity) fromInventory).getWorldObj(), tX, tY, tZ) && dropItem) { + for (final int fromSlot : fromSlots) { + if (listContainsItem(aFilter, fromInventory.getStackInSlot(fromSlot), true, aInvertFilter)) { if (isAllowedToTakeFromSlot( - aTileEntity1, - aGrabSlot, - (byte) aGrabFrom, - aTileEntity1.getStackInSlot(aGrabSlot))) { + fromInventory, + fromSlot, + fromSide, + fromInventory.getStackInSlot(fromSlot))) { if (Math.max(aMinMoveAtOnce, aMinTargetStackSize) - <= aTileEntity1.getStackInSlot(aGrabSlot).stackSize) { - ItemStack tStack = copyAmount( + <= fromInventory.getStackInSlot(fromSlot).stackSize) { + final ItemStack tStack = copyAmount( Math.min( - aTileEntity1.getStackInSlot(aGrabSlot).stackSize, + fromInventory.getStackInSlot(fromSlot).stackSize, Math.min(aMaxMoveAtOnce, aMaxTargetStackSize)), - aTileEntity1.getStackInSlot(aGrabSlot)); - EntityItem tEntity = new EntityItem( - ((TileEntity) aTileEntity1).getWorldObj(), + fromInventory.getStackInSlot(fromSlot)); + final EntityItem tEntity = new EntityItem( + ((TileEntity) fromInventory).getWorldObj(), tX + 0.5, tY + 0.5, tZ + 0.5, tStack); tEntity.motionX = tEntity.motionY = tEntity.motionZ = 0; - ((TileEntity) aTileEntity1).getWorldObj() + ((TileEntity) fromInventory).getWorldObj() .spawnEntityInWorld(tEntity); - aTileEntity1.decrStackSize(aGrabSlot, tStack.stackSize); - aTileEntity1.markDirty(); + assert tStack != null; + fromInventory.decrStackSize(fromSlot, tStack.stackSize); + fromInventory.markDirty(); return (byte) tStack.stackSize; } } @@ -667,14 +667,13 @@ public class GT_Utility { public static byte moveStackFromSlotAToSlotB(IInventory aTileEntity1, IInventory aTileEntity2, int aGrabFrom, int aPutTo, byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { if (aTileEntity1 == null || aTileEntity2 == null - || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMinTargetStackSize > aMaxTargetStackSize || aMaxMoveAtOnce <= 0 || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; ItemStack tStack1 = aTileEntity1.getStackInSlot(aGrabFrom), tStack2 = aTileEntity2.getStackInSlot(aPutTo), - tStack3 = null; + tStack3; if (tStack1 != null) { if (tStack2 != null && !areStacksEqual(tStack1, tStack2)) return 0; tStack3 = copyOrNull(tStack1); @@ -706,35 +705,27 @@ public class GT_Utility { return 0; } - public static boolean isAllowedToTakeFromSlot(IInventory aTileEntity, int aSlot, byte aSide, ItemStack aStack) { - if (ForgeDirection.getOrientation(aSide) == ForgeDirection.UNKNOWN) { - return isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 0, aStack) - || isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 1, aStack) - || isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 2, aStack) - || isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 3, aStack) - || isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 4, aStack) - || isAllowedToTakeFromSlot(aTileEntity, aSlot, (byte) 5, aStack); + public static boolean isAllowedToTakeFromSlot(IInventory aTileEntity, int aSlot, ForgeDirection side, + ItemStack aStack) { + if (side == ForgeDirection.UNKNOWN) { + return Arrays.stream(ForgeDirection.VALID_DIRECTIONS) + .anyMatch(d -> isAllowedToTakeFromSlot(aTileEntity, aSlot, d, aStack)); } - if (aTileEntity instanceof ISidedInventory) - return ((ISidedInventory) aTileEntity).canExtractItem(aSlot, aStack, aSide); + if (aTileEntity instanceof ISidedInventory sided) return sided.canExtractItem(aSlot, aStack, side.ordinal()); return true; } - public static boolean isAllowedToPutIntoSlot(IInventory aTileEntity, int aSlot, byte aSide, ItemStack aStack, - byte aMaxStackSize) { + public static boolean isAllowedToPutIntoSlot(IInventory aTileEntity, int aSlot, ForgeDirection side, + ItemStack aStack, byte aMaxStackSize) { ItemStack tStack = aTileEntity.getStackInSlot(aSlot); if (tStack != null && (!areStacksEqual(tStack, aStack) || tStack.stackSize >= tStack.getMaxStackSize())) return false; - if (ForgeDirection.getOrientation(aSide) == ForgeDirection.UNKNOWN) { - return isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 0, aStack, aMaxStackSize) - || isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 1, aStack, aMaxStackSize) - || isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 2, aStack, aMaxStackSize) - || isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 3, aStack, aMaxStackSize) - || isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 4, aStack, aMaxStackSize) - || isAllowedToPutIntoSlot(aTileEntity, aSlot, (byte) 5, aStack, aMaxStackSize); + if (side == ForgeDirection.UNKNOWN) { + return Arrays.stream(ForgeDirection.VALID_DIRECTIONS) + .anyMatch(d -> isAllowedToPutIntoSlot(aTileEntity, aSlot, d, aStack, aMaxStackSize)); } if (aTileEntity instanceof ISidedInventory - && !((ISidedInventory) aTileEntity).canInsertItem(aSlot, aStack, aSide)) return false; + && !((ISidedInventory) aTileEntity).canInsertItem(aSlot, aStack, side.ordinal())) return false; return aSlot < aTileEntity.getSizeInventory() && aTileEntity.isItemValidForSlot(aSlot, aStack); } @@ -743,14 +734,14 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static int moveMultipleItemStacks(Object aTileEntity1, Object aTileEntity2, byte aGrabFrom, byte aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aStackAmount) { + public static int moveMultipleItemStacks(Object aTileEntity1, Object aTileEntity2, ForgeDirection fromSide, + ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, + byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aStackAmount) { if (aTileEntity1 instanceof IInventory) return moveMultipleItemStacks( (IInventory) aTileEntity1, aTileEntity2, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -762,10 +753,11 @@ public class GT_Utility { return 0; } - public static int moveMultipleItemStacks(IInventory aTileEntity1, Object aTileEntity2, byte aGrabFrom, byte aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aMaxStackTransfer, boolean aDoCheckChests) { - if (aTileEntity1 == null || aMaxTargetStackSize <= 0 + public static int moveMultipleItemStacks(IInventory fromInventory, Object toObject, ForgeDirection fromSide, + ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, + byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aMaxStackTransfer, + boolean aDoCheckChests) { + if (fromInventory == null || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMaxMoveAtOnce <= 0 || aMinTargetStackSize > aMaxTargetStackSize @@ -773,19 +765,19 @@ public class GT_Utility { || aMaxStackTransfer == 0) return 0; // find where to take from - final int[] tGrabSlots = new int[aTileEntity1.getSizeInventory()]; + final int[] tGrabSlots = new int[fromInventory.getSizeInventory()]; int tGrabSlotsSize = 0; - if (aTileEntity1 instanceof ISidedInventory) { - for (int i : ((ISidedInventory) aTileEntity1).getAccessibleSlotsFromSide(aGrabFrom)) { - final ItemStack s = aTileEntity1.getStackInSlot(i); - if (s == null || !isAllowedToTakeFromSlot(aTileEntity1, i, aGrabFrom, s) + if (fromInventory instanceof ISidedInventory) { + for (int i : ((ISidedInventory) fromInventory).getAccessibleSlotsFromSide(fromSide.ordinal())) { + final ItemStack s = fromInventory.getStackInSlot(i); + if (s == null || !isAllowedToTakeFromSlot(fromInventory, i, fromSide, s) || s.stackSize < aMinMoveAtOnce || !listContainsItem(aFilter, s, true, aInvertFilter)) continue; tGrabSlots[tGrabSlotsSize++] = i; } } else { for (int i = 0; i < tGrabSlots.length; i++) { - ItemStack s = aTileEntity1.getStackInSlot(i); + ItemStack s = fromInventory.getStackInSlot(i); if (s == null || s.stackSize < aMinMoveAtOnce || !listContainsItem(aFilter, s, true, aInvertFilter)) continue; tGrabSlots[tGrabSlotsSize++] = i; @@ -795,11 +787,11 @@ public class GT_Utility { // no source, bail out if (tGrabSlotsSize == 0) { // maybe source is a double chest. check it - if (aDoCheckChests && aTileEntity1 instanceof TileEntityChest) return moveFromAdjacentChests( - (TileEntityChest) aTileEntity1, - aTileEntity2, - aGrabFrom, - aPutTo, + if (aDoCheckChests && fromInventory instanceof TileEntityChest chest) return moveFromAdjacentChests( + chest, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -811,35 +803,35 @@ public class GT_Utility { } // if target is an inventory, e.g. chest, machine, drawers... - if (aTileEntity2 instanceof IInventory tPutInventory) { + if (toObject instanceof IInventory toInventory) { // partially filled slot spare space mapping. // value is the sum of all spare space left not counting completely empty slot - final HashMap<ItemId, Integer> tPutItems = new HashMap<>(tPutInventory.getSizeInventory()); + final HashMap<ItemId, Integer> tPutItems = new HashMap<>(toInventory.getSizeInventory()); // partially filled slot contents - final HashMap<ItemId, List<ItemStack>> tPutItemStacks = new HashMap<>(tPutInventory.getSizeInventory()); + final HashMap<ItemId, List<ItemStack>> tPutItemStacks = new HashMap<>(toInventory.getSizeInventory()); // completely empty slots - final List<Integer> tPutFreeSlots = new ArrayList<>(tPutInventory.getSizeInventory()); + final List<Integer> tPutFreeSlots = new ArrayList<>(toInventory.getSizeInventory()); // find possible target slots int[] accessibleSlots = null; - if (aTileEntity2 instanceof ISidedInventory) - accessibleSlots = ((ISidedInventory) tPutInventory).getAccessibleSlotsFromSide(aPutTo); - for (int i = 0; i < tPutInventory.getSizeInventory(); i++) { + if (toObject instanceof ISidedInventory sided) + accessibleSlots = sided.getAccessibleSlotsFromSide(putSide.ordinal()); + for (int i = 0; i < toInventory.getSizeInventory(); i++) { int slot = i; if (accessibleSlots != null) { if (accessibleSlots.length <= i) break; slot = accessibleSlots[slot]; } - ItemStack s = tPutInventory.getStackInSlot(slot); + ItemStack s = toInventory.getStackInSlot(slot); if (s == null) { tPutFreeSlots.add(slot); - } else if ((s.stackSize < s.getMaxStackSize() && s.stackSize < tPutInventory.getInventoryStackLimit()) + } else if ((s.stackSize < s.getMaxStackSize() && s.stackSize < toInventory.getInventoryStackLimit()) && aMinMoveAtOnce <= s.getMaxStackSize() - s.stackSize) { ItemId sID = ItemId.createNoCopy(s); tPutItems.merge( sID, - (Math.min(s.getMaxStackSize(), tPutInventory.getInventoryStackLimit()) - s.stackSize), + (Math.min(s.getMaxStackSize(), toInventory.getInventoryStackLimit()) - s.stackSize), Integer::sum); tPutItemStacks.computeIfAbsent(sID, k -> new ArrayList<>()) .add(s); @@ -849,11 +841,11 @@ public class GT_Utility { // target completely filled, bail out if (tPutItems.isEmpty() && tPutFreeSlots.isEmpty()) { // maybe target is a double chest. check it. - if (aDoCheckChests && aTileEntity2 instanceof TileEntityChest) return moveToAdjacentChests( - aTileEntity1, - (TileEntityChest) aTileEntity2, - aGrabFrom, - aPutTo, + if (aDoCheckChests && toObject instanceof TileEntityChest chest) return moveToAdjacentChests( + fromInventory, + chest, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -872,7 +864,7 @@ public class GT_Utility { int tStackSize; do { tMovedItems = 0; - final ItemStack tGrabStack = aTileEntity1.getStackInSlot(grabSlot); + final ItemStack tGrabStack = fromInventory.getStackInSlot(grabSlot); if (tGrabStack == null) break; tStackSize = tGrabStack.stackSize; final ItemId sID = ItemId.createNoCopy(tGrabStack); @@ -891,7 +883,7 @@ public class GT_Utility { final int sToPut = Math.min( Math.min( Math.min(toPut, s.getMaxStackSize() - s.stackSize), - tPutInventory.getInventoryStackLimit() - s.stackSize), + toInventory.getInventoryStackLimit() - s.stackSize), aMaxTargetStackSize - s.stackSize); if (sToPut <= 0) continue; if (sToPut < aMinMoveAtOnce) continue; @@ -899,7 +891,7 @@ public class GT_Utility { toPut -= sToPut; s.stackSize += sToPut; if (s.stackSize == s.getMaxStackSize() - || s.stackSize == tPutInventory.getInventoryStackLimit()) { + || s.stackSize == toInventory.getInventoryStackLimit()) { // this slot is full. remove this stack from candidate list putStack.remove(i); i--; @@ -913,11 +905,11 @@ public class GT_Utility { // deduct spare space tPutItems.merge(sID, tMovedItems, (a, b) -> a.equals(b) ? null : a - b); - if (tStackSize == 0) aTileEntity1.setInventorySlotContents(grabSlot, null); + if (tStackSize == 0) fromInventory.setInventorySlotContents(grabSlot, null); else tGrabStack.stackSize = tStackSize; - aTileEntity1.markDirty(); - tPutInventory.markDirty(); + fromInventory.markDirty(); + toInventory.markDirty(); } } } @@ -926,11 +918,11 @@ public class GT_Utility { if (tStackSize > 0 && !tPutFreeSlots.isEmpty()) { for (int i = 0; i < tPutFreeSlots.size(); i++) { final int tPutSlot = tPutFreeSlots.get(i); - if (isAllowedToPutIntoSlot(tPutInventory, tPutSlot, aPutTo, tGrabStack, (byte) 64)) { + if (isAllowedToPutIntoSlot(toInventory, tPutSlot, putSide, tGrabStack, (byte) 64)) { // allowed, now do moving final int tMoved = moveStackFromSlotAToSlotB( - aTileEntity1, - tPutInventory, + fromInventory, + toInventory, grabSlot, tPutSlot, aMaxTargetStackSize, @@ -938,12 +930,12 @@ public class GT_Utility { (byte) (aMaxMoveAtOnce - tMovedItems), aMinMoveAtOnce); if (tMoved > 0) { - final ItemStack s = tPutInventory.getStackInSlot(tPutSlot); + final ItemStack s = toInventory.getStackInSlot(tPutSlot); if (s != null) { // s might be null if tPutInventory is very special, e.g. infinity chest // if s is null, we will not mark this slot as target candidate for anything final int spare = Math - .min(s.getMaxStackSize(), tPutInventory.getInventoryStackLimit()) + .min(s.getMaxStackSize(), toInventory.getInventoryStackLimit()) - s.stackSize; if (spare > 0) { final ItemId ssID = ItemId.createNoCopy(s); @@ -977,12 +969,12 @@ public class GT_Utility { } // check if source is a double chest, if yes, try move from the adjacent as well - if (aDoCheckChests && aTileEntity1 instanceof TileEntityChest) { + if (aDoCheckChests && fromInventory instanceof TileEntityChest chest) { final int tAmount = moveFromAdjacentChests( - (TileEntityChest) aTileEntity1, - aTileEntity2, - aGrabFrom, - aPutTo, + chest, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -994,12 +986,12 @@ public class GT_Utility { } // check if target is a double chest, if yes, try move to the adjacent as well - if (aDoCheckChests && aTileEntity2 instanceof TileEntityChest) { + if (aDoCheckChests && toObject instanceof TileEntityChest chest) { final int tAmount = moveToAdjacentChests( - aTileEntity1, - (TileEntityChest) aTileEntity2, - aGrabFrom, - aPutTo, + fromInventory, + chest, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1018,11 +1010,11 @@ public class GT_Utility { final int tGrabInventorySize = tGrabSlots.length; for (int i = 0; i < tGrabInventorySize; i++) { final int tMoved = moveStackIntoPipe( - aTileEntity1, - aTileEntity2, + fromInventory, + toObject, tGrabSlots, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1036,16 +1028,17 @@ public class GT_Utility { return 0; } - private static int moveToAdjacentChests(IInventory aTileEntity1, TileEntityChest aTargetChest, byte aGrabFrom, - byte aPutTo, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aMaxStackTransfer) { + private static int moveToAdjacentChests(IInventory aTileEntity1, TileEntityChest aTargetChest, + ForgeDirection fromSide, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, + byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, + int aMaxStackTransfer) { if (aTargetChest.adjacentChestChecked) { if (aTargetChest.adjacentChestXNeg != null) { return moveMultipleItemStacks( aTileEntity1, aTargetChest.adjacentChestXNeg, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1058,8 +1051,8 @@ public class GT_Utility { return moveMultipleItemStacks( aTileEntity1, aTargetChest.adjacentChestZNeg, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1072,8 +1065,8 @@ public class GT_Utility { return moveMultipleItemStacks( aTileEntity1, aTargetChest.adjacentChestXPos, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1086,8 +1079,8 @@ public class GT_Utility { return moveMultipleItemStacks( aTileEntity1, aTargetChest.adjacentChestZPos, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1101,15 +1094,16 @@ public class GT_Utility { return 0; } - private static int moveFromAdjacentChests(TileEntityChest aChest, Object aTileEntity2, byte aGrabFrom, byte aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, int aMaxStackTransfer) { - if (aChest.adjacentChestXNeg != null) { + private static int moveFromAdjacentChests(TileEntityChest fromTileEntityChest, Object toObject, + ForgeDirection fromSide, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, + byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, + int aMaxStackTransfer) { + if (fromTileEntityChest.adjacentChestXNeg != null) { return moveMultipleItemStacks( - aChest.adjacentChestXNeg, - aTileEntity2, - aGrabFrom, - aPutTo, + fromTileEntityChest.adjacentChestXNeg, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1118,12 +1112,12 @@ public class GT_Utility { aMinMoveAtOnce, aMaxStackTransfer, false); - } else if (aChest.adjacentChestZNeg != null) { + } else if (fromTileEntityChest.adjacentChestZNeg != null) { return moveMultipleItemStacks( - aChest.adjacentChestZNeg, - aTileEntity2, - aGrabFrom, - aPutTo, + fromTileEntityChest.adjacentChestZNeg, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1132,12 +1126,12 @@ public class GT_Utility { aMinMoveAtOnce, aMaxStackTransfer, false); - } else if (aChest.adjacentChestXPos != null) { + } else if (fromTileEntityChest.adjacentChestXPos != null) { return moveMultipleItemStacks( - aChest.adjacentChestXPos, - aTileEntity2, - aGrabFrom, - aPutTo, + fromTileEntityChest.adjacentChestXPos, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1146,12 +1140,12 @@ public class GT_Utility { aMinMoveAtOnce, aMaxStackTransfer, false); - } else if (aChest.adjacentChestZPos != null) { + } else if (fromTileEntityChest.adjacentChestZPos != null) { return moveMultipleItemStacks( - aChest.adjacentChestZPos, - aTileEntity2, - aGrabFrom, - aPutTo, + fromTileEntityChest.adjacentChestZPos, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1169,14 +1163,14 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static byte moveOneItemStack(Object aTileEntity1, Object aTileEntity2, byte aGrabFrom, byte aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { - if (aTileEntity1 instanceof IInventory) return moveOneItemStack( - (IInventory) aTileEntity1, - aTileEntity2, - aGrabFrom, - aPutTo, + public static byte moveOneItemStack(Object fromObject, Object toObject, ForgeDirection fromSide, + ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, + byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { + if (fromObject instanceof IInventory inv) return moveOneItemStack( + inv, + toObject, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1190,190 +1184,184 @@ public class GT_Utility { /** * This is only because I needed an additional Parameter for the Double Chest Check. */ - private static byte moveOneItemStack(IInventory aTileEntity1, Object aTileEntity2, byte aGrabFrom, byte aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, - byte aMaxMoveAtOnce, byte aMinMoveAtOnce, boolean aDoCheckChests) { - if (aTileEntity1 == null || aMaxTargetStackSize <= 0 + private static byte moveOneItemStack(IInventory fromInventory, Object toObject, ForgeDirection fromSide, + ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, + byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, boolean aDoCheckChests) { + if (fromInventory == null || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMaxMoveAtOnce <= 0 || aMinTargetStackSize > aMaxTargetStackSize || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; int[] tGrabSlots = null; - if (aTileEntity1 instanceof ISidedInventory) - tGrabSlots = ((ISidedInventory) aTileEntity1).getAccessibleSlotsFromSide(aGrabFrom); + if (fromInventory instanceof ISidedInventory) + tGrabSlots = ((ISidedInventory) fromInventory).getAccessibleSlotsFromSide(fromSide.ordinal()); if (tGrabSlots == null) { - tGrabSlots = new int[aTileEntity1.getSizeInventory()]; + tGrabSlots = new int[fromInventory.getSizeInventory()]; for (int i = 0; i < tGrabSlots.length; i++) tGrabSlots[i] = i; } - if (aTileEntity2 instanceof IInventory) { + if (toObject instanceof IInventory inv) { int[] tPutSlots = null; - if (aTileEntity2 instanceof ISidedInventory) - tPutSlots = ((ISidedInventory) aTileEntity2).getAccessibleSlotsFromSide(aPutTo); + if (toObject instanceof ISidedInventory sided) + tPutSlots = sided.getAccessibleSlotsFromSide(putSide.ordinal()); if (tPutSlots == null) { - tPutSlots = new int[((IInventory) aTileEntity2).getSizeInventory()]; + tPutSlots = new int[inv.getSizeInventory()]; for (int i = 0; i < tPutSlots.length; i++) tPutSlots[i] = i; } - for (int tGrabSlot : tGrabSlots) { + for (final int tGrabSlot : tGrabSlots) { byte tMovedItemCount = 0; - ItemStack tGrabStack = aTileEntity1.getStackInSlot(tGrabSlot); - if (listContainsItem(aFilter, tGrabStack, true, aInvertFilter)) { - if (tGrabStack.stackSize >= aMinMoveAtOnce - && isAllowedToTakeFromSlot(aTileEntity1, tGrabSlot, aGrabFrom, tGrabStack)) { - for (int tPutSlot : tPutSlots) { - if (isAllowedToPutIntoSlot( - (IInventory) aTileEntity2, + final ItemStack tGrabStack = fromInventory.getStackInSlot(tGrabSlot); + if (listContainsItem(aFilter, tGrabStack, true, aInvertFilter) + && (tGrabStack.stackSize >= aMinMoveAtOnce + && isAllowedToTakeFromSlot(fromInventory, tGrabSlot, fromSide, tGrabStack))) { + for (final int tPutSlot : tPutSlots) { + if (isAllowedToPutIntoSlot(inv, tPutSlot, putSide, tGrabStack, aMaxTargetStackSize)) { + tMovedItemCount += moveStackFromSlotAToSlotB( + fromInventory, + inv, + tGrabSlot, tPutSlot, - aPutTo, - tGrabStack, - aMaxTargetStackSize)) { - tMovedItemCount += moveStackFromSlotAToSlotB( - aTileEntity1, - (IInventory) aTileEntity2, - tGrabSlot, - tPutSlot, - aMaxTargetStackSize, - aMinTargetStackSize, - (byte) (aMaxMoveAtOnce - tMovedItemCount), - aMinMoveAtOnce); - if (tMovedItemCount >= aMaxMoveAtOnce - || (tMovedItemCount > 0 && aMaxTargetStackSize < 64)) return tMovedItemCount; - } + aMaxTargetStackSize, + aMinTargetStackSize, + (byte) (aMaxMoveAtOnce - tMovedItemCount), + aMinMoveAtOnce); + if (tMovedItemCount >= aMaxMoveAtOnce || (tMovedItemCount > 0 && aMaxTargetStackSize < 64)) + return tMovedItemCount; } } + } if (tMovedItemCount > 0) return tMovedItemCount; } - if (aDoCheckChests && aTileEntity1 instanceof TileEntityChest tTileEntity1) { - if (tTileEntity1.adjacentChestChecked) { - byte tAmount = 0; - if (tTileEntity1.adjacentChestXNeg != null) { - tAmount = moveOneItemStack( - tTileEntity1.adjacentChestXNeg, - aTileEntity2, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity1.adjacentChestZNeg != null) { - tAmount = moveOneItemStack( - tTileEntity1.adjacentChestZNeg, - aTileEntity2, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity1.adjacentChestXPos != null) { - tAmount = moveOneItemStack( - tTileEntity1.adjacentChestXPos, - aTileEntity2, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity1.adjacentChestZPos != null) { - tAmount = moveOneItemStack( - tTileEntity1.adjacentChestZPos, - aTileEntity2, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } - if (tAmount != 0) return tAmount; + if (aDoCheckChests && fromInventory instanceof TileEntityChest fromChest + && (fromChest.adjacentChestChecked)) { + byte tAmount = 0; + if (fromChest.adjacentChestXNeg != null) { + tAmount = moveOneItemStack( + fromChest.adjacentChestXNeg, + toObject, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (fromChest.adjacentChestZNeg != null) { + tAmount = moveOneItemStack( + fromChest.adjacentChestZNeg, + toObject, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (fromChest.adjacentChestXPos != null) { + tAmount = moveOneItemStack( + fromChest.adjacentChestXPos, + toObject, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (fromChest.adjacentChestZPos != null) { + tAmount = moveOneItemStack( + fromChest.adjacentChestZPos, + toObject, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); } + if (tAmount != 0) return tAmount; + } - if (aDoCheckChests && aTileEntity2 instanceof TileEntityChest tTileEntity2) { - if (tTileEntity2.adjacentChestChecked) { - byte tAmount = 0; - if (tTileEntity2.adjacentChestXNeg != null) { - tAmount = moveOneItemStack( - aTileEntity1, - tTileEntity2.adjacentChestXNeg, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity2.adjacentChestZNeg != null) { - tAmount = moveOneItemStack( - aTileEntity1, - tTileEntity2.adjacentChestZNeg, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity2.adjacentChestXPos != null) { - tAmount = moveOneItemStack( - aTileEntity1, - tTileEntity2.adjacentChestXPos, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } else if (tTileEntity2.adjacentChestZPos != null) { - tAmount = moveOneItemStack( - aTileEntity1, - tTileEntity2.adjacentChestZPos, - aGrabFrom, - aPutTo, - aFilter, - aInvertFilter, - aMaxTargetStackSize, - aMinTargetStackSize, - aMaxMoveAtOnce, - aMinMoveAtOnce, - false); - } - if (tAmount != 0) return tAmount; + if (aDoCheckChests && toObject instanceof TileEntityChest toChest && (toChest.adjacentChestChecked)) { + byte tAmount = 0; + if (toChest.adjacentChestXNeg != null) { + tAmount = moveOneItemStack( + fromInventory, + toChest.adjacentChestXNeg, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (toChest.adjacentChestZNeg != null) { + tAmount = moveOneItemStack( + fromInventory, + toChest.adjacentChestZNeg, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (toChest.adjacentChestXPos != null) { + tAmount = moveOneItemStack( + fromInventory, + toChest.adjacentChestXPos, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); + } else if (toChest.adjacentChestZPos != null) { + tAmount = moveOneItemStack( + fromInventory, + toChest.adjacentChestZPos, + fromSide, + putSide, + aFilter, + aInvertFilter, + aMaxTargetStackSize, + aMinTargetStackSize, + aMaxMoveAtOnce, + aMinMoveAtOnce, + false); } + if (tAmount != 0) return tAmount; + } } return moveStackIntoPipe( - aTileEntity1, - aTileEntity2, + fromInventory, + toObject, tGrabSlots, - aGrabFrom, - aPutTo, + fromSide, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1388,11 +1376,10 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static byte moveOneItemStackIntoSlot(Object aTileEntity1, Object aTileEntity2, byte aGrabFrom, int aPutTo, - List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, + public static byte moveOneItemStackIntoSlot(Object fromTileEntity, Object toTileEntity, ForgeDirection fromSide, + int putSlot, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { - if (aTileEntity1 == null || !(aTileEntity1 instanceof IInventory) - || aPutTo < 0 + if (fromTileEntity == null || !(fromTileEntity instanceof IInventory fromInv) || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMaxMoveAtOnce <= 0 @@ -1400,36 +1387,28 @@ public class GT_Utility { || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; int[] tGrabSlots = null; - if (aTileEntity1 instanceof ISidedInventory) - tGrabSlots = ((ISidedInventory) aTileEntity1).getAccessibleSlotsFromSide(aGrabFrom); + if (fromTileEntity instanceof ISidedInventory sided) + tGrabSlots = sided.getAccessibleSlotsFromSide(fromSide.ordinal()); if (tGrabSlots == null) { - tGrabSlots = new int[((IInventory) aTileEntity1).getSizeInventory()]; + tGrabSlots = new int[fromInv.getSizeInventory()]; for (int i = 0; i < tGrabSlots.length; i++) tGrabSlots[i] = i; } - if (aTileEntity2 instanceof IInventory) { - for (int tGrabSlot : tGrabSlots) { - if (listContainsItem( - aFilter, - ((IInventory) aTileEntity1).getStackInSlot(tGrabSlot), - true, - aInvertFilter)) { - if (isAllowedToTakeFromSlot( - (IInventory) aTileEntity1, - tGrabSlot, - aGrabFrom, - ((IInventory) aTileEntity1).getStackInSlot(tGrabSlot))) { + if (toTileEntity instanceof IInventory toInv) { + for (final int tGrabSlot : tGrabSlots) { + if (listContainsItem(aFilter, fromInv.getStackInSlot(tGrabSlot), true, aInvertFilter)) { + if (isAllowedToTakeFromSlot(fromInv, tGrabSlot, fromSide, fromInv.getStackInSlot(tGrabSlot))) { if (isAllowedToPutIntoSlot( - (IInventory) aTileEntity2, - aPutTo, - (byte) 6, - ((IInventory) aTileEntity1).getStackInSlot(tGrabSlot), + toInv, + putSlot, + ForgeDirection.UNKNOWN, + fromInv.getStackInSlot(tGrabSlot), aMaxTargetStackSize)) { byte tMovedItemCount = moveStackFromSlotAToSlotB( - (IInventory) aTileEntity1, - (IInventory) aTileEntity2, + fromInv, + toInv, tGrabSlot, - aPutTo, + putSlot, aMaxTargetStackSize, aMinTargetStackSize, aMaxMoveAtOnce, @@ -1441,12 +1420,13 @@ public class GT_Utility { } } + final ForgeDirection toSide = fromSide.getOpposite(); moveStackIntoPipe( - ((IInventory) aTileEntity1), - aTileEntity2, + fromInv, + toTileEntity, tGrabSlots, - aGrabFrom, - aPutTo, + fromSide, + ForgeDirection.UNKNOWN, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1461,28 +1441,31 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static byte moveFromSlotToSlot(IInventory aTileEntity1, IInventory aTileEntity2, int aGrabFrom, int aPutTo, + public static byte moveFromSlotToSlot(IInventory fromInv, IInventory toInv, int aGrabFrom, int aPutTo, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { - if (aTileEntity1 == null || aTileEntity2 == null + if (fromInv == null || toInv == null || aGrabFrom < 0 || aPutTo < 0 - || aMaxTargetStackSize <= 0 || aMinTargetStackSize <= 0 || aMaxMoveAtOnce <= 0 || aMinTargetStackSize > aMaxTargetStackSize || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; - if (listContainsItem(aFilter, aTileEntity1.getStackInSlot(aGrabFrom), true, aInvertFilter)) { - if (isAllowedToTakeFromSlot(aTileEntity1, aGrabFrom, (byte) 6, aTileEntity1.getStackInSlot(aGrabFrom))) { + if (listContainsItem(aFilter, fromInv.getStackInSlot(aGrabFrom), true, aInvertFilter)) { + if (isAllowedToTakeFromSlot( + fromInv, + aGrabFrom, + ForgeDirection.UNKNOWN, + fromInv.getStackInSlot(aGrabFrom))) { if (isAllowedToPutIntoSlot( - aTileEntity2, + toInv, aPutTo, - (byte) 6, - aTileEntity1.getStackInSlot(aGrabFrom), + ForgeDirection.UNKNOWN, + fromInv.getStackInSlot(aGrabFrom), aMaxTargetStackSize)) { byte tMovedItemCount = moveStackFromSlotAToSlotB( - aTileEntity1, - aTileEntity2, + fromInv, + toInv, aGrabFrom, aPutTo, aMaxTargetStackSize, @@ -1501,22 +1484,23 @@ public class GT_Utility { * * @return the Amount of moved Items */ - public static byte moveFromSlotToSide(IInventory fromTile, Object toTile, int aGrabFrom, byte aPutTo, + public static byte moveFromSlotToSide(IInventory fromTile, Object toTile, int fromSlot, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce, boolean aDoCheckChests) { - if (fromTile == null || aGrabFrom < 0 + if (fromTile == null || fromSlot < 0 || aMinTargetStackSize <= 0 || aMaxMoveAtOnce <= 0 || aMinTargetStackSize > aMaxTargetStackSize || aMinMoveAtOnce > aMaxMoveAtOnce) return 0; - if (!listContainsItem(aFilter, fromTile.getStackInSlot(aGrabFrom), true, aInvertFilter) - || !isAllowedToTakeFromSlot(fromTile, aGrabFrom, (byte) 6, fromTile.getStackInSlot(aGrabFrom))) return 0; + if (!listContainsItem(aFilter, fromTile.getStackInSlot(fromSlot), true, aInvertFilter) + || !isAllowedToTakeFromSlot(fromTile, fromSlot, ForgeDirection.UNKNOWN, fromTile.getStackInSlot(fromSlot))) + return 0; if (toTile instanceof IInventory) { int[] tPutSlots = null; - if (toTile instanceof ISidedInventory) - tPutSlots = ((ISidedInventory) toTile).getAccessibleSlotsFromSide(aPutTo); + if (toTile instanceof ISidedInventory sided) + tPutSlots = sided.getAccessibleSlotsFromSide(putSide.ordinal()); if (tPutSlots == null) { tPutSlots = new int[((IInventory) toTile).getSizeInventory()]; @@ -1524,17 +1508,17 @@ public class GT_Utility { } byte tMovedItemCount = 0; - for (int tPutSlot : tPutSlots) { + for (final int tPutSlot : tPutSlots) { if (isAllowedToPutIntoSlot( (IInventory) toTile, tPutSlot, - aPutTo, - fromTile.getStackInSlot(aGrabFrom), + putSide, + fromTile.getStackInSlot(fromSlot), aMaxTargetStackSize)) { tMovedItemCount += moveStackFromSlotAToSlotB( fromTile, (IInventory) toTile, - aGrabFrom, + fromSlot, tPutSlot, aMaxTargetStackSize, aMinTargetStackSize, @@ -1553,8 +1537,8 @@ public class GT_Utility { tMovedItemCount = moveFromSlotToSide( fromTile, tTileEntity2.adjacentChestXNeg, - aGrabFrom, - aPutTo, + fromSlot, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1566,8 +1550,8 @@ public class GT_Utility { tMovedItemCount = moveFromSlotToSide( fromTile, tTileEntity2.adjacentChestZNeg, - aGrabFrom, - aPutTo, + fromSlot, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1579,8 +1563,8 @@ public class GT_Utility { tMovedItemCount = moveFromSlotToSide( fromTile, tTileEntity2.adjacentChestXPos, - aGrabFrom, - aPutTo, + fromSlot, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1592,8 +1576,8 @@ public class GT_Utility { tMovedItemCount = moveFromSlotToSide( fromTile, tTileEntity2.adjacentChestZPos, - aGrabFrom, - aPutTo, + fromSlot, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1609,9 +1593,9 @@ public class GT_Utility { return moveStackIntoPipe( fromTile, toTile, - new int[] { aGrabFrom }, - (byte) 6, - aPutTo, + new int[] { fromSlot }, + ForgeDirection.UNKNOWN, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -1621,14 +1605,14 @@ public class GT_Utility { aDoCheckChests); } - public static byte moveFromSlotToSide(IInventory fromTile, Object toTile, int aGrabFrom, byte aPutTo, + public static byte moveFromSlotToSide(IInventory fromTile, Object toTile, int fromSlot, ForgeDirection putSide, List<ItemStack> aFilter, boolean aInvertFilter, byte aMaxTargetStackSize, byte aMinTargetStackSize, byte aMaxMoveAtOnce, byte aMinMoveAtOnce) { return moveFromSlotToSide( fromTile, toTile, - aGrabFrom, - aPutTo, + fromSlot, + putSide, aFilter, aInvertFilter, aMaxTargetStackSize, @@ -3168,7 +3152,7 @@ public class GT_Utility { } public static int getCoordinateScan(ArrayList<String> aList, EntityPlayer aPlayer, World aWorld, int aScanLevel, - int aX, int aY, int aZ, int aSide, float aClickX, float aClickY, float aClickZ) { + int aX, int aY, int aZ, ForgeDirection side, float aClickX, float aClickY, float aClickZ) { if (aList == null) return 0; ArrayList<String> tList = new ArrayList<>(); @@ -3178,6 +3162,65 @@ public class GT_Utility { final Block tBlock = aWorld.getBlock(aX, aY, aZ); + addBaseInfo(aPlayer, aWorld, aX, aY, aZ, tList, tTileEntity, tBlock); + + if (tTileEntity != null) { + rEUAmount += addFluidHandlerInfo(side, tList, tTileEntity); + + try { + if (tTileEntity instanceof ic2.api.reactor.IReactorChamber chamber) { + rEUAmount += 500; + // Redirect the rest of the scans to the reactor itself + tTileEntity = (TileEntity) chamber.getReactor(); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + rEUAmount += addReactorInfo(tList, tTileEntity); + rEUAmount += addAlignmentInfo(tList, tTileEntity); + rEUAmount += addIC2WrenchableInfo(aPlayer, tList, tTileEntity); + rEUAmount += addIC2EnergyConductorInfo(tList, tTileEntity); + rEUAmount += addIC2EnergyStorageInfo(tList, tTileEntity); + rEUAmount += addUpgradableMachineInfo(tList, tTileEntity); + rEUAmount += addMachineProgressInfo(tList, tTileEntity); + rEUAmount += addCoverableInfo(side, tList, tTileEntity); + addEnergyContainerInfo(tList, tTileEntity); + addOwnerInfo(tList, tTileEntity); + addDeviceInfo(tList, tTileEntity); + + rEUAmount += addIC2CropInfo(tList, tTileEntity); + + rEUAmount += addForestryLeavesInfo(tList, tTileEntity); + } + + final Chunk currentChunk = aWorld.getChunkFromBlockCoords(aX, aZ); + addUndergroundFluidInfo(aPlayer, tList, currentChunk); + addPollutionInfo(tList, currentChunk); + + rEUAmount += addDebuggableBlockInfo(aPlayer, aX, aY, aZ, tList, tBlock); + + final BlockScanningEvent tEvent = new BlockScanningEvent( + aWorld, + aPlayer, + aX, + aY, + aZ, + side, + aScanLevel, + tBlock, + tTileEntity, + tList, + aClickX, + aClickY, + aClickZ); + tEvent.mEUCost = rEUAmount; + MinecraftForge.EVENT_BUS.post(tEvent); + if (!tEvent.isCanceled()) aList.addAll(tList); + return tEvent.mEUCost; + } + + private static void addBaseInfo(EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, ArrayList<String> tList, + TileEntity tTileEntity, Block tBlock) { tList.add( "----- X: " + EnumChatFormatting.AQUA + formatNumbers(aX) @@ -3196,23 +3239,14 @@ public class GT_Utility { + EnumChatFormatting.RESET + " -----"); try { - if (tTileEntity instanceof IInventory) tList.add( - GT_Utility.trans("162", "Name: ") + EnumChatFormatting.BLUE - + ((IInventory) tTileEntity).getInventoryName() - + EnumChatFormatting.RESET - + GT_Utility.trans("163", " MetaData: ") - + EnumChatFormatting.AQUA - + aWorld.getBlockMetadata(aX, aY, aZ) - + EnumChatFormatting.RESET); - else tList.add( + tList.add( GT_Utility.trans("162", "Name: ") + EnumChatFormatting.BLUE - + tBlock.getUnlocalizedName() + + ((tTileEntity instanceof IInventory inv) ? inv.getInventoryName() : tBlock.getUnlocalizedName()) + EnumChatFormatting.RESET + GT_Utility.trans("163", " MetaData: ") + EnumChatFormatting.AQUA + aWorld.getBlockMetadata(aX, aY, aZ) + EnumChatFormatting.RESET); - tList.add( GT_Utility.trans("164", "Hardness: ") + EnumChatFormatting.YELLOW + tBlock.getBlockHardness(aWorld, aX, aY, aZ) @@ -3228,288 +3262,67 @@ public class GT_Utility { } catch (Throwable e) { if (D1) e.printStackTrace(GT_Log.err); } - if (tTileEntity != null) { - try { - if (tTileEntity instanceof IFluidHandler) { - rEUAmount += 500; - final FluidTankInfo[] tTanks = ((IFluidHandler) tTileEntity) - .getTankInfo(ForgeDirection.getOrientation(aSide)); - if (tTanks != null) for (byte i = 0; i < tTanks.length; i++) { - tList.add( - GT_Utility.trans("167", "Tank ") + i - + ": " - + EnumChatFormatting.GREEN - + formatNumbers((tTanks[i].fluid == null ? 0 : tTanks[i].fluid.amount)) - + EnumChatFormatting.RESET - + " L / " - + EnumChatFormatting.YELLOW - + formatNumbers(tTanks[i].capacity) - + EnumChatFormatting.RESET - + " L " - + EnumChatFormatting.GOLD - + getFluidName(tTanks[i].fluid, true) - + EnumChatFormatting.RESET); - } - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.reactor.IReactorChamber) { - rEUAmount += 500; - tTileEntity = (TileEntity) (((ic2.api.reactor.IReactorChamber) tTileEntity).getReactor()); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.reactor.IReactor) { - rEUAmount += 500; - tList.add( - GT_Utility.trans("168", "Heat: ") + EnumChatFormatting.GREEN - + formatNumbers(((ic2.api.reactor.IReactor) tTileEntity).getHeat()) - + EnumChatFormatting.RESET - + " / " - + EnumChatFormatting.YELLOW - + formatNumbers(((ic2.api.reactor.IReactor) tTileEntity).getMaxHeat()) - + EnumChatFormatting.RESET); - tList.add( - GT_Utility.trans("169", "HEM: ") + EnumChatFormatting.YELLOW - + ((ic2.api.reactor.IReactor) tTileEntity).getHeatEffectModifier() - + EnumChatFormatting.RESET - /* - * + GT_Utility.trans("170"," Base EU Output: ")/* + - * ((ic2.api.reactor.IReactor)tTileEntity).getOutput() - */ ); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IAlignmentProvider) { - final IAlignment tAlignment = ((IAlignmentProvider) tTileEntity).getAlignment(); - if (tAlignment != null) { - rEUAmount += 100; - tList.add( - GT_Utility.trans("219", "Extended Facing: ") + EnumChatFormatting.GREEN - + tAlignment.getExtendedFacing() - + EnumChatFormatting.RESET); - } - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.tile.IWrenchable) { - rEUAmount += 100; - tList.add( - GT_Utility.trans("171", "Facing: ") + EnumChatFormatting.GREEN - + ((ic2.api.tile.IWrenchable) tTileEntity).getFacing() - + EnumChatFormatting.RESET - + GT_Utility.trans("172", " / Chance: ") - + EnumChatFormatting.YELLOW - + (((ic2.api.tile.IWrenchable) tTileEntity).getWrenchDropRate() * 100) - + EnumChatFormatting.RESET - + "%"); - tList.add( - ((ic2.api.tile.IWrenchable) tTileEntity).wrenchCanRemove(aPlayer) - ? EnumChatFormatting.GREEN + GT_Utility.trans("173", "You can remove this with a Wrench") - + EnumChatFormatting.RESET - : EnumChatFormatting.RED + GT_Utility.trans("174", "You can NOT remove this with a Wrench") - + EnumChatFormatting.RESET); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.energy.tile.IEnergyConductor) { - rEUAmount += 200; - tList.add( - GT_Utility.trans("175", "Conduction Loss: ") + EnumChatFormatting.YELLOW - + ((ic2.api.energy.tile.IEnergyConductor) tTileEntity).getConductionLoss() - + EnumChatFormatting.RESET); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.tile.IEnergyStorage) { - rEUAmount += 200; - tList.add( - GT_Utility.trans("176", "Contained Energy: ") + EnumChatFormatting.YELLOW - + formatNumbers(((ic2.api.tile.IEnergyStorage) tTileEntity).getStored()) - + EnumChatFormatting.RESET - + " EU / " - + EnumChatFormatting.YELLOW - + formatNumbers(((ic2.api.tile.IEnergyStorage) tTileEntity).getCapacity()) - + EnumChatFormatting.RESET - + " EU"); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IUpgradableMachine) { - rEUAmount += 500; - if (((IUpgradableMachine) tTileEntity).hasMufflerUpgrade()) tList.add( - EnumChatFormatting.GREEN + GT_Utility.trans("177", "Has Muffler Upgrade") - + EnumChatFormatting.RESET); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IMachineProgress) { - if (((IMachineProgress) tTileEntity).isAllowedToWork()) { - tList.add(EnumChatFormatting.RED + "Disabled." + EnumChatFormatting.RESET); - } - if (((IMachineProgress) tTileEntity).wasShutdown()) { - tList.add(EnumChatFormatting.RED + "Shut down due to power loss." + EnumChatFormatting.RESET); - } - rEUAmount += 400; - int tValue = 0; - if (0 < (tValue = ((IMachineProgress) tTileEntity).getMaxProgress())) tList.add( - GT_Utility.trans("178", "Progress/Load: ") + EnumChatFormatting.GREEN - + formatNumbers(((IMachineProgress) tTileEntity).getProgress()) - + EnumChatFormatting.RESET - + " / " - + EnumChatFormatting.YELLOW - + formatNumbers(tValue) - + EnumChatFormatting.RESET); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ICoverable) { - rEUAmount += 300; - final String tString = ((ICoverable) tTileEntity).getCoverInfoAtSide((byte) aSide) - .getBehaviorDescription(); - if (tString != null && !tString.equals(E)) tList.add(tString); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IBasicEnergyContainer - && ((IBasicEnergyContainer) tTileEntity).getEUCapacity() > 0) { - tList.add( - GT_Utility.trans("179", "Max IN: ") + EnumChatFormatting.RED - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getInputVoltage()) - + " (" - + GT_Values.VN[getTier(((IBasicEnergyContainer) tTileEntity).getInputVoltage())] - + ") " - + EnumChatFormatting.RESET - + GT_Utility.trans("182", " EU at ") - + EnumChatFormatting.RED - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getInputAmperage()) - + EnumChatFormatting.RESET - + GT_Utility.trans("183", " A")); - tList.add( - GT_Utility.trans("181", "Max OUT: ") + EnumChatFormatting.RED - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getOutputVoltage()) - + " (" - + GT_Values.VN[getTier(((IBasicEnergyContainer) tTileEntity).getOutputVoltage())] - + ") " - + EnumChatFormatting.RESET - + GT_Utility.trans("182", " EU at ") - + EnumChatFormatting.RED - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getOutputAmperage()) - + EnumChatFormatting.RESET - + GT_Utility.trans("183", " A")); + } + + private static int addFluidHandlerInfo(ForgeDirection side, ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof IFluidHandler fluidHandler) { + rEUAmount += 500; + final FluidTankInfo[] tTanks = fluidHandler.getTankInfo(side); + if (tTanks != null) for (byte i = 0; i < tTanks.length; i++) { tList.add( - GT_Utility.trans("184", "Energy: ") + EnumChatFormatting.GREEN - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getStoredEU()) + GT_Utility.trans("167", "Tank ") + i + + ": " + + EnumChatFormatting.GREEN + + formatNumbers((tTanks[i].fluid == null ? 0 : tTanks[i].fluid.amount)) + EnumChatFormatting.RESET - + " EU / " + + " L / " + EnumChatFormatting.YELLOW - + formatNumbers(((IBasicEnergyContainer) tTileEntity).getEUCapacity()) + + formatNumbers(tTanks[i].capacity) + EnumChatFormatting.RESET - + " EU"); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IGregTechTileEntity) { - tList.add( - GT_Utility.trans("186", "Owned by: ") + EnumChatFormatting.BLUE - + ((IGregTechTileEntity) tTileEntity).getOwnerName() + + " L " + + EnumChatFormatting.GOLD + + getFluidName(tTanks[i].fluid, true) + EnumChatFormatting.RESET); } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof IGregTechDeviceInformation - && ((IGregTechDeviceInformation) tTileEntity).isGivingInformation()) { - tList.addAll(Arrays.asList(((IGregTechDeviceInformation) tTileEntity).getInfoData())); - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); - } - try { - if (tTileEntity instanceof ic2.api.crops.ICropTile crop) { - rEUAmount += 1000; - if (crop.getScanLevel() < 4) crop.setScanLevel((byte) 4); - if (crop.getCrop() != null) { - tList.add( - GT_Utility.trans("187", "Type -- Crop-Name: ") + crop.getCrop() - .name() - + GT_Utility.trans("188", " Growth: ") - + crop.getGrowth() - + GT_Utility.trans("189", " Gain: ") - + crop.getGain() - + GT_Utility.trans("190", " Resistance: ") - + crop.getResistance()); - } - tList.add( - GT_Utility.trans("191", "Plant -- Fertilizer: ") + crop.getNutrientStorage() - + GT_Utility.trans("192", " Water: ") - + crop.getHydrationStorage() - + GT_Utility.trans("193", " Weed-Ex: ") - + crop.getWeedExStorage() - + GT_Utility.trans("194", " Scan-Level: ") - + crop.getScanLevel()); - tList.add( - GT_Utility.trans("195", "Environment -- Nutrients: ") + crop.getNutrients() - + GT_Utility.trans("196", " Humidity: ") - + crop.getHumidity() - + GT_Utility.trans("197", " Air-Quality: ") - + crop.getAirQuality()); - if (crop.getCrop() != null) { - final StringBuilder tStringB = new StringBuilder(); - for (String tAttribute : crop.getCrop() - .attributes()) { - tStringB.append(", ") - .append(tAttribute); - } - final String tString = tStringB.toString(); - tList.add(GT_Utility.trans("198", "Attributes:") + tString.replaceFirst(",", E)); - tList.add( - GT_Utility.trans("199", "Discovered by: ") + crop.getCrop() - .discoveredBy()); - } - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } - try { - if (tTileEntity instanceof forestry.arboriculture.tiles.TileLeaves tileLeaves) { - final forestry.api.arboriculture.ITree tree = tileLeaves.getTree(); - if (tree != null) { - rEUAmount += 1000; - if (!tree.isAnalyzed()) tree.analyze(); - tree.addTooltip(tList); - } - } - } catch (Throwable e) { - if (D1) e.printStackTrace(GT_Log.err); + private static int addDebuggableBlockInfo(EntityPlayer aPlayer, int aX, int aY, int aZ, ArrayList<String> tList, + Block tBlock) { + int rEUAmount = 0; + try { + if (tBlock instanceof IDebugableBlock debugableBlock) { + rEUAmount += 500; + final ArrayList<String> temp = debugableBlock.getDebugInfo(aPlayer, aX, aY, aZ, 3); + if (temp != null) tList.addAll(temp); } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); } + return rEUAmount; + } - final Chunk currentChunk = aWorld.getChunkFromBlockCoords(aX, aZ); + private static void addPollutionInfo(ArrayList<String> tList, Chunk currentChunk) { + if (GT_Pollution.hasPollution(currentChunk)) { + tList.add( + GT_Utility.trans("202", "Pollution in Chunk: ") + EnumChatFormatting.RED + + formatNumbers(GT_Pollution.getPollution(currentChunk)) + + EnumChatFormatting.RESET + + GT_Utility.trans("203", " gibbl")); + } else { + tList.add( + EnumChatFormatting.GREEN + GT_Utility.trans("204", "No Pollution in Chunk! HAYO!") + + EnumChatFormatting.RESET); + } + } + + private static void addUndergroundFluidInfo(EntityPlayer aPlayer, ArrayList<String> tList, Chunk currentChunk) { if (aPlayer.capabilities.isCreativeMode) { final FluidStack tFluid = undergroundOilReadInformation(currentChunk); // -# to only read if (tFluid != null) tList.add( @@ -3529,47 +3342,303 @@ public class GT_Utility { + EnumChatFormatting.RESET + " L"); } - // if(aPlayer.capabilities.isCreativeMode){ - if (GT_Pollution.hasPollution(currentChunk)) { - tList.add( - GT_Utility.trans("202", "Pollution in Chunk: ") + EnumChatFormatting.RED - + formatNumbers(GT_Pollution.getPollution(currentChunk)) - + EnumChatFormatting.RESET - + GT_Utility.trans("203", " gibbl")); - } else { - tList.add( - EnumChatFormatting.GREEN + GT_Utility.trans("204", "No Pollution in Chunk! HAYO!") - + EnumChatFormatting.RESET); + } + + private static int addForestryLeavesInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof forestry.arboriculture.tiles.TileLeaves tileLeaves) { + final forestry.api.arboriculture.ITree tree = tileLeaves.getTree(); + if (tree != null) { + rEUAmount += 1000; + if (!tree.isAnalyzed()) tree.analyze(); + tree.addTooltip(tList); + } + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); } + return rEUAmount; + } + private static int addIC2CropInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ic2.api.crops.ICropTile crop) { + rEUAmount += 1000; + if (crop.getScanLevel() < 4) crop.setScanLevel((byte) 4); + if (crop.getCrop() != null) { + tList.add( + GT_Utility.trans("187", "Type -- Crop-Name: ") + crop.getCrop() + .name() + + GT_Utility.trans("188", " Growth: ") + + crop.getGrowth() + + GT_Utility.trans("189", " Gain: ") + + crop.getGain() + + GT_Utility.trans("190", " Resistance: ") + + crop.getResistance()); + } + tList.add( + GT_Utility.trans("191", "Plant -- Fertilizer: ") + crop.getNutrientStorage() + + GT_Utility.trans("192", " Water: ") + + crop.getHydrationStorage() + + GT_Utility.trans("193", " Weed-Ex: ") + + crop.getWeedExStorage() + + GT_Utility.trans("194", " Scan-Level: ") + + crop.getScanLevel()); + tList.add( + GT_Utility.trans("195", "Environment -- Nutrients: ") + crop.getNutrients() + + GT_Utility.trans("196", " Humidity: ") + + crop.getHumidity() + + GT_Utility.trans("197", " Air-Quality: ") + + crop.getAirQuality()); + if (crop.getCrop() != null) { + final StringBuilder tStringB = new StringBuilder(); + for (final String tAttribute : crop.getCrop() + .attributes()) { + tStringB.append(", ") + .append(tAttribute); + } + final String tString = tStringB.toString(); + tList.add(GT_Utility.trans("198", "Attributes:") + tString.replaceFirst(",", E)); + tList.add( + GT_Utility.trans("199", "Discovered by: ") + crop.getCrop() + .discoveredBy()); + } + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static void addDeviceInfo(ArrayList<String> tList, TileEntity tTileEntity) { + try { + if (tTileEntity instanceof IGregTechDeviceInformation info && info.isGivingInformation()) { + tList.addAll(Arrays.asList(info.getInfoData())); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + } + + private static void addOwnerInfo(ArrayList<String> tList, TileEntity tTileEntity) { try { - if (tBlock instanceof IDebugableBlock) { + if (tTileEntity instanceof IGregTechTileEntity gtTE) { + tList.add( + GT_Utility.trans("186", "Owned by: ") + EnumChatFormatting.BLUE + + gtTE.getOwnerName() + + EnumChatFormatting.RESET); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + } + + private static void addEnergyContainerInfo(ArrayList<String> tList, TileEntity tTileEntity) { + try { + if (tTileEntity instanceof IBasicEnergyContainer energyContainer && energyContainer.getEUCapacity() > 0) { + tList.add( + GT_Utility.trans("179", "Max IN: ") + EnumChatFormatting.RED + + formatNumbers(energyContainer.getInputVoltage()) + + " (" + + GT_Values.VN[getTier(energyContainer.getInputVoltage())] + + ") " + + EnumChatFormatting.RESET + + GT_Utility.trans("182", " EU at ") + + EnumChatFormatting.RED + + formatNumbers(energyContainer.getInputAmperage()) + + EnumChatFormatting.RESET + + GT_Utility.trans("183", " A")); + tList.add( + GT_Utility.trans("181", "Max OUT: ") + EnumChatFormatting.RED + + formatNumbers(energyContainer.getOutputVoltage()) + + " (" + + GT_Values.VN[getTier(energyContainer.getOutputVoltage())] + + ") " + + EnumChatFormatting.RESET + + GT_Utility.trans("182", " EU at ") + + EnumChatFormatting.RED + + formatNumbers(energyContainer.getOutputAmperage()) + + EnumChatFormatting.RESET + + GT_Utility.trans("183", " A")); + tList.add( + GT_Utility.trans("184", "Energy: ") + EnumChatFormatting.GREEN + + formatNumbers(energyContainer.getStoredEU()) + + EnumChatFormatting.RESET + + " EU / " + + EnumChatFormatting.YELLOW + + formatNumbers(energyContainer.getEUCapacity()) + + EnumChatFormatting.RESET + + " EU"); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + } + + private static int addCoverableInfo(ForgeDirection side, ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ICoverable coverable) { + rEUAmount += 300; + final String tString = coverable.getCoverInfoAtSide(side) + .getBehaviorDescription(); + if (tString != null && !tString.equals(E)) tList.add(tString); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addMachineProgressInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof IMachineProgress progress) { + if (progress.isAllowedToWork()) { + tList.add(EnumChatFormatting.RED + "Disabled." + EnumChatFormatting.RESET); + } + if (progress.wasShutdown()) { + tList.add(EnumChatFormatting.RED + "Shut down due to power loss." + EnumChatFormatting.RESET); + } + rEUAmount += 400; + int tValue = 0; + if (0 < (tValue = progress.getMaxProgress())) tList.add( + GT_Utility.trans("178", "Progress/Load: ") + EnumChatFormatting.GREEN + + formatNumbers(progress.getProgress()) + + EnumChatFormatting.RESET + + " / " + + EnumChatFormatting.YELLOW + + formatNumbers(tValue) + + EnumChatFormatting.RESET); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addUpgradableMachineInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof IUpgradableMachine upgradableMachine) { rEUAmount += 500; - final ArrayList<String> temp = ((IDebugableBlock) tBlock).getDebugInfo(aPlayer, aX, aY, aZ, 3); - if (temp != null) tList.addAll(temp); + if (upgradableMachine.hasMufflerUpgrade()) tList.add( + EnumChatFormatting.GREEN + GT_Utility.trans("177", "Has Muffler Upgrade") + + EnumChatFormatting.RESET); } } catch (Throwable e) { if (D1) e.printStackTrace(GT_Log.err); } + return rEUAmount; + } - final BlockScanningEvent tEvent = new BlockScanningEvent( - aWorld, - aPlayer, - aX, - aY, - aZ, - (byte) aSide, - aScanLevel, - tBlock, - tTileEntity, - tList, - aClickX, - aClickY, - aClickZ); - tEvent.mEUCost = rEUAmount; - MinecraftForge.EVENT_BUS.post(tEvent); - if (!tEvent.isCanceled()) aList.addAll(tList); - return tEvent.mEUCost; + private static int addIC2EnergyStorageInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ic2.api.tile.IEnergyStorage storage) { + rEUAmount += 200; + tList.add( + GT_Utility.trans("176", "Contained Energy: ") + EnumChatFormatting.YELLOW + + formatNumbers(storage.getStored()) + + EnumChatFormatting.RESET + + " EU / " + + EnumChatFormatting.YELLOW + + formatNumbers(storage.getCapacity()) + + EnumChatFormatting.RESET + + " EU"); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addIC2EnergyConductorInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ic2.api.energy.tile.IEnergyConductor conductor) { + rEUAmount += 200; + tList.add( + GT_Utility.trans("175", "Conduction Loss: ") + EnumChatFormatting.YELLOW + + conductor.getConductionLoss() + + EnumChatFormatting.RESET); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addIC2WrenchableInfo(EntityPlayer aPlayer, ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ic2.api.tile.IWrenchable wrenchable) { + rEUAmount += 100; + tList.add( + GT_Utility.trans("171", "Facing: ") + EnumChatFormatting.GREEN + + wrenchable.getFacing() + + EnumChatFormatting.RESET + + GT_Utility.trans("172", " / Chance: ") + + EnumChatFormatting.YELLOW + + (wrenchable.getWrenchDropRate() * 100) + + EnumChatFormatting.RESET + + "%"); + tList.add( + wrenchable.wrenchCanRemove(aPlayer) + ? EnumChatFormatting.GREEN + GT_Utility.trans("173", "You can remove this with a Wrench") + + EnumChatFormatting.RESET + : EnumChatFormatting.RED + GT_Utility.trans("174", "You can NOT remove this with a Wrench") + + EnumChatFormatting.RESET); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addAlignmentInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof IAlignmentProvider alignmentProvider) { + final IAlignment tAlignment = alignmentProvider.getAlignment(); + if (tAlignment != null) { + rEUAmount += 100; + tList.add( + GT_Utility.trans("219", "Extended Facing: ") + EnumChatFormatting.GREEN + + tAlignment.getExtendedFacing() + + EnumChatFormatting.RESET); + } + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; + } + + private static int addReactorInfo(ArrayList<String> tList, TileEntity tTileEntity) { + int rEUAmount = 0; + try { + if (tTileEntity instanceof ic2.api.reactor.IReactor reactor) { + rEUAmount += 500; + tList.add( + GT_Utility.trans("168", "Heat: ") + EnumChatFormatting.GREEN + + formatNumbers(reactor.getHeat()) + + EnumChatFormatting.RESET + + " / " + + EnumChatFormatting.YELLOW + + formatNumbers(reactor.getMaxHeat()) + + EnumChatFormatting.RESET); + tList.add( + GT_Utility.trans("169", "HEM: ") + EnumChatFormatting.YELLOW + + reactor.getHeatEffectModifier() + + EnumChatFormatting.RESET); + } + } catch (Throwable e) { + if (D1) e.printStackTrace(GT_Log.err); + } + return rEUAmount; } public static String trans(String aKey, String aEnglish) { @@ -3584,14 +3653,14 @@ public class GT_Utility { * @return an Array containing the X and the Y Coordinate of the clicked Point, with the top left Corner as Origin, * like on the Texture Sheet. return values should always be between [0.0F and 0.99F]. */ - public static float[] getClickedFacingCoords(byte aSide, float aX, float aY, float aZ) { - return switch (aSide) { - case 0 -> new float[] { Math.min(0.99F, Math.max(0, 1 - aX)), Math.min(0.99F, Math.max(0, aZ)) }; - case 1 -> new float[] { Math.min(0.99F, Math.max(0, aX)), Math.min(0.99F, Math.max(0, aZ)) }; - case 2 -> new float[] { Math.min(0.99F, Math.max(0, 1 - aX)), Math.min(0.99F, Math.max(0, 1 - aY)) }; - case 3 -> new float[] { Math.min(0.99F, Math.max(0, aX)), Math.min(0.99F, Math.max(0, 1 - aY)) }; - case 4 -> new float[] { Math.min(0.99F, Math.max(0, aZ)), Math.min(0.99F, Math.max(0, 1 - aY)) }; - case 5 -> new float[] { Math.min(0.99F, Math.max(0, 1 - aZ)), Math.min(0.99F, Math.max(0, 1 - aY)) }; + public static float[] getClickedFacingCoords(ForgeDirection side, float aX, float aY, float aZ) { + return switch (side) { + case DOWN -> new float[] { Math.min(0.99F, Math.max(0, 1 - aX)), Math.min(0.99F, Math.max(0, aZ)) }; + case UP -> new float[] { Math.min(0.99F, Math.max(0, aX)), Math.min(0.99F, Math.max(0, aZ)) }; + case NORTH -> new float[] { Math.min(0.99F, Math.max(0, 1 - aX)), Math.min(0.99F, Math.max(0, 1 - aY)) }; + case SOUTH -> new float[] { Math.min(0.99F, Math.max(0, aX)), Math.min(0.99F, Math.max(0, 1 - aY)) }; + case WEST -> new float[] { Math.min(0.99F, Math.max(0, aZ)), Math.min(0.99F, Math.max(0, 1 - aY)) }; + case EAST -> new float[] { Math.min(0.99F, Math.max(0, 1 - aZ)), Math.min(0.99F, Math.max(0, 1 - aY)) }; default -> new float[] { 0.5F, 0.5F }; }; } @@ -3600,56 +3669,56 @@ public class GT_Utility { * This Function determines the direction a Block gets when being Wrenched. returns -1 if invalid. Even though that * could never happen. */ - public static byte determineWrenchingSide(byte aSide, float aX, float aY, float aZ) { - byte tBack = getOppositeSide(aSide); - switch (aSide) { - case 0, 1 -> { + public static ForgeDirection determineWrenchingSide(ForgeDirection side, float aX, float aY, float aZ) { + ForgeDirection tBack = side.getOpposite(); + switch (side) { + case DOWN, UP -> { if (aX < 0.25) { if (aZ < 0.25) return tBack; if (aZ > 0.75) return tBack; - return 4; + return WEST; } if (aX > 0.75) { if (aZ < 0.25) return tBack; if (aZ > 0.75) return tBack; - return 5; + return EAST; } - if (aZ < 0.25) return 2; - if (aZ > 0.75) return 3; - return aSide; + if (aZ < 0.25) return NORTH; + if (aZ > 0.75) return SOUTH; + return side; } - case 2, 3 -> { + case NORTH, SOUTH -> { if (aX < 0.25) { if (aY < 0.25) return tBack; if (aY > 0.75) return tBack; - return 4; + return WEST; } if (aX > 0.75) { if (aY < 0.25) return tBack; if (aY > 0.75) return tBack; - return 5; + return WEST; } - if (aY < 0.25) return 0; - if (aY > 0.75) return 1; - return aSide; + if (aY < 0.25) return DOWN; + if (aY > 0.75) return UP; + return side; } - case 4, 5 -> { + case WEST, EAST -> { if (aZ < 0.25) { if (aY < 0.25) return tBack; if (aY > 0.75) return tBack; - return 2; + return NORTH; } if (aZ > 0.75) { if (aY < 0.25) return tBack; if (aY > 0.75) return tBack; - return 3; + return SOUTH; } - if (aY < 0.25) return 0; - if (aY > 0.75) return 1; - return aSide; + if (aY < 0.25) return DOWN; + if (aY > 0.75) return UP; + return side; } } - return -1; + return UNKNOWN; } private static DecimalFormat getDecimalFormat() { @@ -3759,7 +3828,7 @@ public class GT_Utility { if (aPlayer == null) return false; World aWorld = aPlayer.worldObj; BlockEvent.PlaceEvent event = ForgeEventFactory - .onPlayerBlockPlace(aPlayer, new BlockSnapshot(aWorld, aX, aY, aZ, aBlock, aMeta), ForgeDirection.UNKNOWN); + .onPlayerBlockPlace(aPlayer, new BlockSnapshot(aWorld, aX, aY, aZ, aBlock, aMeta), UNKNOWN); if (!event.isCanceled()) { if (!isSimulate) return aWorld.setBlock(aX, aY, aZ, aBlock, aMeta, 3); return true; diff --git a/src/main/java/gregtech/api/util/LightingHelper.java b/src/main/java/gregtech/api/util/LightingHelper.java index ad4e00fb7a..ad2510e937 100644 --- a/src/main/java/gregtech/api/util/LightingHelper.java +++ b/src/main/java/gregtech/api/util/LightingHelper.java @@ -14,6 +14,7 @@ import net.minecraft.block.Block; import net.minecraft.client.renderer.EntityRenderer; import net.minecraft.client.renderer.RenderBlocks; import net.minecraft.client.renderer.Tessellator; +import net.minecraftforge.common.util.ForgeDirection; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -195,7 +196,7 @@ public class LightingHelper { * @param side the side * @param rgba the primary short[] RGBA color array */ - public void setupColor(int side, short[] rgba) { + public void setupColor(ForgeDirection side, short[] rgba) { setupColor(side, getColor(rgba)); } @@ -205,9 +206,9 @@ public class LightingHelper { * @param side the side * @param hexColor the primary color */ - public void setupColor(int side, int hexColor) { + public void setupColor(ForgeDirection side, int hexColor) { Tessellator tessellator = Tessellator.instance; - float lightness = hasLightnessOverride ? lightnessOverride : LIGHTNESS[side]; + float lightness = hasLightnessOverride ? lightnessOverride : LIGHTNESS[side.ordinal()]; float[] rgb = getRGB(hexColor); if (hasColorOverride && !renderBlocks.hasOverrideBlockTexture()) { @@ -306,14 +307,14 @@ public class LightingHelper { * @see #setupLightingYPos(Block, int, int, int) * @see #setupLightingZPos(Block, int, int, int) */ - public LightingHelper setupLighting(Block block, int x, int y, int z, byte facing) { + public LightingHelper setupLighting(Block block, int x, int y, int z, ForgeDirection facing) { return switch (facing) { - case 0 -> setupLightingYNeg(block, x, y, z); - case 1 -> setupLightingYPos(block, x, y, z); - case 2 -> setupLightingZNeg(block, x, y, z); - case 3 -> setupLightingZPos(block, x, y, z); - case 4 -> setupLightingXNeg(block, x, y, z); - case 5 -> setupLightingXPos(block, x, y, z); + case DOWN -> setupLightingYNeg(block, x, y, z); + case UP -> setupLightingYPos(block, x, y, z); + case NORTH -> setupLightingZNeg(block, x, y, z); + case SOUTH -> setupLightingZPos(block, x, y, z); + case WEST -> setupLightingXNeg(block, x, y, z); + case EAST -> setupLightingXPos(block, x, y, z); default -> throw new IllegalArgumentException("Unknown side: " + facing); }; } |