diff options
Diffstat (limited to 'src/main/java/gregtech/common')
6 files changed, 887 insertions, 5 deletions
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 @@ -108,6 +108,15 @@ public class GT_Network extends MessageToMessageCodec<FMLProxyPacket, GT_Packet> } @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) .attr(FMLOutboundHandler.FML_MESSAGETARGET) 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) { @@ -1564,6 +1570,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)) && (PREVENTED_ORES.contains(aGenerator.type))) { @@ -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<String> 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 <subcommand>. Valid subcommands are: toggle, chunks, pollution."; + return "Usage: gt <subcommand>. Valid subcommands are: toggle, chunks, pollution, global_energy_add, global_energy_set, global_energy_join, dump_music_durations."; } private void printHelp(ICommandSender sender) { sender.addChatMessage( new ChatComponentText( - "Usage: gt <toggle|chunks|pollution|global_energy_add|global_energy_set|global_energy_join>")); + "Usage: gt <toggle|chunks|pollution|global_energy_add|global_energy_set|global_energy_join|dump_music_durations>")); sender.addChatMessage(new ChatComponentText("\"toggle D1\" - toggles general.Debug (D1)")); sender.addChatMessage(new ChatComponentText("\"toggle D2\" - toggles general.Debug2 (D2)")); sender.addChatMessage(new ChatComponentText("\"toggle debugCleanroom\" - toggles cleanroom debug log")); @@ -96,6 +98,9 @@ public final class GT_Command extends CommandBase { sender.addChatMessage( new ChatComponentText( "Usage:" + EnumChatFormatting.RED + " global_energy_display " + EnumChatFormatting.BLUE + "[Name]")); + sender.addChatMessage( + new ChatComponentText( + "\"dump_music_durations\" - dumps soundmeta/durations.json for all registered records in the game to the log. Client-only")); } @Override @@ -110,7 +115,8 @@ public final class GT_Command extends CommandBase { "global_energy_add", "global_energy_set", "global_energy_join", - "global_energy_display") + "global_energy_display", + "dump_music_durations") .anyMatch(s -> s.startsWith(test)))) { Stream .of( @@ -120,7 +126,8 @@ public final class GT_Command extends CommandBase { "global_energy_add", "global_energy_set", "global_energy_join", - "global_energy_display") + "global_energy_display", + "dump_music_durations") .filter(s -> test.isEmpty() || s.startsWith(test)) .forEach(l::add); } else if (test.equals("toggle")) { @@ -330,6 +337,14 @@ public final class GT_Command extends CommandBase { + ".")); } + case "dump_music_durations" -> { + if (!FMLLaunchHandler.side() + .isClient()) { + sender + .addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "This command is client-only.")); + } + GT_MusicSystem.ClientSystem.dumpAllRecordDurations(); + } default -> { sender .addChatMessage(new ChatComponentText(EnumChatFormatting.RED + "Invalid command/syntax detected.")); diff --git a/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_BetterJukebox.java b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_BetterJukebox.java new file mode 100644 index 0000000000..da14d7c7cb --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_BetterJukebox.java @@ -0,0 +1,707 @@ +package gregtech.common.tileentities.machines.basic; + +import static gregtech.api.enums.GT_Values.V; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PIPE_OUT; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_SIDE_JUKEBOX; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_TOP_JUKEBOX; +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.EnumMap; +import java.util.List; +import java.util.Random; +import java.util.UUID; + +import net.minecraft.item.ItemRecord; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.MathHelper; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.common.util.Constants; +import net.minecraftforge.common.util.ForgeDirection; + +import org.joml.Vector4i; + +import com.google.common.collect.ImmutableList; +import com.gtnewhorizons.modularui.api.drawable.FallbackableUITexture; +import com.gtnewhorizons.modularui.api.drawable.UITexture; +import com.gtnewhorizons.modularui.api.math.Pos2d; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import com.gtnewhorizons.modularui.common.widget.ProgressBar; +import com.gtnewhorizons.modularui.common.widget.SliderWidget; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; + +import appeng.api.implementations.tiles.ISoundP2PHandler; +import appeng.me.GridAccessException; +import appeng.me.cache.helpers.TunnelCollection; +import appeng.me.helpers.AENetworkProxy; +import appeng.parts.p2p.PartP2PSound; +import gregtech.api.enums.GTVoltageIndex; +import gregtech.api.enums.GT_Values; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine; +import gregtech.api.recipe.BasicUIProperties; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_MusicSystem; +import gregtech.common.gui.modularui.UIHelper; +import it.unimi.dsi.fastutil.objects.ObjectArrayList; + +public class GT_MetaTileEntity_BetterJukebox extends GT_MetaTileEntity_BasicMachine + implements IAddUIWidgets, ISoundP2PHandler { + + // Stored state + public UUID jukeboxUuid = UNSET_UUID; + public boolean loopMode = true; + public boolean shuffleMode = false; + public int playbackSlot = 0; + public float playbackVolume = BalanceMath.VANILLA_JUKEBOX_RANGE; + public float p2pVolume = BalanceMath.VANILLA_JUKEBOX_RANGE; + public long discProgressMs = 0; + /** Makes all music discs play for 4 seconds */ + public boolean superFastDebugMode = false; + // Computed state + private final Vector4i interdimPositionCache = new Vector4i(); // XYZ, Dimension ID + private GT_MusicSystem.MusicSource musicSource = null; + private boolean powered = false; + private long discStartMs = 0; + public long discDurationMs = 1; + private ItemRecord currentlyPlaying = null; + + // Constants + public static final UUID UNSET_UUID = UUID.nameUUIDFromBytes(new byte[] { 0 }); + public static final int INPUT_SLOTS = 21; + private static final Random SHUFFLER = new Random(); + + public enum HeadphoneLimit { + + BLOCK_RANGE, + INSIDE_DIMENSION, + BETWEEN_DIMENSIONS; + + public static final ImmutableList<HeadphoneLimit> ENTRIES = ImmutableList.copyOf(values()); + } + + public static final class BalanceMath { + + public static int MAX_TIER = GTVoltageIndex.IV; + public static float VANILLA_JUKEBOX_RANGE = 4.0f; // 64 blocks + + private static final float[] LISTENING_VOLUME = new float[] { // + VANILLA_JUKEBOX_RANGE, // ULV (unpowered fallback) + VANILLA_JUKEBOX_RANGE + 1.0f, // LV, 80 blocks + VANILLA_JUKEBOX_RANGE + 2.0f, // MV, 96 blocks + VANILLA_JUKEBOX_RANGE + 4.0f, // HV, 118 blocks + VANILLA_JUKEBOX_RANGE + 5.0f, // EV, 144 blocks + VANILLA_JUKEBOX_RANGE + 6.0f, // IV, 160 blocks, equivalent to default load distance of 10 chunks + }; + + private static final int[] HEADPHONE_BLOCK_RANGE = new int[] { // + 64, // ULV (unpowered fallback) + 128, // LV + 160, // MV + 320, // HV + 9001, // EV, alreadu unlimited here - this value is ignored + 9002, // IV, already unlimited here - this value is ignored + }; + + public static float listeningVolume(int tier) { + tier = MathHelper.clamp_int(tier, 0, MAX_TIER); + return LISTENING_VOLUME[tier]; + } + + public static int headphoneBlockRange(int tier) { + tier = MathHelper.clamp_int(tier, 0, MAX_TIER); + return HEADPHONE_BLOCK_RANGE[tier]; + } + + public static HeadphoneLimit headphoneLimit(int tier) { + if (tier <= GTVoltageIndex.HV) { + return HeadphoneLimit.BLOCK_RANGE; + } else if (tier == GTVoltageIndex.EV) { + return HeadphoneLimit.INSIDE_DIMENSION; + } else { + return HeadphoneLimit.BETWEEN_DIMENSIONS; + } + } + + public static float volumeToAttenuationDistance(float range) { + // SoundManager.playSound logic + return 16.0f * range; + } + + public static float attenuationDistanceToVolume(float blockRange) { + return blockRange / 16.0f; + } + + public static long eutUsage(int tier) { + tier = MathHelper.clamp_int(tier, 0, MAX_TIER); + return V[tier] / 16; + } + } + + private static String[] buildDescription(int aTier) { + ArrayList<String> strings = new ArrayList<>(4); + strings.add("Plays music better than your average vanilla jukebox."); + if (BalanceMath.headphoneLimit(aTier) != HeadphoneLimit.BLOCK_RANGE) { + strings.add(EnumChatFormatting.BLUE + "The raw power of Hatsune Miku in your ears"); + } + strings.add( + String.format( + "Range: %s%.1f blocks", + EnumChatFormatting.WHITE, + BalanceMath.volumeToAttenuationDistance(BalanceMath.listeningVolume(aTier)))); + strings.add(switch (BalanceMath.headphoneLimit(aTier)) { + case BLOCK_RANGE -> String.format( + "Headphone signal range: %s%d blocks", + EnumChatFormatting.WHITE, + BalanceMath.headphoneBlockRange(aTier)); + case INSIDE_DIMENSION -> String + .format("Headphones work anywhere in %sthe same dimension", EnumChatFormatting.WHITE); + case BETWEEN_DIMENSIONS -> String + .format("Headphones work anywhere, in %sany dimension", EnumChatFormatting.WHITE); + }); + strings.add(String.format("Cost: %s%d EU/t", EnumChatFormatting.WHITE, BalanceMath.eutUsage(aTier))); + strings.add(GT_Values.AuthorEigenRaven); + return strings.toArray(new String[0]); + } + + public GT_MetaTileEntity_BetterJukebox(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 1, buildDescription(aTier), INPUT_SLOTS, 1); + playbackVolume = BalanceMath.listeningVolume(aTier); + } + + public GT_MetaTileEntity_BetterJukebox(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 1, aDescription, aTextures, INPUT_SLOTS, 1); + playbackVolume = BalanceMath.listeningVolume(aTier); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_BetterJukebox(this.mName, this.mTier, this.mDescriptionArray, this.mTextures); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection sideDirection, + ForgeDirection facingDirection, int colorIndex, boolean active, boolean redstoneLevel) { + if (sideDirection == baseMetaTileEntity.getFrontFacing()) { + return new ITexture[] { MACHINE_CASINGS[mTier][colorIndex + 1], TextureFactory.of(OVERLAY_PIPE_OUT) }; + } + if (sideDirection != ForgeDirection.UP) { + return new ITexture[] { MACHINE_CASINGS[mTier][colorIndex + 1], TextureFactory.of(OVERLAY_SIDE_JUKEBOX) }; + } + return new ITexture[] { MACHINE_CASINGS[mTier][colorIndex + 1], TextureFactory.builder() + .addIcon(OVERLAY_TOP_JUKEBOX) + .extFacing() + .build() }; + } + + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + super.onFirstTick(aBaseMetaTileEntity); + if (aBaseMetaTileEntity.isClientSide()) { + return; + } + final Vector4i interdimPosition = interdimPositionCache; + interdimPosition.x = aBaseMetaTileEntity.getXCoord(); + interdimPosition.y = aBaseMetaTileEntity.getYCoord(); + interdimPosition.z = aBaseMetaTileEntity.getZCoord(); + interdimPosition.w = aBaseMetaTileEntity.getWorld().provider.dimensionId; + if (jukeboxUuid == UNSET_UUID) { + jukeboxUuid = UUID.randomUUID(); + markDirty(); + } + if (musicSource == null) { + musicSource = GT_MusicSystem.ServerSystem.registerOrGetMusicSource(jukeboxUuid); + musicSource.originPosition.set(interdimPosition); + musicSource.headphoneLimit = BalanceMath.headphoneLimit(mTier); + musicSource.headphoneBlockRange = BalanceMath.headphoneBlockRange(mTier); + musicSource.startedPlayingAtMs = System.currentTimeMillis(); + updateEmitterList(); + } + if (doesSlotContainValidRecord(playbackSlot) + && mInventory[playbackSlot].getItem() instanceof ItemRecord record) { + final ResourceLocation resource = record.getRecordResource(record.recordName); + currentlyPlaying = record; + // Assume a safe disc duration of 500 seconds if not known in the registry + discDurationMs = GT_MusicSystem.getMusicRecordDurations() + .getOrDefault(resource, 500_000); + discStartMs = System.currentTimeMillis() - discProgressMs; + musicSource.setRecord( + new ResourceLocation(resource.getResourceDomain(), "records." + resource.getResourcePath()), + discProgressMs); + } + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) { + try { + if (aBaseMetaTileEntity.isClientSide() || !aBaseMetaTileEntity.isAllowedToWork() || musicSource == null) { + if (currentlyPlaying != null) { + stopCurrentSong(System.currentTimeMillis()); + } + return; + } + final Vector4i interdimPosition = interdimPositionCache; + interdimPosition.x = aBaseMetaTileEntity.getXCoord(); + interdimPosition.y = aBaseMetaTileEntity.getYCoord(); + interdimPosition.z = aBaseMetaTileEntity.getZCoord(); + interdimPosition.w = aBaseMetaTileEntity.getWorld().provider.dimensionId; + final long now = System.currentTimeMillis(); + + if (superFastDebugMode && discDurationMs > 4000) { + discDurationMs = 4000; + } + + // power check + final boolean hasMinimumEU = aBaseMetaTileEntity.isUniversalEnergyStored(getMinimumStoredEU()); + if (currentlyPlaying != null && hasMinimumEU + && aBaseMetaTileEntity.decreaseStoredEnergyUnits(BalanceMath.eutUsage(mTier), false)) { + if (!powered) { // just got power again + powered = true; + musicSource.modified = true; + musicSource.headphoneLimit = BalanceMath.headphoneLimit(mTier); + musicSource.headphoneBlockRange = BalanceMath.headphoneBlockRange(mTier); + updateEmitterList(); + } + } else if ((!hasMinimumEU || currentlyPlaying != null) && powered) { // was powered, but no longer is + powered = false; + musicSource.modified = true; + musicSource.headphoneLimit = HeadphoneLimit.BLOCK_RANGE; + musicSource.headphoneBlockRange = BalanceMath.headphoneBlockRange(0); + updateEmitterList(); + } + + // check if current disc finished + if (currentlyPlaying != null) { + discProgressMs = now - discStartMs; + final boolean hasValidRecord = doesSlotContainValidRecord(playbackSlot); + final boolean wasDiscSwapped = hasValidRecord + && mInventory[getInputSlot() + playbackSlot].getItem() != currentlyPlaying; + if (discProgressMs >= discDurationMs || !hasValidRecord || wasDiscSwapped) { + stopCurrentSong(now); + if (!loopMode) { + // should be empty, but swap just in case it's not + final ItemStack oldOut = mInventory[getOutputSlot()]; + mInventory[getOutputSlot()] = mInventory[getInputSlot() + playbackSlot]; + mInventory[getInputSlot() + playbackSlot] = oldOut; + markDirty(); + } + if (!(hasValidRecord && wasDiscSwapped)) { + // don't switch slots if someone just put a new disc in the active slot + pickNextSlot(); + } + } else { + // keep on playing + return; + } + } + + if (playbackSlot < 0 || playbackSlot >= INPUT_SLOTS + || ((aTimer % 10) == 0 && !doesSlotContainValidRecord(playbackSlot))) { + pickNextSlot(); + } + + final boolean hasValidRecord = doesSlotContainValidRecord(playbackSlot); + final boolean canStartPlaying = loopMode || isOutputEmpty(); + if (!hasValidRecord) { + stopCurrentSong(now); + } else if (canStartPlaying + && mInventory[getInputSlot() + playbackSlot].getItem() instanceof ItemRecord record) { + final ResourceLocation resource = record.getRecordResource(record.recordName); + currentlyPlaying = record; + musicSource.setRecord( + new ResourceLocation(resource.getResourceDomain(), "records." + resource.getResourcePath())); + // Assume a safe disc duration of 500 seconds if not known in the registry + discDurationMs = GT_MusicSystem.getMusicRecordDurations() + .getOrDefault(resource, 500_000); + discProgressMs = 0; + discStartMs = now; + } + } finally { + super.onPostTick(aBaseMetaTileEntity, aTimer); + } + } + + private void stopCurrentSong(long nowMs) { + if (currentlyPlaying == null) { + return; + } + musicSource.setRecord(null); + currentlyPlaying = null; + discDurationMs = 1; + discProgressMs = 0; + discStartMs = nowMs; + markDirty(); + } + + private void pickNextSlot() { + playbackSlot = MathHelper.clamp_int(playbackSlot, 0, INPUT_SLOTS); + if (shuffleMode) { + final int[] validSlots = new int[INPUT_SLOTS]; + int validSlotCount = 0; + for (int i = 0; i < INPUT_SLOTS; i++) { + if (i != playbackSlot && doesSlotContainValidRecord(i)) { + validSlots[validSlotCount++] = i; + } + } + switch (validSlotCount) { + case 0 -> {} + case 1 -> { + playbackSlot = validSlots[0]; + } + default -> { + playbackSlot = validSlots[SHUFFLER.nextInt(validSlotCount)]; + } + } + } else { + int attempt = 0; + int nextSlot = playbackSlot; + do { + attempt++; + nextSlot = (nextSlot + 1) % INPUT_SLOTS; + } while (!doesSlotContainValidRecord(nextSlot) && attempt <= INPUT_SLOTS); + if (attempt <= INPUT_SLOTS) { + playbackSlot = nextSlot; + } + } + } + + public boolean doesSlotContainValidRecord(int slot) { + return mInventory[getInputSlot() + slot] != null + && mInventory[getInputSlot() + slot].getItem() instanceof ItemRecord; + } + + @Override + public void onRemoval() { + final IGregTechTileEntity baseTE = getBaseMetaTileEntity(); + if (baseTE == null) { + return; + } + if (!baseTE.isServerSide()) { + return; + } + if (jukeboxUuid == UNSET_UUID) { + return; + } + GT_MusicSystem.ServerSystem.removeMusicSource(jukeboxUuid); + } + + @Override + public long getMinimumStoredEU() { + return BalanceMath.eutUsage(mTier) * 20; + } + + @Override + public long maxEUStore() { + return 512L + BalanceMath.eutUsage(mTier) * 50; + } + + @Override + public long maxAmperesIn() { + return 1; + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return null; + } + + public static final String NBTKEY_UUID_LOW = "jukeboxUUIDLow"; + public static final String NBTKEY_UUID_HIGH = "jukeboxUUIDHigh"; + public static final String NBTKEY_LOOP_MODE = "loopMode"; + public static final String NBTKEY_SHUFFLE_MODE = "shuffleMode"; + public static final String NBTKEY_PLAYBACK_SLOT = "playbackSlot"; + public static final String NBTKEY_VOLUME_PLAY = "playbackVolume"; + public static final String NBTKEY_VOLUME_P2P = "p2pVolume"; + public static final String NBTKEY_DISC_PROGRESS_MS = "discProgressMs"; + + @Override + public String[] getInfoData() { + return new String[] { "Jukebox UUID: " + ((jukeboxUuid == UNSET_UUID) ? "unset" : jukeboxUuid), + "Loop mode: " + loopMode, "Shuffle mode: " + shuffleMode, "Played the disc for [ms]: " + discProgressMs, + "Current disc duration [ms]: " + discDurationMs, + "Playback range [blocks]: " + BalanceMath.volumeToAttenuationDistance(playbackVolume), + "P2P range [blocks]: " + BalanceMath.volumeToAttenuationDistance(playbackVolume), + "Raw playback strength: " + playbackVolume, "Raw p2p strength: " + p2pVolume }; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + if (jukeboxUuid != UNSET_UUID) { + aNBT.setLong(NBTKEY_UUID_LOW, jukeboxUuid.getLeastSignificantBits()); + aNBT.setLong(NBTKEY_UUID_HIGH, jukeboxUuid.getMostSignificantBits()); + aNBT.setBoolean(NBTKEY_LOOP_MODE, loopMode); + aNBT.setBoolean(NBTKEY_SHUFFLE_MODE, shuffleMode); + aNBT.setInteger(NBTKEY_PLAYBACK_SLOT, playbackSlot); + aNBT.setFloat(NBTKEY_VOLUME_PLAY, playbackVolume); + aNBT.setFloat(NBTKEY_VOLUME_P2P, p2pVolume); + aNBT.setLong(NBTKEY_DISC_PROGRESS_MS, discProgressMs); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + if (aNBT.hasKey(NBTKEY_UUID_LOW, Constants.NBT.TAG_ANY_NUMERIC) + && aNBT.hasKey(NBTKEY_UUID_HIGH, Constants.NBT.TAG_ANY_NUMERIC)) { + jukeboxUuid = new UUID(aNBT.getLong(NBTKEY_UUID_HIGH), aNBT.getLong(NBTKEY_UUID_LOW)); + } + if (aNBT.hasKey(NBTKEY_LOOP_MODE, Constants.NBT.TAG_ANY_NUMERIC)) { + loopMode = aNBT.getBoolean(NBTKEY_LOOP_MODE); + } + if (aNBT.hasKey(NBTKEY_SHUFFLE_MODE, Constants.NBT.TAG_ANY_NUMERIC)) { + shuffleMode = aNBT.getBoolean(NBTKEY_SHUFFLE_MODE); + } + if (aNBT.hasKey(NBTKEY_PLAYBACK_SLOT, Constants.NBT.TAG_ANY_NUMERIC)) { + playbackSlot = aNBT.getInteger(NBTKEY_PLAYBACK_SLOT); + } + if (aNBT.hasKey(NBTKEY_VOLUME_PLAY, Constants.NBT.TAG_ANY_NUMERIC)) { + playbackVolume = aNBT.getFloat(NBTKEY_VOLUME_PLAY); + } + if (aNBT.hasKey(NBTKEY_VOLUME_P2P, Constants.NBT.TAG_ANY_NUMERIC)) { + p2pVolume = aNBT.getFloat(NBTKEY_VOLUME_P2P); + } + if (aNBT.hasKey(NBTKEY_DISC_PROGRESS_MS, Constants.NBT.TAG_ANY_NUMERIC)) { + discProgressMs = aNBT.getLong(NBTKEY_DISC_PROGRESS_MS); + } + + final float maxVolume = BalanceMath.listeningVolume(mTier); + playbackVolume = MathHelper.clamp_float(playbackVolume, 0.0f, maxVolume); + p2pVolume = MathHelper.clamp_float(p2pVolume, 0.0f, maxVolume); + } + + @Override + public boolean useModularUI() { + return true; + } + + @Override + protected BasicUIProperties getUIProperties() { + return super.getUIProperties().toBuilder() + .itemInputPositionsGetter(count -> UIHelper.getGridPositions(count, 7, 6, 7, 3)) + .itemOutputPositionsGetter(count -> UIHelper.getGridPositions(count, 153, 24, 1)) + .specialItemPositionGetter(() -> new Pos2d(115, 62)) + .progressBarPos(Pos2d.cartesian(133, 24)) + .progressBarTexture(new FallbackableUITexture(GT_UITextures.PROGRESSBAR_ARROW)) + .build(); + } + + @Override + protected void addProgressBar(ModularWindow.Builder builder, BasicUIProperties uiProperties) { + builder.widget( + setNEITransferRect( + new ProgressBar().setProgress(() -> discProgressMs / (float) Math.max(1, discDurationMs)) + .setTexture(uiProperties.progressBarTexture.get(), uiProperties.progressBarImageSize) + .setDirection(uiProperties.progressBarDirection) + .setPos(uiProperties.progressBarPos) + .setSize(uiProperties.progressBarSize) + .setUpdateTooltipEveryTick(true) + .attachSyncer( + new FakeSyncWidget.LongSyncer(() -> this.discProgressMs, val -> this.discProgressMs = val), + builder) + .attachSyncer( + new FakeSyncWidget.LongSyncer(() -> this.discDurationMs, val -> this.discDurationMs = val), + builder) + .dynamicTooltip( + () -> Collections.singletonList( + String.format("%,.2f / %,.2f", discProgressMs / 1000.0f, discDurationMs / 1000.0f))), + uiProperties.neiTransferRectId)); + addProgressBarSpecialTextures(builder, uiProperties); + } + + @Override + protected SlotWidget createChargerSlot(int x, int y) { + return super.createChargerSlot(97, 62); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + super.addUIWidgets(builder, buildContext); + final BasicUIProperties props = getUIProperties(); + final List<Pos2d> inputSlots = props.itemInputPositionsGetter.apply(mInputSlotCount); + // Loop + builder.widget( + new CycleButtonWidget().setToggle(() -> loopMode, val -> loopMode = val) + .setStaticTexture(GT_UITextures.OVERLAY_BUTTON_CYCLIC) + .setVariableBackground(GT_UITextures.BUTTON_STANDARD_TOGGLE) + .setGTTooltip(() -> mTooltipCache.getData("GT5U.machines.betterjukebox.loop.tooltip")) + .setTooltipShowUpDelay(TOOLTIP_DELAY) + .setPos(153, 6) + .setSize(18, 18)); + // Shuffle + builder.widget(new CycleButtonWidget().setToggle(() -> shuffleMode, val -> { + shuffleMode = val; + if (shuffleMode) { + playbackSlot = -1; + } else { + playbackSlot = 0; + } + }) + .setStaticTexture(GT_UITextures.OVERLAY_BUTTON_SHUFFLE) + .setVariableBackground(GT_UITextures.BUTTON_STANDARD_TOGGLE) + .setGTTooltip(() -> mTooltipCache.getData("GT5U.machines.betterjukebox.shuffle.tooltip")) + .setTooltipShowUpDelay(TOOLTIP_DELAY) + .setPos(153, 42) + .setSize(18, 18)); + // Currently playing slot highlight using the hotbar active texture + final DrawableWidget slotHighlight = new DrawableWidget(); + builder.widget( + slotHighlight + .setDrawable( + new UITexture( + new ResourceLocation("minecraft", "textures/gui/widgets.png"), + 0.0f, + 22.0f / 256.0f, + 24.0f / 256.0f, + 46.0f / 256.0f)) + .setSize(24, 24) + .attachSyncer(new FakeSyncWidget.IntegerSyncer(() -> this.playbackSlot, val -> { + this.playbackSlot = val; + slotHighlight.checkNeedsRebuild(); + }), builder) + .setPosProvider( + (screenSize, window, parent) -> inputSlots.get(MathHelper.clamp_int(playbackSlot, 0, INPUT_SLOTS)) + .add(-3, -3))); + // Attenuation distance (controls internal "volume") + // Caching tooltip data caches the formatted p2p range value, so we have to use the uncached variant here. + builder.widget( + new SliderWidget() + .setBounds(0.0f, BalanceMath.volumeToAttenuationDistance(BalanceMath.listeningVolume(mTier))) + .setGetter(this::getPlaybackBlockRange) + .setSetter(this::setPlaybackBlockRange) + .dynamicTooltip( + () -> mTooltipCache.getUncachedTooltipData( + "GT5U.machines.betterjukebox.attenuationDistance.tooltip", + (int) getPlaybackBlockRange()).text) + .setUpdateTooltipEveryTick(true) + .setPos(44, 63) + .setSize(52, 8)); + builder.widget( + new SliderWidget() + .setBounds(0.0f, BalanceMath.volumeToAttenuationDistance(BalanceMath.listeningVolume(mTier))) + .setGetter(this::getP2PBlockRange) + .setSetter(this::setP2PBlockRange) + .dynamicTooltip( + () -> mTooltipCache.getUncachedTooltipData( + "GT5U.machines.betterjukebox.p2pAttenuationDistance.tooltip", + (int) getP2PBlockRange()).text) + .setUpdateTooltipEveryTick(true) + .setPos(44, 71) + .setSize(52, 8)); + } + + private float getPlaybackBlockRange() { + return BalanceMath.volumeToAttenuationDistance(playbackVolume); + } + + private float getP2PBlockRange() { + return BalanceMath.volumeToAttenuationDistance(p2pVolume); + } + + private void setPlaybackBlockRange(float blockRange) { + float volume = BalanceMath.attenuationDistanceToVolume(blockRange); + volume = MathHelper.clamp_float(volume, 0.0f, BalanceMath.listeningVolume(mTier)); + if (volume != playbackVolume) { + playbackVolume = volume; + if (getBaseMetaTileEntity().isServerSide()) { + updateEmitterList(); + } + } + } + + private void setP2PBlockRange(float blockRange) { + float volume = BalanceMath.attenuationDistanceToVolume(blockRange); + volume = MathHelper.clamp_float(volume, 0.0f, BalanceMath.listeningVolume(mTier)); + if (volume != p2pVolume) { + p2pVolume = volume; + if (getBaseMetaTileEntity().isServerSide()) { + updateEmitterList(); + } + } + } + + private final EnumMap<ForgeDirection, PartP2PSound> attachedSoundP2P = new EnumMap<>(ForgeDirection.class); + private final ObjectArrayList<PartP2PSound> combinedOutputsListCache = new ObjectArrayList<>(new PartP2PSound[0]); + + private void updateEmitterList() { + final GT_MusicSystem.MusicSource target = musicSource; + if (target == null) { + return; + } + final ObjectArrayList<PartP2PSound> emitters = combinedOutputsListCache; + emitters.clear(); + + attachedSoundP2P.forEach((ignored, p2p) -> { + if (p2p != null) { + try { + p2p.getOutputs() + .forEach(emitters::add); + } catch (GridAccessException e) { + // skip + } + } + }); + + IGregTechTileEntity te = getBaseMetaTileEntity(); + if (te == null) { + return; + } + final Vector4i position = new Vector4i(); + target.resizeEmitterArray(1 + emitters.size()); + position.set(te.getXCoord(), te.getYCoord(), te.getZCoord(), te.getWorld().provider.dimensionId); + final float actualVolume = MathHelper + .clamp_float(playbackVolume, 0.0f, BalanceMath.listeningVolume(powered ? mTier : 0)); + target.setEmitter(0, position, actualVolume); + final float actualP2PVolume = MathHelper + .clamp_float(p2pVolume, 0.0f, powered ? BalanceMath.listeningVolume(mTier) : 0.0f); + for (int i = 0; i < emitters.size(); i++) { + final PartP2PSound p2p = emitters.get(i); + final AENetworkProxy proxy = p2p.getProxy(); + final TileEntity emitterTe = p2p.getTile(); + final ForgeDirection dir = p2p.getSide(); + position.set( + emitterTe.xCoord + dir.offsetX, + emitterTe.yCoord + dir.offsetY, + emitterTe.zCoord + dir.offsetZ, + emitterTe.getWorldObj().provider.dimensionId); + final boolean active = proxy.isActive(); + target.setEmitter(1 + i, position, active ? actualP2PVolume : 0); + } + } + + @Override + public boolean allowSoundProxying(PartP2PSound p2p) { + return false; // the jukebox proxies sounds by itself + } + + @Override + public void onSoundP2PAttach(PartP2PSound p2p) { + attachedSoundP2P.put(p2p.getSide(), p2p); + updateEmitterList(); + } + + @Override + public void onSoundP2PDetach(PartP2PSound p2p) { + attachedSoundP2P.put(p2p.getSide(), null); + updateEmitterList(); + } + + @Override + public void onSoundP2POutputUpdate(PartP2PSound p2p, TunnelCollection<PartP2PSound> outputs) { + updateEmitterList(); + } + +} |