From 3a2bbefb2ba5d29305c8c702cb00574ebc42b713 Mon Sep 17 00:00:00 2001 From: korneel vandamme Date: Wed, 16 Jun 2021 21:25:34 +0200 Subject: add graph network to pipes and implement it for power --- .../java/gregtech/api/graphs/GenerateNodeMap.java | 174 +++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 src/main/java/gregtech/api/graphs/GenerateNodeMap.java (limited to 'src/main/java/gregtech/api/graphs/GenerateNodeMap.java') diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java new file mode 100644 index 0000000000..c5b60471de --- /dev/null +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java @@ -0,0 +1,174 @@ +package gregtech.api.graphs; + +import gregtech.api.graphs.consumers.ConsumerNode; +import gregtech.api.graphs.paths.NodePath; +import gregtech.api.metatileentity.*; +import net.minecraft.tileentity.TileEntity; + +import java.util.ArrayList; +import java.util.HashSet; + +import static gregtech.api.util.GT_Utility.getOppositeSide; + + +//generates the node map +abstract public class GenerateNodeMap { + //clearign the node map to make sure it is gone on reset + public static void clearNodeMap(Node aNode,int aReturnNodeValue) { + if (aNode.mTileEntity instanceof BaseMetaPipeEntity) { + BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aNode.mTileEntity; + tPipe.setNode(null); + tPipe.setNodePath(null); + if (aNode.mSelfPath != null) { + aNode.mSelfPath.clearPath(); + aNode.mSelfPath = null; + } + } + for (int i = 0;i<6;i++) { + NodePath tPath = aNode.mNodePats[i]; + if (tPath != null) { + tPath.clearPath(); + aNode.mNodePats[i] = null; + } + Node tNextNode = aNode.mNeigbourNodes[i]; + if (tNextNode == null) continue; + if (tNextNode.mNodeValue != aReturnNodeValue) + clearNodeMap(tNextNode,aNode.mNodeValue); + aNode.mNeigbourNodes[i] = null; + } + } + + //gets the next node + protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, int aInvalidSide, int aNextNodeVale, + ArrayList tConsumers, HashSet tNodeMap) { + MetaPipeEntity tMetaPipe = (MetaPipeEntity) aPipe.getMetaTileEntity(); + for (byte i = 0;i<6;i++) { + if (i==aInvalidSide) { + continue; + } + TileEntity tNextTileEntity = aPipe.getTileEntityAtSide(i); + if (tNextTileEntity == null || (tMetaPipe != null && !tMetaPipe.isConnectedAtSide(i))) continue; + ArrayList tNewPipes = new ArrayList(); + Pair nextTileEntity = getNextValidTileEntity(tNextTileEntity,tNewPipes,i,tNodeMap); + if (nextTileEntity != null) { + Node tNextNode = generateNode(nextTileEntity.mTileEntity,aPipeNode,aNextNodeVale+1,tNewPipes, + nextTileEntity.mSide,tConsumers,tNodeMap); + if (tNextNode != null) { + aNextNodeVale = tNextNode.mHigestNodeValue; + aPipeNode.mHigestNodeValue = tNextNode.mHigestNodeValue; + aPipeNode.mNeigbourNodes[i] = tNextNode; + aPipeNode.mNodePats[i] = aPipeNode.mReturnPath; + } + } + } + } + + //on a valid tilentity create a new node + protected Node generateNode(TileEntity aTileEntity, Node aPreviousNode, int aNextNodeVale, ArrayList aPipes, + int aSide, ArrayList aConsumers, HashSet aNodeMap) { + if (aTileEntity.isInvalid()) return null; + int tSideOp = getOppositeSide(aSide); + int tInvalidSide = aPreviousNode == null ? -1 : tSideOp; + Node tThisNode = null; + if (isPipe(aTileEntity)){ + BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; + MetaPipeEntity tMetaPipe = (MetaPipeEntity) tPipe.getMetaTileEntity(); + int tConections = getNumberOfConections(tMetaPipe); + Node tPipeNode; + if (tConections == 1) { + tPipeNode = getEmptyNode(aNextNodeVale,tSideOp,aTileEntity,aConsumers); + if (tPipeNode == null) return null; + } else { + tPipeNode = getPipeNode(aNextNodeVale,tSideOp,aTileEntity,aConsumers); + } + tPipe.setNode(tPipeNode); + aNodeMap.add(tPipeNode); + tPipeNode.mSelfPath = getNewPath(new MetaPipeEntity[]{tMetaPipe}); + tThisNode = tPipeNode; + if (tInvalidSide>0) { + tPipeNode.mNeigbourNodes[tInvalidSide] = aPreviousNode; + tPipeNode.mNodePats[tInvalidSide] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + aPreviousNode.mReturnPath = tPipeNode.mNodePats[tInvalidSide]; + } + if (tConections > 1) + generateNextNode(tPipe,tPipeNode,tInvalidSide,aNextNodeVale,aConsumers,aNodeMap); + } else if (addConsumer(aTileEntity,tSideOp,aNextNodeVale,aConsumers)) { + ConsumerNode tConsumeNode = aConsumers.get(aConsumers.size()-1); + tConsumeNode.mNeigbourNodes[tSideOp] = aPreviousNode; + tConsumeNode.mNodePats[tSideOp] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + aPreviousNode.mReturnPath = tConsumeNode.mNodePats[tSideOp]; + tThisNode = tConsumeNode; + } + return tThisNode; + } + + //go over the pipes until we see a valid tileentity that needs a node + protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList aPipes, int aSide, HashSet aNodeMap) { + if (isPipe(aTileEntity)) { + BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; + MetaPipeEntity tMetaPipe = (MetaPipeEntity) tPipe.getMetaTileEntity(); + Node tNode = tPipe.getNode(); + if (tNode != null) { + if (aNodeMap.contains(tNode)) + return null; + } + int tConections = getNumberOfConections(tMetaPipe); + if (tConections == 2) { + int tSideOp = getOppositeSide(aSide); + for (byte i = 0;i<6;i++) { + if (i == tSideOp || !(tMetaPipe.isConnectedAtSide(i))) continue; + TileEntity tNewTileEntity = tPipe.getTileEntityAtSide(i); + if (tNewTileEntity == null) continue; + if (isPipe(tNewTileEntity)) { + aPipes.add(tMetaPipe); + return getNextValidTileEntity(tNewTileEntity,aPipes,i,aNodeMap); + } else { + return new Pair(aTileEntity,i); + } + } + } else { + return new Pair(aTileEntity,aSide); + } + } else { + return new Pair(aTileEntity,aSide); + } + return null; + } + + private class Pair { + public int mSide; + public TileEntity mTileEntity; + public Pair(TileEntity aTileEntity, int aSide) { + this.mTileEntity = aTileEntity; + this.mSide = aSide; + } + } + + //if check if the tileentity is the correct pipe + protected boolean isPipe(TileEntity aTileEntity) { + return aTileEntity instanceof BaseMetaPipeEntity; + } + //checks if the tileentity is a consumer and add to the list + abstract protected boolean addConsumer(TileEntity aTileEntity, int aSide, int aNodeValue, ArrayList aConsumers); + //get correct pathClass that you need for your node network + protected abstract NodePath getNewPath(MetaPipeEntity[] aPipes); + + //used for if you need to use death ends for somthing + //can be null + protected Node getEmptyNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + return null; + } + //get correct node type you need for your network + protected Node getPipeNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + return new Node(aNodeValue,aTileEntity,aConsumers); + } + + //get how many conections the pipe have + private static int getNumberOfConections(MetaPipeEntity aPipe) { + int tCons = 0; + for (int i = 0; i < 6; i++) { + if (aPipe.isConnectedAtSide(i)) tCons++; + } + return tCons; + } +} -- cgit From d512e0e5fd70cc6ef0555b3c089e3e6bc3b57e8b Mon Sep 17 00:00:00 2001 From: korneel vandamme Date: Mon, 21 Jun 2021 04:05:17 +0200 Subject: fix NPE/infinit loop and small refractoring --- .../java/gregtech/api/graphs/GenerateNodeMap.java | 2 +- .../api/metatileentity/BaseMetaTileEntity.java | 5 +- .../implementations/GT_MetaPipeEntity_Cable.java | 190 +-------------------- 3 files changed, 7 insertions(+), 190 deletions(-) (limited to 'src/main/java/gregtech/api/graphs/GenerateNodeMap.java') diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java index c5b60471de..d61d818dbe 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java @@ -85,7 +85,7 @@ abstract public class GenerateNodeMap { aNodeMap.add(tPipeNode); tPipeNode.mSelfPath = getNewPath(new MetaPipeEntity[]{tMetaPipe}); tThisNode = tPipeNode; - if (tInvalidSide>0) { + if (tInvalidSide>-1) { tPipeNode.mNeigbourNodes[tInvalidSide] = aPreviousNode; tPipeNode.mNodePats[tInvalidSide] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); aPreviousNode.mReturnPath = tPipeNode.mNodePats[tInvalidSide]; diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index 3cd66057de..ab93267fc3 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -94,7 +94,7 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE private String mOwnerName = ""; private UUID mOwnerUuid = GT_Utility.defaultUuid; private NBTTagCompound mRecipeStuff = new NBTTagCompound(); - private int cableUpdateDelay = 10; + private int cableUpdateDelay = 30; public boolean mWasShutdown = false; @@ -449,9 +449,6 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE mActiveEUOutputs[i] = temp; } } - if (mTickTimer == 22) { - generatePowerNodes(); - } } 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 90656e03da..b15e520da7 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 @@ -24,10 +24,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.metatileentity.BaseMetaPipeEntity; import gregtech.api.metatileentity.MetaPipeEntity; import gregtech.api.render.TextureFactory; -import gregtech.api.util.GT_CoverBehavior; -import gregtech.api.util.GT_GC_Compat; -import gregtech.api.util.GT_ModHandler; -import gregtech.api.util.GT_Utility; +import gregtech.api.util.*; import gregtech.common.GT_Client; import gregtech.common.covers.GT_Cover_SolarPanel; import ic2.api.energy.EnergyNet; @@ -164,7 +161,8 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile return 0; if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity())) return 0; - return transferElectricity(aSide, aVoltage, aAmperage, Sets.newHashSet((TileEntity) getBaseMetaTileEntity())); + HashSet nul = null; + return transferElectricity(aSide, aVoltage, aAmperage,nul); } @Override @@ -177,6 +175,8 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile public long transferElectricity(byte aSide, long aVoltage, long aAmperage, HashSet aAlreadyPassedSet) { if (!getBaseMetaTileEntity().isServerSide() || !isConnectedAtSide(aSide) && aSide != 6) return 0; BaseMetaPipeEntity tBase =(BaseMetaPipeEntity) getBaseMetaTileEntity(); + if (!(tBase.getNode() instanceof PowerNode)) + return 0; PowerNode tNode =(PowerNode) tBase.getNode(); if (tNode != null) { int tPlace = 0; @@ -194,119 +194,9 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } return PowerNodes.powerNode(tNode,null,new NodeList(tToPower),(int)aVoltage,(int)aAmperage); } - if (0< 10) { - return 0; - } - long rUsedAmperes = 0; - final IGregTechTileEntity baseMetaTile = getBaseMetaTileEntity(); - byte i = (byte)((((aSide/2)*2)+2)%6); //this bit of trickery makes sure a direction goes to the next cardinal pair. IE, NS goes to E, EW goes to U, UD goes to N. It's a lame way to make sure locally connected machines on a wire get EU first. - aVoltage -= mCableLossPerMeter; - - if (aVoltage > 0) for (byte j = 0; j < 6 && aAmperage > rUsedAmperes; j++, i=(byte)((i+1)%6) ) - if (i != aSide && isConnectedAtSide(i) && baseMetaTile.getCoverBehaviorAtSide(i).letsEnergyOut(i, baseMetaTile.getCoverIDAtSide(i), baseMetaTile.getCoverDataAtSide(i), baseMetaTile)) { - final TileEntity tTileEntity = baseMetaTile.getTileEntityAtSide(i); - - if (tTileEntity != null && aAlreadyPassedSet.add(tTileEntity)) { - final byte tSide = GT_Utility.getOppositeSide(i); - final IGregTechTileEntity tBaseMetaTile = tTileEntity instanceof IGregTechTileEntity ? ((IGregTechTileEntity) tTileEntity) : null; - final IMetaTileEntity tMeta = tBaseMetaTile != null ? tBaseMetaTile.getMetaTileEntity() : null; - - if (tMeta instanceof IMetaTileEntityCable) { - if (tBaseMetaTile.getCoverBehaviorAtSide(tSide).letsEnergyIn(tSide, tBaseMetaTile.getCoverIDAtSide(tSide), tBaseMetaTile.getCoverDataAtSide(tSide), tBaseMetaTile) && ((IGregTechTileEntity) tTileEntity).getTimer() > 50) { - rUsedAmperes += ((IMetaTileEntityCable) ((IGregTechTileEntity) tTileEntity).getMetaTileEntity()).transferElectricity(tSide, aVoltage, aAmperage - rUsedAmperes, aAlreadyPassedSet); - } - } else { - rUsedAmperes += insertEnergyInto(tTileEntity, tSide, aVoltage, aAmperage - rUsedAmperes); - } - - } - } - mTransferredVoltage = Math.max(mTransferredVoltage, aVoltage); - mTransferredAmperage += rUsedAmperes; - mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage); - mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage); - if (aVoltage > mVoltage) { - mOverheat += Math.max(100, 100 * GT_Utility.getTier(aVoltage) - GT_Utility.getTier(mVoltage)); - } - if (mTransferredAmperage > mAmperage) return aAmperage; - - // Always return amount of used amperes, used on overheat - return rUsedAmperes; - } - - - - private long insertEnergyInto(TileEntity tTileEntity, byte tSide, long aVoltage, long aAmperage) { - if (aAmperage == 0 || tTileEntity == null) return 0; - - final IGregTechTileEntity baseMetaTile = getBaseMetaTileEntity(); - final ForgeDirection tDirection = ForgeDirection.getOrientation(tSide); - - if (tTileEntity instanceof IEnergyConnected) { - return ((IEnergyConnected) tTileEntity).injectEnergyUnits(tSide, aVoltage, aAmperage); - } - - // AE2 Compat - if (GT_Mod.gregtechproxy.mAE2Integration && tTileEntity instanceof appeng.tile.powersink.IC2) { - if (((appeng.tile.powersink.IC2) tTileEntity).acceptsEnergyFrom((TileEntity) baseMetaTile, tDirection)) { - long rUsedAmperes = 0; - while (aAmperage > rUsedAmperes && ((appeng.tile.powersink.IC2)tTileEntity).getDemandedEnergy() > 0 && ((appeng.tile.powersink.IC2)tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) <= aVoltage) - rUsedAmperes++; - - return rUsedAmperes; - } - return 0; - } - - if (Loader.isModLoaded("GalacticraftCore")) { - long gc = GT_GC_Compat.insertEnergyInto(tTileEntity, aVoltage, tDirection); - if (gc != 2) - return gc; - } - - // IC2 Compat - { - final TileEntity tIc2Acceptor = (tTileEntity instanceof IEnergyTile || EnergyNet.instance == null) ? tTileEntity : - EnergyNet.instance.getTileEntity(tTileEntity.getWorldObj(), tTileEntity.xCoord, tTileEntity.yCoord, tTileEntity.zCoord); - - if (tIc2Acceptor instanceof IEnergySink && ((IEnergySink) tIc2Acceptor).acceptsEnergyFrom((TileEntity) baseMetaTile, tDirection)) { - long rUsedAmperes = 0; - while (aAmperage > rUsedAmperes && ((IEnergySink) tIc2Acceptor).getDemandedEnergy() > 0 && ((IEnergySink) tIc2Acceptor).injectEnergy(tDirection, aVoltage, aVoltage) <= aVoltage) - rUsedAmperes++; - return rUsedAmperes; - } - } - - // RF Compat - if (GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver) { - final IEnergyReceiver rfReceiver = (IEnergyReceiver) tTileEntity; - long rfOUT = aVoltage * GregTech_API.mEUtoRF / 100, rUsedAmperes = 0; - int rfOut = rfOUT > Integer.MAX_VALUE ? Integer.MAX_VALUE : (int) rfOUT; - - if (rfReceiver.receiveEnergy(tDirection, rfOut, true) == rfOut) { - rfReceiver.receiveEnergy(tDirection, rfOut, false); - rUsedAmperes++; - } - else if (rfReceiver.receiveEnergy(tDirection, rfOut, true) > 0) { - if (mRestRF == 0) { - int RFtrans = rfReceiver.receiveEnergy(tDirection, rfOut, false); - rUsedAmperes++; - mRestRF = rfOut - RFtrans; - } else { - int RFtrans = rfReceiver.receiveEnergy(tDirection, (int) mRestRF, false); - mRestRF = mRestRF - RFtrans; - } - } - if (GregTech_API.mRFExplosions && rfReceiver.getMaxEnergyStored(tDirection) < rfOut * 600) { - if (rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut); - } - return rUsedAmperes; - } - return 0; } - @Override public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { if(aBaseMetaTileEntity.isServerSide()) { @@ -315,76 +205,6 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile } } - @Override - public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { - super.onPostTick(aBaseMetaTileEntity, aTick); - if (aBaseMetaTileEntity.isServerSide()) { - - { //amp handler - long worldTick = aBaseMetaTileEntity.getWorld().getTotalWorldTime(); - int tickDiff = (int) (worldTick - lastWorldTick); - lastWorldTick = worldTick; - - if (tickDiff >= 16) for (int i = 0; i <= 14; i++) lastAmperage[i] = 0; - else { - System.arraycopy(lastAmperage, tickDiff, lastAmperage, 0, 16 - tickDiff); - for (int i = 14; i >= 0; i--) { - if (--tickDiff > 0) lastAmperage[i] = 0; - else break; - } - } - - lastAmperage[15] = mTransferredAmperage; - - if (lastAmperage[15] > mAmperage) { - int i = 0; - for (; i <= 14; i++) { - if (lastAmperage[i] < mAmperage) { - lastAmperage[15] -= (int) mAmperage - lastAmperage[i]; - lastAmperage[i] = (int)mAmperage; - if (lastAmperage[15] <= mAmperage) break; - } - } - if (lastAmperage[15] > mAmperage) { - mOverheat += 100 * (lastAmperage[15] - mAmperage); - lastAmperage[15] = (int) mAmperage; - } else if (lastAmperage[15] < mAmperage) { - lastAmperage[i] = lastAmperage[15]; - lastAmperage[15] = (int) mAmperage; - } - } - } - - if(mOverheat>=mMaxOverheat) { - //TODO someday - //int newMeta=aBaseMetaTileEntity.getMetaTileID()-6; - //if(mInsulated && - // GregTech_API.METATILEENTITIES[newMeta] instanceof GT_MetaPipeEntity_Cable && - // ((GT_MetaPipeEntity_Cable)GregTech_API.METATILEENTITIES[newMeta]).mMaterial==mMaterial && - // ((GT_MetaPipeEntity_Cable)GregTech_API.METATILEENTITIES[newMeta]).mAmperage<=mAmperage){ - // aBaseMetaTileEntity.setOnFire(); - // aBaseMetaTileEntity.setMetaTileEntity(GregTech_API.METATILEENTITIES[newMeta]); - // return; - //}else{ - aBaseMetaTileEntity.setToFire(); - //} - }else if (mOverheat>0) mOverheat--; - - mTransferredVoltageOK=mTransferredVoltage; - mTransferredVoltage=0; - mTransferredAmperageOK=mTransferredAmperage; - mTransferredAmperage = 0; - - if (aTick % 20 == 0) { - mTransferredVoltageLast20OK=mTransferredVoltageLast20; - mTransferredVoltageLast20 = 0; - mTransferredAmperageLast20OK=mTransferredAmperageLast20; - mTransferredAmperageLast20 = 0; - if (!GT_Mod.gregtechproxy.gt6Cable || mCheckConnections) checkConnections(); - } - } - } - @Override public boolean onWireCutterRightClick(byte aSide, byte aWrenchingSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { if (GT_Mod.gregtechproxy.gt6Cable && GT_ModHandler.damageOrDechargeItem(aPlayer.inventory.getCurrentItem(), 1, 500, aPlayer)) { -- cgit From 69e5bbc25bb80418c1939d897fdf0055d280837e Mon Sep 17 00:00:00 2001 From: korneel vandamme Date: Tue, 22 Jun 2021 20:42:30 +0200 Subject: change side to from int to byte --- .../java/gregtech/api/graphs/GenerateNodeMap.java | 22 +++++++++++----------- .../gregtech/api/graphs/GenerateNodeMapPower.java | 8 ++++---- .../api/graphs/consumers/ConsumerNode.java | 4 ++-- .../api/graphs/consumers/EmptyPowerConsumer.java | 2 +- .../api/graphs/consumers/NodeEnergyReceiver.java | 2 +- .../api/graphs/consumers/NodeEnergySink.java | 2 +- .../api/graphs/consumers/NodeGTBaseMetaTile.java | 4 ++-- 7 files changed, 22 insertions(+), 22 deletions(-) (limited to 'src/main/java/gregtech/api/graphs/GenerateNodeMap.java') diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java index d61d818dbe..60a820cdd1 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java @@ -39,7 +39,7 @@ abstract public class GenerateNodeMap { } //gets the next node - protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, int aInvalidSide, int aNextNodeVale, + protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, byte aInvalidSide, int aNextNodeVale, ArrayList tConsumers, HashSet tNodeMap) { MetaPipeEntity tMetaPipe = (MetaPipeEntity) aPipe.getMetaTileEntity(); for (byte i = 0;i<6;i++) { @@ -67,8 +67,8 @@ abstract public class GenerateNodeMap { protected Node generateNode(TileEntity aTileEntity, Node aPreviousNode, int aNextNodeVale, ArrayList aPipes, int aSide, ArrayList aConsumers, HashSet aNodeMap) { if (aTileEntity.isInvalid()) return null; - int tSideOp = getOppositeSide(aSide); - int tInvalidSide = aPreviousNode == null ? -1 : tSideOp; + byte tSideOp = getOppositeSide(aSide); + byte tInvalidSide = aPreviousNode == null ? -1 : tSideOp; Node tThisNode = null; if (isPipe(aTileEntity)){ BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; @@ -103,7 +103,7 @@ abstract public class GenerateNodeMap { } //go over the pipes until we see a valid tileentity that needs a node - protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList aPipes, int aSide, HashSet aNodeMap) { + protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList aPipes, byte aSide, HashSet aNodeMap) { if (isPipe(aTileEntity)) { BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; MetaPipeEntity tMetaPipe = (MetaPipeEntity) tPipe.getMetaTileEntity(); @@ -114,7 +114,7 @@ abstract public class GenerateNodeMap { } int tConections = getNumberOfConections(tMetaPipe); if (tConections == 2) { - int tSideOp = getOppositeSide(aSide); + byte tSideOp = getOppositeSide(aSide); for (byte i = 0;i<6;i++) { if (i == tSideOp || !(tMetaPipe.isConnectedAtSide(i))) continue; TileEntity tNewTileEntity = tPipe.getTileEntityAtSide(i); @@ -135,10 +135,10 @@ abstract public class GenerateNodeMap { return null; } - private class Pair { - public int mSide; + private static class Pair { + public byte mSide; public TileEntity mTileEntity; - public Pair(TileEntity aTileEntity, int aSide) { + public Pair(TileEntity aTileEntity, byte aSide) { this.mTileEntity = aTileEntity; this.mSide = aSide; } @@ -149,17 +149,17 @@ abstract public class GenerateNodeMap { return aTileEntity instanceof BaseMetaPipeEntity; } //checks if the tileentity is a consumer and add to the list - abstract protected boolean addConsumer(TileEntity aTileEntity, int aSide, int aNodeValue, ArrayList aConsumers); + abstract protected boolean addConsumer(TileEntity aTileEntity, byte aSide, int aNodeValue, ArrayList aConsumers); //get correct pathClass that you need for your node network protected abstract NodePath getNewPath(MetaPipeEntity[] aPipes); //used for if you need to use death ends for somthing //can be null - protected Node getEmptyNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + protected Node getEmptyNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList aConsumers) { return null; } //get correct node type you need for your network - protected Node getPipeNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + protected Node getPipeNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList aConsumers) { return new Node(aNodeValue,aTileEntity,aConsumers); } diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java index 41de33080c..c4b9b59a1b 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java @@ -35,22 +35,22 @@ public class GenerateNodeMapPower extends GenerateNodeMap { //used to apply voltage on death ends @Override - protected Node getEmptyNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + protected Node getEmptyNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList aConsumers) { Node tNode = new EmptyPowerConsumer(aNodeValue, aTileEntity, aSide, aConsumers); aConsumers.add((ConsumerNode) tNode); return tNode; } @Override - protected Node getPipeNode(int aNodeValue, int aSide, TileEntity aTileEntity, ArrayList aConsumers) { + protected Node getPipeNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList aConsumers) { return new PowerNode(aNodeValue, aTileEntity, aConsumers); } @Override - protected boolean addConsumer(TileEntity aTileEntity, int aSide, int aNodeValue, ArrayList aConsumers) { + protected boolean addConsumer(TileEntity aTileEntity, byte aSide, int aNodeValue, ArrayList aConsumers) { if (aTileEntity instanceof BaseMetaTileEntity) { BaseMetaTileEntity tBaseTileEntity = (BaseMetaTileEntity) aTileEntity; - if (tBaseTileEntity.inputEnergyFrom((byte) aSide,false)) { + if (tBaseTileEntity.inputEnergyFrom(aSide,false)) { ConsumerNode tConsumerNode = new NodeGTBaseMetaTile(aNodeValue,tBaseTileEntity, aSide, aConsumers); aConsumers.add(tConsumerNode); return true; diff --git a/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java b/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java index 74aa14f5c9..d2be4d94f1 100644 --- a/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java +++ b/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java @@ -7,8 +7,8 @@ import java.util.ArrayList; //node atached to a tileentity that can consume stuff from the network public class ConsumerNode extends Node { - public int mSide; - public ConsumerNode(int aNodeValue, TileEntity aTileEntity, int aSide, ArrayList aConsumers) { + public byte mSide; + public ConsumerNode(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList aConsumers) { super(aNodeValue,aTileEntity,aConsumers); this.mSide = aSide; } diff --git a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java index 4961e77daf..47e3bca144 100644 --- a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java +++ b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java @@ -8,7 +8,7 @@ import java.util.ArrayList; //this is here to aply voltage to death ends public class EmptyPowerConsumer extends ConsumerNode{ - public EmptyPowerConsumer(int aNodeValue, TileEntity aTileEntity, int aSide, ArrayList aConsumers) { + public EmptyPowerConsumer(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList aConsumers) { super(aNodeValue, aTileEntity, aSide, aConsumers); } diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java index a4ff9c62d8..ec25578e8e 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java @@ -17,7 +17,7 @@ import static gregtech.api.enums.GT_Values.V; //consumer for RF machines public class NodeEnergyReceiver extends ConsumerNode { - public NodeEnergyReceiver(int aNodeValue, IEnergyReceiver aTileEntity, int aSide, ArrayList aConsumers) { + public NodeEnergyReceiver(int aNodeValue, IEnergyReceiver aTileEntity, byte aSide, ArrayList aConsumers) { super(aNodeValue, (TileEntity) aTileEntity, aSide, aConsumers); } diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java index e315c75d9f..db9f383492 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java @@ -8,7 +8,7 @@ import java.util.ArrayList; //consumer for IC2 machines public class NodeEnergySink extends ConsumerNode { - public NodeEnergySink(int nodeValue, IEnergySink tileEntity, int side, ArrayList consumers) { + public NodeEnergySink(int nodeValue, IEnergySink tileEntity, byte side, ArrayList consumers) { super(nodeValue, (TileEntity) tileEntity, side, consumers); } diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java b/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java index 1eb562ff68..dbcc3c3b62 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java @@ -6,13 +6,13 @@ import java.util.ArrayList; //consumer for gt machines public class NodeGTBaseMetaTile extends ConsumerNode { - public NodeGTBaseMetaTile(int aNodeValue, BaseMetaTileEntity aTileEntity, int aSide, ArrayList aConsumers) { + public NodeGTBaseMetaTile(int aNodeValue, BaseMetaTileEntity aTileEntity, byte aSide, ArrayList aConsumers) { super(aNodeValue, aTileEntity, aSide, aConsumers); } @Override public int injectEnergy(int aVoltage, int aMaxApms) { - return (int)((IEnergyConnected) mTileEntity).injectEnergyUnits((byte) mSide,aVoltage, aMaxApms); + return (int)((IEnergyConnected) mTileEntity).injectEnergyUnits(mSide,aVoltage, aMaxApms); } @Override -- cgit From a45737253c61e5e2d51ac868b698baadd57b397f Mon Sep 17 00:00:00 2001 From: Glease <4586901+Glease@users.noreply.github.com> Date: Sat, 3 Jul 2021 02:27:44 +0800 Subject: fix typos in enet implementation Signed-off-by: Glease <4586901+Glease@users.noreply.github.com> --- .../java/gregtech/api/graphs/GenerateNodeMap.java | 68 +++++++++++----------- .../gregtech/api/graphs/GenerateNodeMapPower.java | 2 +- src/main/java/gregtech/api/graphs/Node.java | 10 ++-- src/main/java/gregtech/api/graphs/NodeList.java | 12 ++-- src/main/java/gregtech/api/graphs/PowerNodes.java | 44 +++++++------- .../api/graphs/consumers/ConsumerNode.java | 4 +- .../api/graphs/consumers/EmptyPowerConsumer.java | 4 +- .../api/graphs/consumers/NodeEnergyReceiver.java | 4 +- .../api/graphs/consumers/NodeEnergySink.java | 4 +- .../api/graphs/consumers/NodeGTBaseMetaTile.java | 4 +- .../gregtech/api/graphs/paths/PowerNodePath.java | 4 +- .../api/metatileentity/BaseMetaPipeEntity.java | 6 +- .../api/threads/GT_Runnable_Cable_Update.java | 6 +- 13 files changed, 85 insertions(+), 87 deletions(-) (limited to 'src/main/java/gregtech/api/graphs/GenerateNodeMap.java') diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java index 60a820cdd1..98c8215fc7 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMap.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMap.java @@ -13,7 +13,7 @@ import static gregtech.api.util.GT_Utility.getOppositeSide; //generates the node map abstract public class GenerateNodeMap { - //clearign the node map to make sure it is gone on reset + //clearing the node map to make sure it is gone on reset public static void clearNodeMap(Node aNode,int aReturnNodeValue) { if (aNode.mTileEntity instanceof BaseMetaPipeEntity) { BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aNode.mTileEntity; @@ -25,21 +25,21 @@ abstract public class GenerateNodeMap { } } for (int i = 0;i<6;i++) { - NodePath tPath = aNode.mNodePats[i]; + NodePath tPath = aNode.mNodePaths[i]; if (tPath != null) { tPath.clearPath(); - aNode.mNodePats[i] = null; + aNode.mNodePaths[i] = null; } - Node tNextNode = aNode.mNeigbourNodes[i]; + Node tNextNode = aNode.mNeighbourNodes[i]; if (tNextNode == null) continue; if (tNextNode.mNodeValue != aReturnNodeValue) clearNodeMap(tNextNode,aNode.mNodeValue); - aNode.mNeigbourNodes[i] = null; + aNode.mNeighbourNodes[i] = null; } } //gets the next node - protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, byte aInvalidSide, int aNextNodeVale, + protected void generateNextNode(BaseMetaPipeEntity aPipe, Node aPipeNode, byte aInvalidSide, int aNextNodeValue, ArrayList tConsumers, HashSet tNodeMap) { MetaPipeEntity tMetaPipe = (MetaPipeEntity) aPipe.getMetaTileEntity(); for (byte i = 0;i<6;i++) { @@ -51,20 +51,20 @@ abstract public class GenerateNodeMap { ArrayList tNewPipes = new ArrayList(); Pair nextTileEntity = getNextValidTileEntity(tNextTileEntity,tNewPipes,i,tNodeMap); if (nextTileEntity != null) { - Node tNextNode = generateNode(nextTileEntity.mTileEntity,aPipeNode,aNextNodeVale+1,tNewPipes, + Node tNextNode = generateNode(nextTileEntity.mTileEntity,aPipeNode,aNextNodeValue+1,tNewPipes, nextTileEntity.mSide,tConsumers,tNodeMap); if (tNextNode != null) { - aNextNodeVale = tNextNode.mHigestNodeValue; - aPipeNode.mHigestNodeValue = tNextNode.mHigestNodeValue; - aPipeNode.mNeigbourNodes[i] = tNextNode; - aPipeNode.mNodePats[i] = aPipeNode.mReturnPath; + aNextNodeValue = tNextNode.mHighestNodeValue; + aPipeNode.mHighestNodeValue = tNextNode.mHighestNodeValue; + aPipeNode.mNeighbourNodes[i] = tNextNode; + aPipeNode.mNodePaths[i] = aPipeNode.mReturnPath; } } } } - //on a valid tilentity create a new node - protected Node generateNode(TileEntity aTileEntity, Node aPreviousNode, int aNextNodeVale, ArrayList aPipes, + //on a valid tile entity create a new node + protected Node generateNode(TileEntity aTileEntity, Node aPreviousNode, int aNextNodeValue, ArrayList aPipes, int aSide, ArrayList aConsumers, HashSet aNodeMap) { if (aTileEntity.isInvalid()) return null; byte tSideOp = getOppositeSide(aSide); @@ -73,36 +73,36 @@ abstract public class GenerateNodeMap { if (isPipe(aTileEntity)){ BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; MetaPipeEntity tMetaPipe = (MetaPipeEntity) tPipe.getMetaTileEntity(); - int tConections = getNumberOfConections(tMetaPipe); + int tConnections = getNumberOfConnections(tMetaPipe); Node tPipeNode; - if (tConections == 1) { - tPipeNode = getEmptyNode(aNextNodeVale,tSideOp,aTileEntity,aConsumers); + if (tConnections == 1) { + tPipeNode = getEmptyNode(aNextNodeValue,tSideOp,aTileEntity,aConsumers); if (tPipeNode == null) return null; } else { - tPipeNode = getPipeNode(aNextNodeVale,tSideOp,aTileEntity,aConsumers); + tPipeNode = getPipeNode(aNextNodeValue,tSideOp,aTileEntity,aConsumers); } tPipe.setNode(tPipeNode); aNodeMap.add(tPipeNode); tPipeNode.mSelfPath = getNewPath(new MetaPipeEntity[]{tMetaPipe}); tThisNode = tPipeNode; if (tInvalidSide>-1) { - tPipeNode.mNeigbourNodes[tInvalidSide] = aPreviousNode; - tPipeNode.mNodePats[tInvalidSide] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); - aPreviousNode.mReturnPath = tPipeNode.mNodePats[tInvalidSide]; + tPipeNode.mNeighbourNodes[tInvalidSide] = aPreviousNode; + tPipeNode.mNodePaths[tInvalidSide] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + aPreviousNode.mReturnPath = tPipeNode.mNodePaths[tInvalidSide]; } - if (tConections > 1) - generateNextNode(tPipe,tPipeNode,tInvalidSide,aNextNodeVale,aConsumers,aNodeMap); - } else if (addConsumer(aTileEntity,tSideOp,aNextNodeVale,aConsumers)) { + if (tConnections > 1) + generateNextNode(tPipe,tPipeNode,tInvalidSide,aNextNodeValue,aConsumers,aNodeMap); + } else if (addConsumer(aTileEntity,tSideOp,aNextNodeValue,aConsumers)) { ConsumerNode tConsumeNode = aConsumers.get(aConsumers.size()-1); - tConsumeNode.mNeigbourNodes[tSideOp] = aPreviousNode; - tConsumeNode.mNodePats[tSideOp] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); - aPreviousNode.mReturnPath = tConsumeNode.mNodePats[tSideOp]; + tConsumeNode.mNeighbourNodes[tSideOp] = aPreviousNode; + tConsumeNode.mNodePaths[tSideOp] = getNewPath(aPipes.toArray(new MetaPipeEntity[0])); + aPreviousNode.mReturnPath = tConsumeNode.mNodePaths[tSideOp]; tThisNode = tConsumeNode; } return tThisNode; } - //go over the pipes until we see a valid tileentity that needs a node + //go over the pipes until we see a valid tile entity that needs a node protected Pair getNextValidTileEntity(TileEntity aTileEntity, ArrayList aPipes, byte aSide, HashSet aNodeMap) { if (isPipe(aTileEntity)) { BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) aTileEntity; @@ -112,8 +112,8 @@ abstract public class GenerateNodeMap { if (aNodeMap.contains(tNode)) return null; } - int tConections = getNumberOfConections(tMetaPipe); - if (tConections == 2) { + int tConnections = getNumberOfConnections(tMetaPipe); + if (tConnections == 2) { byte tSideOp = getOppositeSide(aSide); for (byte i = 0;i<6;i++) { if (i == tSideOp || !(tMetaPipe.isConnectedAtSide(i))) continue; @@ -144,16 +144,16 @@ abstract public class GenerateNodeMap { } } - //if check if the tileentity is the correct pipe + //if check if the tile entity is the correct pipe protected boolean isPipe(TileEntity aTileEntity) { return aTileEntity instanceof BaseMetaPipeEntity; } - //checks if the tileentity is a consumer and add to the list + //checks if the tile entity is a consumer and add to the list abstract protected boolean addConsumer(TileEntity aTileEntity, byte aSide, int aNodeValue, ArrayList aConsumers); //get correct pathClass that you need for your node network protected abstract NodePath getNewPath(MetaPipeEntity[] aPipes); - //used for if you need to use death ends for somthing + //used for if you need to use death ends for something //can be null protected Node getEmptyNode(int aNodeValue, byte aSide, TileEntity aTileEntity, ArrayList aConsumers) { return null; @@ -163,8 +163,8 @@ abstract public class GenerateNodeMap { return new Node(aNodeValue,aTileEntity,aConsumers); } - //get how many conections the pipe have - private static int getNumberOfConections(MetaPipeEntity aPipe) { + //get how many connections the pipe have + private static int getNumberOfConnections(MetaPipeEntity aPipe) { int tCons = 0; for (int i = 0; i < 6; i++) { if (aPipe.isConnectedAtSide(i)) tCons++; diff --git a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java index c4b9b59a1b..547da44050 100644 --- a/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java +++ b/src/main/java/gregtech/api/graphs/GenerateNodeMapPower.java @@ -16,7 +16,7 @@ import net.minecraftforge.common.util.ForgeDirection; import java.util.ArrayList; import java.util.HashSet; -//node map generator for power distrubution +//node map generator for power distribution public class GenerateNodeMapPower extends GenerateNodeMap { public GenerateNodeMapPower(BaseMetaPipeEntity aTileEntity) { generateNode(aTileEntity,null,1,null, diff --git a/src/main/java/gregtech/api/graphs/Node.java b/src/main/java/gregtech/api/graphs/Node.java index fed599881c..258915e473 100644 --- a/src/main/java/gregtech/api/graphs/Node.java +++ b/src/main/java/gregtech/api/graphs/Node.java @@ -12,8 +12,8 @@ public class Node { this.mNodeValue = aNodeValue; this.mTileEntity = aTileEntity; this.mConsumers = aConsumers; - mHigestNodeValue = aNodeValue; - //you dont want to generate map multiple times in the same tick + mHighestNodeValue = aNodeValue; + //you don't want to generate map multiple times in the same tick mCreationTime = MinecraftServer.getServer().getTickCounter(); } @@ -23,8 +23,8 @@ public class Node { public ArrayList mConsumers; public int mNodeValue; public final TileEntity mTileEntity; - public Node[] mNeigbourNodes = new Node[6]; - public NodePath[] mNodePats = new NodePath[6]; + public Node[] mNeighbourNodes = new Node[6]; + public NodePath[] mNodePaths = new NodePath[6]; public NodePath mReturnPath; - public int mHigestNodeValue; + public int mHighestNodeValue; } diff --git a/src/main/java/gregtech/api/graphs/NodeList.java b/src/main/java/gregtech/api/graphs/NodeList.java index 702e8446c0..36ebbc4f6f 100644 --- a/src/main/java/gregtech/api/graphs/NodeList.java +++ b/src/main/java/gregtech/api/graphs/NodeList.java @@ -1,23 +1,23 @@ package gregtech.api.graphs; -//keep track on wich node is being looked for accrouse the recursif functions +//keep track on which node is being looked for across the recursive functions public class NodeList { Node[] mNodes; - int mConter = 0; + int mCounter = 0; public NodeList(Node[] mNodes) { this.mNodes = mNodes; } Node getNextNode() { - if (++mConter < mNodes.length) - return mNodes[mConter]; + if (++mCounter < mNodes.length) + return mNodes[mCounter]; else return null; } Node getNode() { - if (mConter < mNodes.length) - return mNodes[mConter]; + if (mCounter < mNodes.length) + return mNodes[mCounter]; else return null; } diff --git a/src/main/java/gregtech/api/graphs/PowerNodes.java b/src/main/java/gregtech/api/graphs/PowerNodes.java index 39844bdd17..411d690cca 100644 --- a/src/main/java/gregtech/api/graphs/PowerNodes.java +++ b/src/main/java/gregtech/api/graphs/PowerNodes.java @@ -12,9 +12,9 @@ import gregtech.api.graphs.paths.PowerNodePath; * this network only includes nodes that have a higher value then it self so it does not know the highest known value that * the return node knows * - * with these rules we can know what a node contains the target node in its network as long the target node has a value - * more or equal then the node we are looking but is less or equal then the highest value that node knows - * this way we don't have to go over the entire network too look for it + * with these rules we can know for the target node to be in the network of a node, the target node must have a value no + * less than the node we are looking and no greater than the highest value that node knows + * this way we don't have to go over the entire network to look for it * * we also hold a list of all consumers so we can check before looking if that consumer actually needs power * and only look for nodes that actually need power @@ -27,11 +27,11 @@ public class PowerNodes { ConsumerNode tConsumer =(ConsumerNode) aConsumers.getNode(); int tLoopProtection = 0; while (tConsumer != null) { - int tTagetNodeValue = tConsumer.mNodeValue; + int tTargetNodeValue = tConsumer.mNodeValue; //if the target node has a value less then the current node - if (tTagetNodeValue < aCurrentNode.mNodeValue || tTagetNodeValue > aCurrentNode.mHigestNodeValue) { + if (tTargetNodeValue < aCurrentNode.mNodeValue || tTargetNodeValue > aCurrentNode.mHighestNodeValue) { for (int j = 0;j<6;j++) { - Node tNextNode = aCurrentNode.mNeigbourNodes[j]; + Node tNextNode = aCurrentNode.mNeighbourNodes[j]; if (tNextNode != null && tNextNode.mNodeValue < aCurrentNode.mNodeValue) { if (tNextNode.mNodeValue == tConsumer.mNodeValue) { tAmpsUsed += processNodeInject(aCurrentNode,tConsumer,j,aMaxAmps-tAmpsUsed,aVoltage,false); @@ -46,16 +46,16 @@ public class PowerNodes { } } } else { - //if the target node has a node value greater then current node vale + //if the target node has a node value greater then current node value for (int side = 5;side>-1;side--) { - Node tNextNode = aCurrentNode.mNeigbourNodes[side]; + Node tNextNode = aCurrentNode.mNeighbourNodes[side]; if (tNextNode == null) continue; - if (tNextNode.mNodeValue > aCurrentNode.mNodeValue && tNextNode.mNodeValue < tTagetNodeValue) { + if (tNextNode.mNodeValue > aCurrentNode.mNodeValue && tNextNode.mNodeValue < tTargetNodeValue) { if (tNextNode == aPreviousNode) return tAmpsUsed; tAmpsUsed += processNextNodeAbove(aCurrentNode,tNextNode,aConsumers,side,aMaxAmps-tAmpsUsed,aVoltage); tConsumer =(ConsumerNode) aConsumers.getNode(); break; - } else if (tNextNode.mNodeValue == tTagetNodeValue) { + } else if (tNextNode.mNodeValue == tTargetNodeValue) { tAmpsUsed += processNodeInject(aCurrentNode,tConsumer,side,aMaxAmps-tAmpsUsed,aVoltage,true); tConsumer =(ConsumerNode) aConsumers.getNextNode(); break; @@ -66,32 +66,32 @@ public class PowerNodes { return tAmpsUsed; } if (tLoopProtection++ > 20) { - throw new NullPointerException("infinit loop in powering nodes "); + throw new NullPointerException("infinite loop in powering nodes "); } } return tAmpsUsed; } - //checking if target node is next to it ot has a higer value then current node value - //thse functions are difrent to eayer go down or up the stack + //checking if target node is next to it or has a higher value then current node value + //these functions are different to either go down or up the stack protected static int powerNodeAbove(Node aCurrentNode, Node aPreviousNode, NodeList aConsumers, int aVoltage, int aMaxAmps) { int tAmpsUsed = 0; int tLoopProtection = 0; ConsumerNode tConsumer =(ConsumerNode) aConsumers.getNode(); while (tConsumer != null) { - int tTagetNodeValue = tConsumer.mNodeValue; - if (tTagetNodeValue > aCurrentNode.mHigestNodeValue || tTagetNodeValue < aCurrentNode.mNodeValue) { + int tTargetNodeValue = tConsumer.mNodeValue; + if (tTargetNodeValue > aCurrentNode.mHighestNodeValue || tTargetNodeValue < aCurrentNode.mNodeValue) { return tAmpsUsed; } else { for (int side = 5;side>-1;side--) { - Node tNextNode = aCurrentNode.mNeigbourNodes[side]; + Node tNextNode = aCurrentNode.mNeighbourNodes[side]; if (tNextNode == null) continue; - if (tNextNode.mNodeValue > aCurrentNode.mNodeValue && tNextNode.mNodeValue < tTagetNodeValue) { + if (tNextNode.mNodeValue > aCurrentNode.mNodeValue && tNextNode.mNodeValue < tTargetNodeValue) { if (tNextNode == aPreviousNode) return tAmpsUsed; tAmpsUsed += processNextNodeAbove(aCurrentNode,tNextNode,aConsumers,side,aMaxAmps-tAmpsUsed,aVoltage); tConsumer =(ConsumerNode) aConsumers.getNode(); break; - } else if (tNextNode.mNodeValue == tTagetNodeValue) { + } else if (tNextNode.mNodeValue == tTargetNodeValue) { tAmpsUsed += processNodeInject(aCurrentNode,tConsumer,side,aMaxAmps-tAmpsUsed,aVoltage,true); tConsumer =(ConsumerNode) aConsumers.getNextNode(); break; @@ -102,14 +102,14 @@ public class PowerNodes { return tAmpsUsed; } if (tLoopProtection++ > 20) { - throw new NullPointerException("infinit loop in powering nodes "); + throw new NullPointerException("infinite loop in powering nodes "); } } return tAmpsUsed; } protected static int processNextNode(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int aSide, int aMaxAmps, int aVoltage) { - PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePats[aSide]; + PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePaths[aSide]; PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; int tVoltLoss = 0; if (tSelfPath != null) { @@ -126,7 +126,7 @@ public class PowerNodes { } protected static int processNextNodeAbove(Node aCurrentNode, Node aNextNode, NodeList aConsumers, int aSide, int aMaxAmps, int aVoltage) { - PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePats[aSide]; + PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePaths[aSide]; PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; int tVoltLoss = 0; if (tSelfPath != null) { @@ -144,7 +144,7 @@ public class PowerNodes { protected static int processNodeInject(Node aCurrentNode, ConsumerNode aConsumer, int aSide,int aMaxAmps, int aVoltage, boolean isUp) { - PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePats[aSide]; + PowerNodePath tPath = (PowerNodePath)aCurrentNode.mNodePaths[aSide]; PowerNodePath tSelfPath = (PowerNodePath) aCurrentNode.mSelfPath; int 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 d2be4d94f1..87376008c4 100644 --- a/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java +++ b/src/main/java/gregtech/api/graphs/consumers/ConsumerNode.java @@ -5,7 +5,7 @@ import net.minecraft.tileentity.TileEntity; import java.util.ArrayList; -//node atached to a tileentity that can consume stuff from the network +//node attached to a tile entity that can consume stuff from the network public class ConsumerNode extends Node { public byte mSide; public ConsumerNode(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList aConsumers) { @@ -17,7 +17,7 @@ public class ConsumerNode extends Node { return !mTileEntity.isInvalid(); } - public int injectEnergy(int aVoltage, int aMaxApms) { + public int injectEnergy(int aVoltage, int aMaxAmps) { return 0; } } diff --git a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java index 47e3bca144..da3d0a757b 100644 --- a/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java +++ b/src/main/java/gregtech/api/graphs/consumers/EmptyPowerConsumer.java @@ -6,7 +6,7 @@ import net.minecraft.tileentity.TileEntity; import java.util.ArrayList; -//this is here to aply voltage to death ends +//this is here to apply voltage to death ends public class EmptyPowerConsumer extends ConsumerNode{ public EmptyPowerConsumer(int aNodeValue, TileEntity aTileEntity, byte aSide, ArrayList aConsumers) { super(aNodeValue, aTileEntity, aSide, aConsumers); @@ -18,7 +18,7 @@ public class EmptyPowerConsumer extends ConsumerNode{ } @Override - public int injectEnergy(int aVoltage, int aMaxApms) { + public int injectEnergy(int aVoltage, int aMaxAmps) { BaseMetaPipeEntity tPipe = (BaseMetaPipeEntity) mTileEntity; PowerNodePath tPath =(PowerNodePath) tPipe.getNodePath(); tPath.applyVoltage(aVoltage,true); diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java index ec25578e8e..c8c4c64211 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergyReceiver.java @@ -22,7 +22,7 @@ public class NodeEnergyReceiver extends ConsumerNode { } @Override - public int injectEnergy(int aVoltage, int aMaxApms) { + public int injectEnergy(int aVoltage, int aMaxAmps) { ForgeDirection tDirection = ForgeDirection.getOrientation(mSide); int rfOut = GT_Utility.safeInt(aVoltage * GregTech_API.mEUtoRF / 100); if (((IEnergyReceiver) mTileEntity).receiveEnergy(tDirection, rfOut, true) == rfOut) { @@ -36,7 +36,7 @@ public class NodeEnergyReceiver extends ConsumerNode { return 0; } - //copyed from IEnergyConnected + //copied from IEnergyConnected private void explode(int aRfOut) { if (aRfOut > 32L * GregTech_API.mEUtoRF / 100L) { int aExplosionPower = aRfOut; diff --git a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java index db9f383492..3f93c62010 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeEnergySink.java @@ -18,9 +18,9 @@ public class NodeEnergySink extends ConsumerNode { } @Override - public int injectEnergy(int aVoltage, int aMaxApms) { + public int injectEnergy(int aVoltage, int aMaxAmps) { int tUsedAmps = 0; - while (aMaxApms > tUsedAmps && ((IEnergySink) mTileEntity).getDemandedEnergy() > 0 && + while (aMaxAmps > tUsedAmps && ((IEnergySink) mTileEntity).getDemandedEnergy() > 0 && ((IEnergySink) mTileEntity).injectEnergy(ForgeDirection.getOrientation(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 dbcc3c3b62..5c54ee16f9 100644 --- a/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java +++ b/src/main/java/gregtech/api/graphs/consumers/NodeGTBaseMetaTile.java @@ -11,8 +11,8 @@ public class NodeGTBaseMetaTile extends ConsumerNode { } @Override - public int injectEnergy(int aVoltage, int aMaxApms) { - return (int)((IEnergyConnected) mTileEntity).injectEnergyUnits(mSide,aVoltage, aMaxApms); + public int injectEnergy(int aVoltage, int aMaxAmps) { + return (int)((IEnergyConnected) mTileEntity).injectEnergyUnits(mSide,aVoltage, aMaxAmps); } @Override diff --git a/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java b/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java index 1445e45734..736373a9ca 100644 --- a/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java +++ b/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java @@ -6,7 +6,7 @@ import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable; import net.minecraft.server.MinecraftServer; //path for cables -//al calculations like ams and voltage hapens here +//all calculations like amp and voltage happens here public class PowerNodePath extends NodePath { int mMaxAmps; int mAmps = 0; @@ -59,7 +59,7 @@ public class PowerNodePath extends NodePath { } //if no amps pass trough for more then 0.5 second reduce them to minimize wrong results - //but still allow the player to see if activity is hapening + //but still allow the player to see if activity is happening public int getAmps() { int tTime = MinecraftServer.getServer().getTickCounter() - 10; if (mTick < tTime) { diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java index 39cbee3aa9..b51377550b 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java @@ -283,14 +283,14 @@ public class BaseMetaPipeEntity extends BaseTileEntity implements IGregTechTileE if (!hasValidMetaTileEntity()) return; } } - byte oldConections = mConnections; - // Mask-out Connection direction bits to keep only Foam related connections + byte oldConnections = mConnections; + // Mask-out connection direction bits to keep only Foam related connections mConnections = (byte) (mMetaTileEntity.mConnections | (mConnections & ~IConnectable.CONNECTED_ALL)); // If foam not hardened, tries roll chance to harden if ((mConnections & IConnectable.HAS_FOAM) == IConnectable.HAS_FRESHFOAM && getRandomNumber(1000) == 0) { mConnections = (byte) ((mConnections & ~IConnectable.HAS_FRESHFOAM) | IConnectable.HAS_HARDENEDFOAM); } - if (mTickTimer > 12 && oldConections != mConnections) + if (mTickTimer > 12 && oldConnections != mConnections) GregTech_API.causeCableUpdate(worldObj,xCoord,yCoord,zCoord); } case 8: 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 6bc42e9cc8..7093184533 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 @@ -21,18 +21,16 @@ public class GT_Runnable_Cable_Update extends GT_Runnable_MachineBlockUpdate { } } - @Override public void run() { try { while (!tQueue.isEmpty()) { final ChunkCoordinates aCoords = tQueue.poll(); final TileEntity tTileEntity; - final boolean isMachineBlock; GT_Proxy.TICK_LOCK.lock(); try { - //we dont want to go over cables that are in unloaded chuncks + //we dont want to go over cables that are in unloaded chunks //keeping the lock just to make sure no CME happens if (world.blockExists(aCoords.posX, aCoords.posY, aCoords.posZ)) { tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); @@ -48,7 +46,7 @@ public class GT_Runnable_Cable_Update extends GT_Runnable_MachineBlockUpdate { ((IMachineBlockUpdateable) tTileEntity).onMachineBlockUpdate(); // Now see if we should add the nearby blocks to the queue: - //only add blocks wich the cable is conected too + // only add blocks the cable is connected to if (tTileEntity instanceof BaseMetaPipeEntity && ((BaseMetaPipeEntity) tTileEntity).getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable) { -- cgit