From 5decfda1dd1b3bbfdb1098f409aa50162ea32dc2 Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Thu, 15 Aug 2024 22:44:13 +0100 Subject: Electric jukebox (#2827) * GT music system * Minor fix for some glitches when switching dimensions with P2Ps on both sides * Most features implemented except headphones * Implement wireless headphones * Disable debug mode * Spotless --------- Co-authored-by: Martin Robertz --- .../bartworks/common/net/BW_Network.java | 9 + src/main/java/gregtech/api/enums/GT_Values.java | 5 + src/main/java/gregtech/api/enums/ItemList.java | 10 +- .../java/gregtech/api/enums/MetaTileEntityIDs.java | 5 + src/main/java/gregtech/api/enums/Textures.java | 3 + .../gregtech/api/gui/modularui/GT_UITextures.java | 2 + .../api/metatileentity/CommonMetaTileEntity.java | 34 +- src/main/java/gregtech/api/net/GT_PacketTypes.java | 1 + .../api/net/GT_Packet_MusicSystemData.java | 58 ++ .../java/gregtech/api/net/IGT_NetworkHandler.java | 4 + .../java/gregtech/api/util/GT_MusicSystem.java | 666 +++++++++++++++++++ .../java/gregtech/client/ElectricJukeboxSound.java | 95 +++ src/main/java/gregtech/client/ISeekingSound.java | 14 + src/main/java/gregtech/client/SeekingOggCodec.java | 98 +++ src/main/java/gregtech/common/GT_Client.java | 18 + src/main/java/gregtech/common/GT_Network.java | 9 + src/main/java/gregtech/common/GT_Proxy.java | 17 +- .../common/items/GT_WirelessHeadphones.java | 118 ++++ src/main/java/gregtech/common/misc/GT_Command.java | 23 +- .../basic/GT_MetaTileEntity_BetterJukebox.java | 707 +++++++++++++++++++++ .../preload/GT_Loader_Item_Block_And_Fluid.java | 2 + .../preload/GT_Loader_MetaTileEntities.java | 40 ++ src/main/java/gregtech/mixin/Mixin.java | 6 + .../core/block/machine/Machine_SuperJukebox.java | 18 +- src/main/resources/META-INF/ggfab_at.cfg | 2 - src/main/resources/META-INF/gregtech_at.cfg | 25 + src/main/resources/META-INF/tectech_at.cfg | 17 - src/main/resources/assets/gregtech/lang/en_US.lang | 6 + .../blocks/iconsets/OVERLAY_SIDE_JUKEBOX.png | Bin 0 -> 149 bytes .../blocks/iconsets/OVERLAY_TOP_JUKEBOX.png | Bin 0 -> 208 bytes .../textures/gui/overlay_button/shuffle.png | Bin 0 -> 354 bytes .../textures/items/gt.WirelessHeadphones.png | Bin 0 -> 232 bytes .../resources/assets/miscutils/lang/en_US.lang | 1 + src/main/resources/soundmeta/durations.json | 16 + 34 files changed, 2002 insertions(+), 27 deletions(-) create mode 100644 src/main/java/gregtech/api/net/GT_Packet_MusicSystemData.java create mode 100644 src/main/java/gregtech/api/util/GT_MusicSystem.java create mode 100644 src/main/java/gregtech/client/ElectricJukeboxSound.java create mode 100644 src/main/java/gregtech/client/ISeekingSound.java create mode 100644 src/main/java/gregtech/client/SeekingOggCodec.java create mode 100644 src/main/java/gregtech/common/items/GT_WirelessHeadphones.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_BetterJukebox.java delete mode 100644 src/main/resources/META-INF/ggfab_at.cfg create mode 100644 src/main/resources/META-INF/gregtech_at.cfg delete mode 100644 src/main/resources/META-INF/tectech_at.cfg create mode 100644 src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_SIDE_JUKEBOX.png create mode 100644 src/main/resources/assets/gregtech/textures/blocks/iconsets/OVERLAY_TOP_JUKEBOX.png create mode 100644 src/main/resources/assets/gregtech/textures/gui/overlay_button/shuffle.png create mode 100644 src/main/resources/assets/gregtech/textures/items/gt.WirelessHeadphones.png create mode 100644 src/main/resources/soundmeta/durations.json (limited to 'src/main') diff --git a/src/main/java/com/github/bartimaeusnek/bartworks/common/net/BW_Network.java b/src/main/java/com/github/bartimaeusnek/bartworks/common/net/BW_Network.java index b5e002ef29..01085e2b31 100644 --- a/src/main/java/com/github/bartimaeusnek/bartworks/common/net/BW_Network.java +++ b/src/main/java/com/github/bartimaeusnek/bartworks/common/net/BW_Network.java @@ -120,6 +120,15 @@ public class BW_Network extends MessageToMessageCodec outputs) { + if (hasValidMetaTileEntity() && getMetaTileEntity() instanceof ISoundP2PHandler metaHandler) { + metaHandler.onSoundP2POutputUpdate(p2p, outputs); + } + } } diff --git a/src/main/java/gregtech/api/net/GT_PacketTypes.java b/src/main/java/gregtech/api/net/GT_PacketTypes.java index 18fc5134ba..f59a7918a9 100644 --- a/src/main/java/gregtech/api/net/GT_PacketTypes.java +++ b/src/main/java/gregtech/api/net/GT_PacketTypes.java @@ -31,6 +31,7 @@ public enum GT_PacketTypes { MULTI_TILE_ENTITY(18, new GT_Packet_MultiTileEntity(true)), SEND_OREGEN_PATTERN(19, new GT_Packet_SendOregenPattern()), TOOL_SWITCH_MODE(20, new GT_Packet_ToolSwitchMode()), + MUSIC_SYSTEM_DATA(21, new GT_Packet_MusicSystemData()), // merge conflict prevention comment, keep a trailing comma above ; diff --git a/src/main/java/gregtech/api/net/GT_Packet_MusicSystemData.java b/src/main/java/gregtech/api/net/GT_Packet_MusicSystemData.java new file mode 100644 index 0000000000..13ebf49205 --- /dev/null +++ b/src/main/java/gregtech/api/net/GT_Packet_MusicSystemData.java @@ -0,0 +1,58 @@ +package gregtech.api.net; + +import net.minecraft.world.IBlockAccess; + +import com.google.common.io.ByteArrayDataInput; + +import gregtech.api.util.GT_MusicSystem; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; + +public class GT_Packet_MusicSystemData extends GT_Packet_New { + + ByteBuf storedData; + + public GT_Packet_MusicSystemData() { + super(true); + } + + public GT_Packet_MusicSystemData(ByteBuf data) { + super(false); + this.storedData = data; + } + + @Override + public byte getPacketID() { + return GT_PacketTypes.MUSIC_SYSTEM_DATA.id; + } + + @Override + public void encode(ByteBuf aOut) { + if (storedData == null) { + return; + } + storedData.markReaderIndex(); + final int len = storedData.readableBytes(); + aOut.writeInt(len); + aOut.writeBytes(storedData); + storedData.resetReaderIndex(); + } + + @Override + public GT_Packet_New decode(ByteArrayDataInput aData) { + final int len = aData.readInt(); + final byte[] fullData = new byte[len]; + aData.readFully(fullData); + return new GT_Packet_MusicSystemData(Unpooled.wrappedBuffer(fullData)); + } + + @Override + public void process(IBlockAccess aWorld) { + if (aWorld == null || storedData == null) { + return; + } + storedData.markReaderIndex(); + GT_MusicSystem.ClientSystem.loadUpdatedSources(storedData); + storedData.resetReaderIndex(); + } +} diff --git a/src/main/java/gregtech/api/net/IGT_NetworkHandler.java b/src/main/java/gregtech/api/net/IGT_NetworkHandler.java index 07c4a37030..8436a89e9b 100644 --- a/src/main/java/gregtech/api/net/IGT_NetworkHandler.java +++ b/src/main/java/gregtech/api/net/IGT_NetworkHandler.java @@ -12,6 +12,10 @@ public interface IGT_NetworkHandler { void sendToAllAround(GT_Packet aPacket, TargetPoint aPosition); + default void sendToAll(GT_Packet aPacket) { + throw new UnsupportedOperationException("sendToAll not implemented"); + } + void sendToServer(GT_Packet aPacket); void sendPacketToAllPlayersInRange(World aWorld, GT_Packet aPacket, int aX, int aZ); diff --git a/src/main/java/gregtech/api/util/GT_MusicSystem.java b/src/main/java/gregtech/api/util/GT_MusicSystem.java new file mode 100644 index 0000000000..3a171e0395 --- /dev/null +++ b/src/main/java/gregtech/api/util/GT_MusicSystem.java @@ -0,0 +1,666 @@ +package gregtech.api.util; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Map; +import java.util.TreeMap; +import java.util.UUID; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.audio.SoundEventAccessorComposite; +import net.minecraft.client.audio.SoundRegistry; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemRecord; +import net.minecraft.item.ItemStack; +import net.minecraft.launchwrapper.Launch; +import net.minecraft.util.ResourceLocation; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.io.IOUtils; +import org.jetbrains.annotations.ApiStatus; +import org.joml.Vector4i; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.jcraft.jorbis.VorbisFile; + +import baubles.api.BaublesApi; +import cpw.mods.fml.common.network.ByteBufUtils; +import gregtech.GT_Mod; +import gregtech.api.enums.GT_Values; +import gregtech.api.net.GT_Packet_MusicSystemData; +import gregtech.client.ElectricJukeboxSound; +import gregtech.common.items.GT_WirelessHeadphones; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_BetterJukebox; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; +import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; +import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; + +/** + * A system that keeps track of jukebox music tracks playing in different locations. + * Compared to vanilla jukebox handling, this allows music to resume playing after reloading the chunk the jukeboxes are + * in. + * It also allows the headphone item to modify the hearing range of a given disc, including other dimensions. + *

+ * Vector4i coordinates point to X,Y,Z,Dimension of the source + * + * @author eigenraven + */ +public final class GT_MusicSystem { + + private GT_MusicSystem() {} + + public static final class MusicSource { + + /** Flag keeping track of when the data of this source needs to be sent to clients again */ + public boolean modified; + public final UUID sourceID; + /** Currently playing track */ + public ResourceLocation currentRecord; + /** Headphone range */ + public GT_MetaTileEntity_BetterJukebox.HeadphoneLimit headphoneLimit; + /** + * {@link System#currentTimeMillis()} at the time this record started playing, in server time + */ + public long startedPlayingAtMs; + /** Time the record was playing for at the time it was serialized. */ + public long playingForMs; + /** The origin of this source used for wireless headphone range calculations */ + public final Vector4i originPosition = new Vector4i(); + /** Number of blocks from {@link MusicSource#originPosition} the headphones can work */ + public int headphoneBlockRange; + /** Densely packed parameters for each "emitter" associated with the source, for fast iteration */ + public int[] emitterParameters; // [{x,y,z,dim,volume}, {x, ...}, {x, ...}, ...] + /** Offsets into the parameters array */ + public static final int EMITTER_X = 0; + /** Offsets into the parameters array */ + public static final int EMITTER_Y = 1; + /** Offsets into the parameters array */ + public static final int EMITTER_Z = 2; + /** Offsets into the parameters array */ + public static final int EMITTER_DIMENSION = 3; + /** 100 times the floating point "volume" used by the sound system for range calculations */ + public static final int EMITTER_VOLUME_X_100 = 4; + /** Iteration stride for packed emitter parameters */ + public static final int EMITTER_STRIDE = EMITTER_VOLUME_X_100 + 1; + + public MusicSource(UUID sourceID) { + this.sourceID = sourceID; + } + + public void resizeEmitterArray(int count) { + int len = count * EMITTER_STRIDE; + if (emitterParameters == null || emitterParameters.length != len) { + if (emitterParameters == null) { + emitterParameters = new int[len]; + } else { + emitterParameters = Arrays.copyOf(emitterParameters, len); + } + modified = true; + } + } + + public void setEmitter(int index, Vector4i position, float volume) { + int arrIndex = index * EMITTER_STRIDE; + if (arrIndex < 0 || arrIndex >= emitterParameters.length) { + throw new IndexOutOfBoundsException( + "Trying to access emitter with index " + index + + " in an array of " + + emitterParameters.length / EMITTER_STRIDE); + } + + if (emitterParameters[arrIndex + EMITTER_X] != position.x) { + modified = true; + emitterParameters[arrIndex + EMITTER_X] = position.x; + } + if (emitterParameters[arrIndex + EMITTER_Y] != position.y) { + modified = true; + emitterParameters[arrIndex + EMITTER_Y] = position.y; + } + if (emitterParameters[arrIndex + EMITTER_Z] != position.z) { + modified = true; + emitterParameters[arrIndex + EMITTER_Z] = position.z; + } + if (emitterParameters[arrIndex + EMITTER_DIMENSION] != position.w) { + modified = true; + emitterParameters[arrIndex + EMITTER_DIMENSION] = position.w; + } + final int intVolume = (int) (volume * 100.0f); + if (emitterParameters[arrIndex + EMITTER_VOLUME_X_100] != intVolume) { + modified = true; + emitterParameters[arrIndex + EMITTER_VOLUME_X_100] = intVolume; + } + } + + /** x squared */ + private static int sq(int x) { + return x * x; + } + + /** @return Index of closest emitter in range, or -1 if none is nearby. */ + public int closestEmitter(int x, int y, int z, int dim) { + int closest = -1; + int closestDistanceSq = Integer.MAX_VALUE; + final int emittersCount = emitterParameters.length / EMITTER_STRIDE; + for (int i = 0; i < emittersCount; i++) { + final int offset = i * EMITTER_STRIDE; + final int eDim = emitterParameters[offset + EMITTER_DIMENSION]; + if (eDim != dim) { + continue; + } + final int eX = emitterParameters[offset + EMITTER_X]; + final int eY = emitterParameters[offset + EMITTER_Y]; + final int eZ = emitterParameters[offset + EMITTER_Z]; + final int distanceSq = sq(x - eX) + sq(y - eY) + sq(z - eZ); + if (distanceSq < closestDistanceSq) { + closestDistanceSq = distanceSq; + closest = i; + } + } + return closest; + } + + public boolean inHeadphoneRange(int x, int y, int z, int dim) { + return switch (headphoneLimit) { + case BETWEEN_DIMENSIONS -> true; + case INSIDE_DIMENSION -> dim == originPosition.w; + case BLOCK_RANGE -> dim == originPosition.w + && originPosition.distanceSquared(x, y, z, dim) <= sq(headphoneBlockRange); + }; + } + + public void encode(final ByteBuf target) { + target.writeLong(sourceID.getMostSignificantBits()); + target.writeLong(sourceID.getLeastSignificantBits()); + if (currentRecord != null) { + final int duration = getMusicRecordDurations().getOrDefault(currentRecord, Integer.MAX_VALUE); + if (playingForMs >= duration) { + // Record already finished playing, let's not send it to the client anymore. + target.writeBoolean(false); + } else { + target.writeBoolean(true); + ByteBufUtils.writeUTF8String(target, currentRecord.getResourceDomain()); + ByteBufUtils.writeUTF8String(target, currentRecord.getResourcePath()); + } + } else { + target.writeBoolean(false); + } + target.writeByte((byte) headphoneLimit.ordinal()); + ByteBufUtils.writeVarInt(target, headphoneBlockRange, 5); + target.writeLong(startedPlayingAtMs); + target.writeLong(playingForMs); + ByteBufUtils.writeVarInt(target, originPosition.x, 5); + ByteBufUtils.writeVarInt(target, originPosition.y, 5); + ByteBufUtils.writeVarInt(target, originPosition.z, 5); + ByteBufUtils.writeVarInt(target, originPosition.w, 5); + ByteBufUtils.writeVarInt(target, emitterParameters.length, 5); + for (int emitterParameter : emitterParameters) { + ByteBufUtils.writeVarInt(target, emitterParameter, 5); + } + } + + public static MusicSource decode(final ByteBuf bytes) { + final long uuidMsb = bytes.readLong(); + final long uuidLsb = bytes.readLong(); + final MusicSource source = new MusicSource(new UUID(uuidMsb, uuidLsb)); + final boolean hasRecord = bytes.readBoolean(); + if (hasRecord) { + final String domain = ByteBufUtils.readUTF8String(bytes); + final String path = ByteBufUtils.readUTF8String(bytes); + source.currentRecord = new ResourceLocation(domain, path); + } + source.headphoneLimit = GT_MetaTileEntity_BetterJukebox.HeadphoneLimit.ENTRIES.get(bytes.readByte()); + source.headphoneBlockRange = ByteBufUtils.readVarInt(bytes, 5); + source.startedPlayingAtMs = bytes.readLong(); + source.playingForMs = bytes.readLong(); + final int originX = ByteBufUtils.readVarInt(bytes, 5); + final int originY = ByteBufUtils.readVarInt(bytes, 5); + final int originZ = ByteBufUtils.readVarInt(bytes, 5); + final int originW = ByteBufUtils.readVarInt(bytes, 5); + source.originPosition.set(originX, originY, originZ, originW); + final int emittersLength = ByteBufUtils.readVarInt(bytes, 5); + source.emitterParameters = new int[emittersLength]; + for (int i = 0; i < emittersLength; i++) { + source.emitterParameters[i] = ByteBufUtils.readVarInt(bytes, 5); + } + + return source; + } + + public void setRecord(final ResourceLocation record) { + setRecord(record, 0); + } + + public void setRecord(final ResourceLocation record, long seekOffset) { + modified = true; + currentRecord = record; + playingForMs = seekOffset; + startedPlayingAtMs = System.currentTimeMillis() - seekOffset; + } + } + + public static final class ServerSystem { + + static final Object2ObjectOpenHashMap musicSources = new Object2ObjectOpenHashMap<>(32); + static boolean musicSourcesDirty = false; + + // Everything is synchronized to allow calling into here from the client when singleplayer synchronization is + // needed. + + public static synchronized MusicSource registerOrGetMusicSource(UUID uuid) { + return musicSources.computeIfAbsent(uuid, (UUID id) -> { + musicSourcesDirty = true; + return new MusicSource(id); + }); + } + + public static synchronized void removeMusicSource(UUID uuid) { + musicSources.remove(uuid); + musicSourcesDirty = true; + } + + public static synchronized void reset() { + musicSources.clear(); + musicSourcesDirty = true; + } + + public static synchronized ByteBuf serialize() { + final ByteBuf out = Unpooled.buffer(); + ByteBufUtils.writeVarInt(out, musicSources.size(), 5); + musicSources.forEach((uuid, source) -> source.encode(out)); + return out; + } + + private static boolean tickAnyDirty; + + public static synchronized void tick() { + final long now = System.currentTimeMillis(); + tickAnyDirty = false; + musicSources.forEach((uuid, source) -> { + source.playingForMs = now - source.startedPlayingAtMs; + tickAnyDirty |= source.modified; + source.modified = false; + }); + if (tickAnyDirty || musicSourcesDirty) { + musicSourcesDirty = false; + GT_Values.NW.sendToAll(new GT_Packet_MusicSystemData(serialize())); + } + } + + static synchronized void onPauseMs(long pauseDurationMs) { + musicSources.forEach((uuid, source) -> { source.startedPlayingAtMs += pauseDurationMs; }); + } + } + + public static final class ClientSystem { + + private static final class ClientSourceData { + + /** Currently playing sound data */ + public ElectricJukeboxSound currentSound = null; + /** Currently playing sound data */ + public ResourceLocation currentSoundResource = null; + /** + * Server's timer value of when the music started, mostly meaningless except for checking for replays of the + * same music file. + */ + public long originalStartTime = 0; + /** + * Computed client value of {@link System#currentTimeMillis()} of the time when the playback would have + * started if it was synchronized with the server. + */ + public long clientReferenceStartTime = 0; + /** Flag for mark and sweep removal of outdated sounds */ + public boolean markFlag = false; + + public void resetMark() { + markFlag = false; + } + + public void mark() { + markFlag = true; + } + + public void clearSound(final Minecraft mc) { + currentSoundResource = null; + if (currentSound != null) { + mc.getSoundHandler() + .stopSound(currentSound); + currentSound = null; + originalStartTime = 0; + } + } + + public boolean equalSound(final MusicSource source) { + if (source == null || source.currentRecord == null) { + return currentSoundResource == null; + } else { + return source.currentRecord.equals(currentSoundResource) + && originalStartTime == source.startedPlayingAtMs; + } + } + + public void resetSound(final Minecraft mc, final MusicSource source, final boolean onHeadphones) { + clearSound(mc); + if (source == null || source.emitterParameters.length == 0) { + return; + } + int closestEmitter = onHeadphones ? 0 + : source.closestEmitter( + (int) Math.floor(mc.thePlayer.posX), + (int) Math.floor(mc.thePlayer.posY), + (int) Math.floor(mc.thePlayer.posZ), + currentDimension); + if (closestEmitter < 0) { + return; + } + this.currentSoundResource = source.currentRecord; + this.originalStartTime = source.startedPlayingAtMs; + this.clientReferenceStartTime = System.currentTimeMillis() - source.playingForMs; + if (currentSoundResource != null) { + this.currentSound = makeRecord(source, closestEmitter); + if (onHeadphones) { + this.currentSound.volume = 1.0e20f; + } + mc.getSoundHandler() + .playSound(this.currentSound); + } + } + + public void updateSound(final Minecraft mc, final MusicSource source, final boolean onHeadphones) { + if (source == null || currentSound == null || source.emitterParameters.length == 0) { + return; + } + int closestEmitter = onHeadphones ? 0 + : source.closestEmitter( + (int) Math.floor(mc.thePlayer.posX), + (int) Math.floor(mc.thePlayer.posY), + (int) Math.floor(mc.thePlayer.posZ), + currentDimension); + if (closestEmitter < 0) { + currentSound.volume = 0.0f; + return; + } + final int offset = closestEmitter * MusicSource.EMITTER_STRIDE; + currentSound.xPosition = source.emitterParameters[offset + MusicSource.EMITTER_X]; + currentSound.yPosition = source.emitterParameters[offset + MusicSource.EMITTER_Y]; + currentSound.zPosition = source.emitterParameters[offset + MusicSource.EMITTER_Z]; + currentSound.volume = onHeadphones ? 1.0e20f + : source.emitterParameters[offset + MusicSource.EMITTER_VOLUME_X_100] / 100.0f; + } + } + + /** Latest music source list as synchronized from the server */ + public static final Object2ObjectOpenHashMap musicSources = new Object2ObjectOpenHashMap<>(); + + private static final Object2ObjectOpenHashMap activelyPlayingMusic = new Object2ObjectOpenHashMap<>( + 16); + + private static final ObjectOpenHashSet wornHeadphones = new ObjectOpenHashSet<>(); + + private static int currentDimension = Integer.MIN_VALUE; + + private static boolean soundsPaused = false; + private static long pauseTimeMs = 0; + private static int tickCounter = 0; + + public static void loadUpdatedSources(ByteBuf bytes) { + final int sourceCount = ByteBufUtils.readVarInt(bytes, 5); + musicSources.clear(); + for (int i = 0; i < sourceCount; i++) { + final MusicSource source = MusicSource.decode(bytes); + musicSources.put(source.sourceID, source); + } + } + + private static ElectricJukeboxSound makeRecord(MusicSource source, int emitter) { + final int x = source.emitterParameters[emitter * MusicSource.EMITTER_STRIDE + MusicSource.EMITTER_X]; + final int y = source.emitterParameters[emitter * MusicSource.EMITTER_STRIDE + MusicSource.EMITTER_Y]; + final int z = source.emitterParameters[emitter * MusicSource.EMITTER_STRIDE + MusicSource.EMITTER_Z]; + final float volume = source.emitterParameters[emitter * MusicSource.EMITTER_STRIDE + + MusicSource.EMITTER_VOLUME_X_100] / 100.0f; + return new ElectricJukeboxSound(source.currentRecord, volume, source.playingForMs, x, y, z); + } + + public static void dumpAllRecordDurations() { + try { + final Minecraft mc = Minecraft.getMinecraft(); + final SoundRegistry sm = mc.getSoundHandler().sndRegistry; + final SoundDurationsJson json = new SoundDurationsJson(); + @SuppressWarnings("unchecked") + final Map allRecords = ItemRecord.field_150928_b; + // Cursed hack because JOrbis does not support seeking in anything other than filesystem files. + // This is only a dev tool, so it can be a bit slow and use real files here. + final File tempFile = File.createTempFile("mcdecode", ".ogg"); + for (final ItemRecord record : allRecords.values()) { + try { + final ResourceLocation res = record.getRecordResource(record.recordName); + SoundEventAccessorComposite registryEntry = (SoundEventAccessorComposite) sm.getObject(res); + if (registryEntry == null) { + registryEntry = (SoundEventAccessorComposite) sm.getObject( + new ResourceLocation(res.getResourceDomain(), "records." + res.getResourcePath())); + } + final ResourceLocation realPath = registryEntry.func_148720_g() + .getSoundPoolEntryLocation(); + try (final InputStream is = mc.getResourceManager() + .getResource(realPath) + .getInputStream(); final OutputStream os = FileUtils.openOutputStream(tempFile)) { + IOUtils.copy(is, os); + os.close(); + final VorbisFile vf = new VorbisFile(tempFile.getAbsolutePath()); + final float totalSeconds = vf.time_total(-1); + json.soundDurationsMs.put(res.toString(), (int) Math.ceil(totalSeconds * 1000.0f)); + } + } catch (Exception e) { + GT_Mod.GT_FML_LOGGER.warn("Skipping {}", record.recordName, e); + } + } + GT_Mod.GT_FML_LOGGER.info( + "Sound durations json: \n{}", + new GsonBuilder().setPrettyPrinting() + .create() + .toJson(json)); + tempFile.delete(); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static void reset() { + musicSources.clear(); + tick(); + } + + public static void tick() { + final Minecraft mc = Minecraft.getMinecraft(); + if (mc == null || mc.renderGlobal == null + || mc.theWorld == null + || mc.thePlayer == null + || mc.theWorld.provider == null) { + return; + } + tickCounter++; + final long now = System.currentTimeMillis(); + currentDimension = mc.theWorld.provider.dimensionId; + + headphoneCheck: if ((tickCounter % 20) == 0) { + wornHeadphones.clear(); + final IInventory baubles = BaublesApi.getBaubles(mc.thePlayer); + if (baubles == null) { + break headphoneCheck; + } + final int baublesSize = baubles.getSizeInventory(); + for (int i = 0; i < baublesSize; i++) { + final ItemStack item = baubles.getStackInSlot(i); + if (item != null && item.getItem() instanceof GT_WirelessHeadphones headphones) { + final UUID id = headphones.getBoundJukeboxUUID(item); + if (id != null) { + wornHeadphones.add(id); + } + } + } + } + + activelyPlayingMusic.forEach((uuid, data) -> data.resetMark()); + + // Update and mark all present music streams + musicSources.forEach((uuid, musicSource) -> { + final ClientSourceData data = activelyPlayingMusic + .computeIfAbsent(uuid, ignored -> new ClientSourceData()); + data.mark(); + if (data.currentSound != null && !mc.getSoundHandler() + .isSoundPlaying(data.currentSound) + && (now - data.clientReferenceStartTime) + < getMusicRecordDurations().getOrDefault(data.currentSoundResource, Integer.MAX_VALUE)) { + data.currentSound = null; + data.currentSoundResource = null; + } + final boolean onHeadphones = wornHeadphones.contains(uuid); + if (!data.equalSound(musicSource)) { + data.resetSound(mc, musicSource, onHeadphones); + } else { + data.updateSound(mc, musicSource, onHeadphones); + } + }); + + // Sweep no longer present music streams + final var entries = activelyPlayingMusic.object2ObjectEntrySet() + .fastIterator(); + while (entries.hasNext()) { + final ClientSourceData entry = entries.next() + .getValue(); + if (!entry.markFlag) { + entry.clearSound(mc); + entries.remove(); + } + } + } + + @ApiStatus.Internal + public static void onSoundBatchStop() { + // All music was forcibly stopped, we can forget about the currently playing music + // and let the update loop re-start them on next tick + long now = System.currentTimeMillis(); + activelyPlayingMusic.forEach((uuid, data) -> { + data.currentSound = null; + data.currentSoundResource = null; + final MusicSource source = musicSources.get(uuid); + if (source == null) { + return; + } + source.playingForMs = now - data.clientReferenceStartTime; + }); + } + + @ApiStatus.Internal + public static void onSoundBatchPause() { + if (soundsPaused) { + return; + } + soundsPaused = true; + pauseTimeMs = System.currentTimeMillis(); + } + + @ApiStatus.Internal + public static void onSoundBatchResume() { + if (!soundsPaused) { + return; + } + final Minecraft mc = Minecraft.getMinecraft(); + if (mc == null || mc.renderGlobal == null + || mc.theWorld == null + || mc.thePlayer == null + || mc.theWorld.provider == null) { + return; + } + soundsPaused = false; + + if (!(mc.isSingleplayer() && !mc.getIntegratedServer() + .getPublic())) { + return; + } + final long now = System.currentTimeMillis(); + final long pauseDurationMs = now - pauseTimeMs; + + // We manipulate server state here, because we've checked this is singleplayer pausing. + GT_MusicSystem.ServerSystem.onPauseMs(pauseDurationMs); + musicSources.forEach((uuid, source) -> { source.startedPlayingAtMs += pauseDurationMs; }); + activelyPlayingMusic.forEach((uuid, data) -> { + data.originalStartTime += pauseDurationMs; + data.clientReferenceStartTime += pauseDurationMs; + }); + + } + } + + private static final Object2IntOpenHashMap musicRecordDurations = new Object2IntOpenHashMap<>(); + private static volatile boolean musicRecordsInitialized; + + /** For GSON consumption */ + public static class SoundDurationsJson { + + public Map soundDurationsMs = new TreeMap<>(); + } + + public static Object2IntOpenHashMap getMusicRecordDurations() { + if (musicRecordsInitialized) { + return musicRecordDurations; + } + // double-checked locking for efficiency + synchronized (musicRecordDurations) { + if (musicRecordsInitialized) { + return musicRecordDurations; + } + + final Gson gson = new Gson(); + + try { + final ArrayList candidates = Collections.list( + GT_MusicSystem.class.getClassLoader() + .getResources("soundmeta/durations.json")); + final Path configPath = Launch.minecraftHome.toPath() + .resolve("config") + .resolve("soundmeta") + .resolve("durations.json"); + if (Files.exists(configPath)) { + candidates.add( + configPath.toUri() + .toURL()); + } + for (final URL url : candidates) { + try { + final String objectJson = IOUtils.toString(url); + final SoundDurationsJson object = gson.fromJson(objectJson, SoundDurationsJson.class); + if (object == null || object.soundDurationsMs == null || object.soundDurationsMs.isEmpty()) { + continue; + } + for (final var entry : object.soundDurationsMs.entrySet()) { + musicRecordDurations.put( + new ResourceLocation(entry.getKey()), + entry.getValue() + .intValue()); + } + } catch (Exception e) { + GT_Mod.GT_FML_LOGGER.error("Could not parse sound durations from {}", url, e); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } + + musicRecordsInitialized = true; + return musicRecordDurations; + } + } + +} diff --git a/src/main/java/gregtech/client/ElectricJukeboxSound.java b/src/main/java/gregtech/client/ElectricJukeboxSound.java new file mode 100644 index 0000000000..0ea81ab537 --- /dev/null +++ b/src/main/java/gregtech/client/ElectricJukeboxSound.java @@ -0,0 +1,95 @@ +package gregtech.client; + +import net.minecraft.client.audio.ISound; +import net.minecraft.client.audio.ITickableSound; +import net.minecraft.util.ResourceLocation; + +public class ElectricJukeboxSound implements ISound, ISeekingSound, ITickableSound { + + public final ResourceLocation soundResource; + public float volume = 1.0F; + public float pitch = 1.0F; + public float xPosition; + public float yPosition; + public float zPosition; + public boolean repeating = false; + public int repeatDelay = 0; + public ISound.AttenuationType attenuationType = AttenuationType.LINEAR; + public boolean donePlaying = false; + + public final long seekMs; + + public ElectricJukeboxSound(ResourceLocation resource, long seekMs) { + this.soundResource = resource; + this.seekMs = seekMs; + } + + public ElectricJukeboxSound(ResourceLocation soundResource, float volume, long seekMs, float xPosition, + float yPosition, float zPosition) { + this(soundResource, seekMs); + this.volume = volume; + this.xPosition = xPosition; + this.yPosition = yPosition; + this.zPosition = zPosition; + } + + @Override + public long getSeekMillisecondOffset() { + return seekMs; + } + + @Override + public ResourceLocation getPositionedSoundLocation() { + return soundResource; + } + + @Override + public boolean canRepeat() { + return repeating; + } + + @Override + public int getRepeatDelay() { + return repeatDelay; + } + + @Override + public float getVolume() { + return volume; + } + + @Override + public float getPitch() { + return pitch; + } + + @Override + public float getXPosF() { + return xPosition; + } + + @Override + public float getYPosF() { + return yPosition; + } + + @Override + public float getZPosF() { + return zPosition; + } + + @Override + public AttenuationType getAttenuationType() { + return attenuationType; + } + + @Override + public boolean isDonePlaying() { + return donePlaying; + } + + @Override + public void update() { + // no-op + } +} diff --git a/src/main/java/gregtech/client/ISeekingSound.java b/src/main/java/gregtech/client/ISeekingSound.java new file mode 100644 index 0000000000..091b56f802 --- /dev/null +++ b/src/main/java/gregtech/client/ISeekingSound.java @@ -0,0 +1,14 @@ +package gregtech.client; + +import net.minecraft.client.audio.ISound; + +/** + * Metadata on a sound object used to seek it when starting playback. + */ +public interface ISeekingSound extends ISound { + + /** + * @return The number of milliseconds to seek by. + */ + long getSeekMillisecondOffset(); +} diff --git a/src/main/java/gregtech/client/SeekingOggCodec.java b/src/main/java/gregtech/client/SeekingOggCodec.java new file mode 100644 index 0000000000..7949578f4f --- /dev/null +++ b/src/main/java/gregtech/client/SeekingOggCodec.java @@ -0,0 +1,98 @@ +package gregtech.client; + +import java.net.URL; + +import javax.sound.sampled.AudioFormat; + +import net.minecraft.util.ResourceLocation; + +import org.apache.commons.lang3.StringUtils; + +import paulscode.sound.SoundBuffer; +import paulscode.sound.codecs.CodecJOrbis; + +/** + * A somewhat hacky codec that allows starting music playback from the middle of a Ogg Vorbis file. + * Registers for URLs of the form: {@literal jar:blah/blah.jar!blah/music.ogg?seek_ms=5000&ext=.gt5oggseek} + */ +public class SeekingOggCodec extends CodecJOrbis { + + public static final String EXTENSION = "gt5oggseek"; + + private volatile boolean fullyInitialized = false; + private volatile SoundBuffer nextBuffer = null; + + /** + * Encodes the given millisecond seek amount into a URL/resource name suffix that can be appended to the sound path + * to start playing from that point onwards. + */ + public static String getEncodedSeekSuffxix(long milliseconds) { + return String.format("?seek_ms=%d&ext=." + EXTENSION, milliseconds); + } + + /** + * @return The given path with the seeking metadata stripped from the URL + */ + public static String stripSeekMetadata(String path) { + while (path.endsWith("." + EXTENSION)) { + int qMark = path.lastIndexOf('?'); + if (qMark == -1) { + break; + } + path = path.substring(0, qMark); + } + return path; + } + + /** + * Turns the input sound ResourceLocation into one that is seeked forward the given number of milliseconds + */ + public static ResourceLocation seekResource(ResourceLocation loc, long milliseconds) { + String original = loc.getResourcePath(); + original = stripSeekMetadata(original); + return new ResourceLocation(loc.getResourceDomain(), original + getEncodedSeekSuffxix(milliseconds)); + } + + @Override + public boolean initialize(URL url) { + final String textUrl = url.toString(); + final String[] queryParts = url.getQuery() + .split("&"); + long seekMs = 0; + for (String part : queryParts) { + if (!part.startsWith("seek_ms=")) { + continue; + } + part = StringUtils.removeStart(part, "seek_ms="); + seekMs = Long.parseLong(part); + } + + if (!super.initialize(url)) { + return false; + } + + final AudioFormat format = this.getAudioFormat(); + final long samplesPerS = (long) format.getSampleRate(); + final int bytesPerSample = (format.getChannels() * format.getSampleSizeInBits() / 8); + + long remainingBytes = seekMs * samplesPerS * bytesPerSample / 1000L; + + while (remainingBytes > 0) { + final SoundBuffer buf = read(); + if (buf == null || buf.audioData == null) { + return false; + } + remainingBytes -= buf.audioData.length; + } + + synchronized (this) { + fullyInitialized = true; + } + return true; + } + + @Override + public synchronized boolean initialized() { + return fullyInitialized; + } +} diff --git a/src/main/java/gregtech/common/GT_Client.java b/src/main/java/gregtech/common/GT_Client.java index 0bf578e303..79c8256c04 100644 --- a/src/main/java/gregtech/common/GT_Client.java +++ b/src/main/java/gregtech/common/GT_Client.java @@ -35,6 +35,7 @@ import net.minecraft.util.MovingObjectPosition; import net.minecraft.world.ChunkCoordIntPair; import net.minecraft.world.World; import net.minecraftforge.client.event.DrawBlockHighlightEvent; +import net.minecraftforge.client.event.sound.SoundSetupEvent; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.oredict.OreDictionary; @@ -84,9 +85,11 @@ import gregtech.api.util.GT_ClientPreference; import gregtech.api.util.GT_CoverBehaviorBase; import gregtech.api.util.GT_Log; import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_MusicSystem; import gregtech.api.util.GT_PlayedSound; import gregtech.api.util.GT_Utility; import gregtech.api.util.WorldSpawnedEventBuilder; +import gregtech.client.SeekingOggCodec; import gregtech.common.blocks.GT_Item_Machines; import gregtech.common.render.GT_CapeRenderer; import gregtech.common.render.GT_FlaskRenderer; @@ -105,6 +108,8 @@ import gregtech.loaders.misc.GT_Bees; import gregtech.loaders.preload.GT_PreLoad; import gregtech.nei.NEI_GT_Config; import ic2.api.tile.IWrenchable; +import paulscode.sound.SoundSystemConfig; +import paulscode.sound.SoundSystemException; // Referenced classes of package gregtech.common: // GT_Proxy @@ -692,6 +697,16 @@ public class GT_Client extends GT_Proxy implements Runnable { } } + @SubscribeEvent + @SuppressWarnings("unused") // used by the event bus + public void onSoundSetup(SoundSetupEvent event) { + try { + SoundSystemConfig.setCodec(SeekingOggCodec.EXTENSION, SeekingOggCodec.class); + } catch (SoundSystemException e) { + throw new RuntimeException(e); + } + } + @Override public void run() { GT_Log.out.println("GT_Mod: Downloading Cape List."); @@ -727,6 +742,7 @@ public class GT_Client extends GT_Proxy implements Runnable { public void onClientConnectedToServerEvent(FMLNetworkEvent.ClientConnectedToServerEvent aEvent) { mFirstTick = true; mReloadCount++; + GT_MusicSystem.ClientSystem.reset(); // For utility methods elsewhere. calculateMaxPlasmaTurbineEfficiency(); } @@ -891,6 +907,8 @@ public class GT_Client extends GT_Proxy implements Runnable { @SubscribeEvent public void onClientTickEvent(cpw.mods.fml.common.gameevent.TickEvent.ClientTickEvent aEvent) { if (aEvent.phase == cpw.mods.fml.common.gameevent.TickEvent.Phase.END) { + GT_MusicSystem.ClientSystem.tick(); + if (changeDetected > 0) changeDetected--; final int newHideValue = shouldHeldItemHideThings(); if (newHideValue != hideValue) { diff --git a/src/main/java/gregtech/common/GT_Network.java b/src/main/java/gregtech/common/GT_Network.java index 95385c92ea..bf5826e9ae 100644 --- a/src/main/java/gregtech/common/GT_Network.java +++ b/src/main/java/gregtech/common/GT_Network.java @@ -107,6 +107,15 @@ public class GT_Network extends MessageToMessageCodec .writeAndFlush(aPacket); } + @Override + public void sendToAll(GT_Packet aPacket) { + this.mChannel.get(Side.SERVER) + .attr(FMLOutboundHandler.FML_MESSAGETARGET) + .set(FMLOutboundHandler.OutboundTarget.ALL); + this.mChannel.get(Side.SERVER) + .writeAndFlush(aPacket); + } + @Override public void sendToServer(GT_Packet aPacket) { this.mChannel.get(Side.CLIENT) diff --git a/src/main/java/gregtech/common/GT_Proxy.java b/src/main/java/gregtech/common/GT_Proxy.java index 7e83ae97a7..8e0c636c98 100644 --- a/src/main/java/gregtech/common/GT_Proxy.java +++ b/src/main/java/gregtech/common/GT_Proxy.java @@ -67,6 +67,7 @@ import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.monster.EntityEnderman; import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.entity.projectile.EntityArrow; import net.minecraft.init.Blocks; import net.minecraft.init.Items; @@ -146,6 +147,7 @@ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.items.GT_MetaGenerated_Item; import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.net.GT_Packet_MusicSystemData; import gregtech.api.objects.GT_ChunkManager; import gregtech.api.objects.GT_ItemStack; import gregtech.api.objects.GT_UO_DimensionList; @@ -161,6 +163,7 @@ import gregtech.api.util.GT_CoverBehaviorBase; import gregtech.api.util.GT_LanguageManager; import gregtech.api.util.GT_Log; import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_MusicSystem; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Recipe; import gregtech.api.util.GT_RecipeRegistrator; @@ -1383,6 +1386,8 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler { GT_Log.out.println("GT_Mod: ServerStarting-Phase started!"); GT_Log.ore.println("GT_Mod: ServerStarting-Phase started!"); + GT_MusicSystem.ServerSystem.reset(); + this.mUniverse = null; this.isFirstServerWorldTick = true; for (FluidContainerRegistry.FluidContainerData tData : FluidContainerRegistry @@ -1433,6 +1438,7 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler { } public void onServerStopping() { + GT_MusicSystem.ServerSystem.reset(); File tSaveDirectory = getSaveDirectory(); GregTech_API.sWirelessRedstone.clear(); if (tSaveDirectory != null) { @@ -1563,6 +1569,15 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler { } } + @SubscribeEvent + public void onPlayerJoinEvent(cpw.mods.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent event) { + if (event.player == null || event.player.isClientWorld() + || !(event.player instanceof EntityPlayerMP mpPlayer)) { + return; + } + GT_Values.NW.sendToPlayer(new GT_Packet_MusicSystemData(GT_MusicSystem.ServerSystem.serialize()), mpPlayer); + } + @SubscribeEvent public void onOreGenEvent(OreGenEvent.GenerateMinable aGenerator) { if ((this.mDisableVanillaOres) && ((aGenerator.generator instanceof WorldGenMinable)) @@ -2223,9 +2238,9 @@ public abstract class GT_Proxy implements IGT_Mod, IGuiHandler, IFuelHandler { if (aEvent.side.isServer()) { if (aEvent.phase == TickEvent.Phase.START) { TICK_LOCK.lock(); - } else { TICK_LOCK.unlock(); + GT_MusicSystem.ServerSystem.tick(); } // Making sure it is being freed up in order to prevent exploits or Garbage Collection mishaps. diff --git a/src/main/java/gregtech/common/items/GT_WirelessHeadphones.java b/src/main/java/gregtech/common/items/GT_WirelessHeadphones.java new file mode 100644 index 0000000000..98a6eddb2c --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_WirelessHeadphones.java @@ -0,0 +1,118 @@ +package gregtech.common.items; + +import java.util.List; +import java.util.UUID; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentTranslation; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.Constants; + +import baubles.api.BaubleType; +import baubles.api.IBauble; +import gregtech.api.enums.ItemList; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_BetterJukebox; + +public class GT_WirelessHeadphones extends GT_Generic_Item implements IBauble { + + public static final String NBTKEY_JUKEBOX_COORDINATES = "jukeboxCoords"; + + public GT_WirelessHeadphones() { + super("WirelessHeadphones", "Wireless Headphones", null); + setMaxStackSize(1); + + ItemList.WirelessHeadphones.set(this); + } + + @Override + public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) { + if (aStack == null) { + return; + } + final NBTTagCompound tag = aStack.getTagCompound(); + if (tag == null || !tag.hasKey(NBTKEY_JUKEBOX_COORDINATES, Constants.NBT.TAG_STRING)) { + aList.add(StatCollector.translateToLocal("GT5U.machines.betterjukebox.headphonesunbound")); + } else { + aList.add(StatCollector.translateToLocal("GT5U.machines.betterjukebox.headphonesbound")); + aList.add(tag.getString(NBTKEY_JUKEBOX_COORDINATES)); + } + } + + @Override + public boolean doesSneakBypassUse(World aWorld, int aX, int aY, int aZ, EntityPlayer aPlayer) { + return false; + } + + @Override + public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, + float hitX, float hitY, float hitZ) { + final TileEntity pointedTe = world.getTileEntity(x, y, z); + if (!(pointedTe instanceof BaseMetaTileEntity mte)) { + return false; + } + if (!(mte.getMetaTileEntity() instanceof GT_MetaTileEntity_BetterJukebox jukebox)) { + return false; + } + final UUID uuid = jukebox.jukeboxUuid; + if (uuid == GT_MetaTileEntity_BetterJukebox.UNSET_UUID) { + return false; + } + if (!world.isRemote) { + final NBTTagCompound tag = (stack.getTagCompound() == null) ? new NBTTagCompound() : stack.getTagCompound(); + tag.setLong(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_LOW, uuid.getLeastSignificantBits()); + tag.setLong(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_HIGH, uuid.getMostSignificantBits()); + tag.setString( + NBTKEY_JUKEBOX_COORDINATES, + String.format("(%d, %d, %d) @ %d", x, y, z, world.provider.dimensionId)); + stack.setTagCompound(tag); + + player.addChatMessage(new ChatComponentTranslation("GT5U.machines.betterjukebox.headphonesbound")); + } + return true; + } + + public static UUID getBoundJukeboxUUID(ItemStack stack) { + if (stack == null || stack.getTagCompound() == null) { + return null; + } + final NBTTagCompound tag = stack.getTagCompound(); + if (!tag.hasKey(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_LOW, Constants.NBT.TAG_ANY_NUMERIC) + || !tag.hasKey(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_HIGH, Constants.NBT.TAG_ANY_NUMERIC)) { + return null; + } + final long idLow = tag.getLong(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_LOW); + final long idHigh = tag.getLong(GT_MetaTileEntity_BetterJukebox.NBTKEY_UUID_HIGH); + return new UUID(idHigh, idLow); + } + + @Override + public BaubleType getBaubleType(ItemStack itemStack) { + return BaubleType.UNIVERSAL; + } + + @Override + public void onWornTick(ItemStack itemStack, EntityLivingBase entityLivingBase) {} + + @Override + public void onEquipped(ItemStack itemStack, EntityLivingBase entityLivingBase) {} + + @Override + public void onUnequipped(ItemStack itemStack, EntityLivingBase entityLivingBase) {} + + @Override + public boolean canEquip(ItemStack itemStack, EntityLivingBase entityLivingBase) { + return true; + } + + @Override + public boolean canUnequip(ItemStack itemStack, EntityLivingBase entityLivingBase) { + return true; + } +} diff --git a/src/main/java/gregtech/common/misc/GT_Command.java b/src/main/java/gregtech/common/misc/GT_Command.java index 3bf73b6300..8e342aa928 100644 --- a/src/main/java/gregtech/common/misc/GT_Command.java +++ b/src/main/java/gregtech/common/misc/GT_Command.java @@ -19,9 +19,11 @@ import net.minecraft.util.EnumChatFormatting; import com.gtnewhorizon.structurelib.StructureLib; +import cpw.mods.fml.relauncher.FMLLaunchHandler; import gregtech.GT_Mod; import gregtech.api.enums.GT_Values; import gregtech.api.objects.GT_ChunkManager; +import gregtech.api.util.GT_MusicSystem; import gregtech.api.util.GT_Utility; import gregtech.common.GT_Pollution; import gregtech.common.misc.spaceprojects.SpaceProjectManager; @@ -35,13 +37,13 @@ public final class GT_Command extends CommandBase { @Override public String getCommandUsage(ICommandSender sender) { - return "Usage: gt . Valid subcommands are: toggle, chunks, pollution."; + return "Usage: gt . Valid subcommands are: toggle, c