gg.easy.airship 0.1.2128 → 0.1.2129

package/Editor/Artifacts/AirshipLocalArtifactDatabase.cs

@@ -51,17 +51,17 @@ namespace Airship.Editor {
 
         [CanBeNull] public GameObject Prefab => asset != null ? AssetDatabase.LoadAssetAtPath<GameObject>(asset) : null;
         
-        /// <summary>
-        /// Will return if the given component is synchronized with this data
-        /// </summary>
-        /// <param name="component">The component</param>
-        /// <returns>True if the component matches this data</returns>
-        public bool IsSyncedWith(AirshipComponent component) {
-            if (guid != component.guid) return false;
-            if (metadata == null) return false;
-            
-            return component.componentHash == metadata.hash;
-        }
+        // /// <summary>
+        // /// Will return if the given component is synchronized with this data
+        // /// </summary>
+        // /// <param name="component">The component</param>
+        // /// <returns>True if the component matches this data</returns>
+        // public bool IsSyncedWith(AirshipComponent component) {
+        //     if (guid != component.guid) return false;
+        //     if (metadata == null) return false;
+        //     
+        //     return component.componentHash == metadata.hash;
+        // }
     }
     
     [Serializable]
@@ -94,12 +94,12 @@ namespace Airship.Editor {
         }
 
 
-        /// <summary>
-        /// Will return true if the hash of the component isn't the same as the DB stored script hash
-        /// </summary>
-        public bool IsNotSameHashAsComponent(AirshipComponent component) {
-            return component.componentHash != metadata.hash;
-        }
+        // /// <summary>
+        // /// Will return true if the hash of the component isn't the same as the DB stored script hash
+        // /// </summary>
+        // public bool IsNotSameHashAsComponent(AirshipComponent component) {
+        //     return component.componentHash != metadata.hash;
+        // }
     }
 
     /// <summary>

package/Editor/Artifacts/AirshipReconciliationService.cs

@@ -192,7 +192,7 @@ namespace Airship.Editor {
                 }
             }
 #endif
-            component.componentHash = component.script.sourceFileHash;
+            // component.componentHash = component.script.sourceFileHash;
             return true;
         }
         
@@ -328,7 +328,7 @@ namespace Airship.Editor {
                 // We can run a default reconcile, it wont matter tbh.
                 var component = eventData.Component;
                 ReconcileComponent(component);
-                component.componentHash = component.scriptHash;
+                //component.componentHash = component.scriptHash;
                 return;
             }
             
@@ -374,7 +374,7 @@ namespace Airship.Editor {
             else {
                 var component = eventData.Component;
                 ReconcileComponent(component);
-                component.componentHash = component.scriptHash;
+                //component.componentHash = component.scriptHash;
             }
         }
     }

package/Runtime/Code/Luau/AirshipComponent.cs

