Merge pull request #191 from Raicuparta/dev

master <- dev (0.5.0)

QSB/Animation/AnimFloatParam.cs

@@ -14,6 +14,5 @@ public float Smooth(float smoothTime)
             Current = Mathf.SmoothDamp(Current, Target, ref _velocity, smoothTime);
             return Current;
         }
-
     }
 }

QSB/Animation/AnimTriggerEvent.cs

@@ -0,0 +1,39 @@
+using QSB.Events;
+using QSB.Messaging;
+
+namespace QSB.Animation
+{
+    public class AnimTriggerEvent : QSBEvent<AnimTriggerMessage>
+    {
+        public override EventType Type => EventType.AnimTrigger;
+
+        public override void SetupListener()
+        {
+            GlobalMessenger<short, float>.AddListener(EventNames.QSBAnimTrigger, Handler);
+        }
+
+        public override void CloseListener()
+        {
+            GlobalMessenger<short, float>.RemoveListener(EventNames.QSBAnimTrigger, Handler);
+        }
+
+        private void Handler(short triggerId, float value) => SendEvent(CreateMessage(triggerId, value));
+
+        private AnimTriggerMessage CreateMessage(short triggerId, float value) => new AnimTriggerMessage
+        {
+            AboutId = LocalPlayerId,
+            TriggerId = triggerId,
+            Value = value
+        };
+
+        public override void OnReceiveRemote(AnimTriggerMessage message)
+        {
+            var animationSync = PlayerRegistry.GetSyncObject<AnimationSync>(message.AboutId);
+            if (animationSync == null)
+            {
+                return;
+            }
+            animationSync.HandleTrigger((AnimTrigger)message.TriggerId, message.Value);
+        }
+    }
+}

QSB/Animation/AnimationSync.cs

@@ -1,33 +1,26 @@
-using System;
-using OWML.ModHelper.Events;
+using OWML.ModHelper.Events;
 using QSB.Events;
