From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../api/threads/GT_Runnable_Cable_Update.java | 87 ---------- .../threads/GT_Runnable_MachineBlockUpdate.java | 184 --------------------- .../gregtech/api/threads/GT_Runnable_Sound.java | 41 ----- .../gregtech/api/threads/RunnableCableUpdate.java | 87 ++++++++++ .../api/threads/RunnableMachineUpdate.java | 184 +++++++++++++++++++++ .../java/gregtech/api/threads/RunnableSound.java | 41 +++++ 6 files changed, 312 insertions(+), 312 deletions(-) delete mode 100644 src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java delete mode 100644 src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java delete mode 100644 src/main/java/gregtech/api/threads/GT_Runnable_Sound.java create mode 100644 src/main/java/gregtech/api/threads/RunnableCableUpdate.java create mode 100644 src/main/java/gregtech/api/threads/RunnableMachineUpdate.java create mode 100644 src/main/java/gregtech/api/threads/RunnableSound.java (limited to 'src/main/java/gregtech/api/threads') 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 deleted file mode 100644 index 5e3b36f473..0000000000 --- a/src/main/java/gregtech/api/threads/GT_Runnable_Cable_Update.java +++ /dev/null @@ -1,87 +0,0 @@ -package gregtech.api.threads; - -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.World; -import net.minecraftforge.common.util.ForgeDirection; - -import com.gtnewhorizon.gtnhlib.util.CoordinatePacker; - -import gregtech.GT_Mod; -import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; -import gregtech.api.metatileentity.BaseMetaPipeEntity; -import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable; -import gregtech.common.GT_Proxy; - -public class GT_Runnable_Cable_Update extends GT_Runnable_MachineBlockUpdate { - - protected GT_Runnable_Cable_Update(World aWorld, int posX, int posY, int posZ) { - super(aWorld, posX, posY, posZ); - } - - public static void setCableUpdateValues(World aWorld, int posX, int posY, int posZ) { - if (isEnabled) { - EXECUTOR_SERVICE.submit(new GT_Runnable_Cable_Update(aWorld, posX, posY, posZ)); - } - } - - @Override - public void run() { - int posX, posY, posZ; - try { - while (!tQueue.isEmpty()) { - final long packedCoords = tQueue.dequeueLong(); - posX = CoordinatePacker.unpackX(packedCoords); - posY = CoordinatePacker.unpackY(packedCoords); - posZ = CoordinatePacker.unpackZ(packedCoords); - - final TileEntity tTileEntity; - - GT_Proxy.TICK_LOCK.lock(); - try { - // 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(posX, posY, posZ)) { - tTileEntity = world.getTileEntity(posX, posY, posZ); - } else { - tTileEntity = null; - } - } finally { - GT_Proxy.TICK_LOCK.unlock(); - } - - // 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: - // only add blocks the cable is connected to - if (tTileEntity instanceof BaseMetaPipeEntity metaPipe - && metaPipe.getMetaTileEntity() instanceof GT_MetaPipeEntity_Cable cable) { - for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { - final ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[i]; - if (cable.isConnectedAtSide(side)) { - final long tCoords = CoordinatePacker - .pack(posX + side.offsetX, posY + side.offsetY, posZ + side.offsetZ); - if (visited.add(tCoords)) { - tQueue.enqueue(tCoords); - } - } - } - } - } - } catch (Exception e) { - GT_Mod.GT_FML_LOGGER.error( - "Well this update was broken... " + initialX - + ", " - + initialY - + ", " - + initialZ - + ", mWorld={" - + world.getProviderName() - + " @dimId " - + world.provider.dimensionId - + "}", - e); - } - } -} diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java b/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java deleted file mode 100644 index 339556e246..0000000000 --- a/src/main/java/gregtech/api/threads/GT_Runnable_MachineBlockUpdate.java +++ /dev/null @@ -1,184 +0,0 @@ -package gregtech.api.threads; - -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.ThreadFactory; -import java.util.concurrent.TimeUnit; - -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.World; -import net.minecraftforge.common.util.ForgeDirection; - -import com.gtnewhorizon.gtnhlib.util.CoordinatePacker; - -import gregtech.GT_Mod; -import gregtech.api.GregTech_API; -import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; -import gregtech.common.GT_Proxy; -import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue; -import it.unimi.dsi.fastutil.longs.LongOpenHashSet; -import it.unimi.dsi.fastutil.longs.LongSet; - -public class GT_Runnable_MachineBlockUpdate implements Runnable { - - // used by runner thread - protected final int initialX, initialY, initialZ; - protected final World world; - protected final LongSet visited = new LongOpenHashSet(); - protected final LongArrayFIFOQueue tQueue = new LongArrayFIFOQueue(); - - // Threading - private static final ThreadFactory THREAD_FACTORY = r -> { - Thread thread = new Thread(r); - thread.setName("GT_MachineBlockUpdate"); - return thread; - }; - protected static ExecutorService EXECUTOR_SERVICE; - - // This class should never be initiated outside of this class! - protected GT_Runnable_MachineBlockUpdate(World aWorld, int posX, int posY, int posZ) { - this.world = aWorld; - this.initialX = posX; - this.initialY = posY; - this.initialZ = posZ; - final long coords = CoordinatePacker.pack(posX, posY, posZ); - visited.add(coords); - tQueue.enqueue(coords); - } - - public static boolean isEnabled() { - return isEnabled; - } - - public static void setEnabled() { - GT_Runnable_MachineBlockUpdate.isEnabled = true; - } - - public static void setDisabled() { - GT_Runnable_MachineBlockUpdate.isEnabled = false; - } - - public static void setEnabled(boolean isEnabled) { - GT_Runnable_MachineBlockUpdate.isEnabled = isEnabled; - } - - public static boolean isCurrentThreadEnabled() { - return perThreadEnable.get(); - } - - public static void setCurrentThreadEnabled(boolean perThreadEnable) { - GT_Runnable_MachineBlockUpdate.perThreadEnable.set(perThreadEnable); - } - - protected static boolean isEnabled = true; - protected static final ThreadLocal perThreadEnable = ThreadLocal.withInitial(() -> true); - - public static void setMachineUpdateValues(World aWorld, int posX, int posY, int posZ) { - if (isEnabled() && isCurrentThreadEnabled()) { - EXECUTOR_SERVICE.submit(new GT_Runnable_MachineBlockUpdate(aWorld, posX, posY, posZ)); - } - } - - public static void initExecutorService() { - EXECUTOR_SERVICE = Executors.newFixedThreadPool( - Math.max( - 1, - (Runtime.getRuntime() - .availableProcessors() * 2 - / 3)), - THREAD_FACTORY); - } - - public static void shutdownExecutorService() { - try { - GT_Mod.GT_FML_LOGGER.info("Shutting down Machine block update executor service"); - EXECUTOR_SERVICE.shutdown(); // Disable new tasks from being submitted - // Wait a while for existing tasks to terminate - if (!EXECUTOR_SERVICE.awaitTermination(60, TimeUnit.SECONDS)) { - EXECUTOR_SERVICE.shutdownNow(); // Cancel currently executing tasks - // Wait a while for tasks to respond to being cancelled - if (!EXECUTOR_SERVICE.awaitTermination(60, TimeUnit.SECONDS)) { - GT_Mod.GT_FML_LOGGER.error( - "Well this didn't terminated well... GT_Runnable_MachineBlockUpdate.shutdownExecutorService"); - } - } - } catch (InterruptedException ie) { - GT_Mod.GT_FML_LOGGER.error("Well this interruption got interrupted...", ie); - // (Re-)Cancel if current thread also interrupted - EXECUTOR_SERVICE.shutdownNow(); - // Preserve interrupt status - Thread.currentThread() - .interrupt(); - } catch (Exception e) { - GT_Mod.GT_FML_LOGGER.error("Well this didn't terminated well...", e); - // (Re-)Cancel in case - EXECUTOR_SERVICE.shutdownNow(); - } finally { - GT_Mod.GT_FML_LOGGER.info("Leaving... GT_Runnable_MachineBlockUpdate.shutdownExecutorService"); - } - } - - @Override - public void run() { - int posX, posY, posZ; - try { - while (!tQueue.isEmpty()) { - final long packedCoords = tQueue.dequeueLong(); - posX = CoordinatePacker.unpackX(packedCoords); - posY = CoordinatePacker.unpackY(packedCoords); - posZ = CoordinatePacker.unpackZ(packedCoords); - - 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. - GT_Proxy.TICK_LOCK.lock(); - try { - tTileEntity = world.getTileEntity(posX, posY, posZ); - isMachineBlock = GregTech_API - .isMachineBlock(world.getBlock(posX, posY, posZ), world.getBlockMetadata(posX, posY, posZ)); - } finally { - GT_Proxy.TICK_LOCK.unlock(); - } - - // 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()) - || isMachineBlock) { - for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { - final ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[i]; - final long tCoords = CoordinatePacker - .pack(posX + side.offsetX, posY + side.offsetY, posZ + side.offsetZ); - if (visited.add(tCoords)) { - tQueue.enqueue(tCoords); - } - } - } - } - } catch (Exception e) { - GT_Mod.GT_FML_LOGGER.error( - "Well this update was broken... " + initialX - + ", " - + initialY - + ", " - + initialZ - + ", mWorld={" - + world.getProviderName() - + " @dimId " - + world.provider.dimensionId - + "}", - e); - } - } -} diff --git a/src/main/java/gregtech/api/threads/GT_Runnable_Sound.java b/src/main/java/gregtech/api/threads/GT_Runnable_Sound.java deleted file mode 100644 index 9021a60e89..0000000000 --- a/src/main/java/gregtech/api/threads/GT_Runnable_Sound.java +++ /dev/null @@ -1,41 +0,0 @@ -package gregtech.api.threads; - -import net.minecraft.util.ResourceLocation; -import net.minecraft.world.World; - -import gregtech.api.util.GT_PlayedSound; -import gregtech.api.util.GT_Utility; - -public class GT_Runnable_Sound implements Runnable { - - private final double mX, mY, mZ; - private final int mTimeUntilNextSound; - private final World mWorld; - private final ResourceLocation mSoundResourceLocation; - private final float mSoundStrength, mSoundModulation; - - public GT_Runnable_Sound(World aWorld, double aX, double aY, double aZ, int aTimeUntilNextSound, - ResourceLocation aSoundResourceLocation, float aSoundStrength, float aSoundModulation) { - mWorld = aWorld; - mX = aX; - mY = aY; - mZ = aZ; - mTimeUntilNextSound = aTimeUntilNextSound; - mSoundResourceLocation = aSoundResourceLocation; - mSoundStrength = aSoundStrength; - mSoundModulation = aSoundModulation; - } - - @Override - public void run() { - try { - GT_PlayedSound tSound; - if (GT_Utility.sPlayedSoundMap.containsKey(tSound = new GT_PlayedSound(mSoundResourceLocation, mX, mY, mZ))) - return; - mWorld.playSound(mX, mY, mZ, mSoundResourceLocation.toString(), mSoundStrength, mSoundModulation, false); - GT_Utility.sPlayedSoundMap.put(tSound, mTimeUntilNextSound); - } catch (Throwable e) { - /**/ - } - } -} diff --git a/src/main/java/gregtech/api/threads/RunnableCableUpdate.java b/src/main/java/gregtech/api/threads/RunnableCableUpdate.java new file mode 100644 index 0000000000..7ed4e28554 --- /dev/null +++ b/src/main/java/gregtech/api/threads/RunnableCableUpdate.java @@ -0,0 +1,87 @@ +package gregtech.api.threads; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizon.gtnhlib.util.CoordinatePacker; + +import gregtech.GTMod; +import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; +import gregtech.api.metatileentity.BaseMetaPipeEntity; +import gregtech.api.metatileentity.implementations.MTECable; +import gregtech.common.GTProxy; + +public class RunnableCableUpdate extends RunnableMachineUpdate { + + protected RunnableCableUpdate(World aWorld, int posX, int posY, int posZ) { + super(aWorld, posX, posY, posZ); + } + + public static void setCableUpdateValues(World aWorld, int posX, int posY, int posZ) { + if (isEnabled) { + EXECUTOR_SERVICE.submit(new RunnableCableUpdate(aWorld, posX, posY, posZ)); + } + } + + @Override + public void run() { + int posX, posY, posZ; + try { + while (!tQueue.isEmpty()) { + final long packedCoords = tQueue.dequeueLong(); + posX = CoordinatePacker.unpackX(packedCoords); + posY = CoordinatePacker.unpackY(packedCoords); + posZ = CoordinatePacker.unpackZ(packedCoords); + + final TileEntity tTileEntity; + + GTProxy.TICK_LOCK.lock(); + try { + // 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(posX, posY, posZ)) { + tTileEntity = world.getTileEntity(posX, posY, posZ); + } else { + tTileEntity = null; + } + } finally { + GTProxy.TICK_LOCK.unlock(); + } + + // 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: + // only add blocks the cable is connected to + if (tTileEntity instanceof BaseMetaPipeEntity metaPipe + && metaPipe.getMetaTileEntity() instanceof MTECable cable) { + for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { + final ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[i]; + if (cable.isConnectedAtSide(side)) { + final long tCoords = CoordinatePacker + .pack(posX + side.offsetX, posY + side.offsetY, posZ + side.offsetZ); + if (visited.add(tCoords)) { + tQueue.enqueue(tCoords); + } + } + } + } + } + } catch (Exception e) { + GTMod.GT_FML_LOGGER.error( + "Well this update was broken... " + initialX + + ", " + + initialY + + ", " + + initialZ + + ", mWorld={" + + world.getProviderName() + + " @dimId " + + world.provider.dimensionId + + "}", + e); + } + } +} diff --git a/src/main/java/gregtech/api/threads/RunnableMachineUpdate.java b/src/main/java/gregtech/api/threads/RunnableMachineUpdate.java new file mode 100644 index 0000000000..d11e176f3d --- /dev/null +++ b/src/main/java/gregtech/api/threads/RunnableMachineUpdate.java @@ -0,0 +1,184 @@ +package gregtech.api.threads; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.TimeUnit; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizon.gtnhlib.util.CoordinatePacker; + +import gregtech.GTMod; +import gregtech.api.GregTechAPI; +import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; +import gregtech.common.GTProxy; +import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue; +import it.unimi.dsi.fastutil.longs.LongOpenHashSet; +import it.unimi.dsi.fastutil.longs.LongSet; + +public class RunnableMachineUpdate implements Runnable { + + // used by runner thread + protected final int initialX, initialY, initialZ; + protected final World world; + protected final LongSet visited = new LongOpenHashSet(); + protected final LongArrayFIFOQueue tQueue = new LongArrayFIFOQueue(); + + // Threading + private static final ThreadFactory THREAD_FACTORY = r -> { + Thread thread = new Thread(r); + thread.setName("GT_MachineBlockUpdate"); + return thread; + }; + protected static ExecutorService EXECUTOR_SERVICE; + + // This class should never be initiated outside of this class! + protected RunnableMachineUpdate(World aWorld, int posX, int posY, int posZ) { + this.world = aWorld; + this.initialX = posX; + this.initialY = posY; + this.initialZ = posZ; + final long coords = CoordinatePacker.pack(posX, posY, posZ); + visited.add(coords); + tQueue.enqueue(coords); + } + + public static boolean isEnabled() { + return isEnabled; + } + + public static void setEnabled() { + RunnableMachineUpdate.isEnabled = true; + } + + public static void setDisabled() { + RunnableMachineUpdate.isEnabled = false; + } + + public static void setEnabled(boolean isEnabled) { + RunnableMachineUpdate.isEnabled = isEnabled; + } + + public static boolean isCurrentThreadEnabled() { + return perThreadEnable.get(); + } + + public static void setCurrentThreadEnabled(boolean perThreadEnable) { + RunnableMachineUpdate.perThreadEnable.set(perThreadEnable); + } + + protected static boolean isEnabled = true; + protected static final ThreadLocal perThreadEnable = ThreadLocal.withInitial(() -> true); + + public static void setMachineUpdateValues(World aWorld, int posX, int posY, int posZ) { + if (isEnabled() && isCurrentThreadEnabled()) { + EXECUTOR_SERVICE.submit(new RunnableMachineUpdate(aWorld, posX, posY, posZ)); + } + } + + public static void initExecutorService() { + EXECUTOR_SERVICE = Executors.newFixedThreadPool( + Math.max( + 1, + (Runtime.getRuntime() + .availableProcessors() * 2 + / 3)), + THREAD_FACTORY); + } + + public static void shutdownExecutorService() { + try { + GTMod.GT_FML_LOGGER.info("Shutting down Machine block update executor service"); + EXECUTOR_SERVICE.shutdown(); // Disable new tasks from being submitted + // Wait a while for existing tasks to terminate + if (!EXECUTOR_SERVICE.awaitTermination(60, TimeUnit.SECONDS)) { + EXECUTOR_SERVICE.shutdownNow(); // Cancel currently executing tasks + // Wait a while for tasks to respond to being cancelled + if (!EXECUTOR_SERVICE.awaitTermination(60, TimeUnit.SECONDS)) { + GTMod.GT_FML_LOGGER.error( + "Well this didn't terminated well... GT_Runnable_MachineBlockUpdate.shutdownExecutorService"); + } + } + } catch (InterruptedException ie) { + GTMod.GT_FML_LOGGER.error("Well this interruption got interrupted...", ie); + // (Re-)Cancel if current thread also interrupted + EXECUTOR_SERVICE.shutdownNow(); + // Preserve interrupt status + Thread.currentThread() + .interrupt(); + } catch (Exception e) { + GTMod.GT_FML_LOGGER.error("Well this didn't terminated well...", e); + // (Re-)Cancel in case + EXECUTOR_SERVICE.shutdownNow(); + } finally { + GTMod.GT_FML_LOGGER.info("Leaving... GT_Runnable_MachineBlockUpdate.shutdownExecutorService"); + } + } + + @Override + public void run() { + int posX, posY, posZ; + try { + while (!tQueue.isEmpty()) { + final long packedCoords = tQueue.dequeueLong(); + posX = CoordinatePacker.unpackX(packedCoords); + posY = CoordinatePacker.unpackY(packedCoords); + posZ = CoordinatePacker.unpackZ(packedCoords); + + 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. + GTProxy.TICK_LOCK.lock(); + try { + tTileEntity = world.getTileEntity(posX, posY, posZ); + isMachineBlock = GregTechAPI + .isMachineBlock(world.getBlock(posX, posY, posZ), world.getBlockMetadata(posX, posY, posZ)); + } finally { + GTProxy.TICK_LOCK.unlock(); + } + + // 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()) + || isMachineBlock) { + for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { + final ForgeDirection side = ForgeDirection.VALID_DIRECTIONS[i]; + final long tCoords = CoordinatePacker + .pack(posX + side.offsetX, posY + side.offsetY, posZ + side.offsetZ); + if (visited.add(tCoords)) { + tQueue.enqueue(tCoords); + } + } + } + } + } catch (Exception e) { + GTMod.GT_FML_LOGGER.error( + "Well this update was broken... " + initialX + + ", " + + initialY + + ", " + + initialZ + + ", mWorld={" + + world.getProviderName() + + " @dimId " + + world.provider.dimensionId + + "}", + e); + } + } +} diff --git a/src/main/java/gregtech/api/threads/RunnableSound.java b/src/main/java/gregtech/api/threads/RunnableSound.java new file mode 100644 index 0000000000..30704f2a97 --- /dev/null +++ b/src/main/java/gregtech/api/threads/RunnableSound.java @@ -0,0 +1,41 @@ +package gregtech.api.threads; + +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; + +import gregtech.api.util.GTPlayedSound; +import gregtech.api.util.GTUtility; + +public class RunnableSound implements Runnable { + + private final double mX, mY, mZ; + private final int mTimeUntilNextSound; + private final World mWorld; + private final ResourceLocation mSoundResourceLocation; + private final float mSoundStrength, mSoundModulation; + + public RunnableSound(World aWorld, double aX, double aY, double aZ, int aTimeUntilNextSound, + ResourceLocation aSoundResourceLocation, float aSoundStrength, float aSoundModulation) { + mWorld = aWorld; + mX = aX; + mY = aY; + mZ = aZ; + mTimeUntilNextSound = aTimeUntilNextSound; + mSoundResourceLocation = aSoundResourceLocation; + mSoundStrength = aSoundStrength; + mSoundModulation = aSoundModulation; + } + + @Override + public void run() { + try { + GTPlayedSound tSound; + if (GTUtility.sPlayedSoundMap.containsKey(tSound = new GTPlayedSound(mSoundResourceLocation, mX, mY, mZ))) + return; + mWorld.playSound(mX, mY, mZ, mSoundResourceLocation.toString(), mSoundStrength, mSoundModulation, false); + GTUtility.sPlayedSoundMap.put(tSound, mTimeUntilNextSound); + } catch (Throwable e) { + /**/ + } + } +} -- cgit