Body System Part 1 POGGERS!!! (#855)

2020-05-13 14:48:49 -05:00
parent c9ce38a6a7
commit 27d27f2b59
66 changed files with 2794 additions and 1 deletions
--- a/Content.Server/Health/BodySystem/Surgery/ServerSurgeryToolComponent.cs
+++ b/Content.Server/Health/BodySystem/Surgery/ServerSurgeryToolComponent.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using Content.Server.BodySystem;
+using Content.Server.GameObjects.EntitySystems;
+using Content.Shared.BodySystem;
+using Content.Shared.GameObjects;
+using Content.Shared.GameObjects.Components.Items;
+using Robust.Server.GameObjects;
+using Robust.Server.GameObjects.EntitySystems;
+using Robust.Server.Interfaces.Player;
+using Robust.Server.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.Interfaces.Map;
+using Robust.Shared.Interfaces.Network;
+using Robust.Shared.Interfaces.Physics;
+using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Players;
+using Robust.Shared.Serialization;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.GameObjects.Components.Weapon.Melee
+{
+
+    [RegisterComponent]
+    public class ServerSurgeryToolComponent : SharedSurgeryToolComponent, IAfterAttack
+    {
+#pragma warning disable 649
+        [Dependency] private readonly IMapManager _mapManager;
+        [Dependency] private readonly IEntitySystemManager _entitySystemManager;
+        [Dependency] private readonly IPhysicsManager _physicsManager;
+#pragma warning restore 649
+
+        public HashSet<IPlayerSession> SubscribedSessions = new HashSet<IPlayerSession>();
+        private Dictionary<string, BodyPart> _surgeryOptionsCache = new Dictionary<string, BodyPart>();
+        private BodyManagerComponent _targetCache;
+        private IEntity _performerCache;
+
+        void IAfterAttack.AfterAttack(AfterAttackEventArgs eventArgs)
+        {
+            if (eventArgs.Attacked == null)
+                return;
+            if (eventArgs.Attacked.TryGetComponent<BodySystem.BodyManagerComponent>(out BodySystem.BodyManagerComponent bodyManager))
+            {
+                _surgeryOptionsCache.Clear();
+                var toSend = new Dictionary<string, string>();
+                foreach (var(key, value) in bodyManager.PartDictionary) {
+                    if (value.SurgeryCheck(_surgeryToolClass))
+                    {
+                        _surgeryOptionsCache.Add(key, value);
+                        toSend.Add(key, value.Name);
+                    }
+                }
+                if (_surgeryOptionsCache.Count > 0)
+                {
+                    OpenSurgeryUI(eventArgs.User);
+                    UpdateSurgeryUI(eventArgs.User, toSend);
+                    _performerCache = eventArgs.User;
+                    _targetCache = bodyManager;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Called after the user selects a surgery target.
+        /// </summary>
+        void PerformSurgery(SelectSurgeryUIMessage msg)
+        {
+            //TODO: sanity checks to see whether user is in range, body is still same, etc etc
+            if (!_surgeryOptionsCache.TryGetValue(msg.TargetSlot, out BodyPart target))
+            {
+                Logger.Debug("Error when trying to perform surgery on bodypart in slot " + msg.TargetSlot + ": it was not found!");
+                throw new InvalidOperationException();
+            }
+            if (!target.AttemptSurgery(_surgeryToolClass, _targetCache, _performerCache))
+            {
+                Logger.Debug("Error when trying to perform surgery on bodypart " + target.Name + "!");
+                throw new InvalidOperationException();
+            }
+            CloseSurgeryUI(_performerCache);
+        }
+
+
+        public void OpenSurgeryUI(IEntity character)
+        {
+            var user_session = character.GetComponent<BasicActorComponent>().playerSession;
+            SubscribeSession(user_session);
+            SendNetworkMessage(new OpenSurgeryUIMessage(), user_session.ConnectedClient);
+        }
+        public void UpdateSurgeryUI(IEntity character, Dictionary<string, string> options)
+        {
+            var user_session = character.GetComponent<BasicActorComponent>().playerSession;
+            if (user_session.AttachedEntity == null)
+            {
+                UnsubscribeSession(user_session);
+                return;
+            }
+            SendNetworkMessage(new UpdateSurgeryUIMessage(options), user_session.ConnectedClient);
+        }
+        public void CloseSurgeryUI(IEntity character)
+        {
+            var user_session = character.GetComponent<BasicActorComponent>().playerSession;
+            SubscribeSession(user_session);
+            SendNetworkMessage(new CloseSurgeryUIMessage(), user_session.ConnectedClient);
+        }
+
+        public override void HandleNetworkMessage(ComponentMessage message, INetChannel channel, ICommonSession session = null)
+        {
+            base.HandleNetworkMessage(message, channel, session);
+
+            if (session == null)
+            {
+                throw new ArgumentException(nameof(session));
+            }
+
+            switch (message)
+            {
+                case CloseSurgeryUIMessage msg:
+                    UnsubscribeSession(session as IPlayerSession);
+                    break;
+                case SelectSurgeryUIMessage msg:
+                    PerformSurgery(msg);
+                    break;
+            }
+        }
+
+
+        public void SubscribeSession(IPlayerSession session)
+        {
+            if (!SubscribedSessions.Contains(session))
+            {
+                session.PlayerStatusChanged += HandlePlayerSessionChangeEvent;
+                SubscribedSessions.Add(session);
+            }
+        }
+        public void UnsubscribeSession(IPlayerSession session)
+        {
+            if (SubscribedSessions.Contains(session))
+            {
+                SubscribedSessions.Remove(session);
+                SendNetworkMessage(new CloseSurgeryUIMessage(), session.ConnectedClient);
+            }
+        }
+        public void HandlePlayerSessionChangeEvent(object obj, SessionStatusEventArgs SSEA)
+        {
+            if (SSEA.NewStatus != SessionStatus.InGame)
+            {
+                UnsubscribeSession(SSEA.Session);
+            }
+        }
+    }
+}