From b7c77e1a25b3bc613eaca549cd72c13a0bbfa234 Mon Sep 17 00:00:00 2001 From: botn365 <42187820+botn365@users.noreply.github.com> Date: Mon, 21 Dec 2020 06:56:42 +0100 Subject: attempt fix cme on gt block update attempt to fix a concurentModificationexeption crash when having large gt block updates --- .../java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index ee56a0b0c0..6e57ef486e 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -55,8 +55,10 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { private static boolean isEnabled = true; public static void setMachineUpdateValues(World aWorld, int aX, int aY, int aZ) { - if (isEnabled) + if (isEnabled) { + aWorld.getTileEntity(aX, aY, aZ); EXECUTOR_SERVICE.submit(new GT_Runnable_MachineBlockUpdate(aWorld, aX, aY, aZ)); + } } public static void initExecutorService() { -- cgit From 829cfe74a01c7b13be13379ee3358c2d8cc85ce4 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Sat, 26 Dec 2020 15:43:34 -0800 Subject: Machine Block Update changes * Conditionally trigger an update on front facing (Needed for pipelines) * Use a queue instead of recursion --- .../threads/GT_Runnable_MachineBlockUpdate.java | 126 ++++++++------------- 1 file changed, 48 insertions(+), 78 deletions(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 6e57ef486e..8f7a84e2cb 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -4,10 +4,12 @@ import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.ChunkPosition; +import net.minecraft.util.ChunkCoordinates; import net.minecraft.world.World; import java.util.HashSet; +import java.util.LinkedList; +import java.util.Queue; import java.util.Set; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -15,12 +17,13 @@ import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; public class GT_Runnable_MachineBlockUpdate implements Runnable { - //used by runner thread - private final int x, y, z; + // used by runner thread + private final ChunkCoordinates mCoords; private final World world; - private final Set visited = new HashSet<>(80); - - //Threading + private final Set visited = new HashSet<>(80); + private final Queue tQueue = new LinkedList<>(); + + // Threading private static final ThreadFactory THREAD_FACTORY = r -> { Thread thread = new Thread(r); thread.setName("GT_MachineBlockUpdate"); @@ -28,12 +31,13 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { }; private static ExecutorService EXECUTOR_SERVICE; - //This class should never be initiated outside of this class! - private GT_Runnable_MachineBlockUpdate(World aWorld, int aX, int aY, int aZ) { + // This class should never be initiated outside of this class! + private GT_Runnable_MachineBlockUpdate(World aWorld, ChunkCoordinates aCoords) { this.world = aWorld; - this.x = aX; - this.y = aY; - this.z = aZ; + this.mCoords = aCoords; + visited.add(aCoords); + tQueue.add(aCoords); + } public static boolean isEnabled() { @@ -54,18 +58,15 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { private static boolean isEnabled = true; - public static void setMachineUpdateValues(World aWorld, int aX, int aY, int aZ) { + public static void setMachineUpdateValues(World aWorld, ChunkCoordinates aCoords) { if (isEnabled) { - aWorld.getTileEntity(aX, aY, aZ); - EXECUTOR_SERVICE.submit(new GT_Runnable_MachineBlockUpdate(aWorld, aX, aY, aZ)); + aWorld.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); + EXECUTOR_SERVICE.submit(new GT_Runnable_MachineBlockUpdate(aWorld, aCoords)); } } public static void initExecutorService() { - EXECUTOR_SERVICE = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), THREAD_FACTORY); - //Executors.newSingleThreadExecutor(THREAD_FACTORY); - //Executors.newCachedThreadPool(THREAD_FACTORY); - //Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(),THREAD_FACTORY); + EXECUTOR_SERVICE = Executors.newFixedThreadPool((Runtime.getRuntime().availableProcessors() * 2 / 3), THREAD_FACTORY); } public static void shutdownExecutorService() { @@ -87,7 +88,7 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { // Preserve interrupt status Thread.currentThread().interrupt(); }catch (Exception e){ - GT_Mod.GT_FML_LOGGER.error("Well this didn't terminated well...",e); + GT_Mod.GT_FML_LOGGER.error("Well this didn't terminated well...", e); // (Re-)Cancel in case EXECUTOR_SERVICE.shutdownNow(); }finally { @@ -95,70 +96,39 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { } } - private boolean shouldRecurse(TileEntity aTileEntity, int aX, int aY, int aZ) { - //no check on IGregTechTileEntity as it should call the underlying meta tile isMachineBlockUpdateRecursive - //if (aTileEntity instanceof IGregTechTileEntity) { - // return ((IGregTechTileEntity) aTileEntity).isMachineBlockUpdateRecursive(); - //} - return (aTileEntity instanceof IMachineBlockUpdateable && - ((IMachineBlockUpdateable) aTileEntity).isMachineBlockUpdateRecursive()) || - GregTech_API.isMachineBlock(world.getBlock(aX, aY, aZ), world.getBlockMetadata(aX, aY, aZ)); - } - - private void causeUpdate(TileEntity tileEntity) { - //no check for IGregTechTileEntity as it should call the underlying meta tile onMachineBlockUpdate - if (tileEntity instanceof IMachineBlockUpdateable) { - ((IMachineBlockUpdateable) tileEntity).onMachineBlockUpdate(); - } - } - - private void stepToUpdateMachine(int aX, int aY, int aZ) { - if (!visited.add(new ChunkPosition(aX, aY, aZ))) - return; - TileEntity tTileEntity = world.getTileEntity(aX, aY, aZ); - - causeUpdate(tTileEntity); - - if (visited.size() < 5 || shouldRecurse(tTileEntity, aX, aY, aZ)) { - stepToUpdateMachine(aX + 1, aY, aZ); - stepToUpdateMachine(aX - 1, aY, aZ); - stepToUpdateMachine(aX, aY + 1, aZ); - stepToUpdateMachine(aX, aY - 1, aZ); - stepToUpdateMachine(aX, aY, aZ + 1); - stepToUpdateMachine(aX, aY, aZ - 1); - } - } - @Override public void run() { try { - stepToUpdateMachine(x, y, z); + while (!tQueue.isEmpty()) { + final ChunkCoordinates aCoords = tQueue.poll(); + TileEntity tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); + + // See if the block itself needs an update + if (tTileEntity instanceof IMachineBlockUpdateable) + ((IMachineBlockUpdateable) tTileEntity).onMachineBlockUpdate(); + + // Now see if we should add the nearby blocks to the queue: + // 1) If we've visited less than 5 blocks, then yes + // 2) If the tile says we should recursively updated (pipes don't, machine blocks do) + // 3) If the block at the coordinates is marked as a machine block + if (visited.size() < 5 + || (tTileEntity instanceof IMachineBlockUpdateable && ((IMachineBlockUpdateable) tTileEntity).isMachineBlockUpdateRecursive()) + || GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ))) + { + ChunkCoordinates tCoords; + + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX + 1, aCoords.posY, aCoords.posZ))) tQueue.add(tCoords); + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX - 1, aCoords.posY, aCoords.posZ))) tQueue.add(tCoords); + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX, aCoords.posY + 1, aCoords.posZ))) tQueue.add(tCoords); + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX, aCoords.posY - 1, aCoords.posZ))) tQueue.add(tCoords); + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX, aCoords.posY, aCoords.posZ + 1))) tQueue.add(tCoords); + if (visited.add(tCoords = new ChunkCoordinates(aCoords.posX, aCoords.posY, aCoords.posZ - 1))) tQueue.add(tCoords); + } + } } catch (Exception e) { - GT_Mod.GT_FML_LOGGER.error("Well this update was broken... " + new Coordinates(x, y, z, world), e); + GT_Mod.GT_FML_LOGGER.error( + "Well this update was broken... " + mCoords + ", mWorld={" + world.getProviderName() + " @dimId " + world.provider.dimensionId + "}", e); } } - public static class Coordinates { - public final int mX; - public final int mY; - public final int mZ; - public final World mWorld; - - public Coordinates(int mX, int mY, int mZ, World mWorld) { - this.mX = mX; - this.mY = mY; - this.mZ = mZ; - this.mWorld = mWorld; - } - - @Override - public String toString() { - return "Coordinates{" + - "mX=" + mX + - ", mY=" + mY + - ", mZ=" + mZ + - ", mWorld=" + mWorld.getProviderName() + " @dimId " + mWorld.provider.dimensionId + - '}'; - } - } } -- cgit From f3a6e82f96c2d39b6f0b1066bb2c431addfcbb7d Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Mon, 18 Jan 2021 13:33:49 -0800 Subject: Do some locking around getTileEntity to avoid CMEs on the main thread --- .../threads/GT_Runnable_MachineBlockUpdate.java | 23 +++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 8f7a84e2cb..494b21de1f 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -1,5 +1,8 @@ package gregtech.api.threads; + +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent; import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; @@ -15,6 +18,7 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.ReentrantLock; public class GT_Runnable_MachineBlockUpdate implements Runnable { // used by runner thread @@ -23,6 +27,9 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { private final Set visited = new HashSet<>(80); private final Queue tQueue = new LinkedList<>(); + // Locking + private static ReentrantLock lock = new ReentrantLock(); + // Threading private static final ThreadFactory THREAD_FACTORY = r -> { Thread thread = new Thread(r); @@ -40,6 +47,15 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { } + @SubscribeEvent + public void onServerTick(TickEvent.ServerTickEvent aEvent) { + if (aEvent.phase == TickEvent.Phase.START) { + lock.lock(); + } else { + lock.unlock(); + } + } + public static boolean isEnabled() { return isEnabled; } @@ -101,8 +117,13 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { try { while (!tQueue.isEmpty()) { final ChunkCoordinates aCoords = tQueue.poll(); + + // This might load a chunk... which might load a TileEntity... which might get added to `loadedTileEntityList`... which might be in the process + // of being iterated over during `UpdateEntities()`... which might cause a ConcurrentModificationException. So, lock that shit. + lock.lock(); TileEntity tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); - + lock.unlock(); + // See if the block itself needs an update if (tTileEntity instanceof IMachineBlockUpdateable) ((IMachineBlockUpdateable) tTileEntity).onMachineBlockUpdate(); -- cgit From 94c98540f8a6044aa3e27722218f8eeb395e9cb1 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Mon, 18 Jan 2021 17:20:42 -0800 Subject: Include getBlock and getBlockMetadata in the lock --- .../java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 494b21de1f..09b2801c79 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -121,7 +121,8 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { // This might load a chunk... which might load a TileEntity... which might get added to `loadedTileEntityList`... which might be in the process // of being iterated over during `UpdateEntities()`... which might cause a ConcurrentModificationException. So, lock that shit. lock.lock(); - TileEntity tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); + final TileEntity tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); + final boolean isMachineBlock = GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ)); lock.unlock(); // See if the block itself needs an update @@ -134,7 +135,7 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { // 3) If the block at the coordinates is marked as a machine block if (visited.size() < 5 || (tTileEntity instanceof IMachineBlockUpdateable && ((IMachineBlockUpdateable) tTileEntity).isMachineBlockUpdateRecursive()) - || GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ))) + || isMachineBlock) { ChunkCoordinates tCoords; -- cgit From 6d58f65939261a915761c11ecf01848c2cef451c Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Mon, 18 Jan 2021 18:19:29 -0800 Subject: try/finally --- .../gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 09b2801c79..e46d63cdff 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -117,13 +117,18 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { try { while (!tQueue.isEmpty()) { final ChunkCoordinates aCoords = tQueue.poll(); + final TileEntity tTileEntity; + final boolean isMachineBlock; // This might load a chunk... which might load a TileEntity... which might get added to `loadedTileEntityList`... which might be in the process // of being iterated over during `UpdateEntities()`... which might cause a ConcurrentModificationException. So, lock that shit. lock.lock(); - final TileEntity tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); - final boolean isMachineBlock = GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ)); - lock.unlock(); + try { + tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); + isMachineBlock = GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ)); + } finally { + lock.unlock(); + } // See if the block itself needs an update if (tTileEntity instanceof IMachineBlockUpdateable) -- cgit From 17225fb5d3727f677121ec6017d5f09b632af9a9 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Mon, 18 Jan 2021 18:26:37 -0800 Subject: add comment as to onServerTick vs onWorldTick --- src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java | 1 + 1 file changed, 1 insertion(+) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index e46d63cdff..6564cf316a 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -49,6 +49,7 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { @SubscribeEvent public void onServerTick(TickEvent.ServerTickEvent aEvent) { + // Using onServerTick because there's race conditions in updateTrackedEntities() which is called AFTER the END phase of onWorldTick if (aEvent.phase == TickEvent.Phase.START) { lock.lock(); } else { -- cgit From d060269d882fa450ce8d58b463577a8a8b8eace2 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Thu, 21 Jan 2021 21:20:21 -0800 Subject: Make sure the onServerTick event is actually called. --- .../threads/GT_Runnable_MachineBlockUpdate.java | 22 +++------------------- 1 file changed, 3 insertions(+), 19 deletions(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 6564cf316a..3ce1daf9b2 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -1,11 +1,9 @@ package gregtech.api.threads; - -import cpw.mods.fml.common.eventhandler.SubscribeEvent; -import cpw.mods.fml.common.gameevent.TickEvent; import gregtech.GT_Mod; import gregtech.api.GregTech_API; import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; +import gregtech.common.GT_Proxy; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ChunkCoordinates; import net.minecraft.world.World; @@ -18,7 +16,6 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; -import java.util.concurrent.locks.ReentrantLock; public class GT_Runnable_MachineBlockUpdate implements Runnable { // used by runner thread @@ -27,9 +24,6 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { private final Set visited = new HashSet<>(80); private final Queue tQueue = new LinkedList<>(); - // Locking - private static ReentrantLock lock = new ReentrantLock(); - // Threading private static final ThreadFactory THREAD_FACTORY = r -> { Thread thread = new Thread(r); @@ -47,16 +41,6 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { } - @SubscribeEvent - public void onServerTick(TickEvent.ServerTickEvent aEvent) { - // Using onServerTick because there's race conditions in updateTrackedEntities() which is called AFTER the END phase of onWorldTick - if (aEvent.phase == TickEvent.Phase.START) { - lock.lock(); - } else { - lock.unlock(); - } - } - public static boolean isEnabled() { return isEnabled; } @@ -123,12 +107,12 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { // This might load a chunk... which might load a TileEntity... which might get added to `loadedTileEntityList`... which might be in the process // of being iterated over during `UpdateEntities()`... which might cause a ConcurrentModificationException. So, lock that shit. - lock.lock(); + GT_Proxy.TICK_LOCK.lock(); try { tTileEntity = world.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); isMachineBlock = GregTech_API.isMachineBlock(world.getBlock(aCoords.posX, aCoords.posY, aCoords.posZ), world.getBlockMetadata(aCoords.posX, aCoords.posY, aCoords.posZ)); } finally { - lock.unlock(); + GT_Proxy.TICK_LOCK.unlock(); } // See if the block itself needs an update -- cgit 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/threads/GT_Runnable_MachineBlockUpdate.java | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) (limited to 'src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java') diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java index 3ce1daf9b2..cc224b977d 100644 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java @@ -19,10 +19,10 @@ import java.util.concurrent.TimeUnit; public class GT_Runnable_MachineBlockUpdate implements Runnable { // used by runner thread - private final ChunkCoordinates mCoords; - private final World world; - private final Set visited = new HashSet<>(80); - private final Queue tQueue = new LinkedList<>(); + protected final ChunkCoordinates mCoords; + protected final World world; + protected final Set visited = new HashSet<>(80); + protected final Queue tQueue = new LinkedList<>(); // Threading private static final ThreadFactory THREAD_FACTORY = r -> { @@ -30,15 +30,14 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { thread.setName("GT_MachineBlockUpdate"); return thread; }; - private static ExecutorService EXECUTOR_SERVICE; + protected static ExecutorService EXECUTOR_SERVICE; // This class should never be initiated outside of this class! - private GT_Runnable_MachineBlockUpdate(World aWorld, ChunkCoordinates aCoords) { + protected GT_Runnable_MachineBlockUpdate(World aWorld, ChunkCoordinates aCoords) { this.world = aWorld; this.mCoords = aCoords; visited.add(aCoords); tQueue.add(aCoords); - } public static boolean isEnabled() { @@ -57,11 +56,10 @@ public class GT_Runnable_MachineBlockUpdate implements Runnable { GT_Runnable_MachineBlockUpdate.isEnabled = isEnabled; } - private static boolean isEnabled = true; + protected static boolean isEnabled = true; public static void setMachineUpdateValues(World aWorld, ChunkCoordinates aCoords) { if (isEnabled) { - aWorld.getTileEntity(aCoords.posX, aCoords.posY, aCoords.posZ); EXECUTOR_SERVICE.submit(new GT_Runnable_MachineBlockUpdate(aWorld, aCoords)); } } -- cgit