-using QSB.Messaging;
+using System;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.Networking;
 
 namespace QSB.Animation
 {
-    public class AnimationSync : NetworkBehaviour
+    public class AnimationSync : PlayerSyncObject
     {
-        private const float CrouchSendInterval = 0.1f;
-        private const float CrouchChargeThreshold = 0.01f;
-        private const float CrouchSmoothTime = 0.05f;
-        private const int CrouchLayerIndex = 1;
+        protected override uint PlayerIdOffset => 0;
 
         private Animator _anim;
         private Animator _bodyAnim;
         private NetworkAnimator _netAnim;
-        private MessageHandler<AnimTriggerMessage> _triggerHandler;
 
         private RuntimeAnimatorController _suitedAnimController;
         private AnimatorOverrideController _unsuitedAnimController;
         private GameObject _suitedGraphics;
         private GameObject _unsuitedGraphics;
         private PlayerCharacterController _playerController;
-
-        private readonly AnimFloatParam _crouchParam = new AnimFloatParam();
-        private float _sendTimer;
-        private float _lastSentJumpChargeFraction;
+        private CrouchSync _crouchSync;
 
         private void Awake()
         {
@@ -37,6 +30,20 @@ private void Awake()
             _netAnim.animator = _anim;
         }
 
+        private void OnDestroy()
+        {
+            _netAnim.enabled = false;
+            if (_playerController == null)
+            {
+                return;
+            }
+            _playerController.OnJump -= OnJump;
+            _playerController.OnBecomeGrounded -= OnBecomeGrounded;
+            _playerController.OnBecomeUngrounded -= OnBecomeUngrounded;
+            GlobalMessenger.RemoveListener(EventNames.SuitUp, OnSuitUp);
+            GlobalMessenger.RemoveListener(EventNames.RemoveSuit, OnSuitDown);
+        }
+
         private void InitCommon(Transform body)
         {
             _netAnim.enabled = true;
@@ -51,7 +58,7 @@ private void InitCommon(Transform body)
                 mirror.Init(_anim, _bodyAnim);
             }
 
-            PlayerRegistry.AnimationSyncs.Add(this);
+            PlayerRegistry.PlayerSyncObjects.Add(this);
 
             for (var i = 0; i < _anim.parameterCount; i++)
             {
@@ -63,17 +70,15 @@ public void InitLocal(Transform body)
         {
             InitCommon(body);
 
-            _triggerHandler = new MessageHandler<AnimTriggerMessage>(MessageType.AnimTrigger);
-            _triggerHandler.OnServerReceiveMessage += OnServerReceiveMessage;
-            _triggerHandler.OnClientReceiveMessage += OnClientReceiveMessage;
-
             _playerController = body.parent.GetComponent<PlayerCharacterController>();
             _playerController.OnJump += OnJump;
             _playerController.OnBecomeGrounded += OnBecomeGrounded;
             _playerController.OnBecomeUngrounded += OnBecomeUngrounded;
 
             GlobalMessenger.AddListener(EventNames.SuitUp, OnSuitUp);
             GlobalMessenger.AddListener(EventNames.RemoveSuit, OnSuitDown);
+
+            InitCrouchSync();
         }
 
         public void InitRemote(Transform body)
@@ -92,9 +97,21 @@ public void InitRemote(Transform body)
             playerAnimController.SetValue("_unsuitedGroup", new GameObject());
             playerAnimController.SetValue("_baseAnimController", null);
             playerAnimController.SetValue("_unsuitedAnimOverride", null);
+            playerAnimController.SetValue("_rightArmHidden", false);
+
+            var rightArmObjects = playerAnimController.GetValue<GameObject[]>("_rightArmObjects").ToList();
+            rightArmObjects.ForEach(rightArmObject => rightArmObject.layer = LayerMask.NameToLayer("Default"));
 
             body.Find("player_mesh_noSuit:Traveller_HEA_Player/player_mesh_noSuit:Player_Head").gameObject.layer = 0;
             body.Find("Traveller_Mesh_v01:Traveller_Geo/Traveller_Mesh_v01:PlayerSuit_Helmet").gameObject.layer = 0;
+
+            InitCrouchSync();
+        }
+
+        private void InitCrouchSync()
+        {
+            _crouchSync = gameObject.AddComponent<CrouchSync>();
+            _crouchSync.Init(this, _playerController, _bodyAnim);
         }
 
         private void OnJump() => SendTrigger(AnimTrigger.Jump);
@@ -104,54 +121,12 @@ public void InitRemote(Transform body)
         private void OnSuitUp() => SendTrigger(AnimTrigger.SuitUp);
         private void OnSuitDown() => SendTrigger(AnimTrigger.SuitDown);
 
-        public void Reset()
-        {
-            if (_playerController == null)
-            {
-                return;
-            }
-            _netAnim.enabled = false;
-            _playerController.OnJump -= OnJump;
-            _playerController.OnBecomeGrounded -= OnBecomeGrounded;
-            _playerController.OnBecomeUngrounded -= OnBecomeUngrounded;
-            GlobalMessenger.RemoveListener(EventNames.SuitUp, OnSuitUp);
-            GlobalMessenger.RemoveListener(EventNames.RemoveSuit, OnSuitDown);
-        }
-
-        private void SendTrigger(AnimTrigger trigger, float value = 0)
-        {
-            var message = new AnimTriggerMessage
-            {
-                SenderId = netId.Value,
-                TriggerId = (short)trigger,
-                Value = value
-            };
-            if (isServer)
-            {
-                _triggerHandler.SendToAll(message);
-            }
-            else
-            {
-                _triggerHandler.SendToServer(message);
-            }
-        }
-
-        private void OnServerReceiveMessage(AnimTriggerMessage message)
-        {
-            _triggerHandler.SendToAll(message);
-        }
-
-        private void OnClientReceiveMessage(AnimTriggerMessage message)
+        public void SendTrigger(AnimTrigger trigger, float value = 0)
         {
-            var animationSync = PlayerRegistry.GetAnimationSync(message.SenderId);
-            if (animationSync == null || animationSync == this)
-            {
-                return;
-            }
-            animationSync.HandleTrigger((AnimTrigger)message.TriggerId, message.Value);
+            GlobalMessenger<short, float>.FireEvent(EventNames.QSBAnimTrigger, (short)trigger, value);
         }
 
-        private void HandleTrigger(AnimTrigger trigger, float value)
+        public void HandleTrigger(AnimTrigger trigger, float value)
         {
             switch (trigger)
             {
@@ -167,7 +142,7 @@ private void HandleTrigger(AnimTrigger trigger, float value)
                     SuitDown();
                     break;
                 case AnimTrigger.Crouch:
-                    _crouchParam.Target = value;
+                    _crouchSync.CrouchParam.Target = value;
                     break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(trigger), trigger, null);
@@ -195,56 +170,9 @@ public void SetSuitState(bool state)
             if (state)
             {
                 SuitUp();
-            }
-            else
-            {
-                SuitDown();
-            }
-        }
-
-        private void Update()
-        {
-            if (isLocalPlayer)
-            {
-                SyncLocalCrouch();
-            }
-            else
-            {
-                SyncRemoteCrouch();
-            }
-        }
-
-        private void SyncLocalCrouch()
-        {
-            if (_playerController == null)
-            {
-                return;
-            }
-            _sendTimer += Time.unscaledDeltaTime;
-            if (_sendTimer < CrouchSendInterval)
-            {
                 return;
             }
-            var jumpChargeFraction = _playerController.GetJumpChargeFraction();
-            if (Math.Abs(jumpChargeFraction - _lastSentJumpChargeFraction) < CrouchChargeThreshold)
-            {
-                return;
-            }
-            SendTrigger(AnimTrigger.Crouch, jumpChargeFraction);
-            _lastSentJumpChargeFraction = jumpChargeFraction;
-            _sendTimer = 0;
-        }
-
-        private void SyncRemoteCrouch()
-        {
-            if (_bodyAnim == null)
-            {
-                return;
-            }
-            _crouchParam.Smooth(CrouchSmoothTime);
-            var jumpChargeFraction = _crouchParam.Current;
-            _bodyAnim.SetLayerWeight(CrouchLayerIndex, jumpChargeFraction);
+            SuitDown();
         }
-
     }
 }

