gg.easy.airship 0.1.2176 → 0.1.2177

package/Editor/BuildMenu.cs

@@ -43,9 +43,7 @@ namespace Editor {
         }
 
         private static void OnBuild() {
-            PhysicsSetup.Setup(null);
-
-
+            PhysicsSetup.Setup();
         }
 
         public static void BuildLinuxServerStaging() {

package/Runtime/Code/GameConfig/GameConfig.cs

@@ -6,16 +6,14 @@ using Code.GameBundle;
 using UnityEditor;
 #endif
 using UnityEngine;
-using UnityEngine.Serialization;
 using Object = UnityEngine.Object;
 
 [CreateAssetMenu(fileName = "GameConfig", menuName = "Airship/GameConfig", order = 100)]
-public class GameConfig : ScriptableObject
-{
+public class GameConfig : ScriptableObject {
     public string gameId;
-    #if UNITY_EDITOR
+#if UNITY_EDITOR
     public SceneAsset startingScene;
-    #endif
+#endif
     public Object[] gameScenes;
 
     [Obsolete]
@@ -27,7 +25,10 @@ public class GameConfig : ScriptableObject
     [HideInInspector] public string[] gameLayers;
     [HideInInspector] public string[] gameTags;
     [HideInInspector] public bool[] physicsMatrix;
-    [HideInInspector] public Vector3 gravity = new Vector3(0, -24, 0);
+    [HideInInspector] public bool[] physicsMatrix2D;
+
+    //3D Physics
+    [HideInInspector] public Vector3 gravity = new(0, -9.81f, 0);
     [HideInInspector] public float bounceThreshold = 2;
     [HideInInspector] public float defaultMaxDepenetrationVelocity = 10;
     [HideInInspector] public float sleepThreshold = 0.005f;
@@ -38,6 +39,27 @@ public class GameConfig : ScriptableObject
     [HideInInspector] public bool queriesHitTriggers = true;
     [HideInInspector] public float fixedDeltaTime = .025f;
 
+    [HideInInspector] public Vector3 gravity2D = new(0, -9.81f, 0);
+    [HideInInspector] public int velocityIterations2D = 8;
+    [HideInInspector] public int positionIterations2D = 3;
+    [HideInInspector] public float bounceThreshold2D = 1;
+    [HideInInspector] public float maxLinearCorrection2D = .2f;
+    [HideInInspector] public float maxAngularCorrection2D = 8;
+    [HideInInspector] public float maxTranslationSpeed2D = 100;
+    [HideInInspector] public float maxRotationSpeed2D = 360;
+    [HideInInspector] public float baumgarteScale2D = .2f;
+    [HideInInspector] public float baumgarteTOIScale2D = .75f;
+    [HideInInspector] public float timeToSleep2D = .5f;
+    [HideInInspector] public float linearSleepTolerance2D = .01f;
+    [HideInInspector] public float angularSleepTolerance2D = 2;
+    [HideInInspector] public float defaultContactOffset2D = .01f;
+    [HideInInspector] public float contactThreshold2D = 0f;
+    [HideInInspector] public bool queriesHitTriggers2D = true;
+    [HideInInspector] public bool queriesStartInColliders2D = true;
+    [HideInInspector] public bool callbacksOnDisable2D = true;
+    [HideInInspector] public bool reuseCollisionCallbacks2D = true;
+    [HideInInspector] public bool autoSyncTransforms2D = false;
+
     [HideInInspector] public bool supportsMobile;
     
     [HideInInspector] public bool compileURPShaders = false;
@@ -61,18 +83,20 @@ public class GameConfig : ScriptableObject
             userTag = null;
             return false;
         }
-        
+
         var offset = int.Parse(runtimeTag[TagPrefix.Length..]);
         userTag = gameTags[offset];
         return userTag != null;
     }
-    
+
     public static GameConfig Load() {
 #if UNITY_EDITOR
         var gameConfig = AssetDatabase.LoadAssetAtPath<GameConfig>("Assets/GameConfig.asset");
         // I believe AssetDatabase might not have loaded GameConfig sometimes (like during a publish)
         // TODO if file doesn't exist we could generate GameConfig here
-        if (gameConfig == null) return null;
+        if (gameConfig == null) {
+            return null;
+        }
 
 #if !AIRSHIP_PLAYER && !AIRSHIP_INTERNAL
         if (gameConfig.packages.Find((p) => p.id == "@Easy/Core") == null) {
@@ -100,15 +124,15 @@ public class GameConfig : ScriptableObject
     private void OnValidate() {
 #if UNITY_EDITOR
 #pragma warning disable CS0612
-        if (this.startingScene == null && !string.IsNullOrEmpty(this.startingSceneName)) {
+        if (startingScene == null && !string.IsNullOrEmpty(startingSceneName)) {
             var guids = AssetDatabase.FindAssets("t:Scene").ToList();
             var paths = guids.Select((guid) => AssetDatabase.GUIDToAssetPath(guid));
             foreach (var path in paths) {
                 if (path.StartsWith("Assets/")) {
-                    if (path.EndsWith(this.startingSceneName + ".unity")) {
+                    if (path.EndsWith(startingSceneName + ".unity")) {
                         var sceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);
-                        this.startingScene = sceneAsset;
-                        this.startingSceneName = "";
+                        startingScene = sceneAsset;
+                        startingSceneName = "";
                     }
                 }
             }
@@ -126,58 +150,153 @@ public class GameConfig : ScriptableObject
         return json;
     }
 
-    public void SerializeSettings(){
-		//Update physics matrix        
-		bool[] areLayersIgnored = new bool[15 * 32];
-		string TheMatrixLog = "SAVING GAME LAYER MATRIX: \n";
-		//15 Game Layers and how they collide with all 32 layers
-        for (int i = 0; i < 15; i++) {
-			//Check
-            for (int otherLayerI = 0; otherLayerI < 32; otherLayerI++) {
-				int gameLayerI = 17 + i;
-				bool ignored = Physics.GetIgnoreLayerCollision(gameLayerI, otherLayerI);
-            	areLayersIgnored[i * 32 + otherLayerI] = ignored;
-				TheMatrixLog += "GameLayer" + i + " and Layer: " + otherLayerI +" ignored: " + ignored + " \n";
+    public void SerializeSettings() {
+        try {
+            // Update physics matrix        
+            var areLayersIgnored = new bool[15 * 32];
+            var TheMatrixLog = "SAVING GAME LAYER MATRIX: \n";
+            // 15 Game Layers and how they collide with all 32 layers
+            for (var i = 0; i < 15; i++) {
+                //Check
+                for (var otherLayerI = 0; otherLayerI < 32; otherLayerI++) {
+                    var gameLayerI = 17 + i;
+                    var ignored = Physics.GetIgnoreLayerCollision(gameLayerI, otherLayerI);
+                    areLayersIgnored[i * 32 + otherLayerI] = ignored;
+                    TheMatrixLog += "GameLayer" + i + " and Layer: " + otherLayerI + " ignored: " + ignored + " \n";
+                }
+            }
+
+            // Debug.Log(TheMatrixLog);
+            physicsMatrix = areLayersIgnored;
+
+            // Physics settings
+            gravity = Physics.gravity;
+            bounceThreshold = Physics.bounceThreshold;
+            defaultMaxDepenetrationVelocity = Physics.defaultMaxDepenetrationVelocity;
+            sleepThreshold = Physics.sleepThreshold;
+            defaultContactOffset = Physics.defaultContactOffset;
+            defaultSolverIterations = Physics.defaultSolverIterations;
+            defaultSolverVelocityIterations = Physics.defaultSolverVelocityIterations;
+            queriesHitBackfaces = Physics.queriesHitBackfaces;
+            queriesHitTriggers = Physics.queriesHitTriggers;
+            fixedDeltaTime = Time.fixedDeltaTime;
+
+
+            // Update physics 2D matrix        
+            areLayersIgnored = new bool[15 * 32];
+            TheMatrixLog = "SAVING 2D GAME LAYER MATRIX: \n";
+            // 15 Game Layers and how they collide with all 32 layers
+            for (var i = 0; i < 15; i++) {
+                //Check
+                for (var otherLayerI = 0; otherLayerI < 32; otherLayerI++) {
+                    var gameLayerI = 17 + i;
+                    var ignored = Physics2D.GetIgnoreLayerCollision(gameLayerI, otherLayerI);
+                    areLayersIgnored[i * 32 + otherLayerI] = ignored;
+                    TheMatrixLog += "2D GameLayer" + i + " and Layer: " + otherLayerI + " ignored: " + ignored + " \n";
+                }
             }
+
+            // Debug.Log(TheMatrixLog);
+            physicsMatrix2D = areLayersIgnored;
+
+            // Physics 2D settings
+            gravity2D = Physics2D.gravity;
+            velocityIterations2D = Physics2D.velocityIterations;
+            positionIterations2D = Physics2D.positionIterations;
+            bounceThreshold2D = Physics2D.bounceThreshold;
+            maxLinearCorrection2D = Physics2D.maxLinearCorrection;
+            maxAngularCorrection2D = Physics2D.maxAngularCorrection;
+            maxTranslationSpeed2D = Physics2D.maxTranslationSpeed;
+            maxRotationSpeed2D = Physics2D.maxRotationSpeed;
+            baumgarteScale2D = Physics2D.baumgarteScale;
+            baumgarteTOIScale2D = Physics2D.baumgarteTOIScale;
+            timeToSleep2D = Physics2D.timeToSleep;
+            linearSleepTolerance2D = Physics2D.linearSleepTolerance;
+            angularSleepTolerance2D = Physics2D.angularSleepTolerance;
+            defaultContactOffset2D = Physics2D.defaultContactOffset;
+            contactThreshold2D = Physics2D.contactThreshold;
+            queriesHitTriggers2D = Physics2D.queriesHitTriggers;
+            queriesStartInColliders2D = Physics2D.queriesStartInColliders;
+            callbacksOnDisable2D = Physics2D.callbacksOnDisable;
+            reuseCollisionCallbacks2D = Physics2D.reuseCollisionCallbacks;
+            autoSyncTransforms2D = Physics2D.autoSyncTransforms;
+        } catch (Exception e) {
+            Debug.LogError("Error in Serialize Game Config: " + e);
         }
-        //Debug.Log(TheMatrixLog);
-        physicsMatrix = areLayersIgnored;
-		gravity = Physics.gravity;
-        bounceThreshold = Physics.bounceThreshold;
-        defaultMaxDepenetrationVelocity = Physics.defaultMaxDepenetrationVelocity;
-        sleepThreshold = Physics.sleepThreshold;
-        defaultContactOffset = Physics.defaultContactOffset;
-        defaultSolverIterations = Physics.defaultSolverIterations;
-        defaultSolverVelocityIterations = Physics.defaultSolverVelocityIterations;
-        queriesHitBackfaces = Physics.queriesHitBackfaces;
-        queriesHitTriggers = Physics.queriesHitTriggers;
-        fixedDeltaTime = Time.fixedDeltaTime;
     }
 
-    public void DeserializeSettings(){
-		//15 Game Layers and how they collide with all 32 layers
-        int gameLayerI = 17;
-		string TheMatrixLog = "LOADING GAME LAYER MATRIX: \n";
-        for (int byteI = 0; byteI < this.physicsMatrix.Length; byteI+= 32) {
-            for(int otherLayerI=0; otherLayerI < 32; otherLayerI++){
-                bool ignored = this.physicsMatrix[byteI+otherLayerI];
-                Physics.IgnoreLayerCollision(gameLayerI, otherLayerI, ignored);
-				TheMatrixLog += "GameLayer" + gameLayerI + " and Layer: " + otherLayerI +" ignored: " + ignored + " \n";
+    public void DeserializeSettings() {
+        try { 
+            // 15 Game Layers and how they collide with all 32 layers
+            var gameLayerI = 17;
+            var TheMatrixLog = "LOADING GAME LAYER MATRIX: \n";
+            for (var byteI = 0; byteI < physicsMatrix.Length; byteI += 32) {
+                for (var otherLayerI = 0; otherLayerI < 32; otherLayerI++) {
+                    var ignored = physicsMatrix[byteI + otherLayerI];
+                    Physics.IgnoreLayerCollision(gameLayerI, otherLayerI, ignored);
+				    TheMatrixLog += "GameLayer" + gameLayerI + " and Layer: " + otherLayerI +" ignored: " + ignored + " \n";
+                }
+
+                gameLayerI++;
+            }
+            // Debug.Log(TheMatrixLog);
+
+            // Physics Settings
+            Physics.gravity = gravity;
+            Physics.bounceThreshold = bounceThreshold;
+            Physics.defaultMaxDepenetrationVelocity = defaultMaxDepenetrationVelocity;
+            Physics.sleepThreshold = sleepThreshold;
+            Physics.defaultContactOffset = defaultContactOffset;
+            Physics.defaultSolverIterations = defaultSolverIterations;
+            Physics.defaultSolverVelocityIterations = defaultSolverVelocityIterations;
+            Physics.queriesHitBackfaces = queriesHitBackfaces;
+            Physics.queriesHitTriggers = queriesHitTriggers;
+            Time.fixedDeltaTime = fixedDeltaTime;
+
+
+            // 2D Setup
+            if (physicsMatrix2D != null && physicsMatrix2D.Length > 0) {
+                gameLayerI = 17;
+                TheMatrixLog = "LOADING 2D GAME LAYER MATRIX: \n";
+                for (var byteI = 0; byteI < physicsMatrix2D.Length; byteI += 32) {
+                    for (var otherLayerI = 0; otherLayerI < 32; otherLayerI++) {
+                        var ignored = physicsMatrix2D[byteI + otherLayerI];
+                        Physics2D.IgnoreLayerCollision(gameLayerI, otherLayerI, ignored);
+                        TheMatrixLog += "2D GameLayer" + gameLayerI + " and Layer: " + otherLayerI + " ignored: " + ignored +
+                                        " \n";
+                    }
+
+                    gameLayerI++;
+                }
+                // Debug.Log(TheMatrixLog);
+                
+                // Physics 2D Settings
+                Physics2D.gravity = gravity2D;
+                Physics2D.velocityIterations = velocityIterations2D;
+                Physics2D.positionIterations = positionIterations2D;
+                Physics2D.bounceThreshold = bounceThreshold2D;
+                Physics2D.maxLinearCorrection = maxLinearCorrection2D;
+                Physics2D.maxAngularCorrection = maxAngularCorrection2D;
+                Physics2D.maxTranslationSpeed = maxTranslationSpeed2D;
+                Physics2D.maxRotationSpeed = maxRotationSpeed2D;
+                Physics2D.baumgarteScale = baumgarteScale2D;
+                Physics2D.baumgarteTOIScale = baumgarteTOIScale2D;
+                Physics2D.timeToSleep = timeToSleep2D;
+                Physics2D.linearSleepTolerance = linearSleepTolerance2D;
+                Physics2D.angularSleepTolerance = angularSleepTolerance2D;
+                Physics2D.defaultContactOffset = defaultContactOffset2D;
+                Physics2D.contactThreshold = contactThreshold2D;
+                Physics2D.queriesHitTriggers = queriesHitTriggers2D;
+                Physics2D.queriesStartInColliders = queriesStartInColliders2D;
+                Physics2D.callbacksOnDisable = callbacksOnDisable2D;
+                Physics2D.reuseCollisionCallbacks = reuseCollisionCallbacks2D;
+                Physics2D.autoSyncTransforms = autoSyncTransforms2D;
+            } else {
+                Debug.LogError("Game hasn't generated a 2D game config yet");
             }
-            gameLayerI++;
+        
+        } catch (Exception e) {
+            Debug.LogError("Error in Deserialize Game Config: " + e);
         }
-        //Debug.Log(TheMatrixLog);
-
-        //Physics Settings
-        Physics.gravity = gravity;
-        Physics.bounceThreshold = bounceThreshold;
-        Physics.defaultMaxDepenetrationVelocity = defaultMaxDepenetrationVelocity;
-        Physics.sleepThreshold = sleepThreshold;
-        Physics.defaultContactOffset = defaultContactOffset;
-        Physics.defaultSolverIterations = defaultSolverIterations;
-        Physics.defaultSolverVelocityIterations = defaultSolverVelocityIterations;
-        Physics.queriesHitBackfaces = queriesHitBackfaces;
-        Physics.queriesHitTriggers = queriesHitTriggers;
-        Time.fixedDeltaTime = fixedDeltaTime;
     }
 }

package/Runtime/Code/Luau/AirshipScript.cs

@@ -74,7 +74,12 @@ namespace Luau {
         #endregion
         
         #region Luau Properties
+        
+#if UNITY_EDITOR && !AIRSHIP_PLAYER
         [HideInInspector]
+#else
+        [NonSerialized]
+#endif
         public byte[] m_bytes;
         
         public bool m_compiled = false;

package/Runtime/Code/ProjectSetup/Editor/SetupManager.cs

@@ -19,14 +19,12 @@ public class SetupManager : AssetPostprocessor {
 
     [MenuItem("Airship/Misc/Repair Project")]
     public static void FixProject() {
-        var config = MiscProjectSetup.Setup();
-        PhysicsSetup.Setup(config);
+        PhysicsSetup.Setup();
     }
 
     [MenuItem("Airship/Misc/Reset Physics To Airship Defaults")]
     public static void ResetPhysics() {
-        var config = MiscProjectSetup.GetOrCreateGameConfig();
-        PhysicsSetup.ResetDefaults(config);
+        PhysicsSetup.ResetDefaults();
     }
 }
 #endif

package/Runtime/Code/ProjectSetup/PhysicsSetup.cs

@@ -8,15 +8,16 @@ public static class PhysicsSetup {
     private static List<int> corelayers;
     private static List<int> gameLayers;
 
-    //Setup required settings for Airship that all games need
-    public static void Setup(GameConfig config) {
+    // Setup required settings for Airship that all games need
+    public static void Setup() {
         InitLayerCollection();
 
-        //Set the physics mat
-        //How the heck do I set this? 
-        //UnityEditor.physicsMat??? = AssetDatabase.LoadAllAssetsAtPath("defaultphysicsmat");
+        // Set the physics mat
+        // How the heck do I set this? 
+        // UnityEditor.physicsMat??? = AssetDatabase.LoadAllAssetsAtPath("defaultphysicsmat");
 
         Physics.simulationMode = SimulationMode.FixedUpdate;
+        Physics2D.simulationMode = SimulationMode2D.FixedUpdate;
 
 #if UNITY_EDITOR
         //Airship Core Layers
@@ -34,14 +35,14 @@ public static class PhysicsSetup {
         PhysicsLayerEditor.SetLayer(11, "LocalStencilMask");
         PhysicsLayerEditor.SetLayer(12, "StencilMask");
 
-        //Reserved for future use
+        // Reserved for future use
         for (var i = NumberOfCoreLayers; i < GameLayerStartIndex; i++) {
             PhysicsLayerEditor.SetLayer(i, "");
         }
 #endif
 
-        //Create the Physics Matrix
-        //Non colliding layers
+        // Create the Physics Matrix
+        // Non colliding layers
         IgnoreAllLayers(LayerMask.NameToLayer("Viewmodel"), true);
         IgnoreAllLayers(LayerMask.NameToLayer("IgnoreCollision"), true);
         IgnoreAllLayers(LayerMask.NameToLayer("AvatarEditor"), true);
@@ -50,13 +51,12 @@ public static class PhysicsSetup {
         IgnoreAllLayers(LayerMask.NameToLayer("Water"), true);
         IgnoreAllLayers(LayerMask.NameToLayer("UI"), true);
         IgnoreAllLayers(LayerMask.NameToLayer("WorldUI"), true);
-        //Only collide with game layers
+        // Only collide with game layers
         IgnoreAllLayers(LayerMask.NameToLayer("Character"), false);
         IgnoreAllLayers(LayerMask.NameToLayer("LocalStencilMask"), false);
         IgnoreAllLayers(LayerMask.NameToLayer("StencilMask"), false);
 
-        //Character
-        //Collides with
+        // 3D Matrix
         Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Character"), LayerMask.NameToLayer("Default"), false);
         Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Character"), LayerMask.NameToLayer("VisuallyHidden"),
             false);
@@ -70,31 +70,52 @@ public static class PhysicsSetup {
         Physics.IgnoreLayerCollision(LayerMask.NameToLayer("StencilMask"), LayerMask.NameToLayer("VisuallyHidden"),
             false);
         Physics.IgnoreLayerCollision(LayerMask.NameToLayer("StencilMask"), LayerMask.NameToLayer("Water"), false);
+
+        // 2D Matrix
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Character"), LayerMask.NameToLayer("Default"), false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Character"), LayerMask.NameToLayer("VisuallyHidden"),
+            false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Character"), LayerMask.NameToLayer("Water"), false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("LocalStencilMask"), LayerMask.NameToLayer("Default"),
+            false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("LocalStencilMask"),
+            LayerMask.NameToLayer("VisuallyHidden"),
+            false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("LocalStencilMask"), LayerMask.NameToLayer("Water"),
+            false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("StencilMask"), LayerMask.NameToLayer("Default"), false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("StencilMask"), LayerMask.NameToLayer("VisuallyHidden"),
+            false);
+        Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("StencilMask"), LayerMask.NameToLayer("Water"), false);
     }
 
 
     public static void IgnoreAllLayers(int layer, bool ignoreGameLayers) {
         foreach (var otherLayer in corelayers) {
             Physics.IgnoreLayerCollision(layer, otherLayer, true);
+            Physics2D.IgnoreLayerCollision(layer, otherLayer, true);
         }
 
         foreach (var otherLayer in gameLayers) {
             Physics.IgnoreLayerCollision(layer, otherLayer, ignoreGameLayers);
+            Physics2D.IgnoreLayerCollision(layer, otherLayer, ignoreGameLayers);
         }
     }
 
     public static void CollideWithAllLayers(int layer, bool collideWithGameLayers) {
         foreach (var otherLayer in corelayers) {
             Physics.IgnoreLayerCollision(layer, otherLayer, false);
+            Physics2D.IgnoreLayerCollision(layer, otherLayer, false);
         }
 
         foreach (var otherLayer in gameLayers) {
             Physics.IgnoreLayerCollision(layer, otherLayer, !collideWithGameLayers);
+            Physics2D.IgnoreLayerCollision(layer, otherLayer, !collideWithGameLayers);
         }
     }
 
     private static void InitLayerCollection() {
-        //Compile all of the layer indexes we use
+        // Compile all of the layer indexes we use
         corelayers = new List<int>();
         gameLayers = new List<int>();
         for (var i = 0; i < NumberOfCoreLayers; i++) {
@@ -106,15 +127,16 @@ public static class PhysicsSetup {
         }
     }
 
-    //Reset physics values that users may have changed
-    public static void ResetDefaults(GameConfig config) {
+    // Reset physics values that users may have changed
+    public static void ResetDefaults() {
         InitLayerCollection();
 
-        //PHYSICS SETTINGS
+        // PHYSICS SETTINGS
         SetPhysicsSettings();
+        SetPhysics2DSettings();
 
-        //PHYSICS MATRIX
-        //Make Game Layers Collide With Everything
+        // PHYSICS MATRIX
+        // Make Game Layers Collide With Everything
         var gameId = 0;
         for (var i = GameLayerStartIndex; i <= 31; i++) {
             CollideWithAllLayers(i, true);
@@ -125,13 +147,13 @@ public static class PhysicsSetup {
             gameId++;
         }
 
-        //Run setup to make the game layers collide properly with core layers
-        Setup(config);
+        // Run setup to make the game layers collide properly with core layers
+        Setup();
     }
 
     private static void SetPhysicsSettings(
         Vector3? gravity = null,
-        float bouncThreshold = 2,
+        float bounceThreshold = 2,
         float defaultMaxDepenetrationVelocity = 10,
         float sleepThreshold = 0.005f,
         float defaultContactOffset = 0.01f,
@@ -140,8 +162,8 @@ public static class PhysicsSetup {
         bool queriesHitBackfaces = false,
         bool queriesHitTriggers = true,
         float fixedDeltaTime = 0.025f) {
-        Physics.gravity = gravity??new Vector3(0,-9.81f, 0);
-        Physics.bounceThreshold = bouncThreshold;
+        Physics.gravity = gravity ?? new Vector3(0, -9.81f, 0);
+        Physics.bounceThreshold = bounceThreshold;
         Physics.defaultMaxDepenetrationVelocity = defaultMaxDepenetrationVelocity;
         Physics.sleepThreshold = sleepThreshold;
         Physics.defaultContactOffset = defaultContactOffset;
@@ -152,17 +174,64 @@ public static class PhysicsSetup {
         Time.fixedDeltaTime = fixedDeltaTime;
     }
 
+    private static void SetPhysics2DSettings(
+        Vector3? gravity = null,
+        float bounceThreshold = 1,
+        int velocityIterations = 8,
+        int positionIterations = 3,
+        float maxLinearCorrection = .2f,
+        float maxAngularCorrection = 8,
+        float maxTranslationSpeed = 100,
+        float maxRotationSpeed = 360,
+        float baumgarteScale = .2f,
+        float baumgarteTOIScale = .75f,
+        float timeToSleep = .5f,
+        float linearSleepTolerance = .01f,
+        float angularSleepTolerance = 2,
+        float defaultContactOffset = 0.01f,
+        float contactThreshold = 0,
+        bool queriesHitTriggers = true,
+        bool queriesStartInColliders = true,
+        bool callbacksOnDisable = true,
+        bool reuseCollisionCallbacks = true,
+        bool autoSyncTransforms = false) {
+        Physics2D.gravity = gravity ?? new Vector3(0, -9.81f, 0);
+        Physics2D.velocityIterations = velocityIterations;
+        Physics2D.positionIterations = positionIterations;
+        Physics2D.bounceThreshold = bounceThreshold;
+        Physics2D.maxLinearCorrection = maxLinearCorrection;
+        Physics2D.maxAngularCorrection = maxAngularCorrection;
+        Physics2D.maxTranslationSpeed = maxTranslationSpeed;
+        Physics2D.maxRotationSpeed = maxRotationSpeed;
+        Physics2D.baumgarteScale = baumgarteScale;
+        Physics2D.baumgarteTOIScale = baumgarteTOIScale;
+        Physics2D.timeToSleep = timeToSleep;
+        Physics2D.linearSleepTolerance = linearSleepTolerance;
+        Physics2D.angularSleepTolerance = angularSleepTolerance;
+        Physics2D.defaultContactOffset = defaultContactOffset;
+        Physics2D.contactThreshold = contactThreshold;
+        Physics2D.queriesHitTriggers = queriesHitTriggers;
+        Physics2D.queriesStartInColliders = queriesStartInColliders;
+        Physics2D.callbacksOnDisable = callbacksOnDisable;
+        Physics2D.reuseCollisionCallbacks = reuseCollisionCallbacks;
+        Physics2D.autoSyncTransforms = autoSyncTransforms;
+    }
+
     public static void SetupFromGameConfig() {
 #if AIRSHIP_PLAYER || !UNITY_EDITOR
-        //Reset Unity to Airship defaults and GameConfig customizations
+        // Reset Unity to Airship defaults and GameConfig customizations
         var gameConfig = AssetBridge.Instance.LoadGameConfigAtRuntime();
         if (gameConfig) {
             // Debug.Log("Loading project settings from GameConfig. Physics: " + gameConfig.gravity + " matrix size: " +
             //           gameConfig.physicsMatrix.Length);
-            //Setup the Core Layers
-            Setup(gameConfig);
-            //Load in game specific Layers and Settings
+            // Setup the Core Layers
+            Setup();
+            // Load in game specific Layers and Settings
             gameConfig.DeserializeSettings();
+        } else {
+            // Use default Airship values if we aren't setting up game specific values
+            // Debug.Log("No custom GameConfig settings found. Resetting to defaults");
+            ResetDefaults();
         }
 #endif
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg.easy.airship",
-  "version": "0.1.2176",
+  "version": "0.1.2177",
   "displayName": "Airship",
   "unity": "2021.3",
   "unityRelease": "12f1",