Merge pull request #103 from Raicuparta/dev

Author: misternebula

AssetBundles/debug.manifest

@@ -3,7 +3,7 @@ CRC: 1039691058
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: 1ebde8144d4ce7cbdecece7bbb3c7b82
+    Hash: 09f9f4f247158b6c3e422fc20dae56a0
   TypeTreeHash:
     serializedVersion: 2
     Hash: 737950008f8470fd33adbb15e41f47ec

AssetBundles/network

@@ -1,9 +1,9 @@
 ManifestFileVersion: 0
-CRC: 2285725699
+CRC: 561788810
 Hashes:
   AssetFileHash:
     serializedVersion: 2
-    Hash: bfdfbb9f8479265cc2743fea2a066dda
+    Hash: bde832827d2a891a56083d4ec38bfb92
   TypeTreeHash:
     serializedVersion: 2
     Hash: 47ee499ae8022a6b96ca6a5fd541f154
@@ -25,6 +25,8 @@ ClassTypes:
   Script: {instanceID: 0}
 Assets:
 - Assets/NetworkPlayer.prefab
+- Assets/NetworkCameraRoot.prefab
+- Assets/NetworkProbe.prefab
 - Assets/NetworkManager.prefab
 - Assets/NetworkShip.prefab
 Dependencies: []

AssetBundles/network.manifest

@@ -6,6 +6,7 @@ public enum AnimTrigger
         Grounded = 1,
         Ungrounded = 2,
         SuitUp = 3,
-        SuitDown = 4
+        SuitDown = 4,
+        Crouch = 5
     }
 }

QSB/Animation/AnimTrigger.cs

@@ -9,15 +9,18 @@ public class AnimTriggerMessage : QSBMessage
 
         public short TriggerId;
         public uint SenderId;
+        public float Value;
 
         public override void Deserialize(NetworkReader reader)
         {
+            Value = reader.ReadSingle();
             TriggerId = reader.ReadInt16();
             SenderId = reader.ReadPackedUInt32();
         }
 
         public override void Serialize(NetworkWriter writer)
         {
+            writer.Write(Value);
             writer.Write(TriggerId);
             writer.Write(SenderId);
         }

QSB/Animation/AnimTriggerMessage.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using OWML.ModHelper.Events;
 using QSB.Messaging;
 using UnityEngine;
@@ -9,6 +8,11 @@ namespace QSB.Animation
 {
     public class AnimationSync : NetworkBehaviour
     {
+        private const float CrouchSendInterval = 0.1f;
+        private const float CrouchChargeThreshold = 0.01f;
+        private const float CrouchSmoothTime = 0.05f;
+        private const int CrouchLayerIndex = 1;
+
         private Animator _anim;
         private Animator _bodyAnim;
         private NetworkAnimator _netAnim;
@@ -20,7 +24,9 @@ public class AnimationSync : NetworkBehaviour
         private GameObject _unsuitedGraphics;
         private PlayerCharacterController _playerController;
 
-        private static readonly Dictionary<uint, AnimationSync> PlayerAnimSyncs = new Dictionary<uint, AnimationSync>();
+        private readonly AnimFloatParam _crouchParam = new AnimFloatParam();
+        private float _sendTimer;
+        private float _lastSentJumpChargeFraction;
 
         private void Awake()
         {
@@ -44,7 +50,7 @@ private void InitCommon(Transform body)
                 mirror.Init(_anim, _bodyAnim);
             }
 
-            PlayerAnimSyncs[netId.Value] = this;
+            PlayerRegistry.AnimationSyncs.Add(this);
 
             for (var i = 0; i < _anim.parameterCount; i++)
             {
@@ -111,12 +117,13 @@ public void Reset()
             GlobalMessenger.RemoveListener("RemoveSuit", OnSuitDown);
         }
 
-        private void SendTrigger(AnimTrigger trigger)
+        private void SendTrigger(AnimTrigger trigger, float value = 0)
         {
             var message = new AnimTriggerMessage
             {
                 SenderId = netId.Value,
-                TriggerId = (short)trigger
+                TriggerId = (short)trigger,
+                Value = value
             };
             if (isServer)
             {
@@ -135,13 +142,15 @@ private void OnServerReceiveMessage(AnimTriggerMessage message)
 
         private void OnClientReceiveMessage(AnimTriggerMessage message)
         {
-            if (PlayerAnimSyncs.TryGetValue(message.SenderId, out var animSync) && animSync != this)
+            var animationSync = PlayerRegistry.GetAnimationSync(message.SenderId);
+            if (animationSync == null || animationSync == this)
             {
-                animSync.HandleTrigger((AnimTrigger)message.TriggerId);
+                return;
             }
+            animationSync.HandleTrigger((AnimTrigger)message.TriggerId, message.Value);
         }
 
-        private void HandleTrigger(AnimTrigger trigger)
+        private void HandleTrigger(AnimTrigger trigger, float value)
         {
             switch (trigger)
             {
@@ -160,10 +169,57 @@ private void HandleTrigger(AnimTrigger trigger)
                     _unsuitedGraphics.SetActive(true);
                     _suitedGraphics.SetActive(false);
                     break;
+                case AnimTrigger.Crouch:
+                    _crouchParam.Target = value;
+                    break;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(trigger), trigger, null);
             }
         }
 
+        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);
+        }
+
     }
 }

