WIP: Map Event Sync (Includes MapEvents, recruitment, prisoners)

source/Common.Tests/Utils/AllowedInstanceTests.cs → source/Common.Tests/Utils/AllowedThreadTests.cs

@@ -2,7 +2,7 @@
 
 namespace Common.Tests.Utils
 {
-    public class AllowedInstanceTests
+    public class AllowedThreadTests
     {
         [Fact]
         public void AllowedInstance_DoesNotAllowChange()

source/Coop.Core/Client/Services/Heroes/Handler/ClientPlayerEscapeCaptivityHandler.cs

@@ -0,0 +1,42 @@
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Heroes.Messages;
+using Coop.Core.Server.Services.Heroes.Messages;
+using GameInterface.Services.Heroes.Messages;
+
+namespace Coop.Core.Client.Services.MobileParties.Handlers
+{
+    public class ClientPlayerEscapeCaptivityHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientPlayerEscapeCaptivityHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<LocalPlayerEscaped>(Handle);
+            messageBroker.Subscribe<NetworkPlayerEscapeApproved>(Handle);
+        }
+
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<LocalPlayerEscaped>(Handle);
+            messageBroker.Unsubscribe<NetworkPlayerEscapeApproved>(Handle);
+        }
+
+        private void Handle(MessagePayload<LocalPlayerEscaped> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkPlayerEscapeRequest(payload.HeroId));
+        }
+        private void Handle(MessagePayload<NetworkPlayerEscapeApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new EscapePlayer(payload.HeroId));
+        }
+    }
+}

source/Coop.Core/Client/Services/Heroes/Handler/ClientReleasePrisonerHandler.cs

@@ -0,0 +1,45 @@
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Heroes.Messages;
+using Coop.Core.Server.Services.Heroes.Messages;
+using GameInterface.Services.Heroes.Messages;
+
+namespace Coop.Core.Client.Services.Heroes.Handler
+{
+    /// <summary>
+    /// Handles all releases of prisoners on client
+    /// </summary>
+    public class ClientReleasePrisonerHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientReleasePrisonerHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<PrisonerReleased>(Handle);
+            messageBroker.Subscribe<NetworkReleasePrisonerApproved>(Handle);
+        }
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<PrisonerReleased>(Handle);
+            messageBroker.Unsubscribe<NetworkReleasePrisonerApproved>(Handle);
+        }
+
+        private void Handle(MessagePayload<PrisonerReleased> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkReleasePrisonerRequest(payload.HeroId, payload.EndCaptivityDetail, payload.FacilitatorId));
+        }
+
+        private void Handle(MessagePayload<NetworkReleasePrisonerApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new ReleasePrisoner(payload.HeroId, payload.EndCaptivityDetail, payload.FacilitatorId));
+        }
+    }
+}

source/Coop.Core/Client/Services/Heroes/Handler/ClientTakePrisonerHandler.cs

@@ -0,0 +1,45 @@
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Heroes.Messages;
+using Coop.Core.Server.Services.Heroes.Messages;
+using GameInterface.Services.Heroes.Messages;
+
+namespace Coop.Core.Client.Services.Heroes.Handler
+{
+    /// <summary>
+    /// Handles all captures of prisoners on client
+    /// </summary>
+    public class ClientTakePrisonerHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientTakePrisonerHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<PrisonerTaken>(Handle);
+            messageBroker.Subscribe<NetworkTakePrisonerApproved>(Handle);
+        }
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<PrisonerTaken>(Handle);
+            messageBroker.Unsubscribe<NetworkTakePrisonerApproved>(Handle);
+        }
+
+        private void Handle(MessagePayload<PrisonerTaken> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkTakePrisonerRequest(payload.PartyId, payload.CharacterId, payload.IsEventCalled));
+        }
+
+        private void Handle(MessagePayload<NetworkTakePrisonerApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new TakePrisoner(payload.PartyId, payload.CharacterId, payload.IsEventCalled));
+        }
+    }
+}

source/Coop.Core/Client/Services/Heroes/Messages/NetworkPlayerEscapeRequest.cs

@@ -0,0 +1,20 @@
+using Common.Messaging;
+using ProtoBuf;
+
+namespace Coop.Core.Client.Services.Heroes.Messages
+{
+    /// <summary>
+    /// Request from client to server for player escape
+    /// </summary>
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkPlayerEscapeRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string HeroId { get; }
+
+        public NetworkPlayerEscapeRequest(string heroId)
+        {
+            HeroId = heroId;
+        }
+    }
+}

source/Coop.Core/Client/Services/Heroes/Messages/NetworkReleasePrisonerRequest.cs

@@ -0,0 +1,27 @@
+using Common.Messaging;
+using ProtoBuf;
+#nullable enable
+
+namespace Coop.Core.Client.Services.Heroes.Messages
+{
+    /// <summary>
+    /// Request from client to server to release prisoner
+    /// </summary>
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkReleasePrisonerRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string HeroId { get; }
+        [ProtoMember(2)]
+        public int EndCaptivityDetail { get; }
+        [ProtoMember(3)]
+        public string? FacilitatorId { get; }
+
+        public NetworkReleasePrisonerRequest(string heroId, int endCaptivityDetail, string? facilitatorId)
+        {
+            HeroId = heroId;
+            EndCaptivityDetail = endCaptivityDetail;
+            FacilitatorId = facilitatorId;
+        }
+    }
+}