@@ -72,11 +72,16 @@ public class AirshipComponent : MonoBehaviour {
 #if UNITY_EDITOR
 	internal static event ReconcileAirshipComponent Reconcile;
 	[SerializeField] internal string guid;
-	[SerializeField] private string hash;
+	// [SerializeField] private string hash;
 
+	[Obsolete]
 	internal string componentHash {
-		get => hash;
-		set => hash = value;
+		get {
+			return "";
+		}
+		set {
+			_ = value;
+		}
 	}
 
 	internal string scriptHash => script.sourceFileHash;

package/Runtime/Code/Network/StateSystem/AirshipNetworkedStateManager.cs

@@ -6,6 +6,7 @@ using Code.Network.StateSystem.Structures;
 using Code.Player.Character.Net;
 using Mirror;
 using RSG.Promises;
+using Unity.Mathematics;
 using Unity.VisualScripting;
 using UnityEngine;
 using UnityEngine.Serialization;
@@ -423,8 +424,8 @@ namespace Code.Network.StateSystem
             // TODO: We treat estimatedCommandDelay as a constant, but we should determine this by calculating how long the command that triggered the lag comp was buffered
             // we would need to pass that into lag comp event as an additional parameter since it would need to be calculated in the predicted character component that generated the command.
             // That may prove difficult, so we use a constant for now.
-            var estimatedCommandDelay = this.serverCommandBufferTargetSize * Time.fixedDeltaTime; 
-            var clientBufferTime  = NetworkServer.connections[clientId].bufferTime;
+            var estimatedCommandDelay = this.serverCommandBufferTargetSize * Time.fixedDeltaTime;
+            var clientBufferTime  = NetworkServer.connections[clientId].bufferTime / Math.Min(Time.timeScale, 1); // client buffers more when timescale is set lower than 1
             // Debug.Log("Calculated rollback time for " + this.gameObject.name + " as ping: " + ping + " buffer time: " + clientBufferTime + " command delay: " + estimatedCommandDelay + " for a result of: " + (- ping -
             //     clientBufferTime - estimatedCommandDelay));
             var lagCompensatedTickTime =
@@ -845,14 +846,16 @@ namespace Code.Network.StateSystem
             if (this.observerHistory.Values.Count == 0) return;
 
             // Get the time we should render on the client.
-            var clientTime = (float)NetworkTime.time - NetworkClient.bufferTime;
+            var clientTime = (float)NetworkTime.time - (NetworkClient.bufferTime / Math.Min(Time.timeScale, 1)); // Don't reduce buffer on TS higher than one since send rate is unaffected
 
             // Get the state history around the time that's currently being rendered.
             if (!this.observerHistory.GetAround(clientTime, out State prevState, out State nextState))
             {
-                Debug.LogWarning("Not enough state history for rendering. " + this.observerHistory.Keys.Count +
+                if (clientTime < this.observerHistory.Keys[0]) return; // Our local time hasn't advanced enough to render the positions reported.
+                Debug.LogWarning("Frame " + Time.frameCount + " not enough state history for rendering. " + this.observerHistory.Keys.Count +
                                  " entries. First " + this.observerHistory.Keys[0] + " Last " +
-                                 this.observerHistory.Keys[^1] + " Target " + clientTime);
+                                 this.observerHistory.Keys[^1] + " Target " + clientTime + " Buffer is: " + NetworkClient.bufferTime + " Estimated Latency (1 way): " +
+                                 (NetworkTime.rtt / 2) + " Network Time: " + NetworkTime.time + " TScale: " + Time.timeScale);
                 return;
             }
 

package/Runtime/Code/Player/Character/MovementSystems/Character/CharacterMovement.cs

@@ -6,6 +6,7 @@ using Code.Network.StateSystem;
 using Code.Player.Character.NetworkedMovement;
 using Mirror;
 using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace Code.Player.Character.MovementSystems.Character
 {
@@ -47,7 +48,10 @@ namespace Code.Player.Character.MovementSystems.Character
 
         [Header("Visual Variables")]
         public bool autoCalibrateSkiddingSpeed = true;
-        public float observerRotationLerpMod = 1;
+
+        [Tooltip("Controls the speed in which local character rotates to face look direction.")]
+        public float ownerRotationLerpMod = 6;
+
         [Tooltip("If true animations will be played on the server. This should be true if you care about character movement animations server-side (like for hit boxes).")]
         public bool playAnimationOnServer = true;
 
@@ -112,33 +116,34 @@ namespace Code.Player.Character.MovementSystems.Character
         public event Action<object> OnInterpolateReachedState;
 
         public event Action<object, object> OnCompareSnapshots;
+        
+        /**
+         * Fired when lag compensated checks should occur. ID of check is passed as the event parameter.
+         */
+        public event Action<object> OnLagCompensationCheck;
+        /**
+         * Fired when lag compensated check is over and physics can be modified. ID of check is passed as the event parameter.
+         */
+        public event Action<object> OnLagCompensationComplete;
+        
+        public event Action<object> OnMoveDirectionChanged;
 
         /// <summary>
-        /// Params: Vector3 velocity, RaycastHit hitInfo
+        /// Called when the look vector is externally set
+        /// Params: Vector3 currentLookVector
         /// </summary>
-        public event Action<object, object> OnImpactWithGround;
-        public event Action<object> OnMoveDirectionChanged;
-
+        public event Action<object> OnNewLookVector;
+        
         /// <summary>
         /// Called when movement processes a new jump
         /// Params: Vector3 velocity
         /// </summary>
         public event Action<object> OnJumped;
-
+        
         /// <summary>
-        /// Called when the look vector is externally set
-        /// Params: Vector3 currentLookVector
+        /// Params: Vector3 velocity, RaycastHit hitInfo
         /// </summary>
-        public event Action<object> OnNewLookVector;
-
-        /**
-         * Fired when lag compensated checks should occur. ID of check is passed as the event parameter.
-         */
-        public event Action<object> OnLagCompensationCheck;
-        /**
-         * Fired when lag compensated check is over and physics can be modified. ID of check is passed as the event parameter.
-         */
-        public event Action<object> OnLagCompensationComplete;
+        public event Action<object, object> OnImpactWithGround;
         
         #endregion
         
@@ -183,7 +188,7 @@ namespace Code.Player.Character.MovementSystems.Character
 
         public override void SetMode(NetworkedStateSystemMode mode)
         {
-            Debug.Log("Running movement in " + mode + " mode.");
+            Debug.Log("Running movement in " + mode + " mode for " + this.name + ".");
             if (mode == NetworkedStateSystemMode.Observer)
             {
                 rigidbody.isKinematic = true;
@@ -300,8 +305,7 @@ namespace Code.Player.Character.MovementSystems.Character
             {
                 grounded = true;
             }
-
-            currentMoveSnapshot.isGrounded = grounded;
+            
             this.groundedRaycastHit = groundHit;
 
             if (grounded)
@@ -335,6 +339,13 @@ namespace Code.Player.Character.MovementSystems.Character
                 currentMoveSnapshot.jumpCount = 0;
                 currentMoveSnapshot.timeSinceBecameGrounded = 0f;
                 this.OnImpactWithGround?.Invoke(currentVelocity, groundHit);
+                if (this.mode == NetworkedStateSystemMode.Authority && isServer)
+                {
+                    SAuthImpactEvent(currentVelocity, groundHit);
+                } else if (this.mode == NetworkedStateSystemMode.Authority && isClient)
+                {
+                    CAuthImpactEvent(currentVelocity, groundHit);
+                }
             }
             else
             {
@@ -442,6 +453,14 @@ namespace Code.Player.Character.MovementSystems.Character
                     newVelocity.y = movementSettings.jumpSpeed;
                     currentMoveSnapshot.airborneFromImpulse = false;
                     OnJumped?.Invoke(newVelocity);
+                    if (mode == NetworkedStateSystemMode.Authority && isServer)
+                    {
+                        SAuthJumpedEvent(newVelocity);
+                    }
+                    else if (mode == NetworkedStateSystemMode.Authority && isClient)
+                    {
+                        CAuthJumpedEvent(newVelocity);
+                    }
                 }
             }
 
@@ -1070,7 +1089,7 @@ namespace Code.Player.Character.MovementSystems.Character
                 airshipTransform.rotation = Quaternion.Lerp(
                     airshipTransform.rotation,
                     Quaternion.LookRotation(lookTarget),
-                    observerRotationLerpMod * Time.deltaTime);
+                    ownerRotationLerpMod * Time.deltaTime);
             }
         }
 