QSB/Animation/AnimationSync.cs

@@ -69,6 +69,5 @@ private void SmoothFloats()
                 _to.SetFloat(floatParam.Key, current);
             }
         }
-
     }
 }

QSB/Animation/AnimatorMirror.cs

@@ -0,0 +1,104 @@
+using System.Collections;
+using QSB.Messaging;
+using QSB.TransformSync;
+using UnityEngine;
+using UnityEngine.Networking;
+
+namespace QSB.Events
+{
+    public class EventHandler : NetworkBehaviour
+    {
+        public static EventHandler LocalInstance;
+
+        private MessageHandler<EventMessage> _eventHandler;
+
+        private void Awake()
+        {
+            LocalInstance = this;
+
+            _eventHandler = new MessageHandler<EventMessage>();
+            _eventHandler.OnClientReceiveMessage += OnClientReceiveMessage;
+            _eventHandler.OnServerReceiveMessage += OnServerReceiveMessage;
+        }
+
+        public void Send(EventType eventType)
+        {
+            StartCoroutine(SendEvent(eventType));
+        }
+
+        private IEnumerator SendEvent(EventType eventType)
+        {
+            yield return new WaitUntil(() => PlayerTransformSync.LocalInstance != null);
+            var message = new EventMessage
+            {
+                EventType = (int)eventType,
+                SenderId = PlayerTransformSync.LocalInstance.netId.Value
+            };
+            _eventHandler.SendToServer(message);
+        }
+
+        private void OnServerReceiveMessage(EventMessage message)
+        {
+            _eventHandler.SendToAll(message);
+        }
+
+        private void OnClientReceiveMessage(EventMessage message)
+        {
+            var player = PlayerRegistry.GetPlayer(message.SenderId);
+            player.IsReady = true;
+            if (message.SenderId == PlayerRegistry.LocalPlayer.NetId)
+            {
+                return;
+            }
+            switch ((EventType)message.EventType)
+            {
+                case EventType.TurnOnFlashlight:
+                    player.UpdateState(State.Flashlight, true);
+                    player.FlashLight.TurnOn();
+                    break;
+                case EventType.TurnOffFlashlight:
+                    player.UpdateState(State.Flashlight, false);
+                    player.FlashLight.TurnOff();
+                    break;
+                case EventType.SuitUp:
+                    player.UpdateState(State.Suit, true);
+                    break;
+                case EventType.RemoveSuit:
+                    player.UpdateState(State.Suit, false);
+                    break;
+                case EventType.EquipSignalscope:
+                    player.UpdateState(State.Signalscope, true);
+                    player.Signalscope.EquipTool();
+                    break;
+                case EventType.UnequipSignalscope:
+                    player.UpdateState(State.Signalscope, false);
+                    player.Signalscope.UnequipTool();
+                    break;
+                case EventType.EquipTranslator:
+                    player.UpdateState(State.Translator, true);
+                    player.Translator.EquipTool();
+                    break;
+                case EventType.UnequipTranslator:
+                    player.UpdateState(State.Translator, false);
+                    player.Translator.UnequipTool();
+                    break;
+                case EventType.ProbeLauncherEquipped:
+                    player.UpdateState(State.ProbeLauncher, true);
+                    player.ProbeLauncher.EquipTool();
+                    break;
+                case EventType.ProbeLauncherUnequipped:
+                    player.UpdateState(State.ProbeLauncher, false);
+                    player.ProbeLauncher.UnequipTool();
+                    break;
+                case EventType.RetrieveProbe:
+                    player.UpdateState(State.ProbeActive, false);
+                    player.Probe.Deactivate();
+                    break;
+                case EventType.LaunchProbe:
+                    player.UpdateState(State.ProbeActive, true);
+                    player.Probe.Activate();
+                    break;
+            }
+        }
+    }
+}