gg.easy.airship 0.1.2163 → 0.1.2164

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.cs]
+csharp_new_line_before_open_brace = none
+csharp_new_line_before_else = false
+csharp_new_line_before_catch = false
+csharp_new_line_before_finally = false
+csharp_new_line_before_members_in_object_initializers = false
+csharp_new_line_before_members_in_anonymous_types = false

package/Runtime/Code/AirshipConst.cs

@@ -1,11 +1,11 @@
 // ReSharper disable InconsistentNaming
 namespace Code {
     public static class AirshipConst {
-        public const int playerVersion = 12;
+        public const int playerVersion = 13;
 
         /// <summary>
         /// The server will kick clients that have a playerVersion lower than this value.
         /// </summary>
-        public const int minAcceptedPlayerVersionOnServer = 12;
+        public const int minAcceptedPlayerVersionOnServer = 13;
     }
 }

package/Runtime/Code/Analytics/ClientFolderUploader.cs

@@ -0,0 +1,145 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading.Tasks;
+using Code.Http.Internal;
+using Code.Http.Public;
+using Code.Platform.Shared;
+using Proyecto26;
+using UnityEngine;
+
+namespace Code.Analytics {
+    [Serializable]
+    public class PostArtifactResponse {
+        public string id;
+        public string url;
+    }
+
+    [Serializable]
+    public class RequestBody {
+        public string type;
+        public string name;
+        public string contentType;
+        public long contentLength;
+    }
+
+    public class ClientFolderUploader : MonoBehaviour {
+
+        // Start in the past otherwise they can't do this for the first 10 seconds since time starts at 0.
+        private float timeOfLastUpload = -10;
+
+        public void ButtonClick() {
+            if (Time.unscaledTime - timeOfLastUpload < 10) {
+                Debug.LogWarning("[ClientFolderUploader] Upload already in progress or too soon after last upload");
+                return;
+            }
+            timeOfLastUpload = Time.unscaledTime;
+
+            _ = UploadAsync();
+        }
+
+        private async Task UploadAsync() {
+            try {
+                await Upload();
+                Debug.Log("[ClientFolderUploader] Upload completed successfully");
+            } catch (Exception ex) {
+                Debug.LogError($"[ClientFolderUploader] Upload failed: {ex.Message}");
+            }
+        }
+
+        public async Task Upload() {
+            try {
+                var path = Path.GetDirectoryName(Application.consoleLogPath);
+
+                var zipPath = Path.Combine(Application.temporaryCachePath, "logs.zip");
+                if (File.Exists(zipPath)) {
+                    File.Delete(zipPath);
+                }
+
+                var playerLogFile = Path.Combine(path, "Player.log");
+                var playerPrevLogFile = Path.Combine(path, "Player-prev.log");
+                var editorLogFile = Path.Combine(path, "Editor.log");
+                var editorPrevLogFile = Path.Combine(path, "Editor-prev.log");
+
+                Debug.Log("[ClientFolderUploader] Creating zip archive");
+                try {
+                    using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create)) {
+                        var fileExists = false;
+                        if (File.Exists(playerLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Player.log");
+                            archive.CreateEntryFromFile(playerLogFile, "Player.log");
+                        }
+
+                        if (File.Exists(playerPrevLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Player-prev.log");
+                            archive.CreateEntryFromFile(playerPrevLogFile, "Player-prev.log");
+                        }
+
+                        if (File.Exists(editorLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Editor.log");
+                            archive.CreateEntryFromFile(editorLogFile, "Editor.log");
+                        }
+
+                        if (File.Exists(editorPrevLogFile)) {
+                            fileExists = true;
+                            Debug.Log("[ClientFolderUploader] Adding Editor-prev.log");
+                            archive.CreateEntryFromFile(editorPrevLogFile, "Editor-prev.log");
+                        }
+
+                        if (!fileExists) {
+                            return;
+                        }
+                    }
+                } catch (Exception ex) {
+                    Debug.LogError($"[ClientFolderUploader] Zip creation failed: {ex.Message}");
+                    throw;
+                }
+
+                var contentType = "application/zip";
+                var contentLength = new FileInfo(zipPath).Length;
+
+                var body = new RequestBody {
+                    type = "CLIENT_DEBUG_ARCHIVE",
+                    name = "PlayerLogs.zip",
+                    contentType = contentType,
+                    contentLength = contentLength,
+                };
+
+                Debug.Log("[ClientFolderUploader] Creating artifact");
+                var url = $"{AirshipPlatformUrl.contentService}/artifacts/platform/signed-url";
+
+                Http.HttpResponse res;
+                if (String.IsNullOrEmpty(InternalHttpManager.authToken)) {
+                    res = await HttpManager.PostAsync(url, JsonUtility.ToJson(body));
+                } else {
+                    res = await InternalHttpManager.PostAsync(url, JsonUtility.ToJson(body));
+                }
+
+                if (res.statusCode < 200 || res.statusCode >= 300) {
+                    Debug.LogError($"[ClientFolderUploader] Error response from server: {res.statusCode} - {res.error}");
+                    throw new Exception($"Failed to get signed URL: {res.error}");
+                }
+
+                var response = JsonUtility.FromJson<PostArtifactResponse>(res.data);
+
+                Debug.Log("[ClientFolderUploader] Uploading file");
+                await HttpManager.PutAsync(new RequestHelper() {
+                    Uri = response.url,
+                    BodyRaw = File.ReadAllBytes(zipPath),
+                    Headers = new System.Collections.Generic.Dictionary<string, string>
+                    {
+                        { "Content-Type", contentType },
+                    },
+                }, "");
+
+                File.Delete(zipPath);
+            } catch (Exception ex) {
+                Debug.LogError($"[ClientFolderUploader] Error during upload process: {ex.Message}");
+                throw;
+            }
+        }
+    }
+}

package/Runtime/Code/Analytics/ClientFolderUploader.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 474c8118d514c47d2b470bdd6dd04d84

package/Runtime/Code/Bootstrap/ClientBootstrap.cs

@@ -8,7 +8,11 @@ public class ClientBootstrap : MonoBehaviour
     private void Start()
     {
         if (RunCore.IsClient()) {
+#if UNITY_STANDALONE_OSX
+            Application.targetFrameRate = -1;
+#else
             Application.targetFrameRate = (int)Math.Ceiling(Screen.currentResolution.refreshRateRatio.value);
+#endif
             Application.logMessageReceived += AnalyticsRecorder.RecordLogMessageToAnalytics;
         }
     }

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

@@ -76,6 +76,8 @@ namespace Code.Network.StateSystem
         // Non-auth server command tracking
         // Note: we also re-use some of the above command buffer fields
         private SortedList<int, State> serverReceivedStateBuffer = new SortedList<int, State>();
+        // Last observed state from OnTick when running as a non-auth server.
+        private State serverLastObservedState;
 
         // Client processing for input prediction
         private State clientLastConfirmedState;
@@ -224,6 +226,12 @@ namespace Code.Network.StateSystem
             simManager.OnSetSnapshot -= this.OnSetSnapshot;
             simManager.OnCaptureSnapshot -= this.OnCaptureSnapshot;
             simManager.OnLagCompensationCheck -= this.OnLagCompensationCheck;
+            
+            this.OnClientReceiveSnapshot -= ClientReceiveSnapshot;
+            this.OnClientReceiveDiff -= ClientReceiveDiff;
+            this.OnServerReceiveSnapshot -= ServerReceiveSnapshot;
+            this.OnServerReceiveInput -= ServerReceiveInputCommand;
+            this.OnServerReceiveFullSnapshotRequest -= ServerReceiveFullSnapshotRequest;
         }
 
         private void SendNetworkMessages() {
@@ -810,20 +818,30 @@ namespace Code.Network.StateSystem
                 // not a shared timeline.
                 latestState.tick = tick;
                 latestState.time = time;
+                this.serverLastObservedState = latestState;
                 // Use this as the current state for the server
                 this.stateSystem.SetCurrentState(latestState);
                 // Since it's new, update our server interpolation functions
-                this.stateSystem.InterpolateReachedState(latestState); 
-                // Add the state to our history as we would in a authoritative setup
-                this.stateHistory.Set(tick, latestState);
+                this.stateSystem.InterpolateReachedState(latestState);
             }
         }
 