source/Coop.Core/Client/Services/Heroes/Messages/NetworkTakePrisonerRequest.cs

@@ -0,0 +1,29 @@
+using Common.Messaging;
+using ProtoBuf;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Coop.Core.Client.Services.Heroes.Messages
+{
+    /// <summary>
+    /// Request from client to server to take prisoner
+    /// </summary>
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkTakePrisonerRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string PartyId { get; }
+        [ProtoMember(2)]
+        public string CharacterId { get; }
+        [ProtoMember(3)]
+        public bool IsEventCalled { get; }
+
+        public NetworkTakePrisonerRequest(string partyId, string characterId, bool isEventCalled)
+        {
+            PartyId = partyId;
+            CharacterId = characterId;
+            IsEventCalled = isEventCalled;
+        }
+    }
+}

source/Coop.Core/Client/Services/MapEvent/Handlers/ClientEndBattleHandler.cs

@@ -0,0 +1,49 @@
+using Common.Logging;
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.MapEvent.Messages;
+using Coop.Core.Server.Services.MapEvent.Messages;
+using GameInterface.Services.MapEvents.Messages;
+using Serilog;
+
+namespace Coop.Core.Client.Services.MapEvent.Handlers
+{
+    /// <summary>
+    /// Client handler for Ending Map Events
+    /// </summary>
+    public class ClientEndBattleHandler : IHandler
+    {
+        private readonly ILogger Logger = LogManager.GetLogger<ClientEndBattleHandler>();
+
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientEndBattleHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<BattleEnded>(Handle);
+            messageBroker.Subscribe<NetworkEndBattleApproved>(Handle);
+        }
+
+        public void Dispose()
+        {
+            messageBroker.Subscribe<BattleEnded>(Handle);
+            messageBroker.Unsubscribe<NetworkEndBattleApproved>(Handle);
+        }
+        private void Handle(MessagePayload<BattleEnded> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkBattleEndedRequest(payload.partyId));
+        }
+
+        private void Handle(MessagePayload<NetworkEndBattleApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new EndBattle(payload.partyId));
+        }
+    }
+}

source/Coop.Core/Client/Services/MapEvent/Handlers/ClientStartBattleHandler.cs

@@ -0,0 +1,52 @@
+using Common.Logging;
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.MapEvent.Messages;
+using Coop.Core.Server.Services.MapEvent.Messages;
+using GameInterface.Services.MapEvents.Messages;
+using Serilog;
+
+namespace Coop.Core.Client.Services.MapEvent.Handlers
+{
+    /// <summary>
+    /// Client handler for Starting Map Events
+    /// </summary>
+    public class ClientStartBattleHandler : IHandler
+    {
+        private readonly ILogger Logger = LogManager.GetLogger<ClientStartBattleHandler>();
+
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientStartBattleHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<BattleStarted>(Handle);
+            messageBroker.Subscribe<NetworkStartBattleApproved>(Handle);
+        }
+
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<BattleStarted>(Handle);
+            messageBroker.Unsubscribe<NetworkStartBattleApproved>(Handle);
+        }
+        private void Handle(MessagePayload<BattleStarted> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkBattleStartedRequest(
+                payload.attackerPartyId, 
+                payload.defenderPartyId));
+        }
+        private void Handle(MessagePayload<NetworkStartBattleApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new StartBattle(
+                payload.attackerPartyId,
+                payload.defenderPartyId));
+        }
+    }
+}

source/Coop.Core/Client/Services/MapEvent/Messages/NetworkBattleEndedRequest.cs

@@ -0,0 +1,21 @@
+using Common.Messaging;
+using Common.PacketHandlers;
+using ProtoBuf;
+
+namespace Coop.Core.Client.Services.MapEvent.Messages
+{
+    /// <summary>
+    /// Request from client to server to end battle
+    /// </summary>
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkBattleEndedRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string partyId { get; }
+
+        public NetworkBattleEndedRequest(string partyId)
+        {
+            this.partyId = partyId;
+        }
+    }
+}

source/Coop.Core/Client/Services/MapEvent/Messages/NetworkBattleStartedRequest.cs

@@ -0,0 +1,24 @@
+using Common.Messaging;
+using Common.PacketHandlers;
+using ProtoBuf;
+
+namespace Coop.Core.Client.Services.MapEvent.Messages
+{
+    /// <summary>
+    /// Request from client to server to start battle
+    /// </summary>
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkBattleStartedRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string attackerPartyId { get; }
+        [ProtoMember(2)]
+        public string defenderPartyId { get; }
+
+        public NetworkBattleStartedRequest(string attackerPartyId, string defenderPartyId)
+        {
+            this.attackerPartyId = attackerPartyId;
+            this.defenderPartyId = defenderPartyId;
+        }
+    }
+}