Share Player Progress

Client/Client.csproj

@@ -97,6 +97,10 @@
     </Compile>
     <Compile Include="Systems\Bug\BugSystem.cs" />
     <Compile Include="Systems\Bug\BugEvents.cs" />
+    <Compile Include="Systems\ShareProgress\ShareProgressEvents.cs" />
+    <Compile Include="Systems\ShareProgress\ShareProgressMessageHandler.cs" />
+    <Compile Include="Systems\ShareProgress\ShareProgressMessageSender.cs" />
+    <Compile Include="Systems\ShareProgress\ShareProgressSystem.cs" />
     <Compile Include="Systems\CraftLibrary\CraftLibraryMessageHandler.cs" />
     <Compile Include="Systems\CraftLibrary\CraftLibraryMessageSender.cs" />
     <Compile Include="Systems\CraftLibrary\CraftLibraryStructures.cs" />

Client/Network/NetworkReceiver.cs

@@ -15,6 +15,7 @@
 using LunaClient.Systems.Scenario;
 using LunaClient.Systems.Screenshot;
 using LunaClient.Systems.SettingsSys;
+using LunaClient.Systems.ShareProgress;
 using LunaClient.Systems.Status;
 using LunaClient.Systems.VesselDockSys;
 using LunaClient.Systems.VesselEvaSys;
@@ -204,6 +205,9 @@ private static void EnqueueMessageToSystem(IServerMessageBase msg)
                 case ServerMessageType.Facility:
                     FacilitySystem.Singleton.EnqueueMessage(msg);
                     break;
+                case ServerMessageType.ShareProgress:
+                    ShareProgressSystem.Singleton.EnqueueMessage(msg);
+                    break;
                 case ServerMessageType.Screenshot:
                     ScreenshotSystem.Singleton.EnqueueMessage(msg);
                     break;

Client/Systems/Lock/LockSystem.cs

@@ -93,13 +93,21 @@ public void AcquireSpectatorLock(Guid vesselId)
         }
 
         /// <summary>
-        /// Aquire the spectator lock on the given vessel
+        /// Aquire the asteroid lock for the current player
         /// </summary>
         public void AcquireAsteroidLock()
         {
             AcquireLock(new LockDefinition(LockType.Asteroid, SettingsSystem.CurrentSettings.PlayerName));
         }
 
+        /// <summary>
+        /// Aquire the contract lock for the current player.
+        /// </summary>
+        public void AcquireContractLock()
+        {
+            AcquireLock(new LockDefinition(LockType.Contract, SettingsSystem.CurrentSettings.PlayerName));
+        }
+
         #endregion
 
         #region ReleaseLocks      
@@ -196,6 +204,10 @@ public void ReleasePlayerLocks(LockType type)
                     locksToRelease = LockQuery.SpectatorLockExists(SettingsSystem.CurrentSettings.PlayerName) ?
                         new[] { LockQuery.GetSpectatorLock(SettingsSystem.CurrentSettings.PlayerName) } : new LockDefinition[0];
                     break;
+                case LockType.Contract:
+                    locksToRelease = LockQuery.ContractLockOwner() == playerName ?
+                        new[] { LockQuery.ContractLock() } : new LockDefinition[0];
+                    break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(type), type, null);
             }

Client/Systems/Network/NetworkSystem.cs

@@ -20,6 +20,7 @@
 using LunaClient.Systems.Scenario;
 using LunaClient.Systems.Screenshot;
 using LunaClient.Systems.SettingsSys;
+using LunaClient.Systems.ShareProgress;
 using LunaClient.Systems.Status;
 using LunaClient.Systems.TimeSyncer;
 using LunaClient.Systems.VesselDockSys;
@@ -294,6 +295,10 @@ private void NetworkUpdate()
                         ScreenshotSystem.Singleton.Enabled = true;
                         CraftLibrarySystem.Singleton.Enabled = true;
                         BugSystem.Singleton.Enabled = true;
