API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 26th, 2017
91
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 48.57 KB | None | 0 0
raw download clone embed print report
  1. package sk.henn.techcraft.mods.energia.oprava;
  2.  
  3. import com.google.common.math.DoubleMath;
  4. import ic2.api.Direction;
  5. import ic2.api.energy.EnergyNet;
  6. import ic2.api.energy.NodeStats;
  7. import ic2.api.energy.tile.IEnergyAcceptor;
  8. import ic2.api.energy.tile.IEnergyConductor;
  9. import ic2.api.energy.tile.IEnergyEmitter;
  10. import ic2.api.energy.tile.IEnergySink;
  11. import ic2.api.energy.tile.IEnergySource;
  12. import ic2.api.energy.tile.IEnergyTile;
  13. import ic2.api.energy.tile.IMetaDelegate;
  14. import ic2.core.ExplosionIC2;
  15. import ic2.core.IC2;
  16. import ic2.core.IC2DamageSource;
  17. import ic2.core.block.machine.tileentity.TileEntityMatter;
  18. import ic2.core.block.wiring.TileEntityTransformer;
  19. import java.math.RoundingMode;
  20. import java.util.ArrayList;
  21. import java.util.Collections;
  22. import java.util.HashMap;
  23. import java.util.HashSet;
  24. import java.util.Iterator;
  25. import java.util.LinkedList;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.Set;
  29. import java.util.Vector;
  30. import java.util.Map.Entry;
  31. import net.minecraft.entity.Entity;
  32. import net.minecraft.entity.EntityLivingBase;
  33. import net.minecraft.entity.player.EntityPlayer;
  34. import net.minecraft.init.Blocks;
  35. import net.minecraft.tileentity.TileEntity;
  36. import net.minecraft.util.AxisAlignedBB;
  37. import net.minecraft.util.ChunkCoordinates;
  38. import net.minecraft.world.World;
  39. import net.minecraftforge.common.util.ForgeDirection;
  40. import sk.henn.techcraft.mods.energia.oprava.doplnky.IMultiEnergySource;
  41.  
  42. public class EnergyNetLocal
  43. {
  44. public static double minConductionLoss = 1.0E-4D;
  45. private static Direction[] directions = Direction.values();
  46. public static EnergyTransferList list;
  47. private World world;
  48. private EnergyNetLocal.EnergyPathMap energySourceToEnergyPathMap = new EnergyNetLocal.EnergyPathMap();
  49. private Map<EntityLivingBase, Integer> entityLivingToShockEnergyMap = new HashMap();
  50. private Map<ChunkCoordinates, IEnergyTile> registeredTiles = new HashMap();
  51. private Map<ChunkCoordinates, IEnergySource> sources = new HashMap();
  52. private EnergyNetLocal.WaitingList waitingList = new EnergyNetLocal.WaitingList();
  53. private int x;
  54.  
  55. EnergyNetLocal(World world)
  56. {
  57. this.world = world;
  58. }
  59.  
  60. public void addTile(TileEntity par1)
  61. {
  62.  
  63.  
  64.  
  65.  
  66. if (par1 instanceof IMetaDelegate)
  67. {
  68. List tiles = ((IMetaDelegate)par1).getSubTiles();
  69. Iterator i$ = tiles.iterator();
  70.  
  71. while (i$.hasNext())
  72. {
  73. TileEntity tile = (TileEntity)i$.next();
  74. this.addTileEntity(coords(tile), par1);
  75. }
  76.  
  77. if (par1 instanceof IEnergySource)
  78. {
  79. this.sources.put(coords((TileEntity)tiles.get(0)), (IEnergySource)par1);
  80. }
  81. }
  82. else
  83. {
  84. this.addTileEntity(coords(par1), par1);
  85. }
  86. }
  87.  
  88. public void addTileEntity(ChunkCoordinates coords, TileEntity tile)
  89. {
  90. if (tile instanceof IEnergyTile && !this.registeredTiles.containsKey(coords))
  91. {
  92. this.registeredTiles.put(coords, (IEnergyTile)tile);
  93. this.update(coords.posX, coords.posY, coords.posZ);
  94.  
  95.  
  96. if (tile instanceof IEnergyAcceptor)
  97. {
  98. this.waitingList.onTileEntityAdded(this.getValidReceivers(tile, true), tile);
  99. }
  100.  
  101. if (tile instanceof IEnergySource && !(tile instanceof IMetaDelegate))
  102. {
  103. this.sources.put(coords, (IEnergySource)tile);
  104. }
  105. }
  106. }
  107.  
  108. public void removeTile(TileEntity par1)
  109. {
  110. if (par1 instanceof IMetaDelegate)
  111. {
  112. List tiles = ((IMetaDelegate)par1).getSubTiles();
  113. Iterator i$ = tiles.iterator();
  114.  
  115. while (i$.hasNext())
  116. {
  117. TileEntity tile = (TileEntity)i$.next();
  118. this.removeTileEntity(coords(tile), par1);
  119. }
  120. }
  121. else
  122. {
  123. this.removeTileEntity(coords(par1), par1);
  124. }
  125. }
  126.  
  127. public void removeTileEntity(ChunkCoordinates coords, TileEntity tile)
  128. {
  129. if (tile instanceof IEnergyTile && this.registeredTiles.containsKey(coords))
  130. {
  131. this.registeredTiles.remove(coords);
  132. this.update(coords.posX, coords.posY, coords.posZ);
  133.  
  134. if (tile instanceof IEnergyAcceptor)
  135. {
  136. this.energySourceToEnergyPathMap.removeAll(this.energySourceToEnergyPathMap.getSources((IEnergyAcceptor)tile));
  137. this.waitingList.onTileEntityRemoved(tile);
  138. }
  139.  
  140. if (tile instanceof IEnergySource)
  141. {
  142. this.sources.remove(coords);
  143. this.energySourceToEnergyPathMap.remove(tile);
  144. }
  145. }
  146. else
  147. {
  148. boolean alreadyRemoved = !this.registeredTiles.containsKey(coords);
  149.  
  150. if (!alreadyRemoved)
  151. {
  152. // Uncomplication.log.warn("removing " + tile + " from the EnergyNet failed, already removed: " + alreadyRemoved);
  153. }
  154. }
  155. }
  156.  
  157. public int emitEnergyFrom(ChunkCoordinates coords, IEnergySource energySource, int amount)
  158. {
  159. if (!this.registeredTiles.containsKey(coords))
  160. {
  161. // Uncomplication.log.warn("EnergyNet.emitEnergyFrom: " + energySource + " is not added to the enet");
  162. return amount;
  163. }
  164. else
  165. {
  166. if (!this.energySourceToEnergyPathMap.containsKey(energySource))
  167. {
  168. TileEntity var10003 = (TileEntity)energySource;
  169. EnergyTransferList var10005 = list;
  170. this.energySourceToEnergyPathMap.put(energySource, this.discover(var10003, false, EnergyTransferList.getMaxEnergy(energySource, (int)energySource.getOfferedEnergy())));
  171. }
  172.  
  173. Vector activeEnergyPaths = new Vector();
  174. double totalInvLoss = 0.0D;
  175. double source = (double)energySource.getSourceTier();
  176. Iterator suppliedEnergyPaths = this.energySourceToEnergyPathMap.get(energySource).iterator();
  177. EnergyNetLocal.EnergyPath i$;
  178.  
  179. while (suppliedEnergyPaths.hasNext())
  180. {
  181. i$ = (EnergyNetLocal.EnergyPath)suppliedEnergyPaths.next();
  182. assert i$.target instanceof IEnergySink;
  183. IEnergySink entry = (IEnergySink)i$.target;
  184.  
  185. if (entry.getDemandedEnergy() > 0.0D && i$.loss < (double)amount && !false)
  186. {
  187. totalInvLoss += 1.0D / i$.loss;
  188. activeEnergyPaths.add(i$);
  189. }
  190. }
  191.  
  192. Collections.shuffle(activeEnergyPaths);
  193.  
  194. for (int var28 = activeEnergyPaths.size() - amount; var28 > 0; --var28)
  195. {
  196. i$ = (EnergyNetLocal.EnergyPath)activeEnergyPaths.remove(activeEnergyPaths.size() - 1);
  197. totalInvLoss -= 1.0D / i$.loss;
  198. }
  199.  
  200. int maxShockEnergy;
  201. HashMap var29;
  202. int var30;
  203.  
  204. for (var29 = new HashMap(); !activeEnergyPaths.isEmpty() && amount > 0; amount -= var30)
  205. {
  206. var30 = 0;
  207. double var32 = 0.0D;
  208. Vector energyInjected2 = activeEnergyPaths;
  209. activeEnergyPaths = new Vector();
  210. activeEnergyPaths.iterator();
  211. Iterator energyPath4 = energyInjected2.iterator();
  212.  
  213. while (energyPath4.hasNext())
  214. {
  215. EnergyNetLocal.EnergyPath i$1 = (EnergyNetLocal.EnergyPath)energyPath4.next();
  216. IEnergySink energyConductor3 = (IEnergySink)i$1.target;
  217. int energyConductor2 = (int)Math.floor((double)Math.round((double)amount / totalInvLoss / i$1.loss * 100000.0D) / 100000.0D);
  218. maxShockEnergy = (int)Math.floor(i$1.loss);
  219.  
  220. if (energyConductor2 > maxShockEnergy)
  221. {
  222. double i$2 = (double)(energyConductor2 - maxShockEnergy);
  223. double te = Math.min(i$2, energyConductor3.getDemandedEnergy());
  224.  
  225. if (te <= 0.0D && EnergyTransferList.hasOverrideInput(energyConductor3))
  226. {
  227. te = (double)EnergyTransferList.getOverrideInput(energyConductor3);
  228. }
  229.  
  230. if (te > 0.0D)
  231. {
  232. int tier = energyConductor3.getSinkTier();
  233. int accepting = (int)EnergyNet.instance.getPowerFromTier(tier);
  234.  
  235. if (tier >= Integer.MAX_VALUE || accepting <= 0)
  236. {
  237. accepting = Integer.MAX_VALUE;
  238. }
  239.  
  240. if (i$2 > (double)accepting)
  241. {
  242. if (!false)
  243. {
  244. this.explodeTiles(energyConductor3);
  245. }
  246. }
  247. else
  248. {
  249. double energyReturned = energyConductor3.injectEnergy(i$1.targetDirection.toForgeDirection(), te, source);
  250.  
  251. if (energyReturned == 0.0D)
  252. {
  253. activeEnergyPaths.add(i$1);
  254. var32 += 1.0D / i$1.loss;
  255. }
  256. else if (energyReturned >= (double)(energyConductor2 - maxShockEnergy))
  257. {
  258. energyReturned = (double)(energyConductor2 - maxShockEnergy);
  259. // Uncomplication.log.warn("API ERROR: " + energyConductor3 + " didn\'t implement demandsEnergy() properly, no energy from injectEnergy accepted although demandsEnergy() returned true.");
  260. }
  261.  
  262. var30 = (int)((double)var30 + te - energyReturned + (double)maxShockEnergy);
  263. int energyInjected = (int)(te - energyReturned);
  264.  
  265. if (!var29.containsKey(i$1))
  266. {
  267. var29.put(i$1, Integer.valueOf(energyInjected));
  268. }
  269. else
  270. {
  271. var29.put(i$1, Integer.valueOf(energyInjected + ((Integer)var29.get(i$1)).intValue()));
  272. }
  273. }
  274. }
  275. }
  276. else
  277. {
  278. activeEnergyPaths.add(i$1);
  279. var32 += 1.0D / i$1.loss;
  280. }
  281. }
  282.  
  283. if (var30 == 0 && !activeEnergyPaths.isEmpty())
  284. {
  285. EnergyNetLocal.EnergyPath var35 = (EnergyNetLocal.EnergyPath)activeEnergyPaths.remove(activeEnergyPaths.size() - 1);
  286. var32 -= 1.0D / var35.loss;
  287. }
  288.  
  289. totalInvLoss = var32;
  290. }
  291.  
  292. Iterator var31 = var29.entrySet().iterator();
  293.  
  294. while (var31.hasNext())
  295. {
  296. Entry var33 = (Entry)var31.next();
  297. EnergyNetLocal.EnergyPath energyPath3 = (EnergyNetLocal.EnergyPath)var33.getKey();
  298. int var34 = ((Integer)var33.getValue()).intValue();
  299. energyPath3.totalEnergyConducted += (long)var34;
  300. energyPath3.maxSendedEnergy = Math.max(energyPath3.maxSendedEnergy, (long)var34);
  301.  
  302. if (var34 > energyPath3.minInsulationEnergyAbsorption)
  303. {
  304. List var36 = this.world.getEntitiesWithinAABB(EntityLivingBase.class, AxisAlignedBB.getBoundingBox((double)(energyPath3.minX - 1), (double)(energyPath3.minY - 1), (double)(energyPath3.minZ - 1), (double)(energyPath3.maxX + 2), (double)(energyPath3.maxY + 2), (double)(energyPath3.maxZ + 2)));
  305. Iterator var38 = var36.iterator();
  306.  
  307. while (var38.hasNext())
  308. {
  309. EntityLivingBase var40 = (EntityLivingBase)var38.next();
  310. maxShockEnergy = 0;
  311. Iterator var42 = energyPath3.conductors.iterator();
  312.  
  313. while (true)
  314. {
  315. if (var42.hasNext())
  316. {
  317. IEnergyConductor energyConductor = (IEnergyConductor)var42.next();
  318. TileEntity var43 = (TileEntity)energyConductor;
  319.  
  320. if (!var40.boundingBox.intersectsWith(AxisAlignedBB.getBoundingBox((double)(var43.xCoord - 1), (double)(var43.yCoord - 1), (double)(var43.zCoord - 1), (double)(var43.xCoord + 2), (double)(var43.yCoord + 2), (double)(var43.zCoord + 2))))
  321. {
  322. continue;
  323. }
  324.  
  325. int shockEnergy = (int)((double)var34 - energyConductor.getInsulationEnergyAbsorption());
  326.  
  327. if (shockEnergy > maxShockEnergy)
  328. {
  329. maxShockEnergy = shockEnergy;
  330. }
  331.  
  332. if (energyConductor.getInsulationEnergyAbsorption() != (double)energyPath3.minInsulationEnergyAbsorption)
  333. {
  334. continue;
  335. }
  336. }
  337.  
  338. if (this.entityLivingToShockEnergyMap.containsKey(var40))
  339. {
  340. this.entityLivingToShockEnergyMap.put(var40, Integer.valueOf(((Integer)this.entityLivingToShockEnergyMap.get(var40)).intValue() + maxShockEnergy));
  341. }
  342. else
  343. {
  344. this.entityLivingToShockEnergyMap.put(var40, Integer.valueOf(maxShockEnergy));
  345. }
  346.  
  347. break;
  348. }
  349. }
  350.  
  351. if (var34 >= energyPath3.minInsulationBreakdownEnergy)
  352. {
  353. var38 = energyPath3.conductors.iterator();
  354.  
  355. while (var38.hasNext())
  356. {
  357. IEnergyConductor var41 = (IEnergyConductor)var38.next();
  358.  
  359. if ((double)var34 >= var41.getInsulationBreakdownEnergy())
  360. {
  361. var41.removeInsulation();
  362.  
  363. if (var41.getInsulationEnergyAbsorption() < (double)energyPath3.minInsulationEnergyAbsorption)
  364. {
  365. energyPath3.minInsulationEnergyAbsorption = (int)var41.getInsulationEnergyAbsorption();
  366. }
  367. }
  368. }
  369. }
  370. }
  371.  
  372. if (var34 >= energyPath3.minConductorBreakdownEnergy)
  373. {
  374. Iterator var37 = energyPath3.conductors.iterator();
  375.  
  376. while (var37.hasNext())
  377. {
  378. IEnergyConductor var39 = (IEnergyConductor)var37.next();
  379.  
  380. if ((double)var34 >= var39.getConductorBreakdownEnergy() && !false)
  381. {
  382. var39.removeConductor();
  383. }
  384. }
  385. }
  386. }
  387.  
  388. return amount;
  389. }
  390. }
  391.  
  392. public double getTotalEnergyEmitted(TileEntity tileEntity)
  393. {
  394. double ret = 0.0D;
  395. Iterator i$;
  396. EnergyNetLocal.EnergyPath energyPath2;
  397.  
  398. if (tileEntity instanceof IEnergyConductor)
  399. {
  400. i$ = this.energySourceToEnergyPathMap.getPaths((IEnergyAcceptor)tileEntity).iterator();
  401.  
  402. while (i$.hasNext())
  403. {
  404. energyPath2 = (EnergyNetLocal.EnergyPath)i$.next();
  405.  
  406. if (tileEntity instanceof IEnergyConductor && energyPath2.conductors.contains(tileEntity))
  407. {
  408. ret += (double)energyPath2.totalEnergyConducted;
  409. }
  410. }
  411. }
  412.  
  413. if (tileEntity instanceof IEnergySource && this.energySourceToEnergyPathMap.containsKey(tileEntity))
  414. {
  415. for (i$ = this.energySourceToEnergyPathMap.get(tileEntity).iterator(); i$.hasNext(); ret += (double)energyPath2.totalEnergyConducted)
  416. {
  417. energyPath2 = (EnergyNetLocal.EnergyPath)i$.next();
  418. }
  419. }
  420.  
  421. return ret;
  422. }
  423.  
  424. public double getTotalEnergySunken(TileEntity tileEntity)
  425. {
  426. double ret = 0.0D;
  427.  
  428. if (tileEntity instanceof IEnergyConductor || tileEntity instanceof IEnergySink)
  429. {
  430. Iterator i$ = this.energySourceToEnergyPathMap.getPaths((IEnergyAcceptor)tileEntity).iterator();
  431.  
  432. while (i$.hasNext())
  433. {
  434. EnergyNetLocal.EnergyPath energyPath = (EnergyNetLocal.EnergyPath)i$.next();
  435.  
  436. if (tileEntity instanceof IEnergySink && energyPath.target == tileEntity || tileEntity instanceof IEnergyConductor && energyPath.conductors.contains(tileEntity))
  437. {
  438. ret += (double)energyPath.totalEnergyConducted;
  439. }
  440. }
  441. }
  442.  
  443. return ret;
  444. }
  445.  
  446. private List<EnergyNetLocal.EnergyPath> discover(TileEntity emitter, boolean reverse, int lossLimit)
  447. {
  448. HashMap reachedTileEntities = new HashMap();
  449. LinkedList tileEntitiesToCheck = new LinkedList();
  450. tileEntitiesToCheck.add(emitter);
  451.  
  452. while (!tileEntitiesToCheck.isEmpty())
  453. {
  454. TileEntity energyPaths = (TileEntity)tileEntitiesToCheck.remove();
  455.  
  456. if (!energyPaths.isInvalid())
  457. {
  458. double i$ = 0.0D;
  459.  
  460. if (this.registeredTiles.get(coords(energyPaths)) != null && this.registeredTiles.get(coords(energyPaths)) != emitter && reachedTileEntities.containsKey(energyPaths))
  461. {
  462. i$ = ((EnergyNetLocal.EnergyBlockLink)reachedTileEntities.get(energyPaths)).loss;
  463. }
  464.  
  465. List tileEntity = this.getValidReceivers(energyPaths, reverse);
  466. Iterator energyBlockLink = tileEntity.iterator();
  467.  
  468. while (energyBlockLink.hasNext())
  469. {
  470. EnergyNetLocal.EnergyTarget energyPath = (EnergyNetLocal.EnergyTarget)energyBlockLink.next();
  471.  
  472. if (energyPath.tileEntity != emitter)
  473. {
  474. double energyConductor = 0.0D;
  475.  
  476. if (energyPath.tileEntity instanceof IEnergyConductor)
  477. {
  478. energyConductor = ((IEnergyConductor)energyPath.tileEntity).getConductionLoss();
  479.  
  480. if (energyConductor < 1.0E-4D)
  481. {
  482. energyConductor = 1.0E-4D;
  483. }
  484.  
  485. if (i$ + energyConductor >= (double)lossLimit)
  486. {
  487. continue;
  488. }
  489. }
  490.  
  491. if (!reachedTileEntities.containsKey(energyPath.tileEntity) || ((EnergyNetLocal.EnergyBlockLink)reachedTileEntities.get(energyPath.tileEntity)).loss > i$ + energyConductor)
  492. {
  493. reachedTileEntities.put(energyPath.tileEntity, new EnergyNetLocal.EnergyBlockLink(energyPath.direction, i$ + energyConductor));
  494.  
  495. if (energyPath.tileEntity instanceof IEnergyConductor)
  496. {
  497. tileEntitiesToCheck.remove(energyPath.tileEntity);
  498. tileEntitiesToCheck.add(energyPath.tileEntity);
  499. }
  500. }
  501. }
  502. }
  503. }
  504. }
  505.  
  506. LinkedList energyPaths1 = new LinkedList();
  507. Iterator i$1 = reachedTileEntities.entrySet().iterator();
  508.  
  509. while (i$1.hasNext())
  510. {
  511. Entry entry = (Entry)i$1.next();
  512. TileEntity tileEntity1 = (TileEntity)entry.getKey();
  513.  
  514. if (!reverse && tileEntity1 instanceof IEnergySink || reverse && tileEntity1 instanceof IEnergySource)
  515. {
  516. EnergyNetLocal.EnergyBlockLink energyBlockLink1 = (EnergyNetLocal.EnergyBlockLink)entry.getValue();
  517. EnergyNetLocal.EnergyPath energyPath1 = new EnergyNetLocal.EnergyPath();
  518.  
  519. if (energyBlockLink1.loss > 0.1D)
  520. {
  521. energyPath1.loss = energyBlockLink1.loss;
  522. }
  523. else
  524. {
  525. energyPath1.loss = 0.1D;
  526. }
  527.  
  528. energyPath1.target = tileEntity1;
  529. energyPath1.targetDirection = energyBlockLink1.direction;
  530.  
  531. if (!reverse && emitter instanceof IEnergySource)
  532. {
  533. while (true)
  534. {
  535. tileEntity1 = EnergyNet.instance.getNeighbor(tileEntity1, energyBlockLink1.direction.toForgeDirection());
  536.  
  537. if (tileEntity1 == emitter || !(tileEntity1 instanceof IEnergyConductor))
  538. {
  539. break;
  540. }
  541.  
  542. IEnergyConductor energyConductor1 = (IEnergyConductor)tileEntity1;
  543.  
  544. if (tileEntity1.xCoord < energyPath1.minX)
  545. {
  546. energyPath1.minX = tileEntity1.xCoord;
  547. }
  548.  
  549. if (tileEntity1.yCoord < energyPath1.minY)
  550. {
  551. energyPath1.minY = tileEntity1.yCoord;
  552. }
  553.  
  554. if (tileEntity1.zCoord < energyPath1.minZ)
  555. {
  556. energyPath1.minZ = tileEntity1.zCoord;
  557. }
  558.  
  559. if (tileEntity1.xCoord > energyPath1.maxX)
  560. {
  561. energyPath1.maxX = tileEntity1.xCoord;
  562. }
  563.  
  564. if (tileEntity1.yCoord > energyPath1.maxY)
  565. {
  566. energyPath1.maxY = tileEntity1.yCoord;
  567. }
  568.  
  569. if (tileEntity1.zCoord > energyPath1.maxZ)
  570. {
  571. energyPath1.maxZ = tileEntity1.zCoord;
  572. }
  573.  
  574. energyPath1.conductors.add(energyConductor1);
  575.  
  576. if (energyConductor1.getInsulationEnergyAbsorption() < (double)energyPath1.minInsulationEnergyAbsorption)
  577. {
  578. energyPath1.minInsulationEnergyAbsorption = (int)energyConductor1.getInsulationEnergyAbsorption();
  579. }
  580.  
  581. if (energyConductor1.getInsulationBreakdownEnergy() < (double)energyPath1.minInsulationBreakdownEnergy)
  582. {
  583. energyPath1.minInsulationBreakdownEnergy = (int)energyConductor1.getInsulationBreakdownEnergy();
  584. }
  585.  
  586. if (energyConductor1.getConductorBreakdownEnergy() < (double)energyPath1.minConductorBreakdownEnergy)
  587. {
  588. energyPath1.minConductorBreakdownEnergy = (int)energyConductor1.getConductorBreakdownEnergy();
  589. }
  590.  
  591. energyBlockLink1 = (EnergyNetLocal.EnergyBlockLink)reachedTileEntities.get(tileEntity1);
  592.  
  593. if (energyBlockLink1 == null)
  594. {
  595. IC2.platform.displayError("An energy network pathfinding entry is corrupted.\nThis could happen due to incorrect Minecraft behavior or a bug.\n\n(Technical information: energyBlockLink, tile entities below)\nE: " + emitter + " (" + emitter.xCoord + "," + emitter.yCoord + "," + emitter.zCoord + ")\n" + "C: " + tileEntity1 + " (" + tileEntity1.xCoord + "," + tileEntity1.yCoord + "," + tileEntity1.zCoord + ")\n" + "R: " + energyPath1.target + " (" + energyPath1.target.xCoord + "," + energyPath1.target.yCoord + "," + energyPath1.target.zCoord + ")", new Object[0]);
  596. }
  597. }
  598. }
  599.  
  600. energyPaths1.add(energyPath1);
  601. }
  602. }
  603.  
  604. return energyPaths1;
  605. }
  606.  
  607. private boolean conductorToWeak(Set<IEnergyConductor> par1, int energyToSend)
  608. {
  609. boolean flag = false;
  610. Iterator i$ = par1.iterator();
  611.  
  612. while (i$.hasNext())
  613. {
  614. IEnergyConductor cond = (IEnergyConductor)i$.next();
  615.  
  616. if (cond.getConductorBreakdownEnergy() <= (double)energyToSend)
  617. {
  618. flag = true;
  619. break;
  620. }
  621. }
  622.  
  623. return flag;
  624. }
  625.  
  626. public List<EnergyNetLocal.EnergyPath> discoverTargets(TileEntity emitter, boolean reverse, int lossLimit)
  627. {
  628. List paths = this.discover(emitter, reverse, lossLimit);
  629. LinkedList targets = new LinkedList();
  630. Iterator i$ = paths.iterator();
  631.  
  632. while (i$.hasNext())
  633. {
  634. EnergyNetLocal.EnergyPath path = (EnergyNetLocal.EnergyPath)i$.next();
  635. targets.add(path.target);
  636. }
  637.  
  638. return targets;
  639. }
  640.  
  641. private List<EnergyNetLocal.EnergyTarget> getValidReceivers(TileEntity emitter, boolean reverse)
  642. {
  643. LinkedList validReceivers = new LinkedList();
  644. Direction[] arr$ = directions;
  645. int len$ = arr$.length;
  646.  
  647. for (int i$ = 0; i$ < len$; ++i$)
  648. {
  649. Direction direction = arr$[i$];
  650.  
  651. if (emitter instanceof IMetaDelegate)
  652. {
  653. IMetaDelegate target = (IMetaDelegate)emitter;
  654. List inverseDirection = target.getSubTiles();
  655. Iterator sender = inverseDirection.iterator();
  656.  
  657. while (sender.hasNext())
  658. {
  659. TileEntity receiver = (TileEntity)sender.next();
  660. TileEntity target1 = EnergyNet.instance.getNeighbor(receiver, direction.toForgeDirection());
  661.  
  662. if (target1 != emitter && target1 instanceof IEnergyTile && this.registeredTiles.containsKey(coords(target1)))
  663. {
  664. Direction inverseDirection1 = direction.getInverse();
  665. IEnergyEmitter sender1;
  666. IEnergyAcceptor receiver1;
  667.  
  668. if (reverse)
  669. {
  670. if (emitter instanceof IEnergyAcceptor && target1 instanceof IEnergyEmitter)
  671. {
  672. sender1 = (IEnergyEmitter)target1;
  673. receiver1 = (IEnergyAcceptor)emitter;
  674.  
  675. if (sender1.emitsEnergyTo(emitter, inverseDirection1.toForgeDirection()) && receiver1.acceptsEnergyFrom(target1, direction.toForgeDirection()))
  676. {
  677. validReceivers.add(new EnergyNetLocal.EnergyTarget(target1, inverseDirection1));
  678. }
  679. }
  680. }
  681. else if (emitter instanceof IEnergyEmitter && target1 instanceof IEnergyAcceptor)
  682. {
  683. sender1 = (IEnergyEmitter)emitter;
  684. receiver1 = (IEnergyAcceptor)target1;
  685.  
  686. if (sender1.emitsEnergyTo(target1, direction.toForgeDirection()) && receiver1.acceptsEnergyFrom(emitter, inverseDirection1.toForgeDirection()))
  687. {
  688. validReceivers.add(new EnergyNetLocal.EnergyTarget(target1, inverseDirection1));
  689. }
  690. }
  691. }
  692. }
  693. }
  694. else
  695. {
  696. TileEntity var16 = EnergyNet.instance.getNeighbor(emitter, direction.toForgeDirection());
  697.  
  698. if (var16 instanceof IEnergyTile && this.registeredTiles.containsKey(coords(var16)))
  699. {
  700. Direction var17 = direction.getInverse();
  701. IEnergyEmitter var18;
  702. IEnergyAcceptor var19;
  703.  
  704. if (reverse)
  705. {
  706. if (emitter instanceof IEnergyAcceptor && var16 instanceof IEnergyEmitter)
  707. {
  708. var18 = (IEnergyEmitter)var16;
  709. var19 = (IEnergyAcceptor)emitter;
  710.  
  711. if (var18.emitsEnergyTo(emitter, var17.toForgeDirection()) && var19.acceptsEnergyFrom(var16, direction.toForgeDirection()))
  712. {
  713. validReceivers.add(new EnergyNetLocal.EnergyTarget(var16, var17));
  714. }
  715. }
  716. }
  717. else if (emitter instanceof IEnergyEmitter && var16 instanceof IEnergyAcceptor)
  718. {
  719. var18 = (IEnergyEmitter)emitter;
  720. var19 = (IEnergyAcceptor)var16;
  721.  
  722. if (var18.emitsEnergyTo(var16, direction.toForgeDirection()) && var19.acceptsEnergyFrom(emitter, var17.toForgeDirection()))
  723. {
  724. validReceivers.add(new EnergyNetLocal.EnergyTarget(var16, var17));
  725. }
  726. }
  727. }
  728. }
  729. }
  730.  
  731. return validReceivers;
  732. }
  733.  
  734. public List<IEnergySource> discoverFirstPathOrSources(TileEntity par1)
  735. {
  736. HashSet reached = new HashSet();
  737. ArrayList result = new ArrayList();
  738. ArrayList workList = new ArrayList();
  739. workList.add(par1);
  740.  
  741. while (workList.size() > 0)
  742. {
  743. TileEntity tile = (TileEntity)workList.remove(0);
  744.  
  745. if (!tile.isInvalid())
  746. {
  747. List targets = this.getValidReceivers(tile, true);
  748.  
  749. for (int i = 0; i < targets.size(); ++i)
  750. {
  751. TileEntity target = ((EnergyNetLocal.EnergyTarget)targets.get(i)).tileEntity;
  752.  
  753. if (target != par1 && !reached.contains(target))
  754. {
  755. reached.add(target);
  756.  
  757. if (target instanceof IEnergySource)
  758. {
  759. result.add((IEnergySource)target);
  760. }
  761. else if (target instanceof IEnergyConductor)
  762. {
  763. workList.add(target);
  764. }
  765. }
  766. }
  767. }
  768. }
  769.  
  770. return result;
  771. }
  772.  
  773. public static ChunkCoordinates coords(TileEntity par1)
  774. {
  775.  
  776. return par1 == null ? null : new ChunkCoordinates(par1.xCoord, par1.yCoord, par1.zCoord);
  777. }
  778.  
  779. public void onTickStart()
  780. {
  781.  
  782. Iterator i$ = this.entityLivingToShockEnergyMap.entrySet().iterator();
  783.  
  784. while (i$.hasNext())
  785. {
  786. Entry entry = (Entry)i$.next();
  787. EntityLivingBase target = (EntityLivingBase)entry.getKey();
  788. int damage = (((Integer)entry.getValue()).intValue() + 63) / 64;
  789.  
  790. if (target.isEntityAlive())
  791. {
  792. target.attackEntityFrom(IC2DamageSource.electricity, (float)damage);
  793. }
  794. }
  795.  
  796. this.entityLivingToShockEnergyMap.clear();
  797. }
  798.  
  799. public void onTickEnd()
  800. {
  801. if (this.waitingList.hasWork())
  802. {
  803. List iter = this.waitingList.getPathTiles();
  804. Iterator z = iter.iterator();
  805.  
  806. while (z.hasNext())
  807. {
  808. TileEntity entry = (TileEntity)z.next();
  809. List source = this.discoverFirstPathOrSources(entry);
  810.  
  811. if (source.size() > 0)
  812. {
  813. this.energySourceToEnergyPathMap.removeAll(source);
  814. }
  815. }
  816.  
  817. this.waitingList.clear();
  818. }
  819.  
  820. Iterator var9 = (new HashMap(this.sources)).entrySet().iterator();
  821.  
  822. for (int var10 = 0; var9.hasNext(); ++var10)
  823. {
  824. Entry var11 = (Entry)var9.next();
  825.  
  826. if (var11 != null)
  827. {
  828. IEnergySource var12 = (IEnergySource)var11.getValue();
  829.  
  830. if (var12 != null)
  831. {
  832. EnergyNetLocal.EnergyPath packetAmount;
  833.  
  834. if (this.energySourceToEnergyPathMap.containsKey(var12))
  835. {
  836. for (Iterator offer = this.energySourceToEnergyPathMap.get(var12).iterator(); offer.hasNext(); packetAmount.maxSendedEnergy = 0L)
  837. {
  838. packetAmount = (EnergyNetLocal.EnergyPath)offer.next();
  839. packetAmount.totalEnergyConducted = 0L;
  840. }
  841. }
  842.  
  843. int var13 = DoubleMath.roundToInt(var12.getOfferedEnergy(), RoundingMode.DOWN);
  844.  
  845. if (var13 > 0)
  846. {
  847. int var14 = this.getPacketAmount(var12);
  848.  
  849. for (int i = 0; i < var14; ++i)
  850. {
  851. var13 = DoubleMath.roundToInt(var12.getOfferedEnergy(), RoundingMode.DOWN);
  852.  
  853. if (var13 < 1)
  854. {
  855. break;
  856. }
  857.  
  858. int removed = var13 - this.emitEnergyFrom((ChunkCoordinates)var11.getKey(), var12, var13);
  859.  
  860. if (removed <= 0)
  861. {
  862. break;
  863. }
  864.  
  865. var12.drawEnergy((double)removed);
  866. }
  867. }
  868. }
  869. }
  870. }
  871. }
  872.  
  873. private int getPacketAmount(IEnergySource source)
  874. {
  875. return source instanceof IMultiEnergySource && ((IMultiEnergySource)source).sendMultibleEnergyPackets() ? ((IMultiEnergySource)source).getMultibleEnergyPacketAmount() : (source instanceof TileEntityTransformer ? (((TileEntityTransformer)source).redstone ? 1 : 4) : 1);
  876. }
  877.  
  878. public void explodeTiles(IEnergySink sink)
  879. {
  880. this.removeTile((TileEntity)sink);
  881.  
  882. if (sink instanceof IMetaDelegate)
  883. {
  884. IMetaDelegate meta = (IMetaDelegate)sink;
  885. Iterator i$ = meta.getSubTiles().iterator();
  886.  
  887. while (i$.hasNext())
  888. {
  889. TileEntity tile = (TileEntity)i$.next();
  890. this.explodeMachineAt(tile.xCoord, tile.yCoord, tile.zCoord, tile);
  891. }
  892. }
  893. else
  894. {
  895. this.explodeMachineAt(((TileEntity)sink).xCoord, ((TileEntity)sink).yCoord, ((TileEntity)sink).zCoord, (TileEntity)sink);
  896. }
  897. }
  898.  
  899. public TileEntity getTileEntity(int x, int y, int z)
  900. {
  901. ChunkCoordinates coords = new ChunkCoordinates(x, y, z);
  902. return this.registeredTiles.containsKey(coords) ? (TileEntity)this.registeredTiles.get(coords) : null;
  903. }
  904.  
  905. public NodeStats getNodeStats(TileEntity tile)
  906. {
  907. double emitted = this.getTotalEnergyEmitted(tile);
  908. double received = this.getTotalEnergySunken(tile);
  909. return new NodeStats(received, emitted, (double)EnergyNet.instance.getTierFromPower(this.getVoltage(tile)));
  910. }
  911.  
  912. private double getVoltage(TileEntity tileEntity)
  913. {
  914. double voltage = 0.0D;
  915. Iterator i$;
  916. EnergyNetLocal.EnergyPath energyPath;
  917.  
  918. if (tileEntity instanceof IEnergySource && this.energySourceToEnergyPathMap.containsKey(tileEntity))
  919. {
  920. for (i$ = this.energySourceToEnergyPathMap.get(tileEntity).iterator(); i$.hasNext(); voltage = Math.max(voltage, (double)energyPath.maxSendedEnergy))
  921. {
  922. energyPath = (EnergyNetLocal.EnergyPath)i$.next();
  923. }
  924. }
  925.  
  926. if (tileEntity instanceof IEnergyConductor || tileEntity instanceof IEnergySink)
  927. {
  928. i$ = this.energySourceToEnergyPathMap.getPaths((IEnergyAcceptor)tileEntity).iterator();
  929.  
  930. while (i$.hasNext())
  931. {
  932. energyPath = (EnergyNetLocal.EnergyPath)i$.next();
  933.  
  934. if (tileEntity instanceof IEnergySink && energyPath.target == tileEntity || tileEntity instanceof IEnergyConductor && energyPath.conductors.contains(tileEntity))
  935. {
  936. voltage = Math.max(voltage, (double)energyPath.maxSendedEnergy);
  937. }
  938. }
  939. }
  940.  
  941. return voltage;
  942. }
  943.  
  944. void explodeMachineAt(int x, int y, int z, TileEntity tile)
  945. {
  946. this.world.setBlockToAir(x, y, z);
  947. float power = 2.5F;
  948.  
  949.  
  950. EntityPlayer player = this.world.getClosestPlayer((double)x, (double)y, (double)z, 15.0D);
  951.  
  952. if (player != null)
  953. {
  954.  
  955. }
  956.  
  957. ExplosionIC2 explosion = new ExplosionIC2(this.world, (Entity)null, 0.5D + (double)x, 0.5D + (double)y, 0.5D + (double)z, power, 0.75F);
  958. explosion.doExplosion();
  959. }
  960.  
  961. void update(int x, int y, int z)
  962. {
  963. ForgeDirection[] arr$ = ForgeDirection.values();
  964. int len$ = arr$.length;
  965.  
  966. for (int i$ = 0; i$ < len$; ++i$)
  967. {
  968. ForgeDirection dir = arr$[i$];
  969.  
  970. if (this.world.blockExists(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ))
  971. {
  972.  
  973. this.world.notifyBlockChange(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ, Blocks.air);
  974. //System.out.println(x + dir.offsetX + " " +y + dir.offsetY + " " + z + dir.offsetZ);
  975. //this.
  976. //this.world.markBlockForUpdate(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);;
  977. // this.update(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
  978. }
  979. }
  980. }
  981.  
  982. public void onUnload()
  983. {
  984. this.energySourceToEnergyPathMap.clear();
  985. this.registeredTiles.clear();
  986. this.sources.clear();
  987. this.entityLivingToShockEnergyMap.clear();
  988. this.waitingList.clear();
  989. }
  990.  
  991. static class EnergyBlockLink
  992. {
  993. Direction direction;
  994. double loss;
  995.  
  996. EnergyBlockLink(Direction direction, double loss)
  997. {
  998. this.direction = direction;
  999. this.loss = loss;
  1000. }
  1001. }
  1002.  
  1003. static class EnergyPath
  1004. {
  1005. TileEntity target = null;
  1006. Direction targetDirection;
  1007. Set<IEnergyConductor> conductors = new HashSet();
  1008. int minX = Integer.MAX_VALUE;
  1009. int minY = Integer.MAX_VALUE;
  1010. int minZ = Integer.MAX_VALUE;
  1011. int maxX = Integer.MIN_VALUE;
  1012. int maxY = Integer.MIN_VALUE;
  1013. int maxZ = Integer.MIN_VALUE;
  1014. double loss = 0.0D;
  1015. int minInsulationEnergyAbsorption = Integer.MAX_VALUE;
  1016. int minInsulationBreakdownEnergy = Integer.MAX_VALUE;
  1017. int minConductorBreakdownEnergy = Integer.MAX_VALUE;
  1018. long totalEnergyConducted = 0L;
  1019. long maxSendedEnergy = 0L;
  1020. }
  1021.  
  1022. static class EnergyPathMap
  1023. {
  1024. Map<IEnergySource, List<EnergyNetLocal.EnergyPath>> senderPath = new HashMap();
  1025. Map<EnergyNetLocal.EnergyPath, IEnergySource> pathToSender = new HashMap();
  1026.  
  1027. public void put(IEnergySource par1, List<EnergyNetLocal.EnergyPath> par2)
  1028. {
  1029. this.senderPath.put(par1, par2);
  1030.  
  1031. for (int i = 0; i < par2.size(); ++i)
  1032. {
  1033. this.pathToSender.put(par2.get(i), par1);
  1034. }
  1035. }
  1036.  
  1037. public boolean containsKey(Object par1)
  1038. {
  1039. return this.senderPath.containsKey(par1);
  1040. }
  1041.  
  1042. public List<EnergyNetLocal.EnergyPath> get(Object par1)
  1043. {
  1044. return (List)this.senderPath.get(par1);
  1045. }
  1046.  
  1047. public void remove(Object par1)
  1048. {
  1049. List paths = (List)this.senderPath.remove(par1);
  1050.  
  1051. if (paths != null)
  1052. {
  1053. for (int i = 0; i < paths.size(); ++i)
  1054. {
  1055. this.pathToSender.remove(paths.get(i));
  1056. }
  1057. }
  1058. }
  1059.  
  1060. public void removeAll(List<IEnergySource> par1)
  1061. {
  1062. for (int i = 0; i < par1.size(); ++i)
  1063. {
  1064. this.remove(par1.get(i));
  1065. }
  1066. }
  1067.  
  1068. public List<EnergyNetLocal.EnergyPath> getPaths(IEnergyAcceptor par1)
  1069. {
  1070. ArrayList paths = new ArrayList();
  1071. Iterator i$ = this.getSources(par1).iterator();
  1072.  
  1073. while (i$.hasNext())
  1074. {
  1075. IEnergySource source = (IEnergySource)i$.next();
  1076.  
  1077. if (this.containsKey(source))
  1078. {
  1079. paths.addAll(this.get(source));
  1080. }
  1081. }
  1082.  
  1083. return paths;
  1084. }
  1085.  
  1086. public List<IEnergySource> getSources(IEnergyAcceptor par1)
  1087. {
  1088. ArrayList source = new ArrayList();
  1089. Iterator i$ = this.pathToSender.entrySet().iterator();
  1090.  
  1091. while (i$.hasNext())
  1092. {
  1093. Entry entry = (Entry)i$.next();
  1094.  
  1095. if (!source.contains(entry.getValue()))
  1096. {
  1097. EnergyNetLocal.EnergyPath path = (EnergyNetLocal.EnergyPath)entry.getKey();
  1098.  
  1099. if (par1 instanceof IEnergyConductor && path.conductors.contains(par1) || par1 instanceof IEnergySink && path.target == par1)
  1100. {
  1101. source.add(entry.getValue());
  1102. }
  1103. }
  1104. }
  1105.  
  1106. return source;
  1107. }
  1108.  
  1109. public void clear()
  1110. {
  1111. this.senderPath.clear();
  1112. this.pathToSender.clear();
  1113. }
  1114. }
  1115.  
  1116. static class EnergyTarget
  1117. {
  1118. TileEntity tileEntity;
  1119. Direction direction;
  1120.  
  1121. EnergyTarget(TileEntity tileEntity, Direction direction)
  1122. {
  1123. this.tileEntity = tileEntity;
  1124. this.direction = direction;
  1125. }
  1126. }
  1127.  
  1128. static class PathLogic
  1129. {
  1130. List<TileEntity> tiles = new ArrayList();
  1131.  
  1132. public boolean contains(TileEntity par1)
  1133. {
  1134. return this.tiles.contains(par1);
  1135. }
  1136.  
  1137. public void add(TileEntity par1)
  1138. {
  1139. this.tiles.add(par1);
  1140. }
  1141.  
  1142. public void remove(TileEntity par1)
  1143. {
  1144. this.tiles.remove(par1);
  1145. }
  1146.  
  1147. public void clear()
  1148. {
  1149. this.tiles.clear();
  1150. }
  1151.  
  1152. public TileEntity getRepresentingTile()
  1153. {
  1154. return this.tiles.isEmpty() ? null : (TileEntity)this.tiles.get(0);
  1155. }
  1156. }
  1157.  
  1158. class WaitingList
  1159. {
  1160. List<EnergyNetLocal.PathLogic> paths = new ArrayList();
  1161.  
  1162. public void onTileEntityAdded(List<EnergyNetLocal.EnergyTarget> around, TileEntity tile)
  1163. {
  1164. if (!around.isEmpty() && !this.paths.isEmpty())
  1165. {
  1166. boolean found = false;
  1167. ArrayList logics = new ArrayList();
  1168.  
  1169. for (int newLogic = 0; newLogic < this.paths.size(); ++newLogic)
  1170. {
  1171. EnergyNetLocal.PathLogic i$ = (EnergyNetLocal.PathLogic)this.paths.get(newLogic);
  1172.  
  1173. if (i$.contains(tile))
  1174. {
  1175. found = true;
  1176.  
  1177. if (tile instanceof IEnergyConductor)
  1178. {
  1179. logics.add(i$);
  1180. }
  1181. }
  1182. else
  1183. {
  1184. Iterator logic = around.iterator();
  1185.  
  1186. while (logic.hasNext())
  1187. {
  1188. EnergyNetLocal.EnergyTarget i$1 = (EnergyNetLocal.EnergyTarget)logic.next();
  1189.  
  1190. if (i$.contains(i$1.tileEntity))
  1191. {
  1192. found = true;
  1193. i$.add(tile);
  1194.  
  1195. if (i$1.tileEntity instanceof IEnergyConductor)
  1196. {
  1197. logics.add(i$);
  1198. }
  1199.  
  1200. break;
  1201. }
  1202. }
  1203. }
  1204. }
  1205.  
  1206. if (logics.size() > 1 && tile instanceof IEnergyConductor)
  1207. {
  1208. EnergyNetLocal.PathLogic var10 = new EnergyNetLocal.PathLogic();
  1209. Iterator var11 = logics.iterator();
  1210.  
  1211. while (var11.hasNext())
  1212. {
  1213. EnergyNetLocal.PathLogic var12 = (EnergyNetLocal.PathLogic)var11.next();
  1214. this.paths.remove(var12);
  1215. Iterator var13 = var12.tiles.iterator();
  1216.  
  1217. while (var13.hasNext())
  1218. {
  1219. TileEntity toMove = (TileEntity)var13.next();
  1220.  
  1221. if (!var10.contains(toMove))
  1222. {
  1223. var10.add(toMove);
  1224. }
  1225. }
  1226.  
  1227. var12.clear();
  1228. }
  1229.  
  1230. this.paths.add(var10);
  1231. }
  1232.  
  1233. if (!found)
  1234. {
  1235. this.createNewPath(tile);
  1236. }
  1237. }
  1238. else
  1239. {
  1240. this.createNewPath(tile);
  1241. }
  1242. }
  1243.  
  1244. public void onTileEntityRemoved(TileEntity par1)
  1245. {
  1246. if (!this.paths.isEmpty())
  1247. {
  1248. ArrayList toRecalculate = new ArrayList();
  1249. int i;
  1250.  
  1251. for (i = 0; i < this.paths.size(); ++i)
  1252. {
  1253. EnergyNetLocal.PathLogic tile = (EnergyNetLocal.PathLogic)this.paths.get(i);
  1254.  
  1255. if (tile.contains(par1))
  1256. {
  1257. tile.remove(par1);
  1258. toRecalculate.addAll(tile.tiles);
  1259. this.paths.remove(i--);
  1260. }
  1261. }
  1262.  
  1263. for (i = 0; i < toRecalculate.size(); ++i)
  1264. {
  1265. TileEntity var5 = (TileEntity)toRecalculate.get(i);
  1266. this.onTileEntityAdded(EnergyNetLocal.this.getValidReceivers(var5, true), var5);
  1267. }
  1268. }
  1269. }
  1270.  
  1271. public void createNewPath(TileEntity par1)
  1272. {
  1273. EnergyNetLocal.PathLogic logic = new EnergyNetLocal.PathLogic();
  1274. logic.add(par1);
  1275. this.paths.add(logic);
  1276. }
  1277.  
  1278. public void clear()
  1279. {
  1280. if (!this.paths.isEmpty())
  1281. {
  1282. for (int i = 0; i < this.paths.size(); ++i)
  1283. {
  1284. ((EnergyNetLocal.PathLogic)this.paths.get(i)).clear();
  1285. }
  1286.  
  1287. this.paths.clear();
  1288. }
  1289. }
  1290.  
  1291. public boolean hasWork()
  1292. {
  1293. return this.paths.size() > 0;
  1294. }
  1295.  
  1296. public List<TileEntity> getPathTiles()
  1297. {
  1298. ArrayList tiles = new ArrayList();
  1299.  
  1300. for (int i = 0; i < this.paths.size(); ++i)
  1301. {
  1302. TileEntity tile = ((EnergyNetLocal.PathLogic)this.paths.get(i)).getRepresentingTile();
  1303.  
  1304. if (tile != null)
  1305. {
  1306. tiles.add(tile);
  1307. }
  1308. }
  1309.  
  1310. return tiles;
  1311. }
  1312. }
  1313. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!