QSB/Animation/CrouchSync.cs

@@ -0,0 +1,72 @@
+using System;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace QSB.Animation
+{
+    public class CrouchSync : NetworkBehaviour
+    {
+        public AnimFloatParam CrouchParam { get; } = new AnimFloatParam();
+
+        private const float CrouchSendInterval = 0.1f;
+        private const float CrouchChargeThreshold = 0.01f;
+        private const float CrouchSmoothTime = 0.05f;
+        private const int CrouchLayerIndex = 1;
+
+        private float _sendTimer;
+        private float _lastSentJumpChargeFraction;
+
+        private AnimationSync _animationSync;
+        private PlayerCharacterController _playerController;
+        private Animator _bodyAnim;
+
+        public void Init(AnimationSync animationSync, PlayerCharacterController playerController, Animator bodyAnim)
+        {
+            _animationSync = animationSync;
+            _playerController = playerController;
+            _bodyAnim = bodyAnim;
+        }
+
+        private void Update()
+        {
+            if (isLocalPlayer)
+            {
+                SyncLocalCrouch();
+                return;
+            }
+            SyncRemoteCrouch();
+        }
+
+        private void SyncLocalCrouch()
+        {
+            if (_playerController == null)
+            {
+                return;
+            }
+            _sendTimer += Time.unscaledDeltaTime;
+            if (_sendTimer < CrouchSendInterval)
+            {
+                return;
+            }
+            var jumpChargeFraction = _playerController.GetJumpChargeFraction();
+            if (Math.Abs(jumpChargeFraction - _lastSentJumpChargeFraction) < CrouchChargeThreshold)
+            {
+                return;
+            }
+            _animationSync.SendTrigger(AnimTrigger.Crouch, jumpChargeFraction);
+            _lastSentJumpChargeFraction = jumpChargeFraction;
+            _sendTimer = 0;
+        }
+
+        private void SyncRemoteCrouch()
+        {
+            if (_bodyAnim == null)
+            {
+                return;
+            }
+            CrouchParam.Smooth(CrouchSmoothTime);
+            var jumpChargeFraction = CrouchParam.Current;
+            _bodyAnim.SetLayerWeight(CrouchLayerIndex, jumpChargeFraction);
+        }
+    }
+}

QSB/Animation/PlayerSuitEvent.cs

@@ -5,23 +5,32 @@ namespace QSB.Animation
 {
     public class PlayerSuitEvent : QSBEvent<ToggleMessage>
     {
-        public override MessageType Type => MessageType.SuitActiveChange;
+        public override EventType Type => EventType.SuitActiveChange;
 
         public override void SetupListener()
         {
-            GlobalMessenger.AddListener(EventNames.SuitUp, () => SendEvent(CreateMessage(true)));
-            GlobalMessenger.AddListener(EventNames.RemoveSuit, () => SendEvent(CreateMessage(false)));
+            GlobalMessenger.AddListener(EventNames.SuitUp, HandleSuitUp);
+            GlobalMessenger.AddListener(EventNames.RemoveSuit, HandleSuitDown);
         }
 
+        public override void CloseListener()
+        {
+            GlobalMessenger.RemoveListener(EventNames.SuitUp, HandleSuitUp);
+            GlobalMessenger.RemoveListener(EventNames.RemoveSuit, HandleSuitDown);
+        }
+
+        private void HandleSuitUp() => SendEvent(CreateMessage(true));
+        private void HandleSuitDown() => SendEvent(CreateMessage(false));
+
         private ToggleMessage CreateMessage(bool value) => new ToggleMessage
         {
-            SenderId = LocalPlayerId,
+            AboutId = LocalPlayerId,
             ToggleValue = value
         };
 
         public override void OnReceiveRemote(ToggleMessage message)
         {
-            var player = PlayerRegistry.GetPlayer(message.SenderId);
+            var player = PlayerRegistry.GetPlayer(message.AboutId);
             player?.UpdateState(State.Suit, message.ToggleValue);
         }