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 --- .../api/metatileentity/BaseMetaPipeEntity.java | 24 ++++++++++++ .../api/metatileentity/BaseMetaTileEntity.java | 43 ++++++++++++++++++++++ .../api/metatileentity/MetaTileEntity.java | 1 + .../implementations/GT_MetaPipeEntity_Cable.java | 42 +++++++++++++++++++-- .../GT_MetaTileEntity_Hatch_Dynamo.java | 5 +++ 5 files changed, 111 insertions(+), 4 deletions(-) (limited to 'src/main/java/gregtech/api/metatileentity') diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java index 0fd8779244..39cbee3aa9 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaPipeEntity.java @@ -12,6 +12,8 @@ import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.enums.Textures; import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.graphs.Node; +import gregtech.api.graphs.paths.NodePath; import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IConnectable; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; @@ -62,6 +64,25 @@ public class BaseMetaPipeEntity extends BaseTileEntity implements IGregTechTileE private int oX = 0, oY = 0, oZ = 0, mTimeStatisticsIndex = 0; private short mID = 0; private long mTickTimer = 0; + protected Node node; + protected NodePath nodePath; + + public Node getNode() { + return node; + } + + public void setNode(Node node) { + this.node = node; + } + + public NodePath getNodePath() { + return nodePath; + } + + public void setNodePath(NodePath nodePath) { + this.nodePath = nodePath; + } + public BaseMetaPipeEntity() { } @@ -262,12 +283,15 @@ public class BaseMetaPipeEntity extends BaseTileEntity implements IGregTechTileE if (!hasValidMetaTileEntity()) return; } } + byte oldConections = 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) + GregTech_API.causeCableUpdate(worldObj,xCoord,yCoord,zCoord); } case 8: tCode = 9; diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index f1a15aca40..3cd66057de 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -14,6 +14,9 @@ import gregtech.api.GregTech_API; import gregtech.api.enums.ItemList; import gregtech.api.enums.Textures; import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.graphs.GenerateNodeMap; +import gregtech.api.graphs.GenerateNodeMapPower; +import gregtech.api.graphs.Node; import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IEnergyConnected; @@ -40,6 +43,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagList; import net.minecraft.network.Packet; +import net.minecraft.server.MinecraftServer; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.AxisAlignedBB; import net.minecraft.util.EnumChatFormatting; @@ -90,6 +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; public boolean mWasShutdown = false; @@ -444,6 +449,9 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE mActiveEUOutputs[i] = temp; } } + if (mTickTimer == 22) { + generatePowerNodes(); + } } @@ -568,6 +576,12 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE case 15: tCode++; if (aSideServer) { + if (mTickTimer > 20 && cableUpdateDelay == 0) { + generatePowerNodes(); + cableUpdateDelay--; + } else { + cableUpdateDelay--; + } if (mTickTimer % 10 == 0) { if (mSendClientData) { NW.sendPacketToAllPlayersInRange(worldObj, @@ -869,6 +883,7 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE mMetaTileEntity.onFacingChange(); doEnetUpdate(); + cableUpdateDelay = 10; if (mMetaTileEntity.shouldTriggerBlockUpdate()) { // If we're triggering a block update this will call onMachineBlockUpdate() @@ -971,6 +986,7 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE @Override public void onMachineBlockUpdate() { if (canAccessData()) mMetaTileEntity.onMachineBlockUpdate(); + cableUpdateDelay = 10; } /** @@ -1098,6 +1114,29 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE return isEnergyOutputSide(aSide); } + public void generatePowerNodes() { + if (isServerSide() && mMetaTileEntity != null && (mMetaTileEntity.isEnetInput() || mMetaTileEntity.isEnetOutput())) { + int time = MinecraftServer.getServer().getTickCounter(); + for (byte i = 0;i<6;i++) { + if (outputsEnergyTo(i,false) || inputEnergyFrom(i,false)) { + IGregTechTileEntity TE = getIGregTechTileEntityAtSide(i); + if (TE instanceof BaseMetaPipeEntity) { + Node node = ((BaseMetaPipeEntity) TE).getNode(); + if (node == null) { + new GenerateNodeMapPower((BaseMetaPipeEntity) TE); + } else if (node.mCreationTime != time) { + GenerateNodeMap.clearNodeMap(node,-1); + new GenerateNodeMapPower((BaseMetaPipeEntity) TE); + } else { +// GenerateNodeMap.clearNodeMap(node,-1); +// new GenerateNodeMapPower((BaseMetaPipeEntity) TE); + } + } + } + } + } + } + @Override public long getOutputAmperage() { if (canAccessData() && mMetaTileEntity.isElectric()) return mMetaTileEntity.maxAmperesOut(); @@ -1399,9 +1438,11 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE if(aPlayer.isSneaking() && mMetaTileEntity instanceof GT_MetaTileEntity_BasicMachine && ((GT_MetaTileEntity_BasicMachine)mMetaTileEntity).setMainFacing(GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ))){ GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer); GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord); + cableUpdateDelay = 10; }else if (mMetaTileEntity.onWrenchRightClick(aSide, GT_Utility.determineWrenchingSide(aSide, aX, aY, aZ), aPlayer, aX, aY, aZ)) { GT_ModHandler.damageOrDechargeItem(tCurrentItem, 1, 1000, aPlayer); GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord); + cableUpdateDelay = 10; } return true; } @@ -1452,6 +1493,7 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE issueBlockUpdate(); } doEnetUpdate(); + cableUpdateDelay = 10; return true; } @@ -1462,6 +1504,7 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE GT_Utility.sendSoundToPlayers(worldObj, GregTech_API.sSoundList.get(100), 1.0F, -1, xCoord, yCoord, zCoord); } doEnetUpdate(); + cableUpdateDelay = 10; return true; } diff --git a/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java index 84790ce958..87eee3e6ac 100644 --- a/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/MetaTileEntity.java @@ -63,6 +63,7 @@ public abstract class MetaTileEntity implements IMetaTileEntity { public final ItemStack[] mInventory; public boolean doTickProfilingInThisTick = true; + /** * accessibility to this Field is no longer given, see below */ 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 93d947b9d0..90656e03da 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 @@ -9,6 +9,12 @@ import gregtech.api.enums.Dyes; import gregtech.api.enums.Materials; import gregtech.api.enums.TextureSet; import gregtech.api.enums.Textures; +import gregtech.api.graphs.PowerNode; +import gregtech.api.graphs.PowerNodes; +import gregtech.api.graphs.consumers.ConsumerNode; +import gregtech.api.graphs.Node; +import gregtech.api.graphs.NodeList; +import gregtech.api.graphs.paths.PowerNodePath; import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable; @@ -169,8 +175,28 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile @Override public long transferElectricity(byte aSide, long aVoltage, long aAmperage, HashSet aAlreadyPassedSet) { - if (!isConnectedAtSide(aSide) && aSide != 6) return 0; - + if (!getBaseMetaTileEntity().isServerSide() || !isConnectedAtSide(aSide) && aSide != 6) return 0; + BaseMetaPipeEntity tBase =(BaseMetaPipeEntity) getBaseMetaTileEntity(); + PowerNode tNode =(PowerNode) tBase.getNode(); + if (tNode != null) { + int tPlace = 0; + 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); + } + 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. @@ -506,15 +532,23 @@ public class GT_MetaPipeEntity_Cable extends MetaPipeEntity implements IMetaTile @Override public String[] getInfoData() { + BaseMetaPipeEntity base = (BaseMetaPipeEntity) getBaseMetaTileEntity(); + PowerNodePath path =(PowerNodePath) base.getNodePath(); + int amps = 0; + int volts = 0; + if (path != null) { + amps = path.getAmps(); + volts = path.getVoltage(this); + } return new String[]{ //EnumChatFormatting.BLUE + mName + EnumChatFormatting.RESET, "Heat: "+ EnumChatFormatting.RED+ mOverheat +EnumChatFormatting.RESET+" / "+EnumChatFormatting.YELLOW+ mMaxOverheat + EnumChatFormatting.RESET, "Max Load (1t):", - EnumChatFormatting.GREEN + Integer.toString(mTransferredAmperageOK) + EnumChatFormatting.RESET +" A / "+ + EnumChatFormatting.GREEN + Integer.toString(amps) + EnumChatFormatting.RESET +" A / "+ EnumChatFormatting.YELLOW + mAmperage + EnumChatFormatting.RESET +" A", "Max EU/p (1t):", - EnumChatFormatting.GREEN + Long.toString(mTransferredVoltageOK) + EnumChatFormatting.RESET +" EU / "+ + EnumChatFormatting.GREEN + Long.toString(volts) + EnumChatFormatting.RESET +" EU / "+ EnumChatFormatting.YELLOW + mVoltage + EnumChatFormatting.RESET +" EU", "Max Load (20t): "+ EnumChatFormatting.GREEN + mTransferredAmperageLast20OK + EnumChatFormatting.RESET +" A", 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 1156ed7117..b582654cd7 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 @@ -32,6 +32,11 @@ public class GT_MetaTileEntity_Hatch_Dynamo extends GT_MetaTileEntity_Hatch { return new ITexture[]{aBaseTexture, Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[mTier]}; } + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + } + @Override public boolean isSimpleMachine() { return true; -- 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/metatileentity') 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 dfa013f95f89a1d864f5d44dd118557ef24a7308 Mon Sep 17 00:00:00 2001 From: korneel vandamme Date: Fri, 2 Jul 2021 19:36:32 +0200 Subject: remove debug code --- src/main/java/gregtech/api/graphs/paths/PowerNodePath.java | 2 +- src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java | 3 --- .../implementations/GT_MetaTileEntity_Hatch_Dynamo.java | 5 ----- 3 files changed, 1 insertion(+), 9 deletions(-) (limited to 'src/main/java/gregtech/api/metatileentity') diff --git a/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java b/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java index 7c71a545a6..1445e45734 100644 --- a/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java +++ b/src/main/java/gregtech/api/graphs/paths/PowerNodePath.java @@ -48,7 +48,7 @@ public class PowerNodePath extends NodePath { public void addAmps(int aAmps) { this.mAmps += aAmps; - if (false && this.mAmps > mMaxAmps * 40) { + if (this.mAmps > mMaxAmps * 40) { for (MetaPipeEntity tCable : mPipes) { if (((GT_MetaPipeEntity_Cable)tCable).mAmperage*40 < this.mAmps) { BaseMetaPipeEntity tBaseCable = (BaseMetaPipeEntity) tCable.getBaseMetaTileEntity(); diff --git a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java index ab93267fc3..341e7d5714 100644 --- a/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java +++ b/src/main/java/gregtech/api/metatileentity/BaseMetaTileEntity.java @@ -1124,9 +1124,6 @@ public class BaseMetaTileEntity extends BaseTileEntity implements IGregTechTileE } else if (node.mCreationTime != time) { GenerateNodeMap.clearNodeMap(node,-1); new GenerateNodeMapPower((BaseMetaPipeEntity) TE); - } else { -// GenerateNodeMap.clearNodeMap(node,-1); -// new GenerateNodeMapPower((BaseMetaPipeEntity) TE); } } } 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 b582654cd7..1156ed7117 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 @@ -32,11 +32,6 @@ public class GT_MetaTileEntity_Hatch_Dynamo extends GT_MetaTileEntity_Hatch { return new ITexture[]{aBaseTexture, Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[mTier]}; } - @Override - public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { - super.onPostTick(aBaseMetaTileEntity, aTick); - } - @Override public boolean isSimpleMachine() { return true; -- 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/metatileentity') 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