@@ -1400,6 +1419,36 @@ namespace Code.Player.Character.MovementSystems.Character
         #endregion
         
         #region RPCs
+
+        [Command]
+        public void CAuthJumpedEvent(Vector3 velocity)
+        {
+            // Only used in the client authoritative networking mode.
+            if (mode != NetworkedStateSystemMode.Observer) return;
+            OnJumped?.Invoke(velocity);
+            SAuthJumpedEvent(velocity);
+        }
+
+        [Command]
+        public void CAuthImpactEvent(Vector3 velocity, RaycastHit hitInfo)
+        {
+            // Only used in the client authoritative networking mode.
+            if (mode != NetworkedStateSystemMode.Observer) return;
+            OnImpactWithGround(velocity, hitInfo);
+            SAuthImpactEvent(velocity, hitInfo);
+        }
+
+        [ClientRpc(includeOwner = false)]
+        public void SAuthJumpedEvent(Vector3 velocity)
+        {
+            OnJumped?.Invoke(velocity);
+        }
+
+        [ClientRpc(includeOwner = false)]
+        public void SAuthImpactEvent(Vector3 velocity, RaycastHit hitInfo)
+        {
+            OnImpactWithGround?.Invoke(velocity, hitInfo);
+        }
         
         /**
          * RPCs are used in client authoritative networking to allow server side code to move clients. These

package/Runtime/Code/VoiceChat/AirshipUniVoiceNetwork.cs

@@ -300,10 +300,31 @@ namespace Code.VoiceChat {
             // print($"[client] received audio from server for peer {senderPeerId}. Frame={Time.frameCount} Nonce={nonce}");
             this.EmitAudioInScene(senderPeerId, bytes);
         }
+        
+        private void PreProcessAudio(ChatroomAudioSegment segment) {
+            const float maxAmplitude = 0.25f;
+            
+            // find peak
+            float peak = 0f;
+            for (int i = 0; i < segment.samples.Length; i++) {
+                float absSample = Math.Abs(segment.samples[i]);
+                if (absSample > peak) peak = absSample;
+            }
+            
+            // if too loud, scale down
+            if (peak > maxAmplitude) {
+                float scale = maxAmplitude / peak;
+                for (int i = 0; i < segment.samples.Length; i++) {
+                    segment.samples[i] *= scale;
+                }
+            }
+        }
 
         private void EmitAudioInScene(short senderPeerId, byte[] bytes) {
             var segment = FromByteArray<ChatroomAudioSegment>(bytes);
             
+            this.PreProcessAudio(segment);
+            
             if (senderPeerId == LocalPeerId && RunCore.IsClient() && NetworkClient.isConnected) {
                 // Local speaking
                 var speakingLevel = this.ComputeSpeakingLevel(segment.samples);

package/Runtime/Code/VoxelWorld/Editor/VoxelBuilderEditorWindow.cs

@@ -4,30 +4,27 @@ using UnityEngine;
 
 namespace Code.Airship.Resources.VoxelRenderer.Editor {
     public class VoxelBuilderEditorWindow : EditorWindow {
-        
-        Vector2 scrollPos;
+        private Vector2 scrollPos;
 
         // Enum to represent the different modes
-        enum Mode
-        {
+        private enum Mode {
             Add,
-            Delete,
+            Delete
         }
 
-        int gridWidth = 4;
-        bool[,] grid;
+        private int gridWidth = 4;
+        private bool[,] grid;
 
         // The current mode
-        Mode currentMode;
+        private Mode currentMode;
         public static bool active = true;
 
         [MenuItem("Airship/Misc/VoxelEditor")]
-        static void Init() {
+        private static void Init() {
             ShowWindow();
         }
 
         public static void ForceRepaint() {
-
             if (active) {
                 GetWindow<VoxelBuilderEditorWindow>().Repaint();
             }
@@ -38,25 +35,22 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             if (HasOpenInstances<VoxelBuilderEditorWindow>()) {
                 GetWindow<VoxelBuilderEditorWindow>().Close();
-            }
-            else {
+            } else {
                 var myWindow = GetWindow<VoxelBuilderEditorWindow>();
                 myWindow.titleContent = new GUIContent("Voxel Editor");
             }
         }
-           
+
         public static bool Enabled() {
             return active && HasOpenInstances<VoxelBuilderEditorWindow>();
         }
 
-        VoxelWorld GetVoxelWorld() {
-     
+        private VoxelWorld GetVoxelWorld() {
             //See if the currently selected object in the world is a voxelworld
             var selectedObject = Selection.activeGameObject;
             if (selectedObject) {
                 var voxelWorld = selectedObject.GetComponent<VoxelWorld>();
                 if (voxelWorld) {
-                    
                     return voxelWorld;
                 }
             }
@@ -70,25 +64,22 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             return null;
         }
-  
- 
-        void ShowSelectionGui() {
 
+
+        private void ShowSelectionGui() {
             //Label 
             GUILayout.Label("Select VoxelWorld", EditorStyles.boldLabel);
 
             //Shows a list of all the VoxelWorld objects in the scene as clickable buttons
-            VoxelWorld[] voxelWorlds = GameObject.FindObjectsOfType<VoxelWorld>();
-            
-            for (int i = 0; i < voxelWorlds.Length; i++) {
+            var voxelWorlds = FindObjectsOfType<VoxelWorld>();
 
+            for (var i = 0; i < voxelWorlds.Length; i++) {
+                var selectionZone = voxelWorlds[i].GetComponentInChildren<SelectionZone>();
 
-                SelectionZone selectionZone = voxelWorlds[i].GetComponentInChildren<SelectionZone>();
-
-                if (Selection.activeGameObject == voxelWorlds[i].gameObject || (selectionZone!=null && Selection.activeGameObject == selectionZone.gameObject)) {
+                if (Selection.activeGameObject == voxelWorlds[i].gameObject || (selectionZone != null &&
+                        Selection.activeGameObject == selectionZone.gameObject)) {
                     GUI.backgroundColor = Color.green;
-                }
-                else {
+                } else {
                     GUI.backgroundColor = Color.white;
                 }
 
@@ -104,9 +95,9 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             GUI.backgroundColor = Color.white;
         }
- 
 
-        void OnGUI() {
+
+        private void OnGUI() {
             //Create an active toggle as a button that toggles on and off
             active = GUILayout.Toggle(active, "Voxel Editor Active");
 
@@ -115,14 +106,14 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
             }
 
             ShowSelectionGui();
-            
-            VoxelWorld world = GetVoxelWorld();
+
+            var world = GetVoxelWorld();
             SelectionZone selection = null;
             if (world == null || world.voxelBlocks == null) {
                 GUI.enabled = true; //cleanup from above
-                return; 
+                return;
             }
-            
+
             //See if we're in the selection mode
             if (VoxelWorldSelectionToolBase.buttonActive == true) {
                 //Find or create the SelectionZone for this voxelWorld
@@ -136,30 +127,32 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
                     selection.transform.localScale = Vector3.one;
                     selection.voxelWorld = world;
                 }
+
                 //Select this
                 selection.gameObject.SetActive(true);
                 Selection.activeGameObject = selection.gameObject;
-                
             }
+
             if (VoxelWorldEditorToolBase.buttonActive == true) {
-            
                 //If we're not in selection mode, disable the selection zone
                 selection = world.GetComponentInChildren<SelectionZone>();
-                                
+
                 if (selection) {
                     //Select the world
                     Selection.activeGameObject = world.gameObject;
                     //disable it
                     selection.gameObject.SetActive(false);
-                    
+
                     //we used to destroy it
                     //DestroyImmediate(selection.gameObject);
                 }
             }
 
             //Show a foldable help box
-            EditorGUILayout.HelpBox("Left click to add\nShift+click to delete\nCtrl+click for repeat placement", MessageType.Info);
-            
+            EditorGUILayout.HelpBox(
+                "Left click to add\nShift+click to delete\nCtrl+click for repeat placement\nA to rotate highlighted block",
+                MessageType.Info);
+
             //active = EditorGUILayout.Toggle("Active", active);
 
             //gap
@@ -167,23 +160,24 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
 
             //Prefab
 
-            GameObject prefab = world.GetPrefabAt(world.highlightedBlockPos);
-            
-            ushort blockData = world.GetVoxelAt(world.highlightedBlockPos);
+            var prefab = world.GetPrefabAt(world.highlightedBlockPos);
+
+            var blockData = world.GetVoxelAt(world.highlightedBlockPos);
 
             GUILayout.Label("Highlighted Block");
 
             if (VoxelWorld.VoxelDataToBlockId(blockData) == 0) {
                 GUI.enabled = false;
             }
-            int flipBits = VoxelWorld.GetVoxelFlippedBits(blockData);
 
-            Color def = GUI.backgroundColor;
+            var flipBits = VoxelWorld.GetVoxelFlippedBits(blockData);
+
+            var def = GUI.backgroundColor;
 
             GUILayout.BeginHorizontal();
 
             GUILayout.Label("Rotation: " + VoxelWorld.flipNames[flipBits]);
-          
+
             GUI.backgroundColor = def;
             GUILayout.EndHorizontal();
             GUI.enabled = true;
@@ -199,13 +193,12 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
                 GUILayout.Label("If no blocks are visible, re-load the Voxel World.");
             }
 
-            GUIStyle selectedStyle = new GUIStyle(GUI.skin.button);
+            var selectedStyle = new GUIStyle(GUI.skin.button);
             selectedStyle.normal.textColor = Color.green;
             selectedStyle.hover.textColor = Color.green;
-            
-            foreach (var pair in world.voxelBlocks.loadedBlocks) {
 
-                string name = pair.Value.definition.name;
+            foreach (var pair in world.voxelBlocks.loadedBlocks) {
+                var name = pair.Value.definition.name;
                 if (name == "") {
                     name = "Air";
                 }
@@ -218,27 +211,21 @@ namespace Code.Airship.Resources.VoxelRenderer.Editor {
                     }
                 }
             }
+
             GUILayout.EndScrollView();
             GUI.enabled = true;
- 
-
-        }
-        
-        void onSceneGUIDelegate(SceneView sceneView) {
-           
-           
-            
         }
 
-        void OnEnable() {
-            base.autoRepaintOnSceneChange = true;
+        private void onSceneGUIDelegate(SceneView sceneView) { }
+
+        private void OnEnable() {
+            autoRepaintOnSceneChange = true;
             SceneView.duringSceneGui += onSceneGUIDelegate;
-            
-        } 
+        }
+
         private void OnDisable() {
             SceneView.duringSceneGui -= onSceneGUIDelegate;
         }
     }
-
 }
 #endif