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

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

@@ -0,0 +1,51 @@
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Clans.Messages;
+using Coop.Core.Client.Services.Heroes.Messages;
+using Coop.Core.Server.Services.Clans.Messages;
+using Coop.Core.Server.Services.Heroes.Messages;
+using GameInterface.Services.Clans.Messages;
+using GameInterface.Services.Heroes.Messages;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+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/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/BattleSimulationClientHandler.cs

@@ -0,0 +1,59 @@
+using Common.Logging;
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Clans.Handler;
+using Coop.Core.Client.Services.MapEvent.Messages;
+using Coop.Core.Server.Services.Clans.Messages;
+using Coop.Core.Server.Services.MapEvent.Messages;
+using GameInterface.Services.Clans.Messages;
+using GameInterface.Services.MapEvents.Messages;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Coop.Core.Client.Services.MapEvent.Handlers
+{
+    /// <summary>
+    /// Client handler for Starting Map Events
+    /// </summary>
+    public class BattleSimulationClientHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+        private readonly ILogger Logger = LogManager.GetLogger<BattleSimulationClientHandler>();
+
+        public BattleSimulationClientHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+
+            messageBroker.Subscribe<BattleRoundSimulated>(Handle);
+            messageBroker.Subscribe<NetworkBattleSimulatedApproved>(Handle);
+        }
+
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<BattleRoundSimulated>(Handle);
+            messageBroker.Unsubscribe<NetworkBattleSimulatedApproved>(Handle);
+        }
+        private void Handle(MessagePayload<BattleRoundSimulated> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkBattleRoundSimulatedRequest(
+                payload.PartyId, 
+                payload.Side,
+                payload.Advantage));
+        }
+        private void Handle(MessagePayload<NetworkBattleSimulatedApproved> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new SimulateBattleRound(
+                payload.PartyId,
+                payload.Side,
+                payload.Advantage));
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+using Common.Logging;
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Clans.Handler;
+using Coop.Core.Client.Services.MapEvent.Messages;
+using Coop.Core.Server.Services.Clans.Messages;
+using Coop.Core.Server.Services.MapEvent.Messages;
+using GameInterface.Services.Clans.Messages;
+using GameInterface.Services.MapEvents.Messages;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Coop.Core.Client.Services.MapEvent.Handlers
+{
+    /// <summary>
+    /// Client handler for Ending Map Events
+    /// </summary>
+    public class EndBattleClientHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+        private readonly ILogger Logger = LogManager.GetLogger<EndBattleClientHandler>();
+
+        public EndBattleClientHandler(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/StartBattleClientHandler.cs

@@ -0,0 +1,57 @@
+using Common.Logging;
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.Clans.Handler;
+using Coop.Core.Client.Services.MapEvent.Messages;
+using Coop.Core.Server.Services.Clans.Messages;
+using Coop.Core.Server.Services.MapEvent.Messages;
+using GameInterface.Services.Clans.Messages;
+using GameInterface.Services.MapEvents.Messages;
+using Serilog;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Coop.Core.Client.Services.MapEvent.Handlers
+{
+    /// <summary>
+    /// Client handler for Starting Map Events
+    /// </summary>
+    public class StartBattleClientHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+        private readonly ILogger Logger = LogManager.GetLogger<StartBattleClientHandler>();
+
+        public StartBattleClientHandler(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/NetworkBattleRoundSimulatedRequest.cs

@@ -0,0 +1,24 @@
+using Common.Messaging;
+using Common.PacketHandlers;
+using ProtoBuf;
+
+namespace Coop.Core.Client.Services.MapEvent.Messages
+{
+    [ProtoContract(SkipConstructor = true)]
+    public record NetworkBattleRoundSimulatedRequest : ICommand
+    {
+        [ProtoMember(1)]
+        public string PartyId { get; }
+        [ProtoMember(2)]    
+        public int Side { get; }
+        [ProtoMember(3)]
+        public float Advantage { get; }
+
+        public NetworkBattleRoundSimulatedRequest(string partyId, int side, float advantage)
+        {
+            PartyId = partyId;
+            Side = side;
+            Advantage = advantage;
+        }
+    }
+}

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;
+        }
+    }
+}

source/Coop.Core/Client/Services/MobileParties/Handlers/ClientMobilePartyRecruitHandler.cs

@@ -0,0 +1,65 @@
+using Common.Messaging;
+using Common.Network;
+using Coop.Core.Client.Services.MobileParties.Messages;
+using Coop.Core.Server.Services.MobileParties.Messages;
+using Coop.Core.Server.Services.MobileParties.Packets;
+using GameInterface.Services.MobileParties.Messages;
+using GameInterface.Services.MobileParties.Messages.Behavior;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Coop.Core.Client.Services.MobileParties.Handlers
+{
+    /// <summary>
+    /// Handles all mobile party recruitment routing on client
+    /// </summary>
+    public class ClientMobilePartyRecruitmentHandler : IHandler
+    {
+        private readonly IMessageBroker messageBroker;
+        private readonly INetwork network;
+
+        public ClientMobilePartyRecruitmentHandler(IMessageBroker messageBroker, INetwork network)
+        {
+            this.messageBroker = messageBroker;
+            this.network = network;
+            messageBroker.Subscribe<NewTroopAdded>(Handle);
+            messageBroker.Subscribe<NetworkNewTroopAdded>(Handle);
+            messageBroker.Subscribe<TroopIndexAdded>(Handle);
+            messageBroker.Subscribe<NetworkTroopIndexAdded>(Handle);
+        }
+        public void Dispose()
+        {
+            messageBroker.Unsubscribe<NewTroopAdded>(Handle);
+            messageBroker.Unsubscribe<NetworkNewTroopAdded>(Handle);
+            messageBroker.Unsubscribe<TroopIndexAdded>(Handle);
+            messageBroker.Unsubscribe<NetworkTroopIndexAdded>(Handle);
+        }
+
+        internal void Handle(MessagePayload<NewTroopAdded> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkNewTroopRequest(payload.CharacterId, payload.PartyId, payload.isPrisonerRoster, payload.InsertAtFront, payload.InsertionIndex));
+        }
+        internal void Handle(MessagePayload<NetworkNewTroopAdded> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new AddNewTroop(payload.CharacterId, payload.PartyId, payload.IsPrisonerRoster, payload.InsertAtFront, payload.InsertionIndex));
+        }
+
+        internal void Handle(MessagePayload<TroopIndexAdded> obj)
+        {
+            var payload = obj.What;
+
+            network.SendAll(new NetworkTroopIndexAddRequest(payload.PartyId, payload.IsPrisonerRoster, payload.Index, payload.CountChange, payload.WoundedCountChange, payload.XpChange, payload.RemoveDepleted));
+        }
+        internal void Handle(MessagePayload<NetworkTroopIndexAdded> obj)
+        {
+            var payload = obj.What;
+
+            messageBroker.Publish(this, new AddTroopIndex(payload.PartyId, payload.IsPrisonerRoster, payload.Index, payload.CountChange, payload.WoundedCountChange, payload.XpChange, payload.RemoveDepleted));
+        }
+    }
+}