+                        if (SettingsSystem.ServerSettings.GameMode != GameMode.Sandbox)
+                        {
+                            ShareProgressSystem.Singleton.Enabled = SettingsSystem.ServerSettings.ShareProgress;
+                        }
                         PlayerColorSystem.Singleton.MessageSender.SendPlayerColorToServer();
                         StatusSystem.Singleton.MessageSender.SendOwnStatus();
                         NetworkSimpleMessageSender.SendMotdRequest();

Client/Systems/SettingsSys/SettingsMessageHandler.cs

@@ -18,6 +18,7 @@ public void HandleMessage(IServerMessageBase msg)
 
             SettingsSystem.ServerSettings.WarpMode = msgData.WarpMode;
             SettingsSystem.ServerSettings.GameMode = msgData.GameMode;
+            SettingsSystem.ServerSettings.ShareProgress = msgData.ShareProgress;
             SettingsSystem.ServerSettings.TerrainQuality = msgData.TerrainQuality;
             SettingsSystem.ServerSettings.AllowCheats = msgData.AllowCheats;
             SettingsSystem.ServerSettings.AllowSackKerbals = msgData.AllowSackKerbals;

Client/Systems/SettingsSys/SettingsServerStructure.cs

@@ -10,6 +10,7 @@ public class SettingsServerStructure
         public GameParameters.AdvancedParams ServerAdvancedParameters { get; set; } = new GameParameters.AdvancedParams();
         public CommNetParams ServerCommNetParameters { get; set; } = new CommNetParams();
         public GameMode GameMode { get; set; }
+        public bool ShareProgress { get; set; }
         public TerrainQuality TerrainQuality { get; set; }
         public bool AllowCheats { get; set; }
         public bool AllowSackKerbals { get; set; }

Client/Systems/ShareProgress/ShareProgressEvents.cs

