Implement jukebox dialog

EOLib.Localization/EOResourceID.cs

@@ -152,6 +152,8 @@ public enum EOResourceID
         DIALOG_SHOP_CRAFT_MISSING_INGREDIENTS = 158,
         DIALOG_SHOP_CRAFT_PUT_INGREDIENTS_TOGETHER = 159,
 
+        DIALOG_WORD_CURRENT = 163,
+
         DIALOG_TRADE_BOTH_PLAYERS_OFFER_ONE_ITEM = 165,
 
         DIALOG_TRANSFER_TRANSFER = 176,
@@ -172,6 +174,14 @@ public enum EOResourceID
 
         STATUS_LABEL_KEEP_MOVING_THROUGH_PLAYER = 278,
 
+        JUKEBOX_NOW_VIEWED = 279,
+        JUKEBOX_BROWSE_THROUGH_SONGS = 280,
+        JUKEBOX_PLAY_SONG = 281,
+        JUKEBOX_REQUEST_SONG = 282,
+        JUKEBOX_REQUEST_SONG_FOR = 283,
+        JUKEBOX_PLAYING_REQUEST = 284,
+        JUKEBOX_IS_READY = 285,
+
         DIALOG_TITLE_PERFORMANCE = 286,
         DIALOG_PERFORMANCE_TOTALEXP = 287,
         DIALOG_PERFORMANCE_NEXT_LEVEL = 288,
@@ -185,7 +195,6 @@ public enum EOResourceID
         IDLE_TOO_LONG = 295,
         IDLE_PLEASE_START_MOVING = 296,
 
-
         SKILLMASTER_WORD_SPELL = 297,
         SKILLMASTER_WORD_SKILL = 298,
         SPELL_WAS_SELECTED = 299,

EOLib/Domain/Jukebox/JukeboxActions.cs → EOLib/Domain/Interact/Jukebox/JukeboxActions.cs

@@ -1,13 +1,14 @@
 using AutomaticTypeMapper;
 using EOLib.Domain.Character;
+using EOLib.Domain.Map;
 using EOLib.IO;
 using EOLib.IO.Repositories;
 using EOLib.Net;
 using EOLib.Net.Communication;
 using Optional.Collections;
 using System;
 
-namespace EOLib.Domain.Jukebox
+namespace EOLib.Domain.Interact.Jukebox
 {
     [AutoMappedType]
     public class JukeboxActions : IJukeboxActions
@@ -42,10 +43,23 @@ public void PlayNote(int noteIndex)
                     _packetSendService.SendPacket(packet);
                 });
         }
+
+        public void RequestSong(MapCoordinate coordinate, int songIndex)
+        {
+            var packet = new PacketBuilder(PacketFamily.JukeBox, PacketAction.Message)
+                .AddChar(coordinate.X)
+                .AddChar(coordinate.Y)
+                .AddShort(songIndex)
+                .Build();
+
+            _packetSendService.SendPacket(packet);
+        }
     }
 
     public interface IJukeboxActions
     {
         void PlayNote(int noteIndex);
+
+        void RequestSong(MapCoordinate coordinate, int songIndex);
     }
 }

EOLib/Domain/Interact/Jukebox/JukeboxDataRepository.cs

@@ -0,0 +1,32 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Map;
+using Optional;
+
+namespace EOLib.Domain.Interact.Jukebox
+{
+    public interface IJukeboxRepository
+    {
+        Option<string> PlayingRequestName { get; set; }
+    }
+
+    public interface IJukeboxProvider
+    {
+        Option<string> PlayingRequestName { get; }
+    }
+
+    [AutoMappedType(IsSingleton = true)]
+    public class JukeboxDataRepository : IJukeboxRepository, IJukeboxProvider, IResettable
+    {
+        public Option<string> PlayingRequestName { get; set; }
+
+        public JukeboxDataRepository()
+        {
+            ResetState();
+        }
+
+        public void ResetState()
+        {
+            PlayingRequestName = Option.None<string>();
+        }
+    }
+}

EOLib/Domain/Interact/Board/BoardMapEntity.cs → EOLib/Domain/Interact/TileSpecMapEntity.cs

@@ -1,10 +1,10 @@
 using Amadevus.RecordGenerator;
 using EOLib.IO.Map;
 
