Unstable 0.16.0.0

2022-01-14 01:28:24 +09:00
parent d9baeaa2e1
commit 7d6421a548
237 changed files with 6430 additions and 2205 deletions
@@ -718,7 +718,7 @@ namespace Barotrauma
        /// Sets the character's current order (if it's close enough to receive messages from orderGiver) and
        /// displays the order in the crew UI
        /// </summary>
-        public void SetCharacterOrder(Character character, Order order, string option, int priority, Character orderGiver, Hull targetHull = null)
+        public void SetCharacterOrder(Character character, Order order, string option, int priority, Character orderGiver, Hull targetHull = null, bool isNewOrder = true)
        {
            if (order != null && order.TargetAllCharacters)
            {
@@ -768,7 +768,7 @@ namespace Barotrauma

                if (IsSinglePlayer)
                {
-                    orderGiver.Speak(order.GetChatMessage("", hull?.DisplayName, givingOrderToSelf: character == orderGiver), ChatMessageType.Order);
+                    orderGiver.Speak(order.GetChatMessage("", hull?.DisplayName, givingOrderToSelf: character == orderGiver, isNewOrder: isNewOrder), ChatMessageType.Order);
                }
                else
                {
@@ -784,7 +784,7 @@ namespace Barotrauma
                if (IsSinglePlayer)
                {
                    character.SetOrder(order, option, priority, orderGiver, speak: orderGiver != character);
-                    string message = order?.GetChatMessage(character.Name, orderGiver?.CurrentHull?.DisplayName, givingOrderToSelf: character == orderGiver, orderOption: option, priority: priority);
+                    string message = order?.GetChatMessage(character.Name, orderGiver?.CurrentHull?.DisplayName, givingOrderToSelf: character == orderGiver, orderOption: option, isNewOrder: isNewOrder);
                    orderGiver?.Speak(message);
                }
                else if (orderGiver != null)
@@ -1071,7 +1071,7 @@ namespace Barotrauma
            var priority = Math.Max(CharacterInfo.HighestManualOrderPriority - orderList.Content.GetChildIndex(orderComponent), 1);
            if (orderInfo.ManualPriority == priority) { return; }
            var character = (Character)orderList.UserData;
-            SetCharacterOrder(character, orderInfo.Order, orderInfo.OrderOption, priority, Character.Controlled);
+            SetCharacterOrder(character, orderInfo.Order, orderInfo.OrderOption, priority, Character.Controlled, isNewOrder: false);
        }

        private string CreateOrderTooltip(Order orderPrefab, string option, Entity targetEntity)
@@ -2582,15 +2582,12 @@ namespace Barotrauma
                    {
                        contextualOrders.Remove(pumpOrderInfo);
                    }
-                    if (contextualOrders.None())
+                    orderIdentifier = "cleanupitems";
+                    if (contextualOrders.None(info => info.Order.Identifier.Equals(orderIdentifier)))
                    {
-                        orderIdentifier = "cleanupitems";
-                        if (contextualOrders.None(info => info.Order.Identifier.Equals(orderIdentifier)))
+                        if (AIObjectiveCleanupItems.IsValidTarget(itemContext, Character.Controlled, checkInventory: false) || AIObjectiveCleanupItems.IsValidContainer(itemContext, Character.Controlled))
                        {
-                            if (AIObjectiveCleanupItems.IsValidTarget(itemContext, Character.Controlled, checkInventory: false) || AIObjectiveCleanupItems.IsValidContainer(itemContext, Character.Controlled))
-                            {
-                                contextualOrders.Add(new OrderInfo(new Order(Order.GetPrefab(orderIdentifier), itemContext, targetItem: null, Character.Controlled), null));
-                            }
+                            contextualOrders.Add(new OrderInfo(new Order(Order.GetPrefab(orderIdentifier), itemContext, targetItem: null, Character.Controlled), null));
                        }
                    }
                    AddIgnoreOrder(itemContext);
@@ -3523,16 +3520,6 @@ namespace Barotrauma
            InitRound();
        }

-        public void EndRound()
-        {
-            //remove characterinfos whose characters have been removed or killed
-            characterInfos.RemoveAll(c => c.Character == null || c.Character.Removed || c.CauseOfDeath != null);
-
-            characters.Clear();
-            crewList.ClearChildren();
-            GUIContextMenu.CurrentContextMenu = null;
-        }
-
        public void Reset()
        {
            characters.Clear();
@@ -242,6 +242,11 @@ namespace Barotrauma
            {
                ReadyCheckButton.RectTransform.ScreenSpaceOffset = endRoundButton.RectTransform.ScreenSpaceOffset;
                ReadyCheckButton.DrawManually(spriteBatch);
+                if (ReadyCheck.ReadyCheckCooldown > DateTime.Now)
+                {
+                    float progress = (ReadyCheck.ReadyCheckCooldown - DateTime.Now).Seconds / 60.0f;
+                    ReadyCheckButton.Color = ToolBox.GradientLerp(progress, Color.White, GUI.Style.Red);
+                }
            }
        }

@@ -290,6 +295,9 @@ namespace Barotrauma
                case InteractionType.Crew when GameMain.NetworkMember != null:
                    CampaignUI.CrewManagement.SendCrewState(false);
                    goto default;
+                case InteractionType.MedicalClinic:
+                    CampaignUI.MedicalClinic.RequestLatestPending();
+                    goto default;
                default:
                    ShowCampaignUI = true;
                    CampaignUI.SelectTab(npc.CampaignInteractionType);
@@ -319,6 +327,8 @@ namespace Barotrauma
        {
            base.Update(deltaTime);

+            MedicalClinic?.Update(deltaTime);
+
            if (PlayerInput.KeyHit(Microsoft.Xna.Framework.Input.Keys.Escape))
            {
                GUIMessageBox.MessageBoxes.RemoveAll(mb => mb.UserData is RoundSummary);
@@ -172,7 +172,7 @@ namespace Barotrauma
                }
                else
                {
-                    indicator.Visible = Character.Controlled.Info.GetAvailableTalentPoints() > 0;
+                    indicator.Visible = Character.Controlled.Info.GetAvailableTalentPoints() > 0 && !Character.Controlled.HasUnlockedAllTalents();
                }
            }
        }
@@ -0,0 +1,386 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using Barotrauma.Extensions;
+using Barotrauma.Networking;
+
+namespace Barotrauma
+{
+    internal partial class MedicalClinic
+    {
+        public enum RequestResult
+        {
+            Undecided,
+            Success,
+            Error,
+            Timeout
+        }
+
+        public readonly struct RequestAction<T>
+        {
+            public readonly Action<T> Callback;
+            public readonly DateTimeOffset Timeout;
+
+            public RequestAction(Action<T> callback, DateTimeOffset timeout)
+            {
+                Callback = callback;
+                Timeout = timeout;
+            }
+        }
+
+        public readonly struct AfflictionRequest
+        {
+            public readonly RequestResult Result;
+            public readonly ImmutableArray<NetAffliction> Afflictions;
+
+            public AfflictionRequest(RequestResult result, ImmutableArray<NetAffliction> afflictions)
+            {
+                Result = result;
+                Afflictions = afflictions;
+            }
+        }
+
+        public readonly struct PendingRequest
+        {
+            public readonly RequestResult Result;
+            public readonly ImmutableArray<NetCrewMember> CrewMembers;
+
+            public PendingRequest(RequestResult result, ImmutableArray<NetCrewMember> crewMembers)
+            {
+                Result = result;
+                CrewMembers = crewMembers;
+            }
+        }
+
+        public readonly struct CallbackOnlyRequest
+        {
+            public readonly RequestResult Result;
+
+            public CallbackOnlyRequest(RequestResult result)
+            {
+                Result = result;
+            }
+        }
+
+        public readonly struct HealRequest
+        {
+            public readonly RequestResult Result;
+            public readonly HealRequestResult HealResult;
+
+            public HealRequest(RequestResult result, HealRequestResult healResult)
+            {
+                Result = result;
+                HealResult = healResult;
+            }
+        }
+
+        private readonly List<RequestAction<AfflictionRequest>> afflictionRequests = new List<RequestAction<AfflictionRequest>>();
+        private readonly List<RequestAction<PendingRequest>> pendingHealRequests = new List<RequestAction<PendingRequest>>();
+        private readonly List<RequestAction<CallbackOnlyRequest>> clearAllRequests = new List<RequestAction<CallbackOnlyRequest>>();
+        private readonly List<RequestAction<HealRequest>> healAllRequests = new List<RequestAction<HealRequest>>();
+        private readonly List<RequestAction<CallbackOnlyRequest>> addRequests = new List<RequestAction<CallbackOnlyRequest>>();
+        private readonly List<RequestAction<CallbackOnlyRequest>> removeRequests = new List<RequestAction<CallbackOnlyRequest>>();
+
+        public void RequestAfflictions(CharacterInfo info, Action<AfflictionRequest> onReceived)
+        {
+            if (GameMain.IsSingleplayer)
+            {
+#if DEBUG && LINUX
+                if (Screen.Selected is TestScreen)
+                {
+                    onReceived.Invoke(new AfflictionRequest(RequestResult.Success, TestAfflictions.ToImmutableArray()));
+                    return;
+                }
+#endif
+
+                if (!(info is { Character: { CharacterHealth: { } health } }))
+                {
+                    onReceived.Invoke(new AfflictionRequest(RequestResult.Error, ImmutableArray<NetAffliction>.Empty));
+                    return;
+                }
+
+                ImmutableArray<NetAffliction> pendingAfflictions = GetAllAfflictions(health).ToImmutableArray();
+                onReceived.Invoke(new AfflictionRequest(RequestResult.Success, pendingAfflictions));
+                return;
+            }
+
+            afflictionRequests.Add(new RequestAction<AfflictionRequest>(onReceived, GetTimeout()));
+            SendAfflictionRequest(info);
+        }
+
+        public void RequestLatestPending(Action<PendingRequest> onReceived)
+        {
+            // no need to worry about syncing when there's only one pair of eyes capable of looking at the UI
+            if (GameMain.IsSingleplayer) { return; }
+
+            pendingHealRequests.Add(new RequestAction<PendingRequest>(onReceived, GetTimeout()));
+            SendPendingRequest();
+        }
+
+        public void Update(float deltaTime)
+        {
+            DateTimeOffset now = DateTimeOffset.Now;
+            UpdateQueue(afflictionRequests, now, onTimeout: callback => { callback(new AfflictionRequest(RequestResult.Timeout, ImmutableArray<NetAffliction>.Empty)); });
+            UpdateQueue(pendingHealRequests, now, onTimeout: callback => { callback(new PendingRequest(RequestResult.Timeout, ImmutableArray<NetCrewMember>.Empty)); });
+            UpdateQueue(healAllRequests, now, onTimeout: callback => { callback(new HealRequest(RequestResult.Timeout, HealRequestResult.Unknown)); });
+            UpdateQueue(clearAllRequests, now, onTimeout: CallbackOnlyTimeout);
+            UpdateQueue(addRequests, now, onTimeout: CallbackOnlyTimeout);
+            UpdateQueue(removeRequests, now, onTimeout: CallbackOnlyTimeout);
+
+            void CallbackOnlyTimeout(Action<CallbackOnlyRequest> callback) { callback(new CallbackOnlyRequest(RequestResult.Timeout)); }
+        }
+
+        public bool IsAfflictionPending(NetCrewMember character, NetAffliction affliction)
+        {
+            foreach (NetCrewMember crewMember in PendingHeals)
+            {
+                if (!crewMember.CharacterEquals(character)) { continue; }
+
+                return crewMember.Afflictions.Any(a => a.AfflictionEquals(affliction));
+            }
+
+            return false;
+        }
+
+        private static bool TryDequeue<T>(List<RequestAction<T>> requestQueue, out Action<T> result)
+        {
+            RequestAction<T>? first = requestQueue.FirstOrNull();
+            if (!(first is { } action))
+            {
+                result = _ => { };
+                return false;
+            }
+
+            requestQueue.Remove(action);
+            result = action.Callback;
+            return true;
+        }
+
+        private static void UpdateQueue<T>(List<RequestAction<T>> requestQueue, DateTimeOffset now, Action<Action<T>> onTimeout)
+        {
+            HashSet<RequestAction<T>>? removals = null;
+            foreach (RequestAction<T> action in requestQueue)
+            {
+                if (action.Timeout < now)
+                {
+                    onTimeout.Invoke(action.Callback);
+
+                    removals ??= new HashSet<RequestAction<T>>();
+                    removals.Add(action);
+                }
+            }
+
+            if (removals is null) { return; }
+
+            foreach (RequestAction<T> action in removals)
+            {
+                requestQueue.Remove(action);
+            }
+        }
+
+        // if you have more than 5000 ping there are probably more important things to worry about but hey just in case
+        private static DateTimeOffset GetTimeout() => DateTimeOffset.Now.AddSeconds(5).AddMilliseconds(GetPing());
+
+        private static int GetPing()
+        {
+            if (GameMain.IsSingleplayer || !(GameMain.Client?.Name is { } ownName) || !(GameMain.NetworkMember?.ConnectedClients is { } clients)) { return 0; }
+
+            return (from client in clients where client.Name == ownName select client.Ping).FirstOrDefault();
+        }
+
+        public void HealAllButtonAction(Action<HealRequest> onReceived)
+        {
+            if (GameMain.IsSingleplayer)
+            {
+                HealRequestResult result = HealAllPending();
+                onReceived(new HealRequest(RequestResult.Success, HealAllPending()));
+                if (result == HealRequestResult.Success)
+                {
+                    OnUpdate?.Invoke();
+                }
+
+                return;
+            }
+
+            healAllRequests.Add(new RequestAction<HealRequest>(onReceived, GetTimeout()));
+            ClientSend(null, NetworkHeader.HEAL_PENDING, DeliveryMethod.Reliable);
+        }
+
+        public void ClearAllButtonAction(Action<CallbackOnlyRequest> onReceived)
+        {
+            if (GameMain.IsSingleplayer)
+            {
+                ClearPendingHeals();
+                onReceived(new CallbackOnlyRequest(RequestResult.Success));
+                OnUpdate?.Invoke();
+                return;
+            }
+
+            clearAllRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
+            ClientSend(null, NetworkHeader.CLEAR_PENDING, DeliveryMethod.Reliable);
+        }
+
+        private void ClearRequstReceived()
+        {
+            ClearPendingHeals();
+            if (TryDequeue(clearAllRequests, out var callback))
+            {
+                callback(new CallbackOnlyRequest(RequestResult.Success));
+            }
+            OnUpdate?.Invoke();
+        }
+
+        private void HealRequestReceived(IReadMessage inc)
+        {
+            NetHealRequest request = INetSerializableStruct.Read<NetHealRequest>(inc);
+            if (request.Result == HealRequestResult.Success)
+            {
+                HealAllPending(force: true);
+            }
+
+            if (TryDequeue(healAllRequests, out var callback))
+            {
+                callback(new HealRequest(RequestResult.Success, request.Result));
+            }
+
+            OnUpdate?.Invoke();
+        }
+
+        public void AddPendingButtonAction(NetCrewMember crewMember, Action<CallbackOnlyRequest> onReceived)
+        {
+            if (GameMain.IsSingleplayer)
+            {
+                InsertPendingCrewMember(crewMember);
+                onReceived(new CallbackOnlyRequest(RequestResult.Success));
+                OnUpdate?.Invoke();
+                return;
+            }
+
+            addRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
+            ClientSend(crewMember, NetworkHeader.ADD_PENDING, DeliveryMethod.Reliable);
+        }
+
+        public void RemovePendingButtonAction(NetCrewMember crewMember, NetAffliction affliction, Action<CallbackOnlyRequest> onReceived)
+        {
+            if (GameMain.IsSingleplayer)
+            {
+                RemovePendingAffliction(crewMember, affliction);
+                onReceived(new CallbackOnlyRequest(RequestResult.Success));
+                OnUpdate?.Invoke();
+                return;
+            }
+
+            INetSerializableStruct removedAffliction = new NetRemovedAffliction
+            {
+                CrewMember = crewMember,
+                Affliction = affliction
+            };
+
+            removeRequests.Add(new RequestAction<CallbackOnlyRequest>(onReceived, GetTimeout()));
+            ClientSend(removedAffliction, NetworkHeader.REMOVE_PENDING, DeliveryMethod.Reliable);
+        }
+
+        private void NewAdditonReceived(IReadMessage inc, MessageFlag flag)
+        {
+            NetCrewMember crewMember = INetSerializableStruct.Read<NetCrewMember>(inc);
+            InsertPendingCrewMember(crewMember);
+            if (flag == MessageFlag.Response && TryDequeue(addRequests, out var callback))
+            {
+                callback(new CallbackOnlyRequest(RequestResult.Success));
+            }
+            OnUpdate?.Invoke();
+        }
+
+        private void NewRemovalReceived(IReadMessage inc, MessageFlag flag)
+        {
+            NetRemovedAffliction removed = INetSerializableStruct.Read<NetRemovedAffliction>(inc);
+            RemovePendingAffliction(removed.CrewMember, removed.Affliction);
+            if (flag == MessageFlag.Response && TryDequeue(removeRequests, out var callback))
+            {
+                callback(new CallbackOnlyRequest(RequestResult.Success));
+            }
+            OnUpdate?.Invoke();
+        }
+
+        private static void SendAfflictionRequest(CharacterInfo info)
+        {
+            INetSerializableStruct crewMember = new NetCrewMember
+            {
+                CharacterInfo = info,
+                Afflictions = Array.Empty<NetAffliction>()
+            };
+
+            ClientSend(crewMember, NetworkHeader.REQUEST_AFFLICTIONS, DeliveryMethod.Unreliable);
+        }
+
+        private static void SendPendingRequest()
+        {
+            ClientSend(null, NetworkHeader.REQUEST_PENDING, DeliveryMethod.Reliable);
+        }
+
+        private void AfflictionRequestReceived(IReadMessage inc)
+        {
+            NetCrewMember crewMember = INetSerializableStruct.Read<NetCrewMember>(inc);
+            if (TryDequeue(afflictionRequests, out var callback))
+            {
+                RequestResult result = crewMember.CharacterInfoID == 0 ? RequestResult.Error : RequestResult.Success;
+                callback(new AfflictionRequest(result, crewMember.Afflictions.ToImmutableArray()));
+            }
+        }
+
+        private void PendingRequestReceived(IReadMessage inc)
+        {
+            NetPendingCrew pendingCrew = INetSerializableStruct.Read<NetPendingCrew>(inc);
+            if (TryDequeue(pendingHealRequests, out var callback))
+            {
+                callback(new PendingRequest(RequestResult.Success, pendingCrew.CrewMembers.ToImmutableArray()));
+            }
+        }
+
+        private static IWriteMessage StartSending()
+        {
+            IWriteMessage writeMessage = new WriteOnlyMessage();
+            writeMessage.Write((byte)ClientPacketHeader.MEDICAL);
+            return writeMessage;
+        }
+
+        private static void ClientSend(INetSerializableStruct? netStruct, NetworkHeader header, DeliveryMethod deliveryMethod)
+        {
+            IWriteMessage msg = StartSending();
+            msg.Write((byte)header);
+            netStruct?.Write(msg);
+            GameMain.Client.ClientPeer?.Send(msg, deliveryMethod);
+        }
+
+        public void ClientRead(IReadMessage inc)
+        {
+            NetworkHeader header = (NetworkHeader)inc.ReadByte();
+            MessageFlag flag = (MessageFlag)inc.ReadByte();
+
+            switch (header)
+            {
+                case NetworkHeader.REQUEST_AFFLICTIONS:
+                    AfflictionRequestReceived(inc);
+                    break;
+                case NetworkHeader.REQUEST_PENDING:
+                    PendingRequestReceived(inc);
+                    break;
+                case NetworkHeader.ADD_PENDING:
+                    NewAdditonReceived(inc, flag);
+                    break;
+                case NetworkHeader.REMOVE_PENDING:
+                    NewRemovalReceived(inc, flag);
+                    break;
+                case NetworkHeader.HEAL_PENDING:
+                    HealRequestReceived(inc);
+                    break;
+                case NetworkHeader.CLEAR_PENDING:
+                    ClearRequstReceived();
+                    break;
+            }
+        }
+    }
+}
@@ -31,7 +31,7 @@ namespace Barotrauma
        private GUIMessageBox? msgBox;
        private GUIMessageBox? resultsBox;

-        public static DateTime lastReadyCheck = DateTime.MinValue;
+        public static DateTime ReadyCheckCooldown = DateTime.MinValue;

        public static bool IsReadyCheck(GUIComponent? msgBox) => msgBox?.UserData as string == PromptData || msgBox?.UserData as string == ResultData;

@@ -273,10 +273,10 @@ namespace Barotrauma

        public static void CreateReadyCheck()
        {
-            if (lastReadyCheck < DateTime.Now)
+            if (ReadyCheckCooldown < DateTime.Now)
            {
 #if !DEBUG
-                lastReadyCheck = DateTime.Now.AddMinutes(1);
+                ReadyCheckCooldown = DateTime.Now.AddMinutes(1);
 #endif
                IWriteMessage msg = new WriteOnlyMessage();
                msg.Write((byte) ClientPacketHeader.READY_CHECK);
@@ -285,7 +285,7 @@ namespace Barotrauma
                return;
            }

-            GUIMessageBox msgBox = new GUIMessageBox(readyCheckHeader, readyCheckPleaseWait((lastReadyCheck - DateTime.Now).Seconds), new[] { closeButton });
+            GUIMessageBox msgBox = new GUIMessageBox(readyCheckHeader, readyCheckPleaseWait((ReadyCheckCooldown - DateTime.Now).Seconds), new[] { closeButton });
            msgBox.Buttons[0].OnClicked = delegate
            {
                msgBox.Close();