@@ -0,0 +1,206 @@
+using Contracts;
+using LunaClient.Base;
+using LunaClient.Network;
+using LunaClient.Utilities;
+using LunaCommon.Message.Data.ShareProgress;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace LunaClient.Systems.ShareProgress
+{
+    class ShareProgressEvents : SubSystem<ShareProgressSystem>
+    {
+        #region EventHandling
+        public void FundsChanged(double value, TransactionReasons reason)
+        {
+            if (System.IncomingFundsProcessing)
+                return;
+
+            var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData<ShareProgressFundsMsgData>();
+            msgData.Funds = value;
+            msgData.Reason = reason.ToString();
+            System.MessageSender.SendMessage(msgData);
+            LunaLog.Log("Funds changed to: " + value + " with reason: " + reason.ToString());
+        }
+
+        public void ScienceChanged(float value, TransactionReasons reason)
+        {
+            if (System.IncomingScienceProcessing)
+                return;
+
+            var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData<ShareProgressScienceMsgData>();
+            msgData.Science = value;
+            msgData.Reason = reason.ToString();
+            System.MessageSender.SendMessage(msgData);
+            LunaLog.Log("Science changed to: " + value + " with reason: " + reason.ToString());
+        }
+
+        public void ReputationChanged(float value, TransactionReasons reason)
+        {
+            if (System.IncomingReputationProcessing)
+                return;
+
+            var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData<ShareProgressReputationMsgData>();
+            msgData.Reputation = value;
+            msgData.Reason = reason.ToString();
+            System.MessageSender.SendMessage(msgData);
+            LunaLog.Log("Reputation changed to: " + value + " with reason: " + reason.ToString());
+        }
+
+        public void TechnologyResearched(GameEvents.HostTargetAction<RDTech, RDTech.OperationResult> data)
+        {
+            if (System.IncomingTechnologyProcessing)
+                return;
+
+            if (data.target == RDTech.OperationResult.Successful)
+            {
+                var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData<ShareProgressTechnologyMsgData>();
+                msgData.TechID = data.host.techID;
+                LunaLog.Log("Technology unlocked: " + msgData.TechID);
+                System.MessageSender.SendMessage(msgData);
+            }
+        }
+
+        public void ContractAccepted(Contract contract)
+        {
+            if (System.IncomingContractsProcessing)
+                return;
+
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract accepted: " + contract.ContractGuid);
+        }
+
+        public void ContractCancelled(Contract contract)
+        {
+            if (System.IncomingContractsProcessing)
+                return;
+
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract cancelled: " + contract.ContractGuid);
+        }
+
+        public void ContractCompleted(Contract contract)
+        {
+            if (System.IncomingContractsProcessing)
+                return;
+
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract completed: " + contract.ContractGuid);
+        }
+
+        public void ContractsListChanged()
+        {
+            LunaLog.Log("Contract list changed.");
+        }
+
+        public void ContractsLoaded()
+        {
+            LunaLog.Log("Contracts loaded.");
+        }
+
+        public void ContractDeclined(Contract contract)
+        {
+            if (System.IncomingContractsProcessing)
+                return;
+
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract declined: " + contract.ContractGuid);
+        }
+
+        public void ContractFailed(Contract contract)
+        {
+            if (System.IncomingContractsProcessing)
+                return;
+
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract failed: " + contract.ContractGuid);
+        }
+
+        public void ContractFinished(Contract contract)
+        {
+            /*
+            Doesn't need to be synchronized because there is no ContractFinished state.
+            Also the contract will be finished on the contract complete / failed / cancelled / ...
+            */
+        }
+
+        public void ContractOffered(Contract contract)
+        {
+            //This should be only called on the client with the contract lock, because he has the generationCount != 0.
+            LunaLog.Log("Contract offered: " + contract.ContractGuid + " - " + contract.Title);
+            SendContractUpdate(contract);
+        }
+
+        public void ContractParameterChanged(Contract contract, ContractParameter contractParameter)
+        {
+            SendContractUpdate(contract);
+            LunaLog.Log("Contract parameter changed on:" + contract.ContractGuid.ToString());
+        }
+
+        public void ContractRead(Contract contract)
+        {
+            LunaLog.Log("Contract read:" + contract.ContractGuid.ToString());
+        }
+
+        public void ContractSeen(Contract contract)
+        {
+            LunaLog.Log("Contract seen:" + contract.ContractGuid.ToString());
+        }
+        #endregion
+
+        #region PrivateMethods
+        private void SendContractUpdate(Contract[] contracts)
+        {
+            //Convert the Contract's to ContractInfo's.
+            List<ContractInfo> contractInfos = new List<ContractInfo>();
+            foreach (Contract contract in contracts)
+            {
+                ConfigNode configNode = this.ConvertContractToConfigNode(contract);
+                if (configNode == null)
+                {
+                    break;
+                }
+
+                byte[] data = ConfigNodeSerializer.Serialize(configNode);
+                int numBytes = data.Length;
+
+                contractInfos.Add(new ContractInfo()
+                {
+                    ContractGuid = contract.ContractGuid,
+                    Data = data,
+                    NumBytes = numBytes
+                });
+            }
+
+            //Build the packet and send it.
+            var msgData = NetworkMain.CliMsgFactory.CreateNewMessageData<ShareProgressContractMsgData>();
+            msgData.Contracts = contractInfos.ToArray();
+            msgData.ContractCount = msgData.Contracts.Length;
+            System.MessageSender.SendMessage(msgData);
+        }
+
+        private void SendContractUpdate(Contract contract)
+        {
+            this.SendContractUpdate(new Contract[] { contract });
+        }
+
+        private ConfigNode ConvertContractToConfigNode(Contract contract)
+        {
+            ConfigNode configNode = new ConfigNode();
+            try
+            {
+                contract.Save(configNode);
+            }
+            catch (Exception e)
+            {
+                LunaLog.LogError($"[LMP]: Error while saving contract: {e}");
+                return null;
+            }
+
+            return configNode;
+        }
+        #endregion
+    }
+}