gg.easy.airship 0.1.2126 → 0.1.2128

package/Editor/Artifacts/AirshipLocalArtifactDatabase.cs

@@ -112,6 +112,11 @@ namespace Airship.Editor {
         [SerializeField] internal List<ComponentScriptAssetData> scripts = new();
         [SerializeField] internal List<ComponentData> components = new();
         
+        /// <summary>
+        /// Returns if the Database is empty - if it is, it's likely the project is new or freshly pulled
+        /// </summary>
+        internal static bool isEmpty => instance.scripts.Count == 0 && instance.components.Count == 0;
+        
         /// <summary>
         /// Gets or creates the script asset data in the artifact database for the given script
         /// </summary>

package/Editor/Artifacts/AirshipReconciliationService.cs

@@ -322,11 +322,19 @@ namespace Airship.Editor {
         private static void OnComponentReconcile(AirshipReconcileEventData eventData) {
             // Components must have guids
             if (string.IsNullOrEmpty(eventData.Component.guid)) eventData.Component.guid = Guid.NewGuid().ToString();
+
+            // If an initial setup (e.g. first pull, or new template project)
+            if (AirshipLocalArtifactDatabase.isEmpty) {
+                // We can run a default reconcile, it wont matter tbh.
+                var component = eventData.Component;
+                ReconcileComponent(component);
+                component.componentHash = component.scriptHash;
+                return;
+            }
             
             if (ReconcilerVersion == ReconcilerVersion.Version2) {
                 var component = eventData.Component;
-            
-           
+
                 var isPrefab = PrefabUtility.IsPartOfAnyPrefab(component);
                 var prefabOriginalComponent = PrefabUtility.GetCorrespondingObjectFromOriginalSource(component);
                 if (isPrefab && prefabOriginalComponent.script != null) {

package/Editor/TypescriptServices/Compiler/TypescriptCompilationService.cs

@@ -21,6 +21,7 @@ using Newtonsoft.Json.Linq;
 using ParrelSync;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Android;
 using UnityEngine.PlayerLoop;
 using UnityEngine.Serialization;
 using Debug = UnityEngine.Debug;
@@ -55,6 +56,7 @@ using Object = UnityEngine.Object;
         /// </summary>
         // [InitializeOnLoad]
         public static class TypescriptCompilationService {
+            private const int ExitCodeKill = 137;
             private const string TsCompilerService = "Typescript Compilation Service";
             
             /// <summary>
@@ -768,6 +770,7 @@ using Object = UnityEngine.Object;
 
                 proc.Exited += (_, _) => {
                     if (proc.ExitCode <= 0) return;
+                    if (proc.ExitCode == ExitCodeKill) return;
                     
                     Debug.Log("Compiler process exited with code " + proc.ExitCode);
                     var progressId = TypescriptProjectsService.Project!.ProgressId;

package/Runtime/Code/AirshipConst.cs

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

package/Runtime/Code/Auth/Socket/SocketManager.cs

@@ -106,6 +106,16 @@ public class SocketManager : Singleton<SocketManager> {
                 await Awaitable.MainThreadAsync();
                 Instance.OnDisconnected?.Invoke(s);
             };
+
+            Instance.socket.OnError += async (sender, s) => {
+                if (s.StartsWith("User does not have \"GC Edge\" access")) {
+                    Debug.Log("User does not have \"GC Edge\" access");
+                    await Awaitable.MainThreadAsync();
+                    CrossSceneState.kickForceLogout = true;
+                    TransferManager.Instance.Disconnect(true, "User does not have permission to access Airship");
+                }
+            };
+
         }
 
         if (!Instance.socket.Connected) {

package/Runtime/Code/Bundles/CrossSceneState.cs

@@ -19,6 +19,7 @@ public static class CrossSceneState
     public static ServerTransferData ServerTransferData;
     public static bool UseLocalBundles = false;
     public static string kickMessage = "";
+    public static bool kickForceLogout = false;
     public static bool disconnectKicked = false;
     
     [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]

package/Runtime/Code/Http/HttpResponse.cs

@@ -14,4 +14,4 @@ namespace Code.Http {
             return headers[headerName];
         }
     }
-}
+}

package/Runtime/Code/Luau/ReflectionList.cs

@@ -147,6 +147,7 @@ namespace Luau {
             [typeof(Scrollbar)] = LuauContextAll,
             [typeof(ScrollRect)] = LuauContextAll,
             [typeof(Text)] = LuauContextAll,
+            [typeof(RectMask2D)] = LuauContextAll,
 
             // Particles
             [typeof(ParticleSystem)] = LuauContextAll,

package/Runtime/Code/LuauAPI/Bridge.cs

@@ -389,6 +389,33 @@ public static class Bridge {
     public static void UnloadGlobalSceneByName(string sceneName) {
         // InstanceFinder.SceneManager.UnloadGlobalScenes(new SceneUnloadData(sceneName));
     }
+    
+    [LuauAPI(LuauContext.Protected)]
+    public static bool IsLowEndDevice() {
+        // CPU check
+        string cpu = SystemInfo.processorType.ToLower();
+        if (cpu.Contains("celeron") || cpu.Contains("pentium") || cpu.Contains("atom")) {
+            return true;
+        }
+    
+        // GPU check
+        string gpu = SystemInfo.graphicsDeviceName.ToLower();
+        if (gpu.Contains("intel") || gpu.Contains("uhd") || gpu.Contains("hd graphics")) {
+            return true;
+        }
+
+        // RAM check
+        if (SystemInfo.systemMemorySize < 8000) { // Less than 8GB RAM
+            return true;
+        }
+
+        // GPU memory check
+        if (SystemInfo.graphicsMemorySize < 2000) { // Less than 2GB VRAM
+            return true;
+        }
+
+        return false;
+    }
 
     public static void MoveGameObjectToScene(GameObject gameObject, Scene scene) {
         if (LuauCore.IsProtectedScene(scene) && LuauCore.CurrentContext == LuauContext.Game) {

package/Runtime/Code/MainMenu/DisconnectedScreen.cs

@@ -5,13 +5,35 @@ using UnityEngine.SceneManagement;
 
 public class DisconnectedScreen : MonoBehaviour {
     public TMP_Text reasonText;
+    public GameObject continueButton;
+    public GameObject logoutButton;
+    public GameObject quitButton;
 
     private void Start() {
         this.reasonText.text = CrossSceneState.kickMessage;
         Cursor.lockState = CursorLockMode.None;
+        if (CrossSceneState.kickForceLogout) {
+            CrossSceneState.kickForceLogout = false;
+            this.continueButton.SetActive(false);
+            this.logoutButton.SetActive(true);
+            this.quitButton.SetActive(true);
+        } else {
+            this.continueButton.SetActive(true);
+            this.logoutButton.SetActive(false);
+            this.quitButton.SetActive(false);
+        }
     }
 
     public void ContinueButton_OnClick() {
         SceneManager.LoadScene("MainMenu");
     }
+
+    public void QuitButton_OnClick() {
+        Application.Quit();
+    }
+
+    public void LogoutButton_OnClick() {
+        AuthManager.ClearSavedAccount();
+        SceneManager.LoadScene("Login");
+    }
 }

package/Runtime/Code/Misc/InternalCameraScreenshotRecorder.cs

@@ -11,153 +11,155 @@ public class CameraScreenshotResponse{
 	public string extension = "";
 }
 
-[LuauAPI(LuauContext.Protected)]
-public class InternalCameraScreenshotRecorder : Singleton<InternalCameraScreenshotRecorder> {
-	public enum SaveFolder {
-		ApplicationData,
-		PicturesFolder,
-		Documents,
-	}
-
-	public SaveFolder saveFolder = SaveFolder.PicturesFolder;
-	public bool shouldSaveCaptures = true;
-	public int resWidth = 1920;
-	public int resHeight = 1080;
-	
-	private const int resDepth = 24;
-	private static Texture2D screenShot;
-	private static RenderTexture rt;
-
-	public delegate void OnPictureTaken(Texture2D screenshot);
-	public static OnPictureTaken onPictureTaken;
-	
-	public static Texture2D GetScreenshotTexture {
-		get {
-			return screenShot;
+namespace Assets.Code.Misc {
+	[LuauAPI(LuauContext.Protected)]
+	public class InternalCameraScreenshotRecorder : Singleton<InternalCameraScreenshotRecorder> {
+		public enum SaveFolder {
+			ApplicationData,
+			PicturesFolder,
+			Documents,
 		}
-	}
-	
-	public string ScreenShotName(int width, int height, bool png) {
-		return FolderName + string.Format("screen_{0}x{1}_{2}.{3}", 
-		                     width, height, 
-		                     System.DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"), png?"png":"jpg");
-	}
-
-	public string ScreenShotName(string filename, bool png) {
-		return FolderName + filename + (png?".png":".jpg");
-	}
-	
-	public string FolderName{
-		get {
-			string folderPath = Application.persistentDataPath;
-			switch (saveFolder) {
-				case SaveFolder.PicturesFolder:
-					folderPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
-					break;
-				case SaveFolder.Documents:
-					folderPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
-					break;
-			};
-			return string.Format("{0}/Airship/", folderPath);
+
+		public SaveFolder saveFolder = SaveFolder.PicturesFolder;
+		public bool shouldSaveCaptures = true;
+		public int resWidth = 1920;
+		public int resHeight = 1080;
+		
+		private const int resDepth = 24;
+		private static Texture2D screenShot;
+		private static RenderTexture rt;
+
+		public delegate void OnPictureTaken(Texture2D screenshot);
+		public static OnPictureTaken onPictureTaken;
+		
+		public static Texture2D GetScreenshotTexture {
+			get {
+				return screenShot;
+			}
+		}
+		
+		public string ScreenShotName(int width, int height, bool png) {
+			return FolderName + string.Format("screen_{0}x{1}_{2}.{3}", 
+			                     width, height, 
+			                     System.DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"), png?"png":"jpg");
 		}
-	}
 
-	private void InitFolder() {
-		if (!Directory.Exists (FolderName)) {
-			Directory.CreateDirectory(FolderName);
+		public string ScreenShotName(string filename, bool png) {
+			return FolderName + filename + (png?".png":".jpg");
+		}
+		
+		public string FolderName{
+			get {
+				string folderPath = Application.persistentDataPath;
+				switch (saveFolder) {
+					case SaveFolder.PicturesFolder:
+						folderPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
+						break;
+					case SaveFolder.Documents:
+						folderPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+						break;
+				};
+				return string.Format("{0}/Airship/", folderPath);
+			}
 		}
-	}
 
-	public static void TakeScreenshot(string fileName = "", int superSampleSize = 1, bool png = true) {
-		Instance.InitFolder();
-		Instance.StartCoroutine(Instance.TakeScreenshotCo(fileName, superSampleSize, png));
-	}
+		private void InitFolder() {
+			if (!Directory.Exists (FolderName)) {
+				Directory.CreateDirectory(FolderName);
+			}
+		}
 
-	private IEnumerator TakeScreenshotCo(string fileName = "", int superSampleSize = 1, bool png = true) {
-		//Have to capture at end of frame for ScreenCapture to work
-		yield return new WaitForEndOfFrame();
-		screenShot = ScreenCapture.CaptureScreenshotAsTexture(superSampleSize);
-		SaveScreenshot(fileName, superSampleSize, png);
-	}
+		public static void TakeScreenshot(string fileName = "", int superSampleSize = 1, bool png = true) {
+			Instance.InitFolder();
+			Instance.StartCoroutine(Instance.TakeScreenshotCo(fileName, superSampleSize, png));
+		}
 
+		private IEnumerator TakeScreenshotCo(string fileName = "", int superSampleSize = 1, bool png = true) {
+			//Have to capture at end of frame for ScreenCapture to work
+			yield return new WaitForEndOfFrame();
+			screenShot = ScreenCapture.CaptureScreenshotAsTexture(superSampleSize);
+			SaveScreenshot(fileName, superSampleSize, png);
+		}
 
-	public static void TakeCameraScreenshot(Camera camera, string fileName = "", int superSampleSize = 1) {
-		Instance.InitFolder();
-		Instance.StartCoroutine(Instance.TakeCameraScreenshotCo(camera, fileName, superSampleSize));
-	}
 
-	public IEnumerator TakeCameraScreenshotCo(Camera camera, string fileName = "", int superSampleSize = 1) {
-		bool enabled = camera.enabled;
-		
-		// Have to capture at end of frame for ScreenCapture to work
-		yield return new WaitForEndOfFrame();
-		
-		try {
-			screenShot = new Texture2D(resWidth * superSampleSize, resHeight * superSampleSize, TextureFormat.RGB24, false);
-			rt = new RenderTexture(resWidth, resHeight, resDepth);
-			camera.enabled = true;
-			camera.targetTexture = rt;
-			camera.Render();
-			RenderTexture.active = rt;
-		} catch(Exception e) {
-			Debug.LogError("Error saving: " + e.Message);
+		public static void TakeCameraScreenshot(Camera camera, string fileName = "", int superSampleSize = 1) {
+			Instance.InitFolder();
+			Instance.StartCoroutine(Instance.TakeCameraScreenshotCo(camera, fileName, superSampleSize));
 		}
 
-		// Save the render textures data to a texture2D
-		screenShot.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
-		camera.targetTexture = null;
-		RenderTexture.active = null;
-		rt.Release();
-		rt = null;
-		
-		if (shouldSaveCaptures) {
-			SaveScreenshot(fileName, superSampleSize, true);
-		}
+		public IEnumerator TakeCameraScreenshotCo(Camera camera, string fileName = "", int superSampleSize = 1) {
+			bool enabled = camera.enabled;
+			
+			// Have to capture at end of frame for ScreenCapture to work
+			yield return new WaitForEndOfFrame();
 			
-		if(onPictureTaken != null){
-			onPictureTaken(screenShot);
+			try {
+				screenShot = new Texture2D(resWidth * superSampleSize, resHeight * superSampleSize, TextureFormat.RGB24, false);
+				rt = new RenderTexture(resWidth, resHeight, resDepth);
+				camera.enabled = true;
+				camera.targetTexture = rt;
+				camera.Render();
+				RenderTexture.active = rt;
+			} catch(Exception e) {
+				Debug.LogError("Error saving: " + e.Message);
+			}
+
+			// Save the render textures data to a texture2D
+			screenShot.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
+			camera.targetTexture = null;
+			RenderTexture.active = null;
+			rt.Release();
+			rt = null;
+			
+			if (shouldSaveCaptures) {
+				SaveScreenshot(fileName, superSampleSize, true);
+			}
+				
+			if(onPictureTaken != null){
+				onPictureTaken(screenShot);
+			}
+			camera.enabled = enabled;
 		}
-		camera.enabled = enabled;
-	}
 
-	private void SaveScreenshot(string fileName, int superSampleSize, bool png) {
-		if (!screenShot || screenShot.width <= 0) {
-			return;
+		private void SaveScreenshot(string fileName, int superSampleSize, bool png) {
+			if (!screenShot || screenShot.width <= 0) {
+				return;
+			}
+			SaveTexture(screenShot, fileName, png);
+			screenShot.Apply();
 		}
-		SaveTexture(screenShot, fileName, png);
-		screenShot.Apply();
-	}
 
-	public CameraScreenshotResponse SaveRenderTexture(RenderTexture rt, string fileName, bool png){
-		if(!rt){
-			return new CameraScreenshotResponse();
+		public CameraScreenshotResponse SaveRenderTexture(RenderTexture rt, string fileName, bool png){
+			if(!rt){
+				return new CameraScreenshotResponse();
+			}
+			RenderTexture.active = rt;
+			var texture = new Texture2D(rt.width, rt.height, TextureFormat.RGB24, false);
+			texture.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
+			RenderTexture.active = null;
+			return SaveTexture(texture, fileName, png);
 		}
-		RenderTexture.active = rt;
-		var texture = new Texture2D(rt.width, rt.height, TextureFormat.RGB24, false);
-		texture.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
-		RenderTexture.active = null;
-		return SaveTexture(texture, fileName, png);
-	}
-
-	public CameraScreenshotResponse SaveTexture(Texture2D texture, string fileName, bool png){
-		try {
-			//Debug.Log("Saving Texture size: " + texture.width +", " + texture.height);
-			string filePath = string.IsNullOrEmpty(fileName)
-				? ScreenShotName(texture.width, texture.height, png)
-				: ScreenShotName(fileName, png);
-			byte[] bytes = png ? texture.EncodeToPNG() : texture.EncodeToJPG();
-			string directoryPath = Path.GetDirectoryName(filePath);
-			if(!Directory.Exists(directoryPath)){
-				Directory.CreateDirectory(directoryPath);
+
+		public CameraScreenshotResponse SaveTexture(Texture2D texture, string fileName, bool png){
+			try {
+				//Debug.Log("Saving Texture size: " + texture.width +", " + texture.height);
+				string filePath = string.IsNullOrEmpty(fileName)
+					? ScreenShotName(texture.width, texture.height, png)
+					: ScreenShotName(fileName, png);
+				byte[] bytes = png ? texture.EncodeToPNG() : texture.EncodeToJPG();
+				string directoryPath = Path.GetDirectoryName(filePath);
+				if(!Directory.Exists(directoryPath)){
+					Directory.CreateDirectory(directoryPath);
+				}
+				File.WriteAllBytes(filePath, bytes);
+				Debug.Log(string.Format("Saved screenshot to: {0}", filePath));
+				return new CameraScreenshotResponse(){filesize = bytes.Length, extension = Path.GetExtension(filePath), path = filePath};
+			} catch (Exception e) {
+				Debug.LogError("Error saving texture: " + e.Message);
 			}
-			File.WriteAllBytes(filePath, bytes);
-			Debug.Log(string.Format("Saved screenshot to: {0}", filePath));
-			return new CameraScreenshotResponse(){filesize = bytes.Length, extension = Path.GetExtension(filePath), path = filePath};
-		} catch (Exception e) {
-			Debug.LogError("Error saving texture: " + e.Message);
+			return new CameraScreenshotResponse();
 		}
-		return new CameraScreenshotResponse();
-	}
+	}	
 }
 
 

package/Runtime/Code/Network/Simulation/AirshipNetworkedObject.cs

@@ -0,0 +1,81 @@
+using System;
+using Mirror;
+using UnityEngine;
+
+namespace Code.Network.Simulation
+{
+    struct TransformSnapshot
+    {
+        public Vector3 position;
+        public Quaternion rotation;
+    }
+
+    /**
+     * This component is used to allow lag compensation, prediction, and other networked state systems to
+     * work with a networked object controlled by the server.
+     *
+     * When this component is placed on a object being networked with Mirror, the server can include it
+     * in lag compensation and clients can resimulate their predictions more accurately.
+     */
+    public class AirshipNetworkedObject : NetworkBehaviour
+    {
+        private History<TransformSnapshot> history;
+
+        private void Start()
+        {
+            if (isServer && authority)
+            {
+                history = new History<TransformSnapshot>(NetworkServer.sendRate);
+                AirshipSimulationManager.Instance.OnCaptureSnapshot += this.CaptureSnapshot;
+                AirshipSimulationManager.Instance.OnSetSnapshot += this.SetSnapshot;
+                AirshipSimulationManager.Instance.OnLagCompensationCheck += this.LagCompensationCheck;
+            }
+
+            if (isClient && !authority)
+            {
+                history = new History<TransformSnapshot>(NetworkClient.sendRate);
+                AirshipSimulationManager.Instance.OnCaptureSnapshot += this.CaptureSnapshot;
+                AirshipSimulationManager.Instance.OnSetSnapshot += this.SetSnapshot;
+            }
+        }
+
+        private void OnDestroy()
+        {
+            AirshipSimulationManager.Instance.OnCaptureSnapshot -= this.CaptureSnapshot;
+            AirshipSimulationManager.Instance.OnSetSnapshot -= this.SetSnapshot;
+            AirshipSimulationManager.Instance.OnLagCompensationCheck -= this.LagCompensationCheck;
+        }
+
+        private void CaptureSnapshot(double time, bool replay)
+        {
+            if (replay)
+            {
+                var state = this.history.Get(time);
+                this.transform.position = state.position;
+                this.transform.rotation = state.rotation;
+                return;
+            }
+            
+            this.history.Add(time, new TransformSnapshot()
+            {
+                position = this.transform.position,
+                rotation = this.transform.rotation
+            });
+        }
+
+        private void SetSnapshot(object objTime)
+        {
+            if (objTime is double time) {
+                var snapshot = this.history.Get(time);
+                this.transform.position = snapshot.position;
+                this.transform.rotation = snapshot.rotation;
+            }
+        }
+
+        private void LagCompensationCheck(int clientId, double time, double latency)
+        {
+            var bufferedTime = time - latency - NetworkClient.bufferTime;
+            this.SetSnapshot(bufferedTime);
+        }
+    }
+}

package/Runtime/Code/Network/Simulation/AirshipNetworkedObject.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 06ffda6049064b9aa9449f9b169ff389
+timeCreated: 1739323845

package/Runtime/Code/Network/Simulation/AirshipOfflineRigidbody.cs

@@ -0,0 +1,55 @@
+using System;
+using UnityEngine;
+
+namespace Code.Network.Simulation
+{
+    /**
+     * Disables a rigidbodies physics (sets it to kinematic) when resimulation or lag compensation is taking place.
+     */
+    public class AirshipOfflineRigidbody : MonoBehaviour
+    {
+        public Rigidbody rigidbody;
+        private bool kinematicSetting = false;
+
+        private Vector3 position;
+        private Quaternion rotation;
+        private Vector3 linearVelocity;
+        private Vector3 angularVelocity;
+
+        public void Start()
+        {
+            this.rigidbody = this.GetComponent<Rigidbody>();
+            AirshipSimulationManager.Instance.OnSetPaused += OnPause;
+        }
+
+        private void OnDestroy()
+        {
+            AirshipSimulationManager.Instance.OnSetPaused -= OnPause;
+        }
+
+        private void OnPause(bool paused)
+        {
+            if (this.rigidbody == null) return;
+            if (paused)
+            {
+                this.kinematicSetting = this.rigidbody.isKinematic;
+                this.rigidbody.isKinematic = true;
+                this.position = this.rigidbody.position;
+                this.rotation = this.rigidbody.rotation;
+                this.linearVelocity = this.rigidbody.linearVelocity;
+                this.angularVelocity = this.rigidbody.angularVelocity;
+            }
+            else
+            {
+                this.rigidbody.isKinematic = this.kinematicSetting;
+                this.rigidbody.position = this.position;
+                this.rigidbody.rotation = this.rotation;
+                if (!this.kinematicSetting)
+                {
+                    this.rigidbody.linearVelocity = this.linearVelocity;
+                    this.rigidbody.angularVelocity = this.angularVelocity;
+                }
+            }
+        }
+    }
+}

package/Runtime/Code/Network/Simulation/AirshipOfflineRigidbody.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e81927b37e89412490521c8e87aadcd0
+timeCreated: 1739512084