-        public void NonAuthServerCaptureSnapshot(int tick, double time, bool replay)
-        {
-            // Non server auth will accept the client auth as the official possition. No need to capture
-            // the state after the physics tick as the position that was pulled from the buffer in OnTick
-            // was already added to the state timeline as the official position.
+        public void NonAuthServerCaptureSnapshot(int tick, double time, bool replay) {
+            if (this.serverLastObservedState != null) {
+                // Non server auth will accept the client auth as the official position. No need to get
+                // the state after the physics tick as the position that was pulled from the buffer in OnTick
+                // is the official position.
+                var authState = this.serverLastObservedState.Clone() as State;
+                authState.tick = tick;
+                authState.time = time;
+                this.stateHistory.Set(tick, authState);
+            }
+            else {
+                // If we haven't received any auth state from the client, just use what the server has so we have
+                // something to send to observers.
+                var currentState = this.stateSystem.GetCurrentState(this.serverLastProcessedCommandNumber, tick, time);
+                this.stateHistory.Set(tick, currentState);
+            }
         }
 
         public void NonAuthServerSetSnapshot(int tick)
@@ -977,7 +995,7 @@ namespace Code.Network.StateSystem
             if (!this.observerHistory.GetAround(NetworkTime.time, out State prevState, out State nextState))
             {
                 // if (clientTime < this.observerHistory.Keys[0]) return; // Our local time hasn't advanced enough to render the positions reported. No need to log debug
-                // Debug.LogWarning("Frame " + Time.frameCount + " not enough state history for rendering. " + this.observerHistory.Keys.Count +
+                // Debug.LogWarning("Frame " + Time.frameCount + " not enough state history for rendering " + this.name + ". " + this.observerHistory.Keys.Count +
                 //                  " entries. First " + this.observerHistory.Keys[0] + " Last " +
                 //                  this.observerHistory.Keys[^1] + " Target " + NetworkTime.time + " Buffer is: " +  NetworkClient.bufferTime + " Estimated Latency (1 way): " +
                 //                  (NetworkTime.rtt / 2) + " TScale: " + Time.timeScale);
@@ -1177,7 +1195,7 @@ namespace Code.Network.StateSystem
             // Debug.Log("Server received command " + command.commandNumber + " for " + this.gameObject.name);
             // This should only occur if the server is authoritative.
             if (!serverAuth) {
-                Debug.LogWarning($"Received input command from {this.name}, but the networking mode is not server authoritative. Command will be ignored.");
+                // Debug.LogWarning($"Received input command from {this.name}, but the networking mode is not server authoritative. Command will be ignored.");
                 return;
             }
 
@@ -1198,8 +1216,8 @@ namespace Code.Network.StateSystem
             // Reject commands if our buffer is full.
             if (this.serverCommandBuffer.Count > this.serverCommandBufferMaxSize)
             {
-                Debug.LogWarning("Dropping command " + command.commandNumber +
-                                 " for "+ this.name + " due to exceeding command buffer size. First command in buffer is " + this.serverCommandBuffer.Values[0]);
+                // Debug.LogWarning("Dropping command " + command.commandNumber +
+                //                  " for "+ this.name + " due to exceeding command buffer size. First command in buffer is " + this.serverCommandBuffer.Values[0]);
                 return;
             }
 

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

@@ -28,8 +28,8 @@ namespace Code.Player.Character.MovementSystems.Character {
             CharacterInputData> {
         [FormerlySerializedAs("rigidbody")] public Rigidbody rb;
         public Transform rootTransform;
-        public Transform airshipTransform; //The visual transform controlled by this script
-        public Transform graphicTransform; //A transform that games can animate
+        public Transform airshipTransform; // The visual transform controlled by this script. This always has the exact rotations used for movement
+        public Transform graphicTransform; // A transform that games can animate. This may have slightly altered rotation for visuals
         public CharacterMovementSettings movementSettings;
         public BoxCollider mainCollider;
 
@@ -63,6 +63,19 @@ namespace Code.Player.Character.MovementSystems.Character {
             "Controls the speed in which characters in orbit camera rotate to face look direction. Degrees per second.")]
         public float smoothedRotationSpeed = 360f;
 
+        [Tooltip("If true, the character body will automatically rotate in the direction of the look vector.")]
+        public bool rotateAutomatically = true;
+
+        [Tooltip("If enabled, the head will be rotated to look in the same direction as the look vector. The body will rotate only when needed. \"Rotate Automatically\" must also be checked.")]
+        public bool rotateHeadToLookVector = true;
+
+        [Tooltip("How much influence the look vector has on the look rotation.")]
+        [Range(0, 1)]
+        public float lookVectorInfluence = 0.4f;
+
+        [Tooltip("How far the head can rotate before the body rotates in degrees.")] [Range(0, 180)]
+        public int headRotationThreshold = 60;
+        
         [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;
@@ -71,6 +84,8 @@ namespace Code.Player.Character.MovementSystems.Character {
 
         private CharacterPhysics physics;
         private Transform _cameraTransform;
+        private CharacterRig _rig;
+        private Quaternion initialHeadRotation;
         private bool _smoothLookVector = false;
 
         /**
@@ -209,6 +224,19 @@ namespace Code.Player.Character.MovementSystems.Character {
                 physics = new CharacterPhysics(this);
             }
 
+            _rig = GetComponentInChildren<CharacterRig>();
+            
+            // Verify rig is setup correctly for rotateHeadToLookVector
+            if (rotateHeadToLookVector) {
+                if (_rig == null || _rig.head == null || _rig.spine == null) {
+                    rotateHeadToLookVector = false;
+                    Debug.LogWarning(
+                        "[CharacterMovement] Disabling rotateHeadToLookVector, cannot find rig's head transform.");
+                } else {
+                    initialHeadRotation = _rig.head.rotation;
+                }
+            }
+            
             _cameraTransform = Camera.main.transform;
         }
 
@@ -274,14 +302,9 @@ namespace Code.Player.Character.MovementSystems.Character {
             if (!rb.isKinematic) {
                 rb.linearVelocity = snapshot.velocity;
             }
-
-            var lookTarget = new Vector3(snapshot.lookVector.x, 0, snapshot.lookVector.z);
-            if (lookTarget == Vector3.zero) {
-                lookTarget = new Vector3(0, 0, .01f);
-            }
-
-            airshipTransform.rotation = Quaternion.LookRotation(lookTarget);
-
+            
+            HandleCharacterRotation(snapshot.lookVector);
+            
             OnSetSnapshot?.Invoke(snapshot);
         }
 
@@ -370,13 +393,9 @@ namespace Code.Player.Character.MovementSystems.Character {
             var rootPosition = rb.position;
 
             // Apply rotation when ticking on the server. This rotation is automatically applied on the owning client in LateUpdate.
+            // and for observers in Interpolate()
             if (isServer && !isClient) {
-                var lookTarget = new Vector3(command.lookVector.x, 0, command.lookVector.z);
-                if (lookTarget == Vector3.zero) {
-                    lookTarget = new Vector3(0, 0, .01f);
-                }
-
-                airshipTransform.rotation = Quaternion.LookRotation(lookTarget);
+                HandleCharacterRotation(command.lookVector);
             }
 
             //Ground checks
@@ -554,7 +573,7 @@ namespace Code.Player.Character.MovementSystems.Character {
             var isMoving = currentVelocity.sqrMagnitude > .1f;
             var inAir = didJump || (!detectedGround && !currentMoveSnapshot.prevStepUp);
             var tryingToSprint =  movementSettings.onlySprintForward
-                ? command.sprint && graphicTransform.InverseTransformVector(command.moveDir).z > 0.1f
+                ? command.sprint && airshipTransform.InverseTransformVector(command.moveDir).z > 0.1f
                 : //Only sprint if you are moving forward
                 command.sprint && command.moveDir.magnitude > 0.1f; //Only sprint if you are moving
 
@@ -1422,11 +1441,6 @@ namespace Code.Player.Character.MovementSystems.Character {
                 newLook.z = 0.01f;
             }
 
-            airshipTransform.rotation = Quaternion.Lerp(
-                Quaternion.LookRotation(oldLook),
-                Quaternion.LookRotation(newLook),
-                (float)delta);
-
             lookVector = Vector3.Lerp(snapshotOld.lookVector, snapshotNew.lookVector, (float)delta);
 
             OnInterpolateState?.Invoke(snapshotOld, snapshotNew, delta);
@@ -1459,22 +1473,104 @@ namespace Code.Player.Character.MovementSystems.Character {
         }
 
         public void LateUpdate() {
-            // We only update rotation in late update if we are running on a client that is controlling
-            // this system
+            // We only update rotation in late update if we are running on a client
             if (isServer && !isClient) {
                 return;
             }
 
-            if (mode == NetworkedStateSystemMode.Observer) {
-                return;
-            }
+            HandleCharacterRotation(this.lookVector);
+        }
 
-            var lookTarget = new Vector3(lookVector.x, 0, lookVector.z);
+        /**
+         * Internal character rotation handling. Used in a few places to kick off updating the character's
+         * transform and visual rotation based on the configuration of the character.
+         */
+        private void HandleCharacterRotation(Vector3 lookVector) {
+            if (!rotateAutomatically) return;
+            UpdateCharacterRotation(lookVector);
+        }
+
+        /**
+         * This function allows you to set the rotation of the character body and head when "rotateAutomatically" is turned off.
+         * It will use the specified look direction and respect configured visual settings. This function should be called
+         * in LateUpdate every frame with an updated look direction.
+         *
+         * Calling this only once will update the head and body rotation just enough to look in the specified direction.
+         * It will not align the rotation exactly. If you want to align the rotation exactly. First set the airshipTransform
+         * and graphicsHolder transforms to the desired look direction before calling this function. You can also use
+         * UpdateHeadRotation to set a look direction for the head directly.
+         *
+         * This function is not networked.
+         */
+        public void UpdateCharacterRotation(Vector3 lookDirection) {
+            var lookTarget = new Vector3(lookDirection.x, 0, lookDirection.z);
             if (lookTarget == Vector3.zero) {
                 lookTarget = new Vector3(0, 0, .01f);
             }
 
-            airshipTransform.rotation = Quaternion.LookRotation(lookTarget).normalized;
+            // Debug.Log("Handle rotation: " + rotateHeadToLookVector);
+            if (!rotateHeadToLookVector) {
+                airshipTransform.rotation = Quaternion.LookRotation(lookTarget).normalized;
+                return;
+            }
+            
+            UpdateBodyRotation(lookTarget);
+            UpdateHeadRotation(lookDirection);
+        }
+        
+        private void UpdateBodyRotation(Vector3 direction) {
+            direction.y = 0; // Don't rotate the character off the ground
+            
+            // If we are moving, start rotating towards the correct direction immediately. Don't negate any additional rotation
+            if (this.currentMoveSnapshot.velocity.magnitude > 0) {
+                airshipTransform.rotation = Quaternion.LookRotation(direction).normalized;
+                graphicTransform.rotation = Quaternion.Slerp(graphicTransform.rotation, airshipTransform.rotation, smoothedRotationSpeed * Mathf.Deg2Rad * Time.deltaTime);
+                return;
+            }
+            
+            // Since graphicTransform is a child of the airship transform, we "undo" the
+            // change we are going to apply so that we can rotate the graphicTransform independently
+            Quaternion previousParentRotation = airshipTransform.rotation;
+            airshipTransform.rotation = Quaternion.LookRotation(direction).normalized;
+            Quaternion deltaRotation = airshipTransform.rotation * Quaternion.Inverse(previousParentRotation);
+            graphicTransform.rotation = Quaternion.Inverse(deltaRotation) * graphicTransform.rotation;
+            
+            // Now calculate if we need to rotate the graphicTransform (body) or if the head
+            // rotation will be enough.
+            Vector3 currentForward = graphicTransform.rotation * Vector3.forward;
+            currentForward.y = 0;
+            
+            currentForward.Normalize();
+            direction.Normalize();
+
+            float angle = Vector3.SignedAngle(currentForward, direction, Vector3.up);
+            if (Mathf.Abs(angle) > headRotationThreshold)
+            {
+                float rotateAmount = Mathf.Abs(angle) - headRotationThreshold;
+                float sign = Mathf.Sign(angle);
+
+                // We only rotate just enough to allow us to not snap our neck, but don't rotate the body
+                // any more than that.
+                Quaternion partialRotation = Quaternion.AngleAxis(rotateAmount * sign, Vector3.up);
+                graphicTransform.rotation = partialRotation * graphicTransform.rotation;
+            }
+        }
+        
+        /**
+         * Sets the head look direction independently of the body using "Look Vector Influence". Does _NOT_ limit the
+         * amount of rotation from the body forward direction. Use UpdateCharacterRotation for rotation that take the configured
+         * limits into account.
+         *
+         * This function is not networked.
+         */
+        public void UpdateHeadRotation(Vector3 direction) {
+            if (direction.magnitude == 0) {
+                direction = new Vector3(0, 0, 0.01f);
+            }
+            
+            var characterUp = _rig.spine ? _rig.spine.up : Vector3.up;
+            var lerpedLookRotation = Vector3.Lerp(Quaternion.Inverse(initialHeadRotation) * _rig.head.rotation * Vector3.forward, direction, lookVectorInfluence);
+            _rig.head.rotation = initialHeadRotation * Quaternion.LookRotation(lerpedLookRotation, characterUp);
         }
 
         public void Update() {
@@ -1548,7 +1644,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                     moveDirInput = moveDir;
                     break;
                 case MoveDirectionMode.Character:
-                    moveDirInput = graphicTransform.TransformDirection(moveDir);
+                    moveDirInput = airshipTransform.TransformDirection(moveDir);
                     break;
                 case MoveDirectionMode.Camera:
                     var forwardZeroY = _cameraTransform.forward;
@@ -1625,7 +1721,7 @@ namespace Code.Player.Character.MovementSystems.Character {
             if (mode == NetworkedStateSystemMode.Input || (mode == NetworkedStateSystemMode.Authority && isClient)) {
                 if (_smoothLookVector && moveDirInput != Vector3.zero) {
                     lookVector = Vector3.RotateTowards(
-                        graphicTransform.forward,
+                        airshipTransform.forward,
                         moveDirInput.normalized,
                         smoothedRotationSpeed * Mathf.Deg2Rad * Time.deltaTime,
                         0f