-namespace EOLib.Domain.Interact.Board
+namespace EOLib.Domain.Interact
 {
     [Record]
-    public sealed partial class BoardMapEntity : IMapEntity
+    public sealed partial class TileSpecMapEntity : IMapEntity
     {
         public int X { get; }
 

EOLib/Domain/Map/MapActions.cs

@@ -91,6 +91,16 @@ public void OpenBoard(TileSpec boardSpec)
 
             _packetSendService.SendPacket(packet);
         }
+
+        public void OpenJukebox(MapCoordinate location)
+        {
+            var packet = new PacketBuilder(PacketFamily.JukeBox, PacketAction.Open)
+                .AddChar(location.X)
+                .AddChar(location.Y)
+                .Build();
+
+            _packetSendService.SendPacket(packet);
+        }
     }
 
     public interface IMapActions
@@ -106,5 +116,7 @@ public interface IMapActions
         void OpenLocker(MapCoordinate location);
 
         void OpenBoard(TileSpec boardSpec);
+
+        void OpenJukebox(MapCoordinate location);
     }
 }

EOLib/Domain/Notifiers/ISoundNotifier.cs

@@ -5,11 +5,15 @@ namespace EOLib.Domain.Notifiers
     public interface ISoundNotifier
     {
         void NotifySoundEffect(int soundEffectId);
+
+        void NotifyMusic(int musicEffectId, bool isJukebox);
     }
 
     [AutoMappedType]
     public class NoOpSoundNotifier : ISoundNotifier
     {
         public void NotifySoundEffect(int soundEffectId) { }
+
+        public void NotifyMusic(int musicEffectId, bool isJukebox) { }
     }
 }

EOLib/PacketHandlers/Jukebox/JukeboxAgreeHandler.cs

@@ -0,0 +1,39 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Character;
+using EOLib.Domain.Login;
+using EOLib.Net;
+using EOLib.Net.Handlers;
+using Optional.Collections;
+
+namespace EOLib.PacketHandlers.Jukebox
+{
+    /// <summary>
+    /// Sent to update character's remaining gold after requesting a song
+    /// </summary>
+    [AutoMappedType]
+    public class JukeboxAgreeHandler : InGameOnlyPacketHandler
+    {
+        private readonly ICharacterInventoryRepository _characterInventoryRepository;
+
+        public override PacketFamily Family => PacketFamily.JukeBox;
+
+        public override PacketAction Action => PacketAction.Agree;
+
+        public JukeboxAgreeHandler(IPlayerInfoProvider playerInfoProvider,
+                                   ICharacterInventoryRepository characterInventoryRepository)
+            : base(playerInfoProvider)
+        {
+            _characterInventoryRepository = characterInventoryRepository;
+        }
+
+        public override bool HandlePacket(IPacket packet)
+        {
+            var goldRemaining = packet.ReadInt();
+
+            _characterInventoryRepository.ItemInventory.SingleOrNone(x => x.ItemID == 1).MatchSome(x => _characterInventoryRepository.ItemInventory.Remove(x));
+            _characterInventoryRepository.ItemInventory.Add(new InventoryItem(1, goldRemaining));
+
+            return true;
+        }
+    }
+}

EOLib/PacketHandlers/Jukebox/JukeboxOpenHandler.cs

@@ -0,0 +1,51 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Interact.Jukebox;
+using EOLib.Domain.Login;
+using EOLib.Domain.Notifiers;
+using EOLib.Net;
+using EOLib.Net.Handlers;
+using Optional;
+using System.Collections.Generic;
+using System.IO;
+
+namespace EOLib.PacketHandlers.Jukebox
+{
+    [AutoMappedType]
+    public class JukeboxOpenHandler : InGameOnlyPacketHandler
+    {
+        private readonly IJukeboxRepository _jukeboxRepository;
+        private readonly IEnumerable<IUserInterfaceNotifier> _userInterfaceNotifiers;
+
+        public override PacketFamily Family => PacketFamily.JukeBox;
+
+        public override PacketAction Action => PacketAction.Open;
+
+        public JukeboxOpenHandler(IPlayerInfoProvider playerInfoProvider,
+                                  IJukeboxRepository jukeboxRepository,
+                                  IEnumerable<IUserInterfaceNotifier> userInterfaceNotifiers)
+            : base(playerInfoProvider)
+        {
+            _jukeboxRepository = jukeboxRepository;
+            _userInterfaceNotifiers = userInterfaceNotifiers;
+        }
+
+        public override bool HandlePacket(IPacket packet)
+        {
+            packet.Seek(2, SeekOrigin.Current);
+
+            if (packet.ReadPosition < packet.Length)
+            {
+                _jukeboxRepository.PlayingRequestName = Option.Some(packet.ReadEndString());
+            }
+            else
+            {
+                _jukeboxRepository.PlayingRequestName = Option.None<string>();
+            }
+
+            foreach (var notifier in _userInterfaceNotifiers)
+                notifier.NotifyPacketDialog(PacketFamily.JukeBox);
+
+            return true;
+        }
+    }
+}

EOLib/PacketHandlers/Jukebox/JukeboxPlayerHandler.cs

@@ -0,0 +1,37 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Login;
+using EOLib.Domain.Notifiers;
+using EOLib.Net;
+using EOLib.Net.Handlers;
+using System.Collections.Generic;
+
+namespace EOLib.PacketHandlers.Jukebox
+{
+    /// <summary>
+    /// Sent when background music should be changed (currently only in weddings)
+    /// </summary>
+    [AutoMappedType]
+    public class JukeboxPlayerHandler : InGameOnlyPacketHandler
+    {
+        private readonly IEnumerable<ISoundNotifier> _soundNotifiers;
+
+        public override PacketFamily Family => PacketFamily.JukeBox;
+
+        public override PacketAction Action => PacketAction.Player;
+
+        public JukeboxPlayerHandler(IPlayerInfoProvider playerInfoProvider,
+                                    IEnumerable<ISoundNotifier> soundNotifiers)
+            : base(playerInfoProvider)
+        {
+            _soundNotifiers = soundNotifiers;
+        }
+
+        public override bool HandlePacket(IPacket packet)
+        {
+            var id = packet.ReadChar();
+            foreach (var notifier in _soundNotifiers)
+                notifier.NotifyMusic(id, isJukebox: false);
+            return true;
+        }
+    }
+}

EOLib/PacketHandlers/Jukebox/JukeboxUseHandler.cs

@@ -0,0 +1,46 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Interact.Jukebox;
+using EOLib.Domain.Login;
+using EOLib.Domain.Notifiers;
+using EOLib.Net;
+using EOLib.Net.Handlers;
+using Optional;
+using System.Collections.Generic;
+
+namespace EOLib.PacketHandlers.Jukebox
+{
+    /// <summary>
+    /// Sent when a Jukebox track should be played
+    /// </summary>
+    [AutoMappedType]
+    public class JukeboxUseHandler : InGameOnlyPacketHandler
+    {
+        private readonly IJukeboxRepository _jukeboxRepository;
+        private readonly IEnumerable<ISoundNotifier> _soundNotifiers;
+
+        public override PacketFamily Family => PacketFamily.JukeBox;
+
+        public override PacketAction Action => PacketAction.Use;
+
+        public JukeboxUseHandler(IPlayerInfoProvider playerInfoProvider,
+                                 IJukeboxRepository jukeboxRepository,
+                                 IEnumerable<ISoundNotifier> soundNotifiers)
+            : base(playerInfoProvider)
+        {
+            _jukeboxRepository = jukeboxRepository;
+            _soundNotifiers = soundNotifiers;
+        }
+
+        public override bool HandlePacket(IPacket packet)
+        {
+            var id = packet.ReadShort();
+
+            _jukeboxRepository.PlayingRequestName = Option.Some(string.Empty);
+
+            foreach (var notifier in _soundNotifiers)
+                notifier.NotifyMusic(id, isJukebox: true);
+
+            return true;
+        }
+    }
+}

EOLib/misc.cs

@@ -34,6 +34,7 @@ public static class Constants
 
         public const string SfxDirectory = "sfx";
         public const string MfxDirectory = "mfx";
+        public const string JboxDirectory = "jbox";
 
         public const string FriendListFile = "config/friends.ini";
         public const string IgnoreListFile = "config/ignore.ini";

EndlessClient/Audio/AudioActions.cs

@@ -2,6 +2,7 @@
 using EOLib.Config;
 using EOLib.Domain.Map;
 using EOLib.Domain.Notifiers;
+using EOLib.IO.Map;
 
 namespace EndlessClient.Audio
 {
@@ -59,6 +60,11 @@ public void NotifySoundEffect(int soundEffectId)
         {
             _sfxPlayer.PlaySfx((SoundEffectID)soundEffectId);
         }
+
+        public void NotifyMusic(int musicEffectId, bool isJukebox)
+        {
+            _mfxPlayer.PlayBackgroundMusic(musicEffectId, MusicControl.InterruptIfDifferentPlayOnce, isJukebox);
+        }
     }
 
     public interface IAudioActions