Add support for bard music. Player can click to play harp/guitar note…

…s, and notes played by other players will be played.

EOBot/Program.cs

@@ -158,7 +158,7 @@ public void NotifySelfSpellCast(short playerId, short spellId, int spellHp, byte
 
             public void NotifyStartSpellCast(short playerId, short spellId) { }
             public void NotifyTargetOtherSpellCast(short sourcePlayerID, short targetPlayerID, short spellId, int recoveredHP, byte targetPercentHealth) { }
-            public void StartOtherCharacterAttackAnimation(int characterID) { }
+            public void StartOtherCharacterAttackAnimation(int characterID, int noteIndex) { }
             public void StartOtherCharacterWalkAnimation(int characterID, byte destinationX, byte destinationY, EODirection direction) { }
         }
 

EOLib/Domain/Character/CharacterRenderProperties.cs

@@ -174,7 +174,11 @@ public ICharacterRenderProperties WithNextEmoteFrame()
         {
             var props = MakeCopy(this);
             props.EmoteFrame = (props.EmoteFrame + 1) % MAX_NUMBER_OF_EMOTE_FRAMES;
-            props.CurrentAction = props.EmoteFrame == 0 ? CharacterActionState.Standing : CharacterActionState.Emote;
+            props.CurrentAction = props.EmoteFrame == 0
+                ? CharacterActionState.Standing
+                : props.CurrentAction == CharacterActionState.Attacking // when using an instrument keep the current state as "Attacking"
+                    ? CharacterActionState.Attacking
+                    : CharacterActionState.Emote;
             return props;
         }
 

EOLib/Domain/Character/Emote.cs

@@ -21,6 +21,7 @@ public enum Emote
         /// <summary>
         /// 0 key
         /// </summary>
-        Playful = 14
+        Playful = 14,
+        MusicNotes = 15,
     }
 }

EOLib/Domain/Jukebox/JukeboxActions.cs

@@ -0,0 +1,51 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Character;
+using EOLib.IO;
+using EOLib.IO.Repositories;
+using EOLib.Net;
+using EOLib.Net.Communication;
+using Optional.Collections;
+using System;
+
+namespace EOLib.Domain.Jukebox
+{
+    [AutoMappedType]
+    public class JukeboxActions : IJukeboxActions
+    {
+        private readonly IPacketSendService _packetSendService;
+        private readonly ICharacterProvider _characterProvider;
+        private readonly IEIFFileProvider _eifFileProvider;
+
+        public JukeboxActions(IPacketSendService packetSendService,
+                              ICharacterProvider characterProvider,
+                              IEIFFileProvider eifFileProvider)
+        {
+            _packetSendService = packetSendService;
+            _characterProvider = characterProvider;
+            _eifFileProvider = eifFileProvider;
+        }
+
+        public void PlayNote(int noteIndex)
+        {
+            if (noteIndex < 0 || noteIndex >= 36)
+                throw new ArgumentOutOfRangeException(nameof(noteIndex));
+
+            var weapon = _characterProvider.MainCharacter.RenderProperties.WeaponGraphic;
+            _eifFileProvider.EIFFile.SingleOrNone(x => x.Type == ItemType.Weapon && x.DollGraphic == weapon)
+                .MatchSome(rec =>
+                {
+                    var packet = new PacketBuilder(PacketFamily.JukeBox, PacketAction.Use)
+                        .AddChar((byte)rec.DollGraphic) // todo: determine what GameServer expects; eoserv sends DollGraphic as a response in Character::PlayBard
+                        .AddChar((byte)(noteIndex + 1))
+                        .Build();
+
+                    _packetSendService.SendPacket(packet);
+                });
+        }
+    }
+
+    public interface IJukeboxActions
+    {
+        void PlayNote(int noteIndex);
+    }
+}

EOLib/Domain/Notifiers/IOtherCharacterAnimationNotifier.cs

@@ -6,7 +6,7 @@ public interface IOtherCharacterAnimationNotifier
     {
         void StartOtherCharacterWalkAnimation(int characterID, byte destinationX, byte destinationY, EODirection direction);
 
-        void StartOtherCharacterAttackAnimation(int characterID);
+        void StartOtherCharacterAttackAnimation(int characterID, int noteIndex = -1);
 
         void NotifyStartSpellCast(short playerId, short spellId);
 
@@ -20,7 +20,7 @@ public class NoOpOtherCharacterAnimationNotifier : IOtherCharacterAnimationNotif
     {
         public void StartOtherCharacterWalkAnimation(int characterID, byte destinationX, byte destinationY, EODirection direction) { }
 
-        public void StartOtherCharacterAttackAnimation(int characterID) { }
+        public void StartOtherCharacterAttackAnimation(int characterID, int noteIndex = -1) { }
 
         public void NotifyStartSpellCast(short playerId, short spellId) { }
 

EOLib/PacketHandlers/Jukebox/JukeboxMessageHandler.cs

@@ -0,0 +1,61 @@
+using AutomaticTypeMapper;
+using EOLib.Domain.Character;
+using EOLib.Domain.Login;
+using EOLib.Domain.Map;
+using EOLib.Domain.Notifiers;
+using EOLib.Net;
+using EOLib.Net.Handlers;
+using System.Collections.Generic;
+
+namespace EOLib.PacketHandlers.Jukebox
+{
+    [AutoMappedType]
+    public class JukeboxMessageHandler : InGameOnlyPacketHandler
+    {
+        private readonly ICharacterRepository _characterRepository;
+        private readonly ICurrentMapStateRepository _currentMapStateRepository;
+        private readonly IEnumerable<IMainCharacterEventNotifier> _mainCharacterEventNotifiers;
+        private readonly IEnumerable<IOtherCharacterAnimationNotifier> _otherCharacterAnimationNotifiers;
+
+        public override PacketFamily Family => PacketFamily.JukeBox;
+
+        public override PacketAction Action => PacketAction.Message;
+
+        public JukeboxMessageHandler(IPlayerInfoProvider playerInfoProvider,
+                                     ICurrentMapStateRepository currentMapStateRepository,
+                                     IEnumerable<IOtherCharacterAnimationNotifier> otherCharacterAnimationNotifiers)
+            : base(playerInfoProvider)
+        {
+            _currentMapStateRepository = currentMapStateRepository;
+            _otherCharacterAnimationNotifiers = otherCharacterAnimationNotifiers;
+        }
+
+        public override bool HandlePacket(IPacket packet)
+        {
+            var playerId = packet.ReadShort();
+            var direction = (EODirection)packet.ReadChar();
+            var instrument = packet.ReadChar();
+            var note = packet.ReadChar();
+
+            if (_currentMapStateRepository.Characters.ContainsKey(playerId))
+            {
+                var c = _currentMapStateRepository.Characters[playerId];
+
+                if (c.RenderProperties.WeaponGraphic == instrument)
+                {
+                    c = c.WithRenderProperties(c.RenderProperties.WithDirection(direction));
+                    _currentMapStateRepository.Characters[playerId] = c;
+
+                    foreach (var notifier in _otherCharacterAnimationNotifiers)
+                        notifier.StartOtherCharacterAttackAnimation(playerId, note - 1);
+                }
+            }
+            else
+            {
+                _currentMapStateRepository.UnknownPlayerIDs.Add(playerId);
+            }
+
+            return true;
+        }
+    }
+}

EndlessClient/Controllers/BardController.cs

@@ -1,12 +1,38 @@
 using AutomaticTypeMapper;
+using EndlessClient.Rendering.Character;
+using EOLib.Domain.Character;
+using EOLib.Domain.Extensions;
+using EOLib.Domain.Jukebox;
 
 namespace EndlessClient.Controllers
 {
     [AutoMappedType]
     public class BardController : IBardController
     {
+        private readonly ICharacterAnimationActions _characterAnimationActions;
+        private readonly IJukeboxActions _jukeboxActions;
+        private readonly ICharacterProvider _characterProvider;
+
+        public BardController(ICharacterAnimationActions characterAnimationActions,
+                              IJukeboxActions jukeboxActions,
+                              ICharacterProvider characterProvider)
+        {
+            _characterAnimationActions = characterAnimationActions;
+            _jukeboxActions = jukeboxActions;
+            _characterProvider = characterProvider;
+        }
+
         public void PlayInstrumentNote(int noteIndex)
         {
+            _characterAnimationActions.StartAttacking(noteIndex);
+            _jukeboxActions.PlayNote(noteIndex);
+        }
+
+        private bool CanAttackAgain()
+        {
+            var rp = _characterProvider.MainCharacter.RenderProperties;
+            return rp.IsActing(CharacterActionState.Standing) ||
+                   rp.RenderAttackFrame == CharacterRenderProperties.MAX_NUMBER_OF_ATTACK_FRAMES;
         }
     }
 

EndlessClient/Controllers/NumPadController.cs

@@ -1,6 +1,4 @@
 using AutomaticTypeMapper;
-using EndlessClient.ControlSets;
-using EndlessClient.HUD.Controls;
 using EndlessClient.Rendering.Character;
 using EOLib.Domain.Character;
 using EOLib.Domain.Extensions;
@@ -11,31 +9,25 @@ namespace EndlessClient.Controllers
     public class NumPadController : INumPadController
     {
         private readonly ICharacterActions _characterActions;
-        private readonly IHudControlProvider _hudControlProvider;
-        private readonly ICharacterRendererProvider _characterRendererProvider;
+        private readonly ICharacterAnimationActions _characterAnimationActions;
+        private readonly ICharacterProvider _characterProvider;
 
         public NumPadController(ICharacterActions characterActions,
-                                IHudControlProvider hudControlProvider,
-                                ICharacterRendererProvider characterRendererProvider)
+                                ICharacterAnimationActions characterAnimationActions,
+                                ICharacterProvider characterProvider)
         {
             _characterActions = characterActions;
-            _hudControlProvider = hudControlProvider;
-            _characterRendererProvider = characterRendererProvider;
+            _characterAnimationActions = characterAnimationActions;
+            _characterProvider = characterProvider;
         }
 
         public void Emote(Emote whichEmote)
         {
-            var mainRenderer = _characterRendererProvider.MainCharacterRenderer;
-            mainRenderer.MatchSome(renderer =>
-            {
-                if (!renderer.Character.RenderProperties.IsActing(CharacterActionState.Standing))
-                    return;
+            if (!_characterProvider.MainCharacter.RenderProperties.IsActing(CharacterActionState.Standing))
+                return;
 
-                _characterActions.Emote(whichEmote);
-
-                var animator = _hudControlProvider.GetComponent<ICharacterAnimator>(HudControlIdentifier.CharacterAnimator);
-                animator.Emote(renderer.Character.ID, whichEmote);
-            });
+            _characterActions.Emote(whichEmote);
+            _characterAnimationActions.Emote(whichEmote);
         }
     }