From 27d8253928bb4cdb0e2839ced86eb2a1352ce15a Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 10:52:12 +0000
Subject: [PATCH 01/15] Tidy up InitialiseOnLoad

---
 Editor/InitialiseOnLoad.cs | 167 +++++++++++++++----------------------
 1 file changed, 68 insertions(+), 99 deletions(-)

diff --git a/Editor/InitialiseOnLoad.cs b/Editor/InitialiseOnLoad.cs
index 3c9f6c30..900a8c7f 100644
--- a/Editor/InitialiseOnLoad.cs
+++ b/Editor/InitialiseOnLoad.cs
@@ -1,83 +1,15 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using UnityEditor;
-using UnityEditor.PackageManager;
-using UnityEditor.PackageManager.Requests;
 using UnityEngine;
+using Banter.SDK;
 
 namespace Banter.SDKEditor
 {
-    public class InitialiseOnLoad
+    [InitializeOnLoad]
+    public static class InitialiseOnLoad
     {
-        public static Dictionary<int, string> layersToAdd = new Dictionary<int, string> {
-            { 3, "UserLayer1" },
-            { 6, "UserLayer2" },
-            { 7, "UserLayer3" },
-            { 8, "UserLayer4" },
-            { 9, "UserLayer5" },
-            { 10, "UserLayer6" },
-            { 11, "UserLayer7" },
-            { 12, "UserLayer8" },
-            { 13, "UserLayer9" },
-            { 14, "UserLayer10" },
-            { 15, "UserLayer11" },
-            { 16, "UserLayer12" },
-            { 17, "NetworkPlayer" },
-            { 18, "RPMAvatarHead" },
-            { 19, "RPMAvatarBody" },
-            { 20, "Grabbable" },
-            { 21, "HandColliders" },
-            { 22, "Menu" },
-            { 23, "PhysicsPlayer" },
-            { 24, "BanterInternal1_DONTUSE" },
-            { 25, "BanterInternal2_DONTUSE" },
-            { 26, "BanterInternal3_DONTUSE" },
-            { 27, "BanterInternal4_DONTUSE" },
-            { 28, "BanterInternal5_DONTUSE" },
-            { 29, "BanterInternal6_DONTUSE" },
-            { 30, "BanterInternal7_DONTUSE" },
-            { 31, "BanterInternal8_DONTUSE" }
-        };
-
-        public static Dictionary<int, string> tagsToAdd = new Dictionary<int, string> {
-            { 0,  "__BA_NameTag" },
-            { 1,  "__BA_NameTagMenu" },
-            { 2,  "__BA_FootRig" },
-            { 3,  "__BA_PlayerHead" },
-            { 4,  "__BA_UNUSED0" },
-            { 5,  "__BA_UNUSED1" },
-            { 6,  "__BA_TriggerIndex" },
-            { 7,  "__BA_PlayerTorso" },
-            { 8,  "__BA_PlayerLegs" },
-            { 9,  "__BA_LocalPlayer" },
-            { 10, "__BA_PlayerLeftHand" },
-            { 11, "__BA_PlayerRightHand" },
-            { 12, "__BA_LocalPlayerFeet" },
-            { 13, "__BA_UserTag0" },
-            { 14, "__BA_UserTag1" },
-            { 15, "__BA_UserTag2" },
-            { 16, "__BA_UserTag3" },
-            { 17, "__BA_UserTag4" },
-            { 18, "__BA_UserTag5" },
-            { 19, "__BA_UserTag6" },
-            { 20, "__BA_UserTag7" },
-            { 21, "__BA_UserTag8" },
-            { 22, "__BA_UserTag9" },
-            { 23, "__BA_UserTag10" },
-            { 24, "__BA_UserTag11" },
-            { 25, "__BA_UserTag12" },
-            { 26, "__BA_UserTag13" },
-            { 27, "__BA_UserTag14" },
-            { 28, "MenuWorldSpace" },
-            { 29, "VRPlayerContextMenu" },
-            { 30, "PortalBall" },
-        };
-
-        static AddRequest Request;
-        [InitializeOnLoadMethod()]
-        static void Go()
+        static InitialiseOnLoad()
         {
             SetupLayersAndTags();
             CreateWebRoot();
@@ -172,36 +104,73 @@ static void AddTagManagerObjectAt(SerializedProperty prop, string semantic, int
 
             // set layer name at index
             var element = prop.GetArrayElementAtIndex(index);
-            // if (string.IsNullOrEmpty(element.stringValue))
-            // {
+
             element.stringValue = name;
             Debug.Log($"Added {semantic} '{name}' at index {index}.");
-            // }
-            // else
-            // {
-            //     Debug.LogWarning("Could not add layer at index " + index + " because there already is another layer '" + element.stringValue + "'." );
-
-            //     if (tryOtherIndex)
-            //     {
-            //         // Go up in layer indices and try to find an empty spot.
-            //         for (int i = index + 1; i < 32; ++i)
-            //         {
-            //             // Extend layers if necessary
-            //             if (i >= layers.arraySize)
-            //                 layers.arraySize = i + 1;
+        }
 
-            //             element = layers.GetArrayElementAtIndex(i);
-            //             if (string.IsNullOrEmpty(element.stringValue))
-            //             {
-            //                 element.stringValue = layerName;
-            //                 Debug.Log("Added layer '" + layerName + "' at index " + i + " instead of " + index + ".");
-            //                 return;
-            //             }
-            //         }
+        public static Dictionary<int, string> layersToAdd = new Dictionary<int, string> {
+            { 3, "UserLayer1" },
+            { 6, "UserLayer2" },
+            { 7, "UserLayer3" },
+            { 8, "UserLayer4" },
+            { 9, "UserLayer5" },
+            { 10, "UserLayer6" },
+            { 11, "UserLayer7" },
+            { 12, "UserLayer8" },
+            { 13, "UserLayer9" },
+            { 14, "UserLayer10" },
+            { 15, "UserLayer11" },
+            { 16, "UserLayer12" },
+            { 17, "NetworkPlayer" },
+            { 18, "RPMAvatarHead" },
+            { 19, "RPMAvatarBody" },
+            { 20, "Grabbable" },
+            { 21, "HandColliders" },
+            { 22, "Menu" },
+            { 23, "PhysicsPlayer" },
+            { 24, "BanterInternal1_DONTUSE" },
+            { 25, "BanterInternal2_DONTUSE" },
+            { 26, "BanterInternal3_DONTUSE" },
+            { 27, "BanterInternal4_DONTUSE" },
+            { 28, "BanterInternal5_DONTUSE" },
+            { 29, "BanterInternal6_DONTUSE" },
+            { 30, "BanterInternal7_DONTUSE" },
+            { 31, "BanterInternal8_DONTUSE" }
+        };
 
-            //         Debug.LogError("Could not add layer " + layerName + " because there is no space left in the layers array.");
-            //     }
-            // }
-        }
+        public static Dictionary<int, string> tagsToAdd = new Dictionary<int, string> {
+            { 0,  "__BA_NameTag" },
+            { 1,  "__BA_NameTagMenu" },
+            { 2,  "__BA_FootRig" },
+            { 3,  "__BA_PlayerHead" },
+            { 4,  "__BA_UNUSED0" },
+            { 5,  "__BA_UNUSED1" },
+            { 6,  "__BA_TriggerIndex" },
+            { 7,  "__BA_PlayerTorso" },
+            { 8,  "__BA_PlayerLegs" },
+            { 9,  "__BA_LocalPlayer" },
+            { 10, "__BA_PlayerLeftHand" },
+            { 11, "__BA_PlayerRightHand" },
+            { 12, "__BA_LocalPlayerFeet" },
+            { 13, "__BA_UserTag0" },
+            { 14, "__BA_UserTag1" },
+            { 15, "__BA_UserTag2" },
+            { 16, "__BA_UserTag3" },
+            { 17, "__BA_UserTag4" },
+            { 18, "__BA_UserTag5" },
+            { 19, "__BA_UserTag6" },
+            { 20, "__BA_UserTag7" },
+            { 21, "__BA_UserTag8" },
+            { 22, "__BA_UserTag9" },
+            { 23, "__BA_UserTag10" },
+            { 24, "__BA_UserTag11" },
+            { 25, "__BA_UserTag12" },
+            { 26, "__BA_UserTag13" },
+            { 27, "__BA_UserTag14" },
+            { 28, "MenuWorldSpace" },
+            { 29, "VRPlayerContextMenu" },
+            { 30, "PortalBall" },
+        };
     }
 }

From 3ce6835fe5a273d572c1caeeb087e3a3793c6adf Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 10:54:55 +0000
Subject: [PATCH 02/15] Add BanterStarterUpper automatically if not present

Fixes BANTS-1042
---
 Editor/InitialiseOnLoad.cs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/Editor/InitialiseOnLoad.cs b/Editor/InitialiseOnLoad.cs
index 900a8c7f..2feee2b8 100644
--- a/Editor/InitialiseOnLoad.cs
+++ b/Editor/InitialiseOnLoad.cs
@@ -11,8 +11,23 @@ public static class InitialiseOnLoad
     {
         static InitialiseOnLoad()
         {
+#if !BANTER_EDITOR
             SetupLayersAndTags();
             CreateWebRoot();
+            EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
+#endif
+        }
+
+        private static void OnPlayModeStateChanged(PlayModeStateChange change)
+        {
+            if (change == PlayModeStateChange.EnteredPlayMode)
+            {
+                if (Object.FindObjectOfType<BanterStarterUpper>() == null)
+                {
+                    var go = new GameObject("BanterStarterUpper");
+                    go.AddComponent<BanterStarterUpper>();
+                }
+            }
         }
 
         static void CreateWebRoot()

From 31ec94dc860d34602c9389cc10ea212a77f4e85f Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 11:00:52 +0000
Subject: [PATCH 03/15] Rename class

---
 Editor/Resources/Builder/BuilderWindow.cs                    | 2 +-
 Editor/{InitialiseOnLoad.cs => SDKInitialiseOnLoad.cs}       | 5 +++--
 ...{InitialiseOnLoad.cs.meta => SDKInitialiseOnLoad.cs.meta} | 0
 3 files changed, 4 insertions(+), 3 deletions(-)
 rename Editor/{InitialiseOnLoad.cs => SDKInitialiseOnLoad.cs} (97%)
 rename Editor/{InitialiseOnLoad.cs.meta => SDKInitialiseOnLoad.cs.meta} (100%)

diff --git a/Editor/Resources/Builder/BuilderWindow.cs b/Editor/Resources/Builder/BuilderWindow.cs
index 1d04156e..7f79d604 100644
--- a/Editor/Resources/Builder/BuilderWindow.cs
+++ b/Editor/Resources/Builder/BuilderWindow.cs
@@ -625,7 +625,7 @@ private void SetupUI()
         Remove(rootVisualElement.Q<Button>("compileInjection"));
         Remove(rootVisualElement.Q<Button>("kitchenSink"));
 
-        rootVisualElement.Q<Button>("setupLayers").clicked += () => InitialiseOnLoad.SetupLayersAndTags();
+        rootVisualElement.Q<Button>("setupLayers").clicked += () => SDKInitializeOnLoad.SetupLayersAndTags();
 #endif
 
 #if BANTER_VISUAL_SCRIPTING
diff --git a/Editor/InitialiseOnLoad.cs b/Editor/SDKInitialiseOnLoad.cs
similarity index 97%
rename from Editor/InitialiseOnLoad.cs
rename to Editor/SDKInitialiseOnLoad.cs
index 2feee2b8..297472d6 100644
--- a/Editor/InitialiseOnLoad.cs
+++ b/Editor/SDKInitialiseOnLoad.cs
@@ -7,9 +7,9 @@
 namespace Banter.SDKEditor
 {
     [InitializeOnLoad]
-    public static class InitialiseOnLoad
+    public static class SDKInitializeOnLoad
     {
-        static InitialiseOnLoad()
+        static SDKInitializeOnLoad()
         {
 #if !BANTER_EDITOR
             SetupLayersAndTags();
@@ -24,6 +24,7 @@ private static void OnPlayModeStateChanged(PlayModeStateChange change)
             {
                 if (Object.FindObjectOfType<BanterStarterUpper>() == null)
                 {
+                    Debug.LogWarning("BanterStarterUpper not found, adding one.");
                     var go = new GameObject("BanterStarterUpper");
                     go.AddComponent<BanterStarterUpper>();
                 }
diff --git a/Editor/InitialiseOnLoad.cs.meta b/Editor/SDKInitialiseOnLoad.cs.meta
similarity index 100%
rename from Editor/InitialiseOnLoad.cs.meta
rename to Editor/SDKInitialiseOnLoad.cs.meta

From c95c21c19c000b81501374b117d1ddfeb1d4f6ec Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 16:23:00 +0000
Subject: [PATCH 04/15] Fix broken ref in main project

whoops
---
 Editor/Resources/Builder/BuilderWindow.cs | 2 +-
 Editor/SDKInitialiseOnLoad.cs             | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Editor/Resources/Builder/BuilderWindow.cs b/Editor/Resources/Builder/BuilderWindow.cs
index 7f79d604..1d04156e 100644
--- a/Editor/Resources/Builder/BuilderWindow.cs
+++ b/Editor/Resources/Builder/BuilderWindow.cs
@@ -625,7 +625,7 @@ private void SetupUI()
         Remove(rootVisualElement.Q<Button>("compileInjection"));
         Remove(rootVisualElement.Q<Button>("kitchenSink"));
 
-        rootVisualElement.Q<Button>("setupLayers").clicked += () => SDKInitializeOnLoad.SetupLayersAndTags();
+        rootVisualElement.Q<Button>("setupLayers").clicked += () => InitialiseOnLoad.SetupLayersAndTags();
 #endif
 
 #if BANTER_VISUAL_SCRIPTING
diff --git a/Editor/SDKInitialiseOnLoad.cs b/Editor/SDKInitialiseOnLoad.cs
index 297472d6..3aa3fc0f 100644
--- a/Editor/SDKInitialiseOnLoad.cs
+++ b/Editor/SDKInitialiseOnLoad.cs
@@ -7,9 +7,9 @@
 namespace Banter.SDKEditor
 {
     [InitializeOnLoad]
-    public static class SDKInitializeOnLoad
+    public static class InitialiseOnLoad
     {
-        static SDKInitializeOnLoad()
+        static InitialiseOnLoad()
         {
 #if !BANTER_EDITOR
             SetupLayersAndTags();

From b6a84097904ca55dad62070815ab52b9ed005ecd Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 17:39:38 +0000
Subject: [PATCH 05/15] DataBridge for main proj to override

BANTS-1047
---
 Runtime/Scripts/Scene/BanterScene.cs          |  1 +
 Runtime/Scripts/Utils/DataBridge.cs           | 14 +++++++++++
 Runtime/Scripts/Utils/DataBridge.cs.meta      | 11 +++++++++
 VisualScripting/Space/IsSpaceFavourited.cs    | 24 +++++++++++++++++++
 .../Space/IsSpaceFavourited.cs.meta           | 11 +++++++++
 5 files changed, 61 insertions(+)
 create mode 100644 Runtime/Scripts/Utils/DataBridge.cs
 create mode 100644 Runtime/Scripts/Utils/DataBridge.cs.meta
 create mode 100644 VisualScripting/Space/IsSpaceFavourited.cs
 create mode 100644 VisualScripting/Space/IsSpaceFavourited.cs.meta

diff --git a/Runtime/Scripts/Scene/BanterScene.cs b/Runtime/Scripts/Scene/BanterScene.cs
index 1965a9c5..7310030a 100644
--- a/Runtime/Scripts/Scene/BanterScene.cs
+++ b/Runtime/Scripts/Scene/BanterScene.cs
@@ -69,6 +69,7 @@ public class BanterScene
         public InputActionMap RightHandActions;
         public List<UserData> users = new List<UserData>();
         public List<GameObject> kitItems = new List<GameObject>();
+        public DataBridge data = new DataBridge();
         // SpaceState spaceState = new SpaceState();
         public bool loaded = false;
         public bool bundlesLoaded = false;
diff --git a/Runtime/Scripts/Utils/DataBridge.cs b/Runtime/Scripts/Utils/DataBridge.cs
new file mode 100644
index 00000000..7a572225
--- /dev/null
+++ b/Runtime/Scripts/Utils/DataBridge.cs
@@ -0,0 +1,14 @@
+using System;
+using UnityEngine;
+
+namespace Banter.SDK
+{
+    /// <summary>
+    /// DataBridge exists to give the SDK access to data
+    /// that can't be accessed outside the Banter client itself.
+    /// </summary>
+    public class DataBridge
+    {
+        public Func<bool> IsSpaceFavourited = () => false;
+    }
+}
diff --git a/Runtime/Scripts/Utils/DataBridge.cs.meta b/Runtime/Scripts/Utils/DataBridge.cs.meta
new file mode 100644
index 00000000..88187aec
--- /dev/null
+++ b/Runtime/Scripts/Utils/DataBridge.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4a5bf7245a3643479c135f60fcc0c6d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VisualScripting/Space/IsSpaceFavourited.cs b/VisualScripting/Space/IsSpaceFavourited.cs
new file mode 100644
index 00000000..1d1dbf97
--- /dev/null
+++ b/VisualScripting/Space/IsSpaceFavourited.cs
@@ -0,0 +1,24 @@
+#if BANTER_VISUAL_SCRIPTING
+using Unity.VisualScripting;
+using Banter.SDK;
+
+namespace Banter.VisualScripting
+{
+    [UnitTitle("Is Space Favourited")]
+    [UnitShortTitle("Space Favourited?")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class IsSpaceFavourited : Unit
+    {
+        [DoNotSerialize]
+        public ValueOutput isFavourited;
+
+        protected override void Definition()
+        {
+            isFavourited = ValueOutput<bool>("isFavourited", flow => {
+                return BanterScene.Instance().data.IsSpaceFavourited();
+            });
+        }
+    }
+}
+#endif
diff --git a/VisualScripting/Space/IsSpaceFavourited.cs.meta b/VisualScripting/Space/IsSpaceFavourited.cs.meta
new file mode 100644
index 00000000..fced54a1
--- /dev/null
+++ b/VisualScripting/Space/IsSpaceFavourited.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3005e93b18d782a4282050e5b5c6bfff
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From 26bc9cd70b282afed2c522c05e78f07385c40c49 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 25 Nov 2024 17:59:02 +0000
Subject: [PATCH 06/15] IsSpaceOwner

Stub for BANTS-1057
---
 Runtime/Scripts/Utils/DataBridge.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Runtime/Scripts/Utils/DataBridge.cs b/Runtime/Scripts/Utils/DataBridge.cs
index 7a572225..87730128 100644
--- a/Runtime/Scripts/Utils/DataBridge.cs
+++ b/Runtime/Scripts/Utils/DataBridge.cs
@@ -10,5 +10,6 @@ namespace Banter.SDK
     public class DataBridge
     {
         public Func<bool> IsSpaceFavourited = () => false;
+        public Func<bool> IsSpaceOwner = () => false;
     }
 }

From aec3212a1e0e5dc579389bcea3f8dfebd8942967 Mon Sep 17 00:00:00 2001
From: Gareth Williams <gareth@garethw.net>
Date: Wed, 27 Nov 2024 17:23:58 +0000
Subject: [PATCH 07/15] BANTS-935 Make SDK message counter ubiquitous and
 publicly available on BanterPipe

---
 Runtime/Scripts/BanterLink/AndroidPipe.cs      |  8 +++-----
 Runtime/Scripts/BanterLink/BanterPipe.cs       |  3 +++
 Runtime/Scripts/BanterLink/DebuggingClasses.cs | 14 +++++++-------
 Runtime/Scripts/BanterLink/ElectronPipe.cs     |  6 ++----
 4 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/Runtime/Scripts/BanterLink/AndroidPipe.cs b/Runtime/Scripts/BanterLink/AndroidPipe.cs
index 4ee250b9..753b95d3 100644
--- a/Runtime/Scripts/BanterLink/AndroidPipe.cs
+++ b/Runtime/Scripts/BanterLink/AndroidPipe.cs
@@ -8,9 +8,7 @@ namespace Banter.SDK
     public class AndroidPipe : BanterPipe
     {
         AndroidJavaObject activity;
-
-        private CountingLogger incomingLogger = new CountingLogger("AndroidPipe: Web -> Unity");
-        private CountingLogger outgoingLogger = new CountingLogger("AndroidPipe: Unity -> Web");
+        
         private CountingLogger fromAndroid = new CountingLogger("AndroidPipe: from android -> unity");
         private BanterSocketClient socketClient;
         public override void Start(Action connectedCallback, Action<string> msgCallback)
@@ -20,7 +18,7 @@ public override void Start(Action connectedCallback, Action<string> msgCallback)
             var aframe = new AframeCallback();
             aframe.SetCallback(str =>
             {
-                // incomingLogger.Add();
+                IncomingLogger.Add();
 
                 if (str == "A")
                 {
@@ -101,7 +99,7 @@ public override void Send(string msg)
             AndroidJNI.AttachCurrentThread();
             if (activity != null)
             {
-                // outgoingLogger.Add();
+                OutgoingLogger.Add();
                 activity.Call("sendMessage", msg);
             }
         }
diff --git a/Runtime/Scripts/BanterLink/BanterPipe.cs b/Runtime/Scripts/BanterLink/BanterPipe.cs
index d562ac64..877cfc6e 100644
--- a/Runtime/Scripts/BanterLink/BanterPipe.cs
+++ b/Runtime/Scripts/BanterLink/BanterPipe.cs
@@ -1,8 +1,11 @@
 using System;
 using System.Threading.Tasks;
+using Banter.SDK;
 
 public abstract class BanterPipe
 {
+    public CountingLogger IncomingLogger = new CountingLogger("Pipe: Web -> Unity");
+    public CountingLogger OutgoingLogger = new CountingLogger("Pipe: Unity -> Web");
     public abstract void Start(Action connectedCallback, Action<string> msgCallback);
     public abstract void Stop();
     public abstract void Send(string msg);
diff --git a/Runtime/Scripts/BanterLink/DebuggingClasses.cs b/Runtime/Scripts/BanterLink/DebuggingClasses.cs
index b1a407c3..1873e4fe 100644
--- a/Runtime/Scripts/BanterLink/DebuggingClasses.cs
+++ b/Runtime/Scripts/BanterLink/DebuggingClasses.cs
@@ -40,21 +40,21 @@ public CountingLogger(string name)
         private const double LOG_INTERVAL_SEC = 1;
         public string Name { get; private set; }
 
-        private long totalCount = 0;
+        public long TotalCount = 0;
         // private double firstStartStamp = 0;
 
         private double lastStamp = 0;
-        private long lastCount = 0;
+        public long LastCount = 0;
 
         private bool started = false;
 
         private void DumpLog(double nextStamp)
         {
             var delta = nextStamp - lastStamp;
-            string logstr = $"Counter {Name}: {lastCount} in {delta:F2} ({(lastCount / delta):F2}/sec), {totalCount} total";
-            lastCount = 0;
+            string logstr = $"Counter {Name}: {LastCount} in {delta:F2} ({(LastCount / delta):F2}/sec), {TotalCount} total";
+            LastCount = 0;
             lastStamp = nextStamp;
-            Debug.Log(logstr);
+            //Debug.Log(logstr);
         }
 
 
@@ -62,8 +62,8 @@ public void Add(int num = 1)
         {
             try
             {
-                totalCount += num;
-                lastCount += num;
+                TotalCount += num;
+                LastCount += num;
 
                 if (!started)
                 {
diff --git a/Runtime/Scripts/BanterLink/ElectronPipe.cs b/Runtime/Scripts/BanterLink/ElectronPipe.cs
index b9e4817a..1fe1af5d 100644
--- a/Runtime/Scripts/BanterLink/ElectronPipe.cs
+++ b/Runtime/Scripts/BanterLink/ElectronPipe.cs
@@ -10,8 +10,6 @@
 
 public class ElectronPipe : BanterPipe
 {
-    private CountingLogger incomingLogger = new CountingLogger("ElectronPipe: Web -> Unity");
-    private CountingLogger outgoingLogger = new CountingLogger("ElectronPipe: Unity -> Web");
     private Thread SenderThread;
     private object _SenderThreadLock = new object();
     private ConcurrentQueue<string> toSendQueue = new ConcurrentQueue<string>();
@@ -156,7 +154,7 @@ public void ReadThread(Action<string> callback)
                     if (read > 0)
                     {
                         var strResult = Encoding.Default.GetString(result);
-                        // incomingLogger.Add();
+                        IncomingLogger.Add();
                         callback(strResult);
                     }
                 }
@@ -196,7 +194,7 @@ private void QueueSend(string data)
                                 byte[] concat = new byte[b.Length + blen.Length];
                                 Buffer.BlockCopy(blen, 0, concat, 0, 4);
                                 Buffer.BlockCopy(b, 0, concat, 4, b.Length);
-                                // outgoingLogger.Add();
+                                OutgoingLogger.Add();
                                 SendMessage(concat);
                             }
                             else

From 42d70195a0f38126c0a9799a4ab9ca201ad1bf0e Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Wed, 27 Nov 2024 18:05:59 +0000
Subject: [PATCH 08/15] pre-commit

---
 Runtime/Scripts/BanterLink/AndroidPipe.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Runtime/Scripts/BanterLink/AndroidPipe.cs b/Runtime/Scripts/BanterLink/AndroidPipe.cs
index 753b95d3..3448c1eb 100644
--- a/Runtime/Scripts/BanterLink/AndroidPipe.cs
+++ b/Runtime/Scripts/BanterLink/AndroidPipe.cs
@@ -8,7 +8,7 @@ namespace Banter.SDK
     public class AndroidPipe : BanterPipe
     {
         AndroidJavaObject activity;
-        
+
         private CountingLogger fromAndroid = new CountingLogger("AndroidPipe: from android -> unity");
         private BanterSocketClient socketClient;
         public override void Start(Action connectedCallback, Action<string> msgCallback)

From e79f065494c2c4f0cf3866766e0cb2b12a76c4b7 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Mon, 2 Dec 2024 14:46:20 +0000
Subject: [PATCH 09/15] Feature/sprint1 vs updates (#76)

* Fix banterstarterupper instantiate time

* stubs update

BANTS-1081, BANTS-1082, BANTS-1083

* Load Data nodes

BANTS-1049, BANTS-1050

* portal url node

* Set Avatar

BANTS-1053

* browser open

BANTS-1063
---
 Editor/SDKInitialiseOnLoad.cs                 |    2 +-
 .../VisualScripting/VsNodeGeneration.cs       |    2 +
 .../Scripts/VisualScripting/VsStubsAllowed.cs | 1452 +++++++++++++++++
 Runtime/Scripts/Scene/BanterSceneEvents.cs    |    2 +
 VisualScripting/Space/SetPortalUrl.cs         |   45 +
 VisualScripting/Space/SetPortalUrl.cs.meta    |   11 +
 VisualScripting/User/SetAvatar.cs             |   40 +
 VisualScripting/User/SetAvatar.cs.meta        |   11 +
 VisualScripting/Utils/BrowserOpenUrl.cs       |   73 +
 VisualScripting/Utils/BrowserOpenUrl.cs.meta  |   11 +
 VisualScripting/Utils/LoadDataFromUrl.cs      |  125 ++
 VisualScripting/Utils/LoadDataFromUrl.cs.meta |   11 +
 12 files changed, 1784 insertions(+), 1 deletion(-)
 create mode 100644 VisualScripting/Space/SetPortalUrl.cs
 create mode 100644 VisualScripting/Space/SetPortalUrl.cs.meta
 create mode 100644 VisualScripting/User/SetAvatar.cs
 create mode 100644 VisualScripting/User/SetAvatar.cs.meta
 create mode 100644 VisualScripting/Utils/BrowserOpenUrl.cs
 create mode 100644 VisualScripting/Utils/BrowserOpenUrl.cs.meta
 create mode 100644 VisualScripting/Utils/LoadDataFromUrl.cs
 create mode 100644 VisualScripting/Utils/LoadDataFromUrl.cs.meta

diff --git a/Editor/SDKInitialiseOnLoad.cs b/Editor/SDKInitialiseOnLoad.cs
index 3aa3fc0f..648887ab 100644
--- a/Editor/SDKInitialiseOnLoad.cs
+++ b/Editor/SDKInitialiseOnLoad.cs
@@ -20,7 +20,7 @@ static InitialiseOnLoad()
 
         private static void OnPlayModeStateChanged(PlayModeStateChange change)
         {
-            if (change == PlayModeStateChange.EnteredPlayMode)
+            if (change == PlayModeStateChange.ExitingEditMode)
             {
                 if (Object.FindObjectOfType<BanterStarterUpper>() == null)
                 {
diff --git a/Editor/Scripts/VisualScripting/VsNodeGeneration.cs b/Editor/Scripts/VisualScripting/VsNodeGeneration.cs
index 32feeba4..425c1a5b 100644
--- a/Editor/Scripts/VisualScripting/VsNodeGeneration.cs
+++ b/Editor/Scripts/VisualScripting/VsNodeGeneration.cs
@@ -102,6 +102,8 @@ private static string SetJSONArrayValueHelper(this string target, string arrayCo
             "UnityEngine",
             "UnityEngine.CoreModule",
             "UnityEngine.PhysicsModule",
+            "UnityEngine.Physics2DModule",
+            "UnityEngine.VehiclesModule",
             "UnityEngine.AudioModule",
             "UnityEngine.AnimationModule",
             "UnityEngine.VideoModule",
diff --git a/Editor/Scripts/VisualScripting/VsStubsAllowed.cs b/Editor/Scripts/VisualScripting/VsStubsAllowed.cs
index 5da148b9..34540fc1 100644
--- a/Editor/Scripts/VisualScripting/VsStubsAllowed.cs
+++ b/Editor/Scripts/VisualScripting/VsStubsAllowed.cs
@@ -1482,6 +1482,7 @@ public struct VsStubsAllowed
             "UnityEngine.AnimationCurve.CopyFrom",
             "UnityEngine.AnimationCurve.ToString",
             "UnityEngine.AnimationCurve.ReferenceEquals",
+            "UnityEngine.AnimationCurve..ctor",
             "UnityEngine.AnimationCurve.keys",
             "UnityEngine.AnimationCurve.length",
             "UnityEngine.AnimationCurve.preWrapMode",
@@ -1758,6 +1759,13 @@ public struct VsStubsAllowed
             "UnityEngine.Ray..ctor",
             "UnityEngine.Ray.origin",
             "UnityEngine.Ray.direction",
+            "UnityEngine.Ray2D.GetPoint",
+            "UnityEngine.Ray2D.ToString",
+            "UnityEngine.Ray2D.Equals",
+            "UnityEngine.Ray2D.ReferenceEquals",
+            "UnityEngine.Ray2D..ctor",
+            "UnityEngine.Ray2D.origin",
+            "UnityEngine.Ray2D.direction",
             "UnityEngine.Rect.MinMaxRect",
             "UnityEngine.Rect.Set",
             "UnityEngine.Rect.Contains",
@@ -5152,6 +5160,1383 @@ public struct VsStubsAllowed
             "UnityEngine.ContactPoint.thisCollider",
             "UnityEngine.ContactPoint.otherCollider",
             "UnityEngine.ContactPoint.separation",
+            "UnityEngine.Physics2D.Simulate",
+            "UnityEngine.Physics2D.SyncTransforms",
+            "UnityEngine.Physics2D.IgnoreCollision",
+            "UnityEngine.Physics2D.GetIgnoreCollision",
+            "UnityEngine.Physics2D.IgnoreLayerCollision",
+            "UnityEngine.Physics2D.GetIgnoreLayerCollision",
+            "UnityEngine.Physics2D.SetLayerCollisionMask",
+            "UnityEngine.Physics2D.GetLayerCollisionMask",
+            "UnityEngine.Physics2D.IsTouching",
+            "UnityEngine.Physics2D.IsTouchingLayers",
+            "UnityEngine.Physics2D.Distance",
+            "UnityEngine.Physics2D.ClosestPoint",
+            "UnityEngine.Physics2D.Linecast",
+            "UnityEngine.Physics2D.LinecastAll",
+            "UnityEngine.Physics2D.LinecastNonAlloc",
+            "UnityEngine.Physics2D.Raycast",
+            "UnityEngine.Physics2D.RaycastNonAlloc",
+            "UnityEngine.Physics2D.RaycastAll",
+            "UnityEngine.Physics2D.CircleCast",
+            "UnityEngine.Physics2D.CircleCastAll",
+            "UnityEngine.Physics2D.CircleCastNonAlloc",
+            "UnityEngine.Physics2D.BoxCast",
+            "UnityEngine.Physics2D.BoxCastAll",
+            "UnityEngine.Physics2D.BoxCastNonAlloc",
+            "UnityEngine.Physics2D.CapsuleCast",
+            "UnityEngine.Physics2D.CapsuleCastAll",
+            "UnityEngine.Physics2D.CapsuleCastNonAlloc",
+            "UnityEngine.Physics2D.GetRayIntersection",
+            "UnityEngine.Physics2D.GetRayIntersectionAll",
+            "UnityEngine.Physics2D.GetRayIntersectionNonAlloc",
+            "UnityEngine.Physics2D.OverlapPoint",
+            "UnityEngine.Physics2D.OverlapPointAll",
+            "UnityEngine.Physics2D.OverlapPointNonAlloc",
+            "UnityEngine.Physics2D.OverlapCircle",
+            "UnityEngine.Physics2D.OverlapCircleAll",
+            "UnityEngine.Physics2D.OverlapCircleNonAlloc",
+            "UnityEngine.Physics2D.OverlapBox",
+            "UnityEngine.Physics2D.OverlapBoxAll",
+            "UnityEngine.Physics2D.OverlapBoxNonAlloc",
+            "UnityEngine.Physics2D.OverlapArea",
+            "UnityEngine.Physics2D.OverlapAreaAll",
+            "UnityEngine.Physics2D.OverlapAreaNonAlloc",
+            "UnityEngine.Physics2D.OverlapCapsule",
+            "UnityEngine.Physics2D.OverlapCapsuleAll",
+            "UnityEngine.Physics2D.OverlapCapsuleNonAlloc",
+            "UnityEngine.Physics2D.OverlapCollider",
+            "UnityEngine.Physics2D.GetContacts",
+            "UnityEngine.Physics2D.Equals",
+            "UnityEngine.Physics2D.ToString",
+            "UnityEngine.Physics2D.ReferenceEquals",
+            "UnityEngine.Physics2D..ctor",
+            "UnityEngine.Physics2D.defaultPhysicsScene",
+            "UnityEngine.Physics2D.velocityIterations",
+            "UnityEngine.Physics2D.positionIterations",
+            "UnityEngine.Physics2D.gravity",
+            "UnityEngine.Physics2D.queriesHitTriggers",
+            "UnityEngine.Physics2D.queriesStartInColliders",
+            "UnityEngine.Physics2D.callbacksOnDisable",
+            "UnityEngine.Physics2D.reuseCollisionCallbacks",
+            "UnityEngine.Physics2D.autoSyncTransforms",
+            "UnityEngine.Physics2D.simulationMode",
+            "UnityEngine.Physics2D.jobOptions",
+            "UnityEngine.Physics2D.velocityThreshold",
+            "UnityEngine.Physics2D.maxLinearCorrection",
+            "UnityEngine.Physics2D.maxAngularCorrection",
+            "UnityEngine.Physics2D.maxTranslationSpeed",
+            "UnityEngine.Physics2D.maxRotationSpeed",
+            "UnityEngine.Physics2D.defaultContactOffset",
+            "UnityEngine.Physics2D.baumgarteScale",
+            "UnityEngine.Physics2D.baumgarteTOIScale",
+            "UnityEngine.Physics2D.timeToSleep",
+            "UnityEngine.Physics2D.linearSleepTolerance",
+            "UnityEngine.Physics2D.angularSleepTolerance",
+            "UnityEngine.Physics2D.IgnoreRaycastLayer",
+            "UnityEngine.Physics2D.DefaultRaycastLayers",
+            "UnityEngine.Physics2D.AllLayers",
+            "UnityEngine.Physics2D.MaxPolygonShapeVertices",
+            "UnityEngine.ContactPoint2D.Equals",
+            "UnityEngine.ContactPoint2D.ToString",
+            "UnityEngine.ContactPoint2D.ReferenceEquals",
+            "UnityEngine.ContactPoint2D.point",
+            "UnityEngine.ContactPoint2D.normal",
+            "UnityEngine.ContactPoint2D.separation",
+            "UnityEngine.ContactPoint2D.normalImpulse",
+            "UnityEngine.ContactPoint2D.tangentImpulse",
+            "UnityEngine.ContactPoint2D.relativeVelocity",
+            "UnityEngine.ContactPoint2D.collider",
+            "UnityEngine.ContactPoint2D.otherCollider",
+            "UnityEngine.ContactPoint2D.rigidbody",
+            "UnityEngine.ContactPoint2D.otherRigidbody",
+            "UnityEngine.ContactPoint2D.enabled",
+            "UnityEngine.RaycastHit2D.op_Implicit",
+            "UnityEngine.RaycastHit2D.CompareTo",
+            "UnityEngine.RaycastHit2D.Equals",
+            "UnityEngine.RaycastHit2D.ToString",
+            "UnityEngine.RaycastHit2D.ReferenceEquals",
+            "UnityEngine.RaycastHit2D.centroid",
+            "UnityEngine.RaycastHit2D.point",
+            "UnityEngine.RaycastHit2D.normal",
+            "UnityEngine.RaycastHit2D.distance",
+            "UnityEngine.RaycastHit2D.fraction",
+            "UnityEngine.RaycastHit2D.collider",
+            "UnityEngine.RaycastHit2D.rigidbody",
+            "UnityEngine.RaycastHit2D.transform",
+            "UnityEngine.Rigidbody2D.SetRotation",
+            "UnityEngine.Rigidbody2D.MovePosition",
+            "UnityEngine.Rigidbody2D.MoveRotation",
+            "UnityEngine.Rigidbody2D.IsSleeping",
+            "UnityEngine.Rigidbody2D.IsAwake",
+            "UnityEngine.Rigidbody2D.Sleep",
+            "UnityEngine.Rigidbody2D.WakeUp",
+            "UnityEngine.Rigidbody2D.IsTouching",
+            "UnityEngine.Rigidbody2D.IsTouchingLayers",
+            "UnityEngine.Rigidbody2D.OverlapPoint",
+            "UnityEngine.Rigidbody2D.Distance",
+            "UnityEngine.Rigidbody2D.ClosestPoint",
+            "UnityEngine.Rigidbody2D.AddForce",
+            "UnityEngine.Rigidbody2D.AddRelativeForce",
+            "UnityEngine.Rigidbody2D.AddForceAtPosition",
+            "UnityEngine.Rigidbody2D.AddTorque",
+            "UnityEngine.Rigidbody2D.GetPoint",
+            "UnityEngine.Rigidbody2D.GetRelativePoint",
+            "UnityEngine.Rigidbody2D.GetVector",
+            "UnityEngine.Rigidbody2D.GetRelativeVector",
+            "UnityEngine.Rigidbody2D.GetPointVelocity",
+            "UnityEngine.Rigidbody2D.GetRelativePointVelocity",
+            "UnityEngine.Rigidbody2D.OverlapCollider",
+            "UnityEngine.Rigidbody2D.GetContacts",
+            "UnityEngine.Rigidbody2D.GetAttachedColliders",
+            "UnityEngine.Rigidbody2D.Cast",
+            "UnityEngine.Rigidbody2D.GetShapes",
+            "UnityEngine.Rigidbody2D.GetComponent",
+            "UnityEngine.Rigidbody2D.GetComponentInChildren",
+            "UnityEngine.Rigidbody2D.GetComponentsInChildren",
+            "UnityEngine.Rigidbody2D.GetComponentInParent",
+            "UnityEngine.Rigidbody2D.GetComponentsInParent",
+            "UnityEngine.Rigidbody2D.GetComponents",
+            "UnityEngine.Rigidbody2D.GetComponentIndex",
+            "UnityEngine.Rigidbody2D.CompareTag",
+            "UnityEngine.Rigidbody2D.Equals",
+            "UnityEngine.Rigidbody2D.op_Implicit",
+            "UnityEngine.Rigidbody2D.Instantiate",
+            "UnityEngine.Rigidbody2D.Destroy",
+            "UnityEngine.Rigidbody2D.FindObjectsByType",
+            "UnityEngine.Rigidbody2D.FindFirstObjectByType",
+            "UnityEngine.Rigidbody2D.FindAnyObjectByType",
+            "UnityEngine.Rigidbody2D.ToString",
+            "UnityEngine.Rigidbody2D.ReferenceEquals",
+            "UnityEngine.Rigidbody2D.position",
+            "UnityEngine.Rigidbody2D.rotation",
+            "UnityEngine.Rigidbody2D.velocity",
+            "UnityEngine.Rigidbody2D.angularVelocity",
+            "UnityEngine.Rigidbody2D.useAutoMass",
+            "UnityEngine.Rigidbody2D.mass",
+            "UnityEngine.Rigidbody2D.sharedMaterial",
+            "UnityEngine.Rigidbody2D.centerOfMass",
+            "UnityEngine.Rigidbody2D.worldCenterOfMass",
+            "UnityEngine.Rigidbody2D.inertia",
+            "UnityEngine.Rigidbody2D.drag",
+            "UnityEngine.Rigidbody2D.angularDrag",
+            "UnityEngine.Rigidbody2D.gravityScale",
+            "UnityEngine.Rigidbody2D.bodyType",
+            "UnityEngine.Rigidbody2D.useFullKinematicContacts",
+            "UnityEngine.Rigidbody2D.isKinematic",
+            "UnityEngine.Rigidbody2D.freezeRotation",
+            "UnityEngine.Rigidbody2D.constraints",
+            "UnityEngine.Rigidbody2D.simulated",
+            "UnityEngine.Rigidbody2D.interpolation",
+            "UnityEngine.Rigidbody2D.sleepMode",
+            "UnityEngine.Rigidbody2D.collisionDetectionMode",
+            "UnityEngine.Rigidbody2D.attachedColliderCount",
+            "UnityEngine.Rigidbody2D.totalForce",
+            "UnityEngine.Rigidbody2D.totalTorque",
+            "UnityEngine.Rigidbody2D.excludeLayers",
+            "UnityEngine.Rigidbody2D.includeLayers",
+            "UnityEngine.Rigidbody2D.transform",
+            "UnityEngine.Rigidbody2D.gameObject",
+            "UnityEngine.Rigidbody2D.tag",
+            "UnityEngine.Rigidbody2D.name",
+            "UnityEngine.Rigidbody2D.hideFlags",
+            "UnityEngine.Collider2D.CreateMesh",
+            "UnityEngine.Collider2D.GetShapeHash",
+            "UnityEngine.Collider2D.GetShapes",
+            "UnityEngine.Collider2D.IsTouching",
+            "UnityEngine.Collider2D.IsTouchingLayers",
+            "UnityEngine.Collider2D.OverlapPoint",
+            "UnityEngine.Collider2D.Distance",
+            "UnityEngine.Collider2D.OverlapCollider",
+            "UnityEngine.Collider2D.GetContacts",
+            "UnityEngine.Collider2D.Cast",
+            "UnityEngine.Collider2D.Raycast",
+            "UnityEngine.Collider2D.ClosestPoint",
+            "UnityEngine.Collider2D.GetComponent",
+            "UnityEngine.Collider2D.GetComponentInChildren",
+            "UnityEngine.Collider2D.GetComponentsInChildren",
+            "UnityEngine.Collider2D.GetComponentInParent",
+            "UnityEngine.Collider2D.GetComponentsInParent",
+            "UnityEngine.Collider2D.GetComponents",
+            "UnityEngine.Collider2D.GetComponentIndex",
+            "UnityEngine.Collider2D.CompareTag",
+            "UnityEngine.Collider2D.Equals",
+            "UnityEngine.Collider2D.op_Implicit",
+            "UnityEngine.Collider2D.Instantiate",
+            "UnityEngine.Collider2D.Destroy",
+            "UnityEngine.Collider2D.FindObjectsByType",
+            "UnityEngine.Collider2D.FindFirstObjectByType",
+            "UnityEngine.Collider2D.FindAnyObjectByType",
+            "UnityEngine.Collider2D.ToString",
+            "UnityEngine.Collider2D.ReferenceEquals",
+            "UnityEngine.Collider2D.density",
+            "UnityEngine.Collider2D.isTrigger",
+            "UnityEngine.Collider2D.usedByEffector",
+            "UnityEngine.Collider2D.usedByComposite",
+            "UnityEngine.Collider2D.composite",
+            "UnityEngine.Collider2D.offset",
+            "UnityEngine.Collider2D.attachedRigidbody",
+            "UnityEngine.Collider2D.shapeCount",
+            "UnityEngine.Collider2D.bounds",
+            "UnityEngine.Collider2D.errorState",
+            "UnityEngine.Collider2D.sharedMaterial",
+            "UnityEngine.Collider2D.layerOverridePriority",
+            "UnityEngine.Collider2D.excludeLayers",
+            "UnityEngine.Collider2D.includeLayers",
+            "UnityEngine.Collider2D.forceSendLayers",
+            "UnityEngine.Collider2D.forceReceiveLayers",
+            "UnityEngine.Collider2D.contactCaptureLayers",
+            "UnityEngine.Collider2D.callbackLayers",
+            "UnityEngine.Collider2D.friction",
+            "UnityEngine.Collider2D.bounciness",
+            "UnityEngine.Collider2D.enabled",
+            "UnityEngine.Collider2D.isActiveAndEnabled",
+            "UnityEngine.Collider2D.transform",
+            "UnityEngine.Collider2D.gameObject",
+            "UnityEngine.Collider2D.tag",
+            "UnityEngine.Collider2D.name",
+            "UnityEngine.Collider2D.hideFlags",
+            "UnityEngine.CustomCollider2D.GetCustomShapes",
+            "UnityEngine.CustomCollider2D.SetCustomShapes",
+            "UnityEngine.CustomCollider2D.SetCustomShape",
+            "UnityEngine.CustomCollider2D.ClearCustomShapes",
+            "UnityEngine.CustomCollider2D.CreateMesh",
+            "UnityEngine.CustomCollider2D.GetShapeHash",
+            "UnityEngine.CustomCollider2D.GetShapes",
+            "UnityEngine.CustomCollider2D.IsTouching",
+            "UnityEngine.CustomCollider2D.IsTouchingLayers",
+            "UnityEngine.CustomCollider2D.OverlapPoint",
+            "UnityEngine.CustomCollider2D.Distance",
+            "UnityEngine.CustomCollider2D.OverlapCollider",
+            "UnityEngine.CustomCollider2D.GetContacts",
+            "UnityEngine.CustomCollider2D.Cast",
+            "UnityEngine.CustomCollider2D.Raycast",
+            "UnityEngine.CustomCollider2D.ClosestPoint",
+            "UnityEngine.CustomCollider2D.GetComponent",
+            "UnityEngine.CustomCollider2D.GetComponentInChildren",
+            "UnityEngine.CustomCollider2D.GetComponentsInChildren",
+            "UnityEngine.CustomCollider2D.GetComponentInParent",
+            "UnityEngine.CustomCollider2D.GetComponentsInParent",
+            "UnityEngine.CustomCollider2D.GetComponents",
+            "UnityEngine.CustomCollider2D.GetComponentIndex",
+            "UnityEngine.CustomCollider2D.CompareTag",
+            "UnityEngine.CustomCollider2D.Equals",
+            "UnityEngine.CustomCollider2D.op_Implicit",
+            "UnityEngine.CustomCollider2D.Instantiate",
+            "UnityEngine.CustomCollider2D.Destroy",
+            "UnityEngine.CustomCollider2D.FindObjectsByType",
+            "UnityEngine.CustomCollider2D.FindFirstObjectByType",
+            "UnityEngine.CustomCollider2D.FindAnyObjectByType",
+            "UnityEngine.CustomCollider2D.ToString",
+            "UnityEngine.CustomCollider2D.ReferenceEquals",
+            "UnityEngine.CustomCollider2D.customShapeCount",
+            "UnityEngine.CustomCollider2D.customVertexCount",
+            "UnityEngine.CustomCollider2D.density",
+            "UnityEngine.CustomCollider2D.isTrigger",
+            "UnityEngine.CustomCollider2D.usedByEffector",
+            "UnityEngine.CustomCollider2D.usedByComposite",
+            "UnityEngine.CustomCollider2D.composite",
+            "UnityEngine.CustomCollider2D.offset",
+            "UnityEngine.CustomCollider2D.attachedRigidbody",
+            "UnityEngine.CustomCollider2D.shapeCount",
+            "UnityEngine.CustomCollider2D.bounds",
+            "UnityEngine.CustomCollider2D.errorState",
+            "UnityEngine.CustomCollider2D.sharedMaterial",
+            "UnityEngine.CustomCollider2D.layerOverridePriority",
+            "UnityEngine.CustomCollider2D.excludeLayers",
+            "UnityEngine.CustomCollider2D.includeLayers",
+            "UnityEngine.CustomCollider2D.forceSendLayers",
+            "UnityEngine.CustomCollider2D.forceReceiveLayers",
+            "UnityEngine.CustomCollider2D.contactCaptureLayers",
+            "UnityEngine.CustomCollider2D.callbackLayers",
+            "UnityEngine.CustomCollider2D.friction",
+            "UnityEngine.CustomCollider2D.bounciness",
+            "UnityEngine.CustomCollider2D.enabled",
+            "UnityEngine.CustomCollider2D.isActiveAndEnabled",
+            "UnityEngine.CustomCollider2D.transform",
+            "UnityEngine.CustomCollider2D.gameObject",
+            "UnityEngine.CustomCollider2D.tag",
+            "UnityEngine.CustomCollider2D.name",
+            "UnityEngine.CustomCollider2D.hideFlags",
+            "UnityEngine.CircleCollider2D.CreateMesh",
+            "UnityEngine.CircleCollider2D.GetShapeHash",
+            "UnityEngine.CircleCollider2D.GetShapes",
+            "UnityEngine.CircleCollider2D.IsTouching",
+            "UnityEngine.CircleCollider2D.IsTouchingLayers",
+            "UnityEngine.CircleCollider2D.OverlapPoint",
+            "UnityEngine.CircleCollider2D.Distance",
+            "UnityEngine.CircleCollider2D.OverlapCollider",
+            "UnityEngine.CircleCollider2D.GetContacts",
+            "UnityEngine.CircleCollider2D.Cast",
+            "UnityEngine.CircleCollider2D.Raycast",
+            "UnityEngine.CircleCollider2D.ClosestPoint",
+            "UnityEngine.CircleCollider2D.GetComponent",
+            "UnityEngine.CircleCollider2D.GetComponentInChildren",
+            "UnityEngine.CircleCollider2D.GetComponentsInChildren",
+            "UnityEngine.CircleCollider2D.GetComponentInParent",
+            "UnityEngine.CircleCollider2D.GetComponentsInParent",
+            "UnityEngine.CircleCollider2D.GetComponents",
+            "UnityEngine.CircleCollider2D.GetComponentIndex",
+            "UnityEngine.CircleCollider2D.CompareTag",
+            "UnityEngine.CircleCollider2D.Equals",
+            "UnityEngine.CircleCollider2D.op_Implicit",
+            "UnityEngine.CircleCollider2D.Instantiate",
+            "UnityEngine.CircleCollider2D.Destroy",
+            "UnityEngine.CircleCollider2D.FindObjectsByType",
+            "UnityEngine.CircleCollider2D.FindFirstObjectByType",
+            "UnityEngine.CircleCollider2D.FindAnyObjectByType",
+            "UnityEngine.CircleCollider2D.ToString",
+            "UnityEngine.CircleCollider2D.ReferenceEquals",
+            "UnityEngine.CircleCollider2D.radius",
+            "UnityEngine.CircleCollider2D.density",
+            "UnityEngine.CircleCollider2D.isTrigger",
+            "UnityEngine.CircleCollider2D.usedByEffector",
+            "UnityEngine.CircleCollider2D.usedByComposite",
+            "UnityEngine.CircleCollider2D.composite",
+            "UnityEngine.CircleCollider2D.offset",
+            "UnityEngine.CircleCollider2D.attachedRigidbody",
+            "UnityEngine.CircleCollider2D.shapeCount",
+            "UnityEngine.CircleCollider2D.bounds",
+            "UnityEngine.CircleCollider2D.errorState",
+            "UnityEngine.CircleCollider2D.sharedMaterial",
+            "UnityEngine.CircleCollider2D.layerOverridePriority",
+            "UnityEngine.CircleCollider2D.excludeLayers",
+            "UnityEngine.CircleCollider2D.includeLayers",
+            "UnityEngine.CircleCollider2D.forceSendLayers",
+            "UnityEngine.CircleCollider2D.forceReceiveLayers",
+            "UnityEngine.CircleCollider2D.contactCaptureLayers",
+            "UnityEngine.CircleCollider2D.callbackLayers",
+            "UnityEngine.CircleCollider2D.friction",
+            "UnityEngine.CircleCollider2D.bounciness",
+            "UnityEngine.CircleCollider2D.enabled",
+            "UnityEngine.CircleCollider2D.isActiveAndEnabled",
+            "UnityEngine.CircleCollider2D.transform",
+            "UnityEngine.CircleCollider2D.gameObject",
+            "UnityEngine.CircleCollider2D.tag",
+            "UnityEngine.CircleCollider2D.name",
+            "UnityEngine.CircleCollider2D.hideFlags",
+            "UnityEngine.CapsuleCollider2D.CreateMesh",
+            "UnityEngine.CapsuleCollider2D.GetShapeHash",
+            "UnityEngine.CapsuleCollider2D.GetShapes",
+            "UnityEngine.CapsuleCollider2D.IsTouching",
+            "UnityEngine.CapsuleCollider2D.IsTouchingLayers",
+            "UnityEngine.CapsuleCollider2D.OverlapPoint",
+            "UnityEngine.CapsuleCollider2D.Distance",
+            "UnityEngine.CapsuleCollider2D.OverlapCollider",
+            "UnityEngine.CapsuleCollider2D.GetContacts",
+            "UnityEngine.CapsuleCollider2D.Cast",
+            "UnityEngine.CapsuleCollider2D.Raycast",
+            "UnityEngine.CapsuleCollider2D.ClosestPoint",
+            "UnityEngine.CapsuleCollider2D.GetComponent",
+            "UnityEngine.CapsuleCollider2D.GetComponentInChildren",
+            "UnityEngine.CapsuleCollider2D.GetComponentsInChildren",
+            "UnityEngine.CapsuleCollider2D.GetComponentInParent",
+            "UnityEngine.CapsuleCollider2D.GetComponentsInParent",
+            "UnityEngine.CapsuleCollider2D.GetComponents",
+            "UnityEngine.CapsuleCollider2D.GetComponentIndex",
+            "UnityEngine.CapsuleCollider2D.CompareTag",
+            "UnityEngine.CapsuleCollider2D.Equals",
+            "UnityEngine.CapsuleCollider2D.op_Implicit",
+            "UnityEngine.CapsuleCollider2D.Instantiate",
+            "UnityEngine.CapsuleCollider2D.Destroy",
+            "UnityEngine.CapsuleCollider2D.FindObjectsByType",
+            "UnityEngine.CapsuleCollider2D.FindFirstObjectByType",
+            "UnityEngine.CapsuleCollider2D.FindAnyObjectByType",
+            "UnityEngine.CapsuleCollider2D.ToString",
+            "UnityEngine.CapsuleCollider2D.ReferenceEquals",
+            "UnityEngine.CapsuleCollider2D.size",
+            "UnityEngine.CapsuleCollider2D.direction",
+            "UnityEngine.CapsuleCollider2D.density",
+            "UnityEngine.CapsuleCollider2D.isTrigger",
+            "UnityEngine.CapsuleCollider2D.usedByEffector",
+            "UnityEngine.CapsuleCollider2D.usedByComposite",
+            "UnityEngine.CapsuleCollider2D.composite",
+            "UnityEngine.CapsuleCollider2D.offset",
+            "UnityEngine.CapsuleCollider2D.attachedRigidbody",
+            "UnityEngine.CapsuleCollider2D.shapeCount",
+            "UnityEngine.CapsuleCollider2D.bounds",
+            "UnityEngine.CapsuleCollider2D.errorState",
+            "UnityEngine.CapsuleCollider2D.sharedMaterial",
+            "UnityEngine.CapsuleCollider2D.layerOverridePriority",
+            "UnityEngine.CapsuleCollider2D.excludeLayers",
+            "UnityEngine.CapsuleCollider2D.includeLayers",
+            "UnityEngine.CapsuleCollider2D.forceSendLayers",
+            "UnityEngine.CapsuleCollider2D.forceReceiveLayers",
+            "UnityEngine.CapsuleCollider2D.contactCaptureLayers",
+            "UnityEngine.CapsuleCollider2D.callbackLayers",
+            "UnityEngine.CapsuleCollider2D.friction",
+            "UnityEngine.CapsuleCollider2D.bounciness",
+            "UnityEngine.CapsuleCollider2D.enabled",
+            "UnityEngine.CapsuleCollider2D.isActiveAndEnabled",
+            "UnityEngine.CapsuleCollider2D.transform",
+            "UnityEngine.CapsuleCollider2D.gameObject",
+            "UnityEngine.CapsuleCollider2D.tag",
+            "UnityEngine.CapsuleCollider2D.name",
+            "UnityEngine.CapsuleCollider2D.hideFlags",
+            "UnityEngine.EdgeCollider2D.Reset",
+            "UnityEngine.EdgeCollider2D.GetPoints",
+            "UnityEngine.EdgeCollider2D.SetPoints",
+            "UnityEngine.EdgeCollider2D.CreateMesh",
+            "UnityEngine.EdgeCollider2D.GetShapeHash",
+            "UnityEngine.EdgeCollider2D.GetShapes",
+            "UnityEngine.EdgeCollider2D.IsTouching",
+            "UnityEngine.EdgeCollider2D.IsTouchingLayers",
+            "UnityEngine.EdgeCollider2D.OverlapPoint",
+            "UnityEngine.EdgeCollider2D.Distance",
+            "UnityEngine.EdgeCollider2D.OverlapCollider",
+            "UnityEngine.EdgeCollider2D.GetContacts",
+            "UnityEngine.EdgeCollider2D.Cast",
+            "UnityEngine.EdgeCollider2D.Raycast",
+            "UnityEngine.EdgeCollider2D.ClosestPoint",
+            "UnityEngine.EdgeCollider2D.GetComponent",
+            "UnityEngine.EdgeCollider2D.GetComponentInChildren",
+            "UnityEngine.EdgeCollider2D.GetComponentsInChildren",
+            "UnityEngine.EdgeCollider2D.GetComponentInParent",
+            "UnityEngine.EdgeCollider2D.GetComponentsInParent",
+            "UnityEngine.EdgeCollider2D.GetComponents",
+            "UnityEngine.EdgeCollider2D.GetComponentIndex",
+            "UnityEngine.EdgeCollider2D.CompareTag",
+            "UnityEngine.EdgeCollider2D.Equals",
+            "UnityEngine.EdgeCollider2D.op_Implicit",
+            "UnityEngine.EdgeCollider2D.Instantiate",
+            "UnityEngine.EdgeCollider2D.Destroy",
+            "UnityEngine.EdgeCollider2D.FindObjectsByType",
+            "UnityEngine.EdgeCollider2D.FindFirstObjectByType",
+            "UnityEngine.EdgeCollider2D.FindAnyObjectByType",
+            "UnityEngine.EdgeCollider2D.ToString",
+            "UnityEngine.EdgeCollider2D.ReferenceEquals",
+            "UnityEngine.EdgeCollider2D.edgeRadius",
+            "UnityEngine.EdgeCollider2D.edgeCount",
+            "UnityEngine.EdgeCollider2D.pointCount",
+            "UnityEngine.EdgeCollider2D.points",
+            "UnityEngine.EdgeCollider2D.useAdjacentStartPoint",
+            "UnityEngine.EdgeCollider2D.useAdjacentEndPoint",
+            "UnityEngine.EdgeCollider2D.adjacentStartPoint",
+            "UnityEngine.EdgeCollider2D.adjacentEndPoint",
+            "UnityEngine.EdgeCollider2D.density",
+            "UnityEngine.EdgeCollider2D.isTrigger",
+            "UnityEngine.EdgeCollider2D.usedByEffector",
+            "UnityEngine.EdgeCollider2D.usedByComposite",
+            "UnityEngine.EdgeCollider2D.composite",
+            "UnityEngine.EdgeCollider2D.offset",
+            "UnityEngine.EdgeCollider2D.attachedRigidbody",
+            "UnityEngine.EdgeCollider2D.shapeCount",
+            "UnityEngine.EdgeCollider2D.bounds",
+            "UnityEngine.EdgeCollider2D.errorState",
+            "UnityEngine.EdgeCollider2D.sharedMaterial",
+            "UnityEngine.EdgeCollider2D.layerOverridePriority",
+            "UnityEngine.EdgeCollider2D.excludeLayers",
+            "UnityEngine.EdgeCollider2D.includeLayers",
+            "UnityEngine.EdgeCollider2D.forceSendLayers",
+            "UnityEngine.EdgeCollider2D.forceReceiveLayers",
+            "UnityEngine.EdgeCollider2D.contactCaptureLayers",
+            "UnityEngine.EdgeCollider2D.callbackLayers",
+            "UnityEngine.EdgeCollider2D.friction",
+            "UnityEngine.EdgeCollider2D.bounciness",
+            "UnityEngine.EdgeCollider2D.enabled",
+            "UnityEngine.EdgeCollider2D.isActiveAndEnabled",
+            "UnityEngine.EdgeCollider2D.transform",
+            "UnityEngine.EdgeCollider2D.gameObject",
+            "UnityEngine.EdgeCollider2D.tag",
+            "UnityEngine.EdgeCollider2D.name",
+            "UnityEngine.EdgeCollider2D.hideFlags",
+            "UnityEngine.BoxCollider2D.CreateMesh",
+            "UnityEngine.BoxCollider2D.GetShapeHash",
+            "UnityEngine.BoxCollider2D.GetShapes",
+            "UnityEngine.BoxCollider2D.IsTouching",
+            "UnityEngine.BoxCollider2D.IsTouchingLayers",
+            "UnityEngine.BoxCollider2D.OverlapPoint",
+            "UnityEngine.BoxCollider2D.Distance",
+            "UnityEngine.BoxCollider2D.OverlapCollider",
+            "UnityEngine.BoxCollider2D.GetContacts",
+            "UnityEngine.BoxCollider2D.Cast",
+            "UnityEngine.BoxCollider2D.Raycast",
+            "UnityEngine.BoxCollider2D.ClosestPoint",
+            "UnityEngine.BoxCollider2D.GetComponent",
+            "UnityEngine.BoxCollider2D.GetComponentInChildren",
+            "UnityEngine.BoxCollider2D.GetComponentsInChildren",
+            "UnityEngine.BoxCollider2D.GetComponentInParent",
+            "UnityEngine.BoxCollider2D.GetComponentsInParent",
+            "UnityEngine.BoxCollider2D.GetComponents",
+            "UnityEngine.BoxCollider2D.GetComponentIndex",
+            "UnityEngine.BoxCollider2D.CompareTag",
+            "UnityEngine.BoxCollider2D.Equals",
+            "UnityEngine.BoxCollider2D.op_Implicit",
+            "UnityEngine.BoxCollider2D.Instantiate",
+            "UnityEngine.BoxCollider2D.Destroy",
+            "UnityEngine.BoxCollider2D.FindObjectsByType",
+            "UnityEngine.BoxCollider2D.FindFirstObjectByType",
+            "UnityEngine.BoxCollider2D.FindAnyObjectByType",
+            "UnityEngine.BoxCollider2D.ToString",
+            "UnityEngine.BoxCollider2D.ReferenceEquals",
+            "UnityEngine.BoxCollider2D.size",
+            "UnityEngine.BoxCollider2D.edgeRadius",
+            "UnityEngine.BoxCollider2D.autoTiling",
+            "UnityEngine.BoxCollider2D.density",
+            "UnityEngine.BoxCollider2D.isTrigger",
+            "UnityEngine.BoxCollider2D.usedByEffector",
+            "UnityEngine.BoxCollider2D.usedByComposite",
+            "UnityEngine.BoxCollider2D.composite",
+            "UnityEngine.BoxCollider2D.offset",
+            "UnityEngine.BoxCollider2D.attachedRigidbody",
+            "UnityEngine.BoxCollider2D.shapeCount",
+            "UnityEngine.BoxCollider2D.bounds",
+            "UnityEngine.BoxCollider2D.errorState",
+            "UnityEngine.BoxCollider2D.sharedMaterial",
+            "UnityEngine.BoxCollider2D.layerOverridePriority",
+            "UnityEngine.BoxCollider2D.excludeLayers",
+            "UnityEngine.BoxCollider2D.includeLayers",
+            "UnityEngine.BoxCollider2D.forceSendLayers",
+            "UnityEngine.BoxCollider2D.forceReceiveLayers",
+            "UnityEngine.BoxCollider2D.contactCaptureLayers",
+            "UnityEngine.BoxCollider2D.callbackLayers",
+            "UnityEngine.BoxCollider2D.friction",
+            "UnityEngine.BoxCollider2D.bounciness",
+            "UnityEngine.BoxCollider2D.enabled",
+            "UnityEngine.BoxCollider2D.isActiveAndEnabled",
+            "UnityEngine.BoxCollider2D.transform",
+            "UnityEngine.BoxCollider2D.gameObject",
+            "UnityEngine.BoxCollider2D.tag",
+            "UnityEngine.BoxCollider2D.name",
+            "UnityEngine.BoxCollider2D.hideFlags",
+            "UnityEngine.PolygonCollider2D.GetTotalPointCount",
+            "UnityEngine.PolygonCollider2D.GetPath",
+            "UnityEngine.PolygonCollider2D.SetPath",
+            "UnityEngine.PolygonCollider2D.CreatePrimitive",
+            "UnityEngine.PolygonCollider2D.CreateMesh",
+            "UnityEngine.PolygonCollider2D.GetShapeHash",
+            "UnityEngine.PolygonCollider2D.GetShapes",
+            "UnityEngine.PolygonCollider2D.IsTouching",
+            "UnityEngine.PolygonCollider2D.IsTouchingLayers",
+            "UnityEngine.PolygonCollider2D.OverlapPoint",
+            "UnityEngine.PolygonCollider2D.Distance",
+            "UnityEngine.PolygonCollider2D.OverlapCollider",
+            "UnityEngine.PolygonCollider2D.GetContacts",
+            "UnityEngine.PolygonCollider2D.Cast",
+            "UnityEngine.PolygonCollider2D.Raycast",
+            "UnityEngine.PolygonCollider2D.ClosestPoint",
+            "UnityEngine.PolygonCollider2D.GetComponent",
+            "UnityEngine.PolygonCollider2D.GetComponentInChildren",
+            "UnityEngine.PolygonCollider2D.GetComponentsInChildren",
+            "UnityEngine.PolygonCollider2D.GetComponentInParent",
+            "UnityEngine.PolygonCollider2D.GetComponentsInParent",
+            "UnityEngine.PolygonCollider2D.GetComponents",
+            "UnityEngine.PolygonCollider2D.GetComponentIndex",
+            "UnityEngine.PolygonCollider2D.CompareTag",
+            "UnityEngine.PolygonCollider2D.Equals",
+            "UnityEngine.PolygonCollider2D.op_Implicit",
+            "UnityEngine.PolygonCollider2D.Instantiate",
+            "UnityEngine.PolygonCollider2D.Destroy",
+            "UnityEngine.PolygonCollider2D.FindObjectsByType",
+            "UnityEngine.PolygonCollider2D.FindFirstObjectByType",
+            "UnityEngine.PolygonCollider2D.FindAnyObjectByType",
+            "UnityEngine.PolygonCollider2D.ToString",
+            "UnityEngine.PolygonCollider2D.ReferenceEquals",
+            "UnityEngine.PolygonCollider2D.useDelaunayMesh",
+            "UnityEngine.PolygonCollider2D.autoTiling",
+            "UnityEngine.PolygonCollider2D.points",
+            "UnityEngine.PolygonCollider2D.pathCount",
+            "UnityEngine.PolygonCollider2D.density",
+            "UnityEngine.PolygonCollider2D.isTrigger",
+            "UnityEngine.PolygonCollider2D.usedByEffector",
+            "UnityEngine.PolygonCollider2D.usedByComposite",
+            "UnityEngine.PolygonCollider2D.composite",
+            "UnityEngine.PolygonCollider2D.offset",
+            "UnityEngine.PolygonCollider2D.attachedRigidbody",
+            "UnityEngine.PolygonCollider2D.shapeCount",
+            "UnityEngine.PolygonCollider2D.bounds",
+            "UnityEngine.PolygonCollider2D.errorState",
+            "UnityEngine.PolygonCollider2D.sharedMaterial",
+            "UnityEngine.PolygonCollider2D.layerOverridePriority",
+            "UnityEngine.PolygonCollider2D.excludeLayers",
+            "UnityEngine.PolygonCollider2D.includeLayers",
+            "UnityEngine.PolygonCollider2D.forceSendLayers",
+            "UnityEngine.PolygonCollider2D.forceReceiveLayers",
+            "UnityEngine.PolygonCollider2D.contactCaptureLayers",
+            "UnityEngine.PolygonCollider2D.callbackLayers",
+            "UnityEngine.PolygonCollider2D.friction",
+            "UnityEngine.PolygonCollider2D.bounciness",
+            "UnityEngine.PolygonCollider2D.enabled",
+            "UnityEngine.PolygonCollider2D.isActiveAndEnabled",
+            "UnityEngine.PolygonCollider2D.transform",
+            "UnityEngine.PolygonCollider2D.gameObject",
+            "UnityEngine.PolygonCollider2D.tag",
+            "UnityEngine.PolygonCollider2D.name",
+            "UnityEngine.PolygonCollider2D.hideFlags",
+            "UnityEngine.CompositeCollider2D.GenerateGeometry",
+            "UnityEngine.CompositeCollider2D.GetPathPointCount",
+            "UnityEngine.CompositeCollider2D.GetPath",
+            "UnityEngine.CompositeCollider2D.CreateMesh",
+            "UnityEngine.CompositeCollider2D.GetShapeHash",
+            "UnityEngine.CompositeCollider2D.GetShapes",
+            "UnityEngine.CompositeCollider2D.IsTouching",
+            "UnityEngine.CompositeCollider2D.IsTouchingLayers",
+            "UnityEngine.CompositeCollider2D.OverlapPoint",
+            "UnityEngine.CompositeCollider2D.Distance",
+            "UnityEngine.CompositeCollider2D.OverlapCollider",
+            "UnityEngine.CompositeCollider2D.GetContacts",
+            "UnityEngine.CompositeCollider2D.Cast",
+            "UnityEngine.CompositeCollider2D.Raycast",
+            "UnityEngine.CompositeCollider2D.ClosestPoint",
+            "UnityEngine.CompositeCollider2D.GetComponent",
+            "UnityEngine.CompositeCollider2D.GetComponentInChildren",
+            "UnityEngine.CompositeCollider2D.GetComponentsInChildren",
+            "UnityEngine.CompositeCollider2D.GetComponentInParent",
+            "UnityEngine.CompositeCollider2D.GetComponentsInParent",
+            "UnityEngine.CompositeCollider2D.GetComponents",
+            "UnityEngine.CompositeCollider2D.GetComponentIndex",
+            "UnityEngine.CompositeCollider2D.CompareTag",
+            "UnityEngine.CompositeCollider2D.Equals",
+            "UnityEngine.CompositeCollider2D.op_Implicit",
+            "UnityEngine.CompositeCollider2D.Instantiate",
+            "UnityEngine.CompositeCollider2D.Destroy",
+            "UnityEngine.CompositeCollider2D.FindObjectsByType",
+            "UnityEngine.CompositeCollider2D.FindFirstObjectByType",
+            "UnityEngine.CompositeCollider2D.FindAnyObjectByType",
+            "UnityEngine.CompositeCollider2D.ToString",
+            "UnityEngine.CompositeCollider2D.ReferenceEquals",
+            "UnityEngine.CompositeCollider2D.geometryType",
+            "UnityEngine.CompositeCollider2D.generationType",
+            "UnityEngine.CompositeCollider2D.useDelaunayMesh",
+            "UnityEngine.CompositeCollider2D.vertexDistance",
+            "UnityEngine.CompositeCollider2D.edgeRadius",
+            "UnityEngine.CompositeCollider2D.offsetDistance",
+            "UnityEngine.CompositeCollider2D.pathCount",
+            "UnityEngine.CompositeCollider2D.pointCount",
+            "UnityEngine.CompositeCollider2D.density",
+            "UnityEngine.CompositeCollider2D.isTrigger",
+            "UnityEngine.CompositeCollider2D.usedByEffector",
+            "UnityEngine.CompositeCollider2D.usedByComposite",
+            "UnityEngine.CompositeCollider2D.composite",
+            "UnityEngine.CompositeCollider2D.offset",
+            "UnityEngine.CompositeCollider2D.attachedRigidbody",
+            "UnityEngine.CompositeCollider2D.shapeCount",
+            "UnityEngine.CompositeCollider2D.bounds",
+            "UnityEngine.CompositeCollider2D.errorState",
+            "UnityEngine.CompositeCollider2D.sharedMaterial",
+            "UnityEngine.CompositeCollider2D.layerOverridePriority",
+            "UnityEngine.CompositeCollider2D.excludeLayers",
+            "UnityEngine.CompositeCollider2D.includeLayers",
+            "UnityEngine.CompositeCollider2D.forceSendLayers",
+            "UnityEngine.CompositeCollider2D.forceReceiveLayers",
+            "UnityEngine.CompositeCollider2D.contactCaptureLayers",
+            "UnityEngine.CompositeCollider2D.callbackLayers",
+            "UnityEngine.CompositeCollider2D.friction",
+            "UnityEngine.CompositeCollider2D.bounciness",
+            "UnityEngine.CompositeCollider2D.enabled",
+            "UnityEngine.CompositeCollider2D.isActiveAndEnabled",
+            "UnityEngine.CompositeCollider2D.transform",
+            "UnityEngine.CompositeCollider2D.gameObject",
+            "UnityEngine.CompositeCollider2D.tag",
+            "UnityEngine.CompositeCollider2D.name",
+            "UnityEngine.CompositeCollider2D.hideFlags",
+            "UnityEngine.Joint2D.GetReactionForce",
+            "UnityEngine.Joint2D.GetReactionTorque",
+            "UnityEngine.Joint2D.GetComponent",
+            "UnityEngine.Joint2D.GetComponentInChildren",
+            "UnityEngine.Joint2D.GetComponentsInChildren",
+            "UnityEngine.Joint2D.GetComponentInParent",
+            "UnityEngine.Joint2D.GetComponentsInParent",
+            "UnityEngine.Joint2D.GetComponents",
+            "UnityEngine.Joint2D.GetComponentIndex",
+            "UnityEngine.Joint2D.CompareTag",
+            "UnityEngine.Joint2D.Equals",
+            "UnityEngine.Joint2D.op_Implicit",
+            "UnityEngine.Joint2D.Instantiate",
+            "UnityEngine.Joint2D.Destroy",
+            "UnityEngine.Joint2D.FindObjectsByType",
+            "UnityEngine.Joint2D.FindFirstObjectByType",
+            "UnityEngine.Joint2D.FindAnyObjectByType",
+            "UnityEngine.Joint2D.ToString",
+            "UnityEngine.Joint2D.ReferenceEquals",
+            "UnityEngine.Joint2D.attachedRigidbody",
+            "UnityEngine.Joint2D.connectedBody",
+            "UnityEngine.Joint2D.enableCollision",
+            "UnityEngine.Joint2D.breakForce",
+            "UnityEngine.Joint2D.breakTorque",
+            "UnityEngine.Joint2D.breakAction",
+            "UnityEngine.Joint2D.reactionForce",
+            "UnityEngine.Joint2D.reactionTorque",
+            "UnityEngine.Joint2D.enabled",
+            "UnityEngine.Joint2D.isActiveAndEnabled",
+            "UnityEngine.Joint2D.transform",
+            "UnityEngine.Joint2D.gameObject",
+            "UnityEngine.Joint2D.tag",
+            "UnityEngine.Joint2D.name",
+            "UnityEngine.Joint2D.hideFlags",
+            "UnityEngine.AnchoredJoint2D.GetReactionForce",
+            "UnityEngine.AnchoredJoint2D.GetReactionTorque",
+            "UnityEngine.AnchoredJoint2D.GetComponent",
+            "UnityEngine.AnchoredJoint2D.GetComponentInChildren",
+            "UnityEngine.AnchoredJoint2D.GetComponentsInChildren",
+            "UnityEngine.AnchoredJoint2D.GetComponentInParent",
+            "UnityEngine.AnchoredJoint2D.GetComponentsInParent",
+            "UnityEngine.AnchoredJoint2D.GetComponents",
+            "UnityEngine.AnchoredJoint2D.GetComponentIndex",
+            "UnityEngine.AnchoredJoint2D.CompareTag",
+            "UnityEngine.AnchoredJoint2D.Equals",
+            "UnityEngine.AnchoredJoint2D.op_Implicit",
+            "UnityEngine.AnchoredJoint2D.Instantiate",
+            "UnityEngine.AnchoredJoint2D.Destroy",
+            "UnityEngine.AnchoredJoint2D.FindObjectsByType",
+            "UnityEngine.AnchoredJoint2D.FindFirstObjectByType",
+            "UnityEngine.AnchoredJoint2D.FindAnyObjectByType",
+            "UnityEngine.AnchoredJoint2D.ToString",
+            "UnityEngine.AnchoredJoint2D.ReferenceEquals",
+            "UnityEngine.AnchoredJoint2D.anchor",
+            "UnityEngine.AnchoredJoint2D.connectedAnchor",
+            "UnityEngine.AnchoredJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.AnchoredJoint2D.attachedRigidbody",
+            "UnityEngine.AnchoredJoint2D.connectedBody",
+            "UnityEngine.AnchoredJoint2D.enableCollision",
+            "UnityEngine.AnchoredJoint2D.breakForce",
+            "UnityEngine.AnchoredJoint2D.breakTorque",
+            "UnityEngine.AnchoredJoint2D.breakAction",
+            "UnityEngine.AnchoredJoint2D.reactionForce",
+            "UnityEngine.AnchoredJoint2D.reactionTorque",
+            "UnityEngine.AnchoredJoint2D.enabled",
+            "UnityEngine.AnchoredJoint2D.isActiveAndEnabled",
+            "UnityEngine.AnchoredJoint2D.transform",
+            "UnityEngine.AnchoredJoint2D.gameObject",
+            "UnityEngine.AnchoredJoint2D.tag",
+            "UnityEngine.AnchoredJoint2D.name",
+            "UnityEngine.AnchoredJoint2D.hideFlags",
+            "UnityEngine.SpringJoint2D.GetReactionForce",
+            "UnityEngine.SpringJoint2D.GetReactionTorque",
+            "UnityEngine.SpringJoint2D.GetComponent",
+            "UnityEngine.SpringJoint2D.GetComponentInChildren",
+            "UnityEngine.SpringJoint2D.GetComponentsInChildren",
+            "UnityEngine.SpringJoint2D.GetComponentInParent",
+            "UnityEngine.SpringJoint2D.GetComponentsInParent",
+            "UnityEngine.SpringJoint2D.GetComponents",
+            "UnityEngine.SpringJoint2D.GetComponentIndex",
+            "UnityEngine.SpringJoint2D.CompareTag",
+            "UnityEngine.SpringJoint2D.Equals",
+            "UnityEngine.SpringJoint2D.op_Implicit",
+            "UnityEngine.SpringJoint2D.Instantiate",
+            "UnityEngine.SpringJoint2D.Destroy",
+            "UnityEngine.SpringJoint2D.FindObjectsByType",
+            "UnityEngine.SpringJoint2D.FindFirstObjectByType",
+            "UnityEngine.SpringJoint2D.FindAnyObjectByType",
+            "UnityEngine.SpringJoint2D.ToString",
+            "UnityEngine.SpringJoint2D.ReferenceEquals",
+            "UnityEngine.SpringJoint2D.autoConfigureDistance",
+            "UnityEngine.SpringJoint2D.distance",
+            "UnityEngine.SpringJoint2D.dampingRatio",
+            "UnityEngine.SpringJoint2D.frequency",
+            "UnityEngine.SpringJoint2D.anchor",
+            "UnityEngine.SpringJoint2D.connectedAnchor",
+            "UnityEngine.SpringJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.SpringJoint2D.attachedRigidbody",
+            "UnityEngine.SpringJoint2D.connectedBody",
+            "UnityEngine.SpringJoint2D.enableCollision",
+            "UnityEngine.SpringJoint2D.breakForce",
+            "UnityEngine.SpringJoint2D.breakTorque",
+            "UnityEngine.SpringJoint2D.breakAction",
+            "UnityEngine.SpringJoint2D.reactionForce",
+            "UnityEngine.SpringJoint2D.reactionTorque",
+            "UnityEngine.SpringJoint2D.enabled",
+            "UnityEngine.SpringJoint2D.isActiveAndEnabled",
+            "UnityEngine.SpringJoint2D.transform",
+            "UnityEngine.SpringJoint2D.gameObject",
+            "UnityEngine.SpringJoint2D.tag",
+            "UnityEngine.SpringJoint2D.name",
+            "UnityEngine.SpringJoint2D.hideFlags",
+            "UnityEngine.DistanceJoint2D.GetReactionForce",
+            "UnityEngine.DistanceJoint2D.GetReactionTorque",
+            "UnityEngine.DistanceJoint2D.GetComponent",
+            "UnityEngine.DistanceJoint2D.GetComponentInChildren",
+            "UnityEngine.DistanceJoint2D.GetComponentsInChildren",
+            "UnityEngine.DistanceJoint2D.GetComponentInParent",
+            "UnityEngine.DistanceJoint2D.GetComponentsInParent",
+            "UnityEngine.DistanceJoint2D.GetComponents",
+            "UnityEngine.DistanceJoint2D.GetComponentIndex",
+            "UnityEngine.DistanceJoint2D.CompareTag",
+            "UnityEngine.DistanceJoint2D.Equals",
+            "UnityEngine.DistanceJoint2D.op_Implicit",
+            "UnityEngine.DistanceJoint2D.Instantiate",
+            "UnityEngine.DistanceJoint2D.Destroy",
+            "UnityEngine.DistanceJoint2D.FindObjectsByType",
+            "UnityEngine.DistanceJoint2D.FindFirstObjectByType",
+            "UnityEngine.DistanceJoint2D.FindAnyObjectByType",
+            "UnityEngine.DistanceJoint2D.ToString",
+            "UnityEngine.DistanceJoint2D.ReferenceEquals",
+            "UnityEngine.DistanceJoint2D.autoConfigureDistance",
+            "UnityEngine.DistanceJoint2D.distance",
+            "UnityEngine.DistanceJoint2D.maxDistanceOnly",
+            "UnityEngine.DistanceJoint2D.anchor",
+            "UnityEngine.DistanceJoint2D.connectedAnchor",
+            "UnityEngine.DistanceJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.DistanceJoint2D.attachedRigidbody",
+            "UnityEngine.DistanceJoint2D.connectedBody",
+            "UnityEngine.DistanceJoint2D.enableCollision",
+            "UnityEngine.DistanceJoint2D.breakForce",
+            "UnityEngine.DistanceJoint2D.breakTorque",
+            "UnityEngine.DistanceJoint2D.breakAction",
+            "UnityEngine.DistanceJoint2D.reactionForce",
+            "UnityEngine.DistanceJoint2D.reactionTorque",
+            "UnityEngine.DistanceJoint2D.enabled",
+            "UnityEngine.DistanceJoint2D.isActiveAndEnabled",
+            "UnityEngine.DistanceJoint2D.transform",
+            "UnityEngine.DistanceJoint2D.gameObject",
+            "UnityEngine.DistanceJoint2D.tag",
+            "UnityEngine.DistanceJoint2D.name",
+            "UnityEngine.DistanceJoint2D.hideFlags",
+            "UnityEngine.FrictionJoint2D.GetReactionForce",
+            "UnityEngine.FrictionJoint2D.GetReactionTorque",
+            "UnityEngine.FrictionJoint2D.GetComponent",
+            "UnityEngine.FrictionJoint2D.GetComponentInChildren",
+            "UnityEngine.FrictionJoint2D.GetComponentsInChildren",
+            "UnityEngine.FrictionJoint2D.GetComponentInParent",
+            "UnityEngine.FrictionJoint2D.GetComponentsInParent",
+            "UnityEngine.FrictionJoint2D.GetComponents",
+            "UnityEngine.FrictionJoint2D.GetComponentIndex",
+            "UnityEngine.FrictionJoint2D.CompareTag",
+            "UnityEngine.FrictionJoint2D.Equals",
+            "UnityEngine.FrictionJoint2D.op_Implicit",
+            "UnityEngine.FrictionJoint2D.Instantiate",
+            "UnityEngine.FrictionJoint2D.Destroy",
+            "UnityEngine.FrictionJoint2D.FindObjectsByType",
+            "UnityEngine.FrictionJoint2D.FindFirstObjectByType",
+            "UnityEngine.FrictionJoint2D.FindAnyObjectByType",
+            "UnityEngine.FrictionJoint2D.ToString",
+            "UnityEngine.FrictionJoint2D.ReferenceEquals",
+            "UnityEngine.FrictionJoint2D.maxForce",
+            "UnityEngine.FrictionJoint2D.maxTorque",
+            "UnityEngine.FrictionJoint2D.anchor",
+            "UnityEngine.FrictionJoint2D.connectedAnchor",
+            "UnityEngine.FrictionJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.FrictionJoint2D.attachedRigidbody",
+            "UnityEngine.FrictionJoint2D.connectedBody",
+            "UnityEngine.FrictionJoint2D.enableCollision",
+            "UnityEngine.FrictionJoint2D.breakForce",
+            "UnityEngine.FrictionJoint2D.breakTorque",
+            "UnityEngine.FrictionJoint2D.breakAction",
+            "UnityEngine.FrictionJoint2D.reactionForce",
+            "UnityEngine.FrictionJoint2D.reactionTorque",
+            "UnityEngine.FrictionJoint2D.enabled",
+            "UnityEngine.FrictionJoint2D.isActiveAndEnabled",
+            "UnityEngine.FrictionJoint2D.transform",
+            "UnityEngine.FrictionJoint2D.gameObject",
+            "UnityEngine.FrictionJoint2D.tag",
+            "UnityEngine.FrictionJoint2D.name",
+            "UnityEngine.FrictionJoint2D.hideFlags",
+            "UnityEngine.HingeJoint2D.GetMotorTorque",
+            "UnityEngine.HingeJoint2D.GetReactionForce",
+            "UnityEngine.HingeJoint2D.GetReactionTorque",
+            "UnityEngine.HingeJoint2D.GetComponent",
+            "UnityEngine.HingeJoint2D.GetComponentInChildren",
+            "UnityEngine.HingeJoint2D.GetComponentsInChildren",
+            "UnityEngine.HingeJoint2D.GetComponentInParent",
+            "UnityEngine.HingeJoint2D.GetComponentsInParent",
+            "UnityEngine.HingeJoint2D.GetComponents",
+            "UnityEngine.HingeJoint2D.GetComponentIndex",
+            "UnityEngine.HingeJoint2D.CompareTag",
+            "UnityEngine.HingeJoint2D.Equals",
+            "UnityEngine.HingeJoint2D.op_Implicit",
+            "UnityEngine.HingeJoint2D.Instantiate",
+            "UnityEngine.HingeJoint2D.Destroy",
+            "UnityEngine.HingeJoint2D.FindObjectsByType",
+            "UnityEngine.HingeJoint2D.FindFirstObjectByType",
+            "UnityEngine.HingeJoint2D.FindAnyObjectByType",
+            "UnityEngine.HingeJoint2D.ToString",
+            "UnityEngine.HingeJoint2D.ReferenceEquals",
+            "UnityEngine.HingeJoint2D.useMotor",
+            "UnityEngine.HingeJoint2D.useLimits",
+            "UnityEngine.HingeJoint2D.motor",
+            "UnityEngine.HingeJoint2D.limits",
+            "UnityEngine.HingeJoint2D.limitState",
+            "UnityEngine.HingeJoint2D.referenceAngle",
+            "UnityEngine.HingeJoint2D.jointAngle",
+            "UnityEngine.HingeJoint2D.jointSpeed",
+            "UnityEngine.HingeJoint2D.anchor",
+            "UnityEngine.HingeJoint2D.connectedAnchor",
+            "UnityEngine.HingeJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.HingeJoint2D.attachedRigidbody",
+            "UnityEngine.HingeJoint2D.connectedBody",
+            "UnityEngine.HingeJoint2D.enableCollision",
+            "UnityEngine.HingeJoint2D.breakForce",
+            "UnityEngine.HingeJoint2D.breakTorque",
+            "UnityEngine.HingeJoint2D.breakAction",
+            "UnityEngine.HingeJoint2D.reactionForce",
+            "UnityEngine.HingeJoint2D.reactionTorque",
+            "UnityEngine.HingeJoint2D.enabled",
+            "UnityEngine.HingeJoint2D.isActiveAndEnabled",
+            "UnityEngine.HingeJoint2D.transform",
+            "UnityEngine.HingeJoint2D.gameObject",
+            "UnityEngine.HingeJoint2D.tag",
+            "UnityEngine.HingeJoint2D.name",
+            "UnityEngine.HingeJoint2D.hideFlags",
+            "UnityEngine.RelativeJoint2D.GetReactionForce",
+            "UnityEngine.RelativeJoint2D.GetReactionTorque",
+            "UnityEngine.RelativeJoint2D.GetComponent",
+            "UnityEngine.RelativeJoint2D.GetComponentInChildren",
+            "UnityEngine.RelativeJoint2D.GetComponentsInChildren",
+            "UnityEngine.RelativeJoint2D.GetComponentInParent",
+            "UnityEngine.RelativeJoint2D.GetComponentsInParent",
+            "UnityEngine.RelativeJoint2D.GetComponents",
+            "UnityEngine.RelativeJoint2D.GetComponentIndex",
+            "UnityEngine.RelativeJoint2D.CompareTag",
+            "UnityEngine.RelativeJoint2D.Equals",
+            "UnityEngine.RelativeJoint2D.op_Implicit",
+            "UnityEngine.RelativeJoint2D.Instantiate",
+            "UnityEngine.RelativeJoint2D.Destroy",
+            "UnityEngine.RelativeJoint2D.FindObjectsByType",
+            "UnityEngine.RelativeJoint2D.FindFirstObjectByType",
+            "UnityEngine.RelativeJoint2D.FindAnyObjectByType",
+            "UnityEngine.RelativeJoint2D.ToString",
+            "UnityEngine.RelativeJoint2D.ReferenceEquals",
+            "UnityEngine.RelativeJoint2D.maxForce",
+            "UnityEngine.RelativeJoint2D.maxTorque",
+            "UnityEngine.RelativeJoint2D.correctionScale",
+            "UnityEngine.RelativeJoint2D.autoConfigureOffset",
+            "UnityEngine.RelativeJoint2D.linearOffset",
+            "UnityEngine.RelativeJoint2D.angularOffset",
+            "UnityEngine.RelativeJoint2D.target",
+            "UnityEngine.RelativeJoint2D.attachedRigidbody",
+            "UnityEngine.RelativeJoint2D.connectedBody",
+            "UnityEngine.RelativeJoint2D.enableCollision",
+            "UnityEngine.RelativeJoint2D.breakForce",
+            "UnityEngine.RelativeJoint2D.breakTorque",
+            "UnityEngine.RelativeJoint2D.breakAction",
+            "UnityEngine.RelativeJoint2D.reactionForce",
+            "UnityEngine.RelativeJoint2D.reactionTorque",
+            "UnityEngine.RelativeJoint2D.enabled",
+            "UnityEngine.RelativeJoint2D.isActiveAndEnabled",
+            "UnityEngine.RelativeJoint2D.transform",
+            "UnityEngine.RelativeJoint2D.gameObject",
+            "UnityEngine.RelativeJoint2D.tag",
+            "UnityEngine.RelativeJoint2D.name",
+            "UnityEngine.RelativeJoint2D.hideFlags",
+            "UnityEngine.SliderJoint2D.GetMotorForce",
+            "UnityEngine.SliderJoint2D.GetReactionForce",
+            "UnityEngine.SliderJoint2D.GetReactionTorque",
+            "UnityEngine.SliderJoint2D.GetComponent",
+            "UnityEngine.SliderJoint2D.GetComponentInChildren",
+            "UnityEngine.SliderJoint2D.GetComponentsInChildren",
+            "UnityEngine.SliderJoint2D.GetComponentInParent",
+            "UnityEngine.SliderJoint2D.GetComponentsInParent",
+            "UnityEngine.SliderJoint2D.GetComponents",
+            "UnityEngine.SliderJoint2D.GetComponentIndex",
+            "UnityEngine.SliderJoint2D.CompareTag",
+            "UnityEngine.SliderJoint2D.Equals",
+            "UnityEngine.SliderJoint2D.op_Implicit",
+            "UnityEngine.SliderJoint2D.Instantiate",
+            "UnityEngine.SliderJoint2D.Destroy",
+            "UnityEngine.SliderJoint2D.FindObjectsByType",
+            "UnityEngine.SliderJoint2D.FindFirstObjectByType",
+            "UnityEngine.SliderJoint2D.FindAnyObjectByType",
+            "UnityEngine.SliderJoint2D.ToString",
+            "UnityEngine.SliderJoint2D.ReferenceEquals",
+            "UnityEngine.SliderJoint2D.autoConfigureAngle",
+            "UnityEngine.SliderJoint2D.angle",
+            "UnityEngine.SliderJoint2D.useMotor",
+            "UnityEngine.SliderJoint2D.useLimits",
+            "UnityEngine.SliderJoint2D.motor",
+            "UnityEngine.SliderJoint2D.limits",
+            "UnityEngine.SliderJoint2D.limitState",
+            "UnityEngine.SliderJoint2D.referenceAngle",
+            "UnityEngine.SliderJoint2D.jointTranslation",
+            "UnityEngine.SliderJoint2D.jointSpeed",
+            "UnityEngine.SliderJoint2D.anchor",
+            "UnityEngine.SliderJoint2D.connectedAnchor",
+            "UnityEngine.SliderJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.SliderJoint2D.attachedRigidbody",
+            "UnityEngine.SliderJoint2D.connectedBody",
+            "UnityEngine.SliderJoint2D.enableCollision",
+            "UnityEngine.SliderJoint2D.breakForce",
+            "UnityEngine.SliderJoint2D.breakTorque",
+            "UnityEngine.SliderJoint2D.breakAction",
+            "UnityEngine.SliderJoint2D.reactionForce",
+            "UnityEngine.SliderJoint2D.reactionTorque",
+            "UnityEngine.SliderJoint2D.enabled",
+            "UnityEngine.SliderJoint2D.isActiveAndEnabled",
+            "UnityEngine.SliderJoint2D.transform",
+            "UnityEngine.SliderJoint2D.gameObject",
+            "UnityEngine.SliderJoint2D.tag",
+            "UnityEngine.SliderJoint2D.name",
+            "UnityEngine.SliderJoint2D.hideFlags",
+            "UnityEngine.TargetJoint2D.GetReactionForce",
+            "UnityEngine.TargetJoint2D.GetReactionTorque",
+            "UnityEngine.TargetJoint2D.GetComponent",
+            "UnityEngine.TargetJoint2D.GetComponentInChildren",
+            "UnityEngine.TargetJoint2D.GetComponentsInChildren",
+            "UnityEngine.TargetJoint2D.GetComponentInParent",
+            "UnityEngine.TargetJoint2D.GetComponentsInParent",
+            "UnityEngine.TargetJoint2D.GetComponents",
+            "UnityEngine.TargetJoint2D.GetComponentIndex",
+            "UnityEngine.TargetJoint2D.CompareTag",
+            "UnityEngine.TargetJoint2D.Equals",
+            "UnityEngine.TargetJoint2D.op_Implicit",
+            "UnityEngine.TargetJoint2D.Instantiate",
+            "UnityEngine.TargetJoint2D.Destroy",
+            "UnityEngine.TargetJoint2D.FindObjectsByType",
+            "UnityEngine.TargetJoint2D.FindFirstObjectByType",
+            "UnityEngine.TargetJoint2D.FindAnyObjectByType",
+            "UnityEngine.TargetJoint2D.ToString",
+            "UnityEngine.TargetJoint2D.ReferenceEquals",
+            "UnityEngine.TargetJoint2D.anchor",
+            "UnityEngine.TargetJoint2D.target",
+            "UnityEngine.TargetJoint2D.autoConfigureTarget",
+            "UnityEngine.TargetJoint2D.maxForce",
+            "UnityEngine.TargetJoint2D.dampingRatio",
+            "UnityEngine.TargetJoint2D.frequency",
+            "UnityEngine.TargetJoint2D.attachedRigidbody",
+            "UnityEngine.TargetJoint2D.connectedBody",
+            "UnityEngine.TargetJoint2D.enableCollision",
+            "UnityEngine.TargetJoint2D.breakForce",
+            "UnityEngine.TargetJoint2D.breakTorque",
+            "UnityEngine.TargetJoint2D.breakAction",
+            "UnityEngine.TargetJoint2D.reactionForce",
+            "UnityEngine.TargetJoint2D.reactionTorque",
+            "UnityEngine.TargetJoint2D.enabled",
+            "UnityEngine.TargetJoint2D.isActiveAndEnabled",
+            "UnityEngine.TargetJoint2D.transform",
+            "UnityEngine.TargetJoint2D.gameObject",
+            "UnityEngine.TargetJoint2D.tag",
+            "UnityEngine.TargetJoint2D.name",
+            "UnityEngine.TargetJoint2D.hideFlags",
+            "UnityEngine.FixedJoint2D.GetReactionForce",
+            "UnityEngine.FixedJoint2D.GetReactionTorque",
+            "UnityEngine.FixedJoint2D.GetComponent",
+            "UnityEngine.FixedJoint2D.GetComponentInChildren",
+            "UnityEngine.FixedJoint2D.GetComponentsInChildren",
+            "UnityEngine.FixedJoint2D.GetComponentInParent",
+            "UnityEngine.FixedJoint2D.GetComponentsInParent",
+            "UnityEngine.FixedJoint2D.GetComponents",
+            "UnityEngine.FixedJoint2D.GetComponentIndex",
+            "UnityEngine.FixedJoint2D.CompareTag",
+            "UnityEngine.FixedJoint2D.Equals",
+            "UnityEngine.FixedJoint2D.op_Implicit",
+            "UnityEngine.FixedJoint2D.Instantiate",
+            "UnityEngine.FixedJoint2D.Destroy",
+            "UnityEngine.FixedJoint2D.FindObjectsByType",
+            "UnityEngine.FixedJoint2D.FindFirstObjectByType",
+            "UnityEngine.FixedJoint2D.FindAnyObjectByType",
+            "UnityEngine.FixedJoint2D.ToString",
+            "UnityEngine.FixedJoint2D.ReferenceEquals",
+            "UnityEngine.FixedJoint2D.dampingRatio",
+            "UnityEngine.FixedJoint2D.frequency",
+            "UnityEngine.FixedJoint2D.referenceAngle",
+            "UnityEngine.FixedJoint2D.anchor",
+            "UnityEngine.FixedJoint2D.connectedAnchor",
+            "UnityEngine.FixedJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.FixedJoint2D.attachedRigidbody",
+            "UnityEngine.FixedJoint2D.connectedBody",
+            "UnityEngine.FixedJoint2D.enableCollision",
+            "UnityEngine.FixedJoint2D.breakForce",
+            "UnityEngine.FixedJoint2D.breakTorque",
+            "UnityEngine.FixedJoint2D.breakAction",
+            "UnityEngine.FixedJoint2D.reactionForce",
+            "UnityEngine.FixedJoint2D.reactionTorque",
+            "UnityEngine.FixedJoint2D.enabled",
+            "UnityEngine.FixedJoint2D.isActiveAndEnabled",
+            "UnityEngine.FixedJoint2D.transform",
+            "UnityEngine.FixedJoint2D.gameObject",
+            "UnityEngine.FixedJoint2D.tag",
+            "UnityEngine.FixedJoint2D.name",
+            "UnityEngine.FixedJoint2D.hideFlags",
+            "UnityEngine.WheelJoint2D.GetMotorTorque",
+            "UnityEngine.WheelJoint2D.GetReactionForce",
+            "UnityEngine.WheelJoint2D.GetReactionTorque",
+            "UnityEngine.WheelJoint2D.GetComponent",
+            "UnityEngine.WheelJoint2D.GetComponentInChildren",
+            "UnityEngine.WheelJoint2D.GetComponentsInChildren",
+            "UnityEngine.WheelJoint2D.GetComponentInParent",
+            "UnityEngine.WheelJoint2D.GetComponentsInParent",
+            "UnityEngine.WheelJoint2D.GetComponents",
+            "UnityEngine.WheelJoint2D.GetComponentIndex",
+            "UnityEngine.WheelJoint2D.CompareTag",
+            "UnityEngine.WheelJoint2D.Equals",
+            "UnityEngine.WheelJoint2D.op_Implicit",
+            "UnityEngine.WheelJoint2D.Instantiate",
+            "UnityEngine.WheelJoint2D.Destroy",
+            "UnityEngine.WheelJoint2D.FindObjectsByType",
+            "UnityEngine.WheelJoint2D.FindFirstObjectByType",
+            "UnityEngine.WheelJoint2D.FindAnyObjectByType",
+            "UnityEngine.WheelJoint2D.ToString",
+            "UnityEngine.WheelJoint2D.ReferenceEquals",
+            "UnityEngine.WheelJoint2D.suspension",
+            "UnityEngine.WheelJoint2D.useMotor",
+            "UnityEngine.WheelJoint2D.motor",
+            "UnityEngine.WheelJoint2D.jointTranslation",
+            "UnityEngine.WheelJoint2D.jointLinearSpeed",
+            "UnityEngine.WheelJoint2D.jointSpeed",
+            "UnityEngine.WheelJoint2D.jointAngle",
+            "UnityEngine.WheelJoint2D.anchor",
+            "UnityEngine.WheelJoint2D.connectedAnchor",
+            "UnityEngine.WheelJoint2D.autoConfigureConnectedAnchor",
+            "UnityEngine.WheelJoint2D.attachedRigidbody",
+            "UnityEngine.WheelJoint2D.connectedBody",
+            "UnityEngine.WheelJoint2D.enableCollision",
+            "UnityEngine.WheelJoint2D.breakForce",
+            "UnityEngine.WheelJoint2D.breakTorque",
+            "UnityEngine.WheelJoint2D.breakAction",
+            "UnityEngine.WheelJoint2D.reactionForce",
+            "UnityEngine.WheelJoint2D.reactionTorque",
+            "UnityEngine.WheelJoint2D.enabled",
+            "UnityEngine.WheelJoint2D.isActiveAndEnabled",
+            "UnityEngine.WheelJoint2D.transform",
+            "UnityEngine.WheelJoint2D.gameObject",
+            "UnityEngine.WheelJoint2D.tag",
+            "UnityEngine.WheelJoint2D.name",
+            "UnityEngine.WheelJoint2D.hideFlags",
+            "UnityEngine.Effector2D.GetComponent",
+            "UnityEngine.Effector2D.GetComponentInChildren",
+            "UnityEngine.Effector2D.GetComponentsInChildren",
+            "UnityEngine.Effector2D.GetComponentInParent",
+            "UnityEngine.Effector2D.GetComponentsInParent",
+            "UnityEngine.Effector2D.GetComponents",
+            "UnityEngine.Effector2D.GetComponentIndex",
+            "UnityEngine.Effector2D.CompareTag",
+            "UnityEngine.Effector2D.Equals",
+            "UnityEngine.Effector2D.op_Implicit",
+            "UnityEngine.Effector2D.Instantiate",
+            "UnityEngine.Effector2D.Destroy",
+            "UnityEngine.Effector2D.FindObjectsByType",
+            "UnityEngine.Effector2D.FindFirstObjectByType",
+            "UnityEngine.Effector2D.FindAnyObjectByType",
+            "UnityEngine.Effector2D.ToString",
+            "UnityEngine.Effector2D.ReferenceEquals",
+            "UnityEngine.Effector2D.useColliderMask",
+            "UnityEngine.Effector2D.colliderMask",
+            "UnityEngine.Effector2D.enabled",
+            "UnityEngine.Effector2D.isActiveAndEnabled",
+            "UnityEngine.Effector2D.transform",
+            "UnityEngine.Effector2D.gameObject",
+            "UnityEngine.Effector2D.tag",
+            "UnityEngine.Effector2D.name",
+            "UnityEngine.Effector2D.hideFlags",
+            "UnityEngine.AreaEffector2D.GetComponent",
+            "UnityEngine.AreaEffector2D.GetComponentInChildren",
+            "UnityEngine.AreaEffector2D.GetComponentsInChildren",
+            "UnityEngine.AreaEffector2D.GetComponentInParent",
+            "UnityEngine.AreaEffector2D.GetComponentsInParent",
+            "UnityEngine.AreaEffector2D.GetComponents",
+            "UnityEngine.AreaEffector2D.GetComponentIndex",
+            "UnityEngine.AreaEffector2D.CompareTag",
+            "UnityEngine.AreaEffector2D.Equals",
+            "UnityEngine.AreaEffector2D.op_Implicit",
+            "UnityEngine.AreaEffector2D.Instantiate",
+            "UnityEngine.AreaEffector2D.Destroy",
+            "UnityEngine.AreaEffector2D.FindObjectsByType",
+            "UnityEngine.AreaEffector2D.FindFirstObjectByType",
+            "UnityEngine.AreaEffector2D.FindAnyObjectByType",
+            "UnityEngine.AreaEffector2D.ToString",
+            "UnityEngine.AreaEffector2D.ReferenceEquals",
+            "UnityEngine.AreaEffector2D.forceAngle",
+            "UnityEngine.AreaEffector2D.useGlobalAngle",
+            "UnityEngine.AreaEffector2D.forceMagnitude",
+            "UnityEngine.AreaEffector2D.forceVariation",
+            "UnityEngine.AreaEffector2D.drag",
+            "UnityEngine.AreaEffector2D.angularDrag",
+            "UnityEngine.AreaEffector2D.forceTarget",
+            "UnityEngine.AreaEffector2D.useColliderMask",
+            "UnityEngine.AreaEffector2D.colliderMask",
+            "UnityEngine.AreaEffector2D.enabled",
+            "UnityEngine.AreaEffector2D.isActiveAndEnabled",
+            "UnityEngine.AreaEffector2D.transform",
+            "UnityEngine.AreaEffector2D.gameObject",
+            "UnityEngine.AreaEffector2D.tag",
+            "UnityEngine.AreaEffector2D.name",
+            "UnityEngine.AreaEffector2D.hideFlags",
+            "UnityEngine.BuoyancyEffector2D.GetComponent",
+            "UnityEngine.BuoyancyEffector2D.GetComponentInChildren",
+            "UnityEngine.BuoyancyEffector2D.GetComponentsInChildren",
+            "UnityEngine.BuoyancyEffector2D.GetComponentInParent",
+            "UnityEngine.BuoyancyEffector2D.GetComponentsInParent",
+            "UnityEngine.BuoyancyEffector2D.GetComponents",
+            "UnityEngine.BuoyancyEffector2D.GetComponentIndex",
+            "UnityEngine.BuoyancyEffector2D.CompareTag",
+            "UnityEngine.BuoyancyEffector2D.Equals",
+            "UnityEngine.BuoyancyEffector2D.op_Implicit",
+            "UnityEngine.BuoyancyEffector2D.Instantiate",
+            "UnityEngine.BuoyancyEffector2D.Destroy",
+            "UnityEngine.BuoyancyEffector2D.FindObjectsByType",
+            "UnityEngine.BuoyancyEffector2D.FindFirstObjectByType",
+            "UnityEngine.BuoyancyEffector2D.FindAnyObjectByType",
+            "UnityEngine.BuoyancyEffector2D.ToString",
+            "UnityEngine.BuoyancyEffector2D.ReferenceEquals",
+            "UnityEngine.BuoyancyEffector2D.surfaceLevel",
+            "UnityEngine.BuoyancyEffector2D.density",
+            "UnityEngine.BuoyancyEffector2D.linearDrag",
+            "UnityEngine.BuoyancyEffector2D.angularDrag",
+            "UnityEngine.BuoyancyEffector2D.flowAngle",
+            "UnityEngine.BuoyancyEffector2D.flowMagnitude",
+            "UnityEngine.BuoyancyEffector2D.flowVariation",
+            "UnityEngine.BuoyancyEffector2D.useColliderMask",
+            "UnityEngine.BuoyancyEffector2D.colliderMask",
+            "UnityEngine.BuoyancyEffector2D.enabled",
+            "UnityEngine.BuoyancyEffector2D.isActiveAndEnabled",
+            "UnityEngine.BuoyancyEffector2D.transform",
+            "UnityEngine.BuoyancyEffector2D.gameObject",
+            "UnityEngine.BuoyancyEffector2D.tag",
+            "UnityEngine.BuoyancyEffector2D.name",
+            "UnityEngine.BuoyancyEffector2D.hideFlags",
+            "UnityEngine.PointEffector2D.GetComponent",
+            "UnityEngine.PointEffector2D.GetComponentInChildren",
+            "UnityEngine.PointEffector2D.GetComponentsInChildren",
+            "UnityEngine.PointEffector2D.GetComponentInParent",
+            "UnityEngine.PointEffector2D.GetComponentsInParent",
+            "UnityEngine.PointEffector2D.GetComponents",
+            "UnityEngine.PointEffector2D.GetComponentIndex",
+            "UnityEngine.PointEffector2D.CompareTag",
+            "UnityEngine.PointEffector2D.Equals",
+            "UnityEngine.PointEffector2D.op_Implicit",
+            "UnityEngine.PointEffector2D.Instantiate",
+            "UnityEngine.PointEffector2D.Destroy",
+            "UnityEngine.PointEffector2D.FindObjectsByType",
+            "UnityEngine.PointEffector2D.FindFirstObjectByType",
+            "UnityEngine.PointEffector2D.FindAnyObjectByType",
+            "UnityEngine.PointEffector2D.ToString",
+            "UnityEngine.PointEffector2D.ReferenceEquals",
+            "UnityEngine.PointEffector2D.forceMagnitude",
+            "UnityEngine.PointEffector2D.forceVariation",
+            "UnityEngine.PointEffector2D.distanceScale",
+            "UnityEngine.PointEffector2D.drag",
+            "UnityEngine.PointEffector2D.angularDrag",
+            "UnityEngine.PointEffector2D.forceSource",
+            "UnityEngine.PointEffector2D.forceTarget",
+            "UnityEngine.PointEffector2D.forceMode",
+            "UnityEngine.PointEffector2D.useColliderMask",
+            "UnityEngine.PointEffector2D.colliderMask",
+            "UnityEngine.PointEffector2D.enabled",
+            "UnityEngine.PointEffector2D.isActiveAndEnabled",
+            "UnityEngine.PointEffector2D.transform",
+            "UnityEngine.PointEffector2D.gameObject",
+            "UnityEngine.PointEffector2D.tag",
+            "UnityEngine.PointEffector2D.name",
+            "UnityEngine.PointEffector2D.hideFlags",
+            "UnityEngine.PlatformEffector2D.GetComponent",
+            "UnityEngine.PlatformEffector2D.GetComponentInChildren",
+            "UnityEngine.PlatformEffector2D.GetComponentsInChildren",
+            "UnityEngine.PlatformEffector2D.GetComponentInParent",
+            "UnityEngine.PlatformEffector2D.GetComponentsInParent",
+            "UnityEngine.PlatformEffector2D.GetComponents",
+            "UnityEngine.PlatformEffector2D.GetComponentIndex",
+            "UnityEngine.PlatformEffector2D.CompareTag",
+            "UnityEngine.PlatformEffector2D.Equals",
+            "UnityEngine.PlatformEffector2D.op_Implicit",
+            "UnityEngine.PlatformEffector2D.Instantiate",
+            "UnityEngine.PlatformEffector2D.Destroy",
+            "UnityEngine.PlatformEffector2D.FindObjectsByType",
+            "UnityEngine.PlatformEffector2D.FindFirstObjectByType",
+            "UnityEngine.PlatformEffector2D.FindAnyObjectByType",
+            "UnityEngine.PlatformEffector2D.ToString",
+            "UnityEngine.PlatformEffector2D.ReferenceEquals",
+            "UnityEngine.PlatformEffector2D.useOneWay",
+            "UnityEngine.PlatformEffector2D.useOneWayGrouping",
+            "UnityEngine.PlatformEffector2D.useSideFriction",
+            "UnityEngine.PlatformEffector2D.useSideBounce",
+            "UnityEngine.PlatformEffector2D.surfaceArc",
+            "UnityEngine.PlatformEffector2D.sideArc",
+            "UnityEngine.PlatformEffector2D.rotationalOffset",
+            "UnityEngine.PlatformEffector2D.useColliderMask",
+            "UnityEngine.PlatformEffector2D.colliderMask",
+            "UnityEngine.PlatformEffector2D.enabled",
+            "UnityEngine.PlatformEffector2D.isActiveAndEnabled",
+            "UnityEngine.PlatformEffector2D.transform",
+            "UnityEngine.PlatformEffector2D.gameObject",
+            "UnityEngine.PlatformEffector2D.tag",
+            "UnityEngine.PlatformEffector2D.name",
+            "UnityEngine.PlatformEffector2D.hideFlags",
+            "UnityEngine.SurfaceEffector2D.GetComponent",
+            "UnityEngine.SurfaceEffector2D.GetComponentInChildren",
+            "UnityEngine.SurfaceEffector2D.GetComponentsInChildren",
+            "UnityEngine.SurfaceEffector2D.GetComponentInParent",
+            "UnityEngine.SurfaceEffector2D.GetComponentsInParent",
+            "UnityEngine.SurfaceEffector2D.GetComponents",
+            "UnityEngine.SurfaceEffector2D.GetComponentIndex",
+            "UnityEngine.SurfaceEffector2D.CompareTag",
+            "UnityEngine.SurfaceEffector2D.Equals",
+            "UnityEngine.SurfaceEffector2D.op_Implicit",
+            "UnityEngine.SurfaceEffector2D.Instantiate",
+            "UnityEngine.SurfaceEffector2D.Destroy",
+            "UnityEngine.SurfaceEffector2D.FindObjectsByType",
+            "UnityEngine.SurfaceEffector2D.FindFirstObjectByType",
+            "UnityEngine.SurfaceEffector2D.FindAnyObjectByType",
+            "UnityEngine.SurfaceEffector2D.ToString",
+            "UnityEngine.SurfaceEffector2D.ReferenceEquals",
+            "UnityEngine.SurfaceEffector2D.speed",
+            "UnityEngine.SurfaceEffector2D.speedVariation",
+            "UnityEngine.SurfaceEffector2D.forceScale",
+            "UnityEngine.SurfaceEffector2D.useContactForce",
+            "UnityEngine.SurfaceEffector2D.useFriction",
+            "UnityEngine.SurfaceEffector2D.useBounce",
+            "UnityEngine.SurfaceEffector2D.useColliderMask",
+            "UnityEngine.SurfaceEffector2D.colliderMask",
+            "UnityEngine.SurfaceEffector2D.enabled",
+            "UnityEngine.SurfaceEffector2D.isActiveAndEnabled",
+            "UnityEngine.SurfaceEffector2D.transform",
+            "UnityEngine.SurfaceEffector2D.gameObject",
+            "UnityEngine.SurfaceEffector2D.tag",
+            "UnityEngine.SurfaceEffector2D.name",
+            "UnityEngine.SurfaceEffector2D.hideFlags",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponent",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponentInChildren",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponentsInChildren",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponentInParent",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponentsInParent",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponents",
+            "UnityEngine.PhysicsUpdateBehaviour2D.GetComponentIndex",
+            "UnityEngine.PhysicsUpdateBehaviour2D.CompareTag",
+            "UnityEngine.PhysicsUpdateBehaviour2D.Equals",
+            "UnityEngine.PhysicsUpdateBehaviour2D.op_Implicit",
+            "UnityEngine.PhysicsUpdateBehaviour2D.Instantiate",
+            "UnityEngine.PhysicsUpdateBehaviour2D.Destroy",
+            "UnityEngine.PhysicsUpdateBehaviour2D.FindObjectsByType",
+            "UnityEngine.PhysicsUpdateBehaviour2D.FindFirstObjectByType",
+            "UnityEngine.PhysicsUpdateBehaviour2D.FindAnyObjectByType",
+            "UnityEngine.PhysicsUpdateBehaviour2D.ToString",
+            "UnityEngine.PhysicsUpdateBehaviour2D.ReferenceEquals",
+            "UnityEngine.PhysicsUpdateBehaviour2D.enabled",
+            "UnityEngine.PhysicsUpdateBehaviour2D.isActiveAndEnabled",
+            "UnityEngine.PhysicsUpdateBehaviour2D.transform",
+            "UnityEngine.PhysicsUpdateBehaviour2D.gameObject",
+            "UnityEngine.PhysicsUpdateBehaviour2D.tag",
+            "UnityEngine.PhysicsUpdateBehaviour2D.name",
+            "UnityEngine.PhysicsUpdateBehaviour2D.hideFlags",
+            "UnityEngine.ConstantForce2D.GetComponent",
+            "UnityEngine.ConstantForce2D.GetComponentInChildren",
+            "UnityEngine.ConstantForce2D.GetComponentsInChildren",
+            "UnityEngine.ConstantForce2D.GetComponentInParent",
+            "UnityEngine.ConstantForce2D.GetComponentsInParent",
+            "UnityEngine.ConstantForce2D.GetComponents",
+            "UnityEngine.ConstantForce2D.GetComponentIndex",
+            "UnityEngine.ConstantForce2D.CompareTag",
+            "UnityEngine.ConstantForce2D.Equals",
+            "UnityEngine.ConstantForce2D.op_Implicit",
+            "UnityEngine.ConstantForce2D.Instantiate",
+            "UnityEngine.ConstantForce2D.Destroy",
+            "UnityEngine.ConstantForce2D.FindObjectsByType",
+            "UnityEngine.ConstantForce2D.FindFirstObjectByType",
+            "UnityEngine.ConstantForce2D.FindAnyObjectByType",
+            "UnityEngine.ConstantForce2D.ToString",
+            "UnityEngine.ConstantForce2D.ReferenceEquals",
+            "UnityEngine.ConstantForce2D.force",
+            "UnityEngine.ConstantForce2D.relativeForce",
+            "UnityEngine.ConstantForce2D.torque",
+            "UnityEngine.ConstantForce2D.enabled",
+            "UnityEngine.ConstantForce2D.isActiveAndEnabled",
+            "UnityEngine.ConstantForce2D.transform",
+            "UnityEngine.ConstantForce2D.gameObject",
+            "UnityEngine.ConstantForce2D.tag",
+            "UnityEngine.ConstantForce2D.name",
+            "UnityEngine.ConstantForce2D.hideFlags",
+            "UnityEngine.PhysicsMaterial2D.Equals",
+            "UnityEngine.PhysicsMaterial2D.op_Implicit",
+            "UnityEngine.PhysicsMaterial2D.Instantiate",
+            "UnityEngine.PhysicsMaterial2D.Destroy",
+            "UnityEngine.PhysicsMaterial2D.FindObjectsByType",
+            "UnityEngine.PhysicsMaterial2D.FindFirstObjectByType",
+            "UnityEngine.PhysicsMaterial2D.FindAnyObjectByType",
+            "UnityEngine.PhysicsMaterial2D.ToString",
+            "UnityEngine.PhysicsMaterial2D.ReferenceEquals",
+            "UnityEngine.PhysicsMaterial2D..ctor",
+            "UnityEngine.PhysicsMaterial2D.bounciness",
+            "UnityEngine.PhysicsMaterial2D.friction",
+            "UnityEngine.PhysicsMaterial2D.name",
+            "UnityEngine.PhysicsMaterial2D.hideFlags",
             "UnityEngine.SpriteMask.ResetBounds",
             "UnityEngine.SpriteMask.ResetLocalBounds",
             "UnityEngine.SpriteMask.HasPropertyBlock",
@@ -6559,6 +7944,73 @@ public struct VsStubsAllowed
             "UnityEngine.UIElements.VisualElementExtensions.Equals",
             "UnityEngine.UIElements.VisualElementExtensions.ToString",
             "UnityEngine.UIElements.VisualElementExtensions.ReferenceEquals",
+            "UnityEngine.WheelHit.Equals",
+            "UnityEngine.WheelHit.ToString",
+            "UnityEngine.WheelHit.ReferenceEquals",
+            "UnityEngine.WheelHit.collider",
+            "UnityEngine.WheelHit.point",
+            "UnityEngine.WheelHit.normal",
+            "UnityEngine.WheelHit.forwardDir",
+            "UnityEngine.WheelHit.sidewaysDir",
+            "UnityEngine.WheelHit.force",
+            "UnityEngine.WheelHit.forwardSlip",
+            "UnityEngine.WheelHit.sidewaysSlip",
+            "UnityEngine.WheelCollider.ResetSprungMasses",
+            "UnityEngine.WheelCollider.ConfigureVehicleSubsteps",
+            "UnityEngine.WheelCollider.ClosestPoint",
+            "UnityEngine.WheelCollider.ClosestPointOnBounds",
+            "UnityEngine.WheelCollider.GetComponent",
+            "UnityEngine.WheelCollider.GetComponentInChildren",
+            "UnityEngine.WheelCollider.GetComponentsInChildren",
+            "UnityEngine.WheelCollider.GetComponentInParent",
+            "UnityEngine.WheelCollider.GetComponentsInParent",
+            "UnityEngine.WheelCollider.GetComponents",
+            "UnityEngine.WheelCollider.GetComponentIndex",
+            "UnityEngine.WheelCollider.CompareTag",
+            "UnityEngine.WheelCollider.Equals",
+            "UnityEngine.WheelCollider.op_Implicit",
+            "UnityEngine.WheelCollider.Instantiate",
+            "UnityEngine.WheelCollider.Destroy",
+            "UnityEngine.WheelCollider.FindObjectsByType",
+            "UnityEngine.WheelCollider.FindFirstObjectByType",
+            "UnityEngine.WheelCollider.FindAnyObjectByType",
+            "UnityEngine.WheelCollider.ToString",
+            "UnityEngine.WheelCollider.ReferenceEquals",
+            "UnityEngine.WheelCollider.center",
+            "UnityEngine.WheelCollider.radius",
+            "UnityEngine.WheelCollider.suspensionDistance",
+            "UnityEngine.WheelCollider.suspensionSpring",
+            "UnityEngine.WheelCollider.suspensionExpansionLimited",
+            "UnityEngine.WheelCollider.forceAppPointDistance",
+            "UnityEngine.WheelCollider.mass",
+            "UnityEngine.WheelCollider.wheelDampingRate",
+            "UnityEngine.WheelCollider.forwardFriction",
+            "UnityEngine.WheelCollider.sidewaysFriction",
+            "UnityEngine.WheelCollider.motorTorque",
+            "UnityEngine.WheelCollider.brakeTorque",
+            "UnityEngine.WheelCollider.steerAngle",
+            "UnityEngine.WheelCollider.isGrounded",
+            "UnityEngine.WheelCollider.rpm",
+            "UnityEngine.WheelCollider.sprungMass",
+            "UnityEngine.WheelCollider.rotationSpeed",
+            "UnityEngine.WheelCollider.enabled",
+            "UnityEngine.WheelCollider.attachedRigidbody",
+            "UnityEngine.WheelCollider.attachedArticulationBody",
+            "UnityEngine.WheelCollider.isTrigger",
+            "UnityEngine.WheelCollider.contactOffset",
+            "UnityEngine.WheelCollider.bounds",
+            "UnityEngine.WheelCollider.hasModifiableContacts",
+            "UnityEngine.WheelCollider.providesContacts",
+            "UnityEngine.WheelCollider.layerOverridePriority",
+            "UnityEngine.WheelCollider.excludeLayers",
+            "UnityEngine.WheelCollider.includeLayers",
+            "UnityEngine.WheelCollider.sharedMaterial",
+            "UnityEngine.WheelCollider.material",
+            "UnityEngine.WheelCollider.transform",
+            "UnityEngine.WheelCollider.gameObject",
+            "UnityEngine.WheelCollider.tag",
+            "UnityEngine.WheelCollider.name",
+            "UnityEngine.WheelCollider.hideFlags",
             "UnityEngine.Video.VideoClip.GetAudioChannelCount",
             "UnityEngine.Video.VideoClip.GetAudioSampleRate",
             "UnityEngine.Video.VideoClip.GetAudioLanguage",
diff --git a/Runtime/Scripts/Scene/BanterSceneEvents.cs b/Runtime/Scripts/Scene/BanterSceneEvents.cs
index 3b397b16..79bd4622 100644
--- a/Runtime/Scripts/Scene/BanterSceneEvents.cs
+++ b/Runtime/Scripts/Scene/BanterSceneEvents.cs
@@ -48,6 +48,7 @@ public class BanterSceneEvents
     public UnityEvent<BanterGrabHandle> OnGrabHandle = new UnityEvent<BanterGrabHandle>();
     public UnityEvent<BanterWorldObject> OnWorldObject = new UnityEvent<BanterWorldObject>();
     public UnityEvent<BanterWorldObject> OnWorldObjectCollectColliders = new UnityEvent<BanterWorldObject>();
+    public UnityEvent<string, string> OnAvatarSet = new UnityEvent<string, string>();
 
     #region Legacy stuff
 
@@ -102,6 +103,7 @@ public void RemoveAllListeners()
         OnTakeOwnership.RemoveAllListeners();
         OnPlayAvatar.RemoveAllListeners();
         OnSyncedObject.RemoveAllListeners();
+        OnAvatarSet.RemoveAllListeners();
 
         // Legacy stuff
         OnLegacyPlayerLockChanged.RemoveAllListeners();
diff --git a/VisualScripting/Space/SetPortalUrl.cs b/VisualScripting/Space/SetPortalUrl.cs
new file mode 100644
index 00000000..83c4fa3f
--- /dev/null
+++ b/VisualScripting/Space/SetPortalUrl.cs
@@ -0,0 +1,45 @@
+#if BANTER_VISUAL_SCRIPTING
+using UnityEngine;
+using Unity.VisualScripting;
+using Banter.SDK;
+
+namespace Banter.VisualScripting
+{
+    [UnitTitle("Set Portal URL")]
+    [UnitShortTitle("Set Portal URL")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class SetPortalUrl : Unit
+    {
+        [DoNotSerialize]
+        public ValueInput url;
+
+        [DoNotSerialize]
+        [NullMeansSelf]
+        public ValueInput portal;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlInput input;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlOutput output;
+
+        protected override void Definition()
+        {
+            url = ValueInput<string>("URL");
+            portal = ValueInput<Portal>("TargetPortal");
+            portal.SetDefaultValue(null);
+            portal.NullMeansSelf();
+
+            input = ControlInput("", (flow) => {
+                var target = flow.GetValue<Portal>(portal);
+                target.url = flow.GetValue<string>(url);
+                return output;
+            });
+            output = ControlOutput("");
+        }
+    }
+}
+#endif
diff --git a/VisualScripting/Space/SetPortalUrl.cs.meta b/VisualScripting/Space/SetPortalUrl.cs.meta
new file mode 100644
index 00000000..b420f1e4
--- /dev/null
+++ b/VisualScripting/Space/SetPortalUrl.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3357598bccb07ae449588aeb535eb0fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VisualScripting/User/SetAvatar.cs b/VisualScripting/User/SetAvatar.cs
new file mode 100644
index 00000000..e5ef77b4
--- /dev/null
+++ b/VisualScripting/User/SetAvatar.cs
@@ -0,0 +1,40 @@
+#if BANTER_VISUAL_SCRIPTING
+using Unity.VisualScripting;
+using Banter.SDK;
+
+namespace Banter.VisualScripting
+{
+    [UnitTitle("Set User Avatar")]
+    [UnitShortTitle("Set Avatar")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class SetAvatar : Unit
+    {
+        [DoNotSerialize]
+        public ControlInput inputTrigger;
+
+        [DoNotSerialize]
+        public ControlOutput outputTrigger;
+
+        [DoNotSerialize]
+        public ValueInput localAvatarUrl;
+
+        [DoNotSerialize]
+        public ValueInput remoteAvatarUrl;
+
+        protected override void Definition()
+        {
+            inputTrigger = ControlInput("", (flow) => {
+                var local = flow.GetValue<string>(localAvatarUrl);
+                var remote = flow.GetValue<string>(remoteAvatarUrl);
+                BanterScene.Instance().events.OnAvatarSet?.Invoke(remote, local);
+
+                return outputTrigger;
+            });
+            outputTrigger = ControlOutput("");
+            localAvatarUrl = ValueInput("Local Avatar URL", string.Empty);
+            remoteAvatarUrl = ValueInput("Remote Avatar URL", string.Empty);
+        }
+    }
+}
+#endif
diff --git a/VisualScripting/User/SetAvatar.cs.meta b/VisualScripting/User/SetAvatar.cs.meta
new file mode 100644
index 00000000..58c55f0a
--- /dev/null
+++ b/VisualScripting/User/SetAvatar.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9ef64b74c420ecb41b0ccb8e58b2879b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VisualScripting/Utils/BrowserOpenUrl.cs b/VisualScripting/Utils/BrowserOpenUrl.cs
new file mode 100644
index 00000000..29c2dec3
--- /dev/null
+++ b/VisualScripting/Utils/BrowserOpenUrl.cs
@@ -0,0 +1,73 @@
+#if BANTER_VISUAL_SCRIPTING
+using Unity.VisualScripting;
+using Banter.SDK;
+
+namespace Banter.VisualScripting
+{
+    [UnitTitle("Menu Browser Open URL")]
+    [UnitShortTitle("Menu Browser Nav")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class MenuOpenUrl : Unit
+    {
+        [DoNotSerialize]
+        public ControlInput inputTrigger;
+
+        [DoNotSerialize]
+        public ControlOutput outputTrigger;
+
+        [DoNotSerialize]
+        public ValueInput url;
+
+        protected override void Definition()
+        {
+            inputTrigger = ControlInput("", (flow) => {
+                var urlVal = flow.GetValue<string>(url);
+
+                BanterScene.Instance().OpenPage(urlVal, 0);
+
+                return outputTrigger;
+            });
+            outputTrigger = ControlOutput("");
+            url = ValueInput("Url", string.Empty);
+        }
+    }
+
+    [UnitTitle("World Browser Open URL")]
+    [UnitShortTitle("World Browser Nav")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class WorldOpenUrl : Unit
+    {
+        [DoNotSerialize]
+        public ControlInput inputTrigger;
+
+        [DoNotSerialize]
+        public ControlOutput outputTrigger;
+
+        [DoNotSerialize]
+        public ValueInput url;
+
+        [DoNotSerialize]
+        [NullMeansSelf]
+        public ValueInput browserComponent;
+
+        protected override void Definition()
+        {
+            inputTrigger = ControlInput("", (flow) => {
+                var urlVal = flow.GetValue<string>(url);
+                var browser = flow.GetValue<BanterBrowser>(browserComponent);
+
+                browser.url = urlVal;
+
+                return outputTrigger;
+            });
+            outputTrigger = ControlOutput("");
+            url = ValueInput("Url", string.Empty);
+            browserComponent = ValueInput<BanterBrowser>("Banter Browser", null);
+            browserComponent.SetDefaultValue(null);
+            browserComponent.NullMeansSelf();
+        }
+    }
+}
+#endif
diff --git a/VisualScripting/Utils/BrowserOpenUrl.cs.meta b/VisualScripting/Utils/BrowserOpenUrl.cs.meta
new file mode 100644
index 00000000..c8d6c246
--- /dev/null
+++ b/VisualScripting/Utils/BrowserOpenUrl.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 33940379b96929a4ab113b05321edbca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/VisualScripting/Utils/LoadDataFromUrl.cs b/VisualScripting/Utils/LoadDataFromUrl.cs
new file mode 100644
index 00000000..3a4861ff
--- /dev/null
+++ b/VisualScripting/Utils/LoadDataFromUrl.cs
@@ -0,0 +1,125 @@
+#if BANTER_VISUAL_SCRIPTING
+using UnityEngine;
+using Unity.VisualScripting;
+using Banter.SDK;
+using UnityEngine.Networking;
+using System.Collections;
+using System.Runtime.Serialization;
+
+namespace Banter.VisualScripting
+{
+    [UnitTitle("Load Texture from URL")]
+    [UnitShortTitle("Load Texture")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class LoadTextureUrl : Unit
+    {
+        [DoNotSerialize]
+        public ValueInput url;
+
+        [DoNotSerialize]
+        public ValueOutput texture;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlInput input;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlOutput success;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlOutput failure;
+
+        protected override void Definition()
+        {
+            input = ControlInputCoroutine("Load", (flow) => LoadTexture(flow));
+            success = ControlOutput("Loaded");
+            failure = ControlOutput("Failed");
+            url = ValueInput<string>("URL");
+            texture = ValueOutput<Texture2D>("Texture");
+        }
+
+        private IEnumerator LoadTexture(Flow flow)
+        {
+            var url = flow.GetValue<string>(this.url);
+
+            using (var request = UnityWebRequestTexture.GetTexture(url))
+            {
+                yield return request.SendWebRequest();
+
+                if (request.result != UnityWebRequest.Result.Success)
+                {
+                    flow.Invoke(failure);
+                    yield break;
+                }
+
+                var texture = DownloadHandlerTexture.GetContent(request);
+                flow.SetValue(this.texture, texture);
+                flow.Invoke(success);
+            }
+        }
+    }
+
+    [UnitTitle("Load Audio from URL")]
+    [UnitShortTitle("Load Audio")]
+    [UnitCategory("Banter")]
+    [TypeIcon(typeof(BanterObjectId))]
+    public class LoadAudioUrl : Unit
+    {
+        [DoNotSerialize]
+        public ValueInput url;
+
+        [DoNotSerialize]
+        public ValueInput audioType;
+
+        [DoNotSerialize]
+        public ValueOutput audio;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlInput input;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlOutput success;
+
+        [DoNotSerialize]
+        [PortLabelHidden]
+        public ControlOutput failure;
+
+        protected override void Definition()
+        {
+            input = ControlInputCoroutine("Load", (flow) => LoadAudioClip(flow));
+            success = ControlOutput("Loaded");
+            failure = ControlOutput("Failed");
+
+            url = ValueInput<string>("URL");
+            audioType = ValueInput<AudioType>("Audio Type");
+            audio = ValueOutput<AudioClip>("Audio Clip");
+        }
+
+        private IEnumerator LoadAudioClip(Flow flow)
+        {
+            var url = flow.GetValue<string>(this.url);
+            var type = flow.GetValue<AudioType>(audioType);
+
+            using (var request = UnityWebRequestMultimedia.GetAudioClip(url, type))
+            {
+                yield return request.SendWebRequest();
+
+                if (request.result != UnityWebRequest.Result.Success)
+                {
+                    flow.Invoke(failure);
+                    yield break;
+                }
+
+                var clip = DownloadHandlerAudioClip.GetContent(request);
+                flow.SetValue(audio, clip);
+                flow.Invoke(success);
+            }
+        }
+    }
+}
+#endif
diff --git a/VisualScripting/Utils/LoadDataFromUrl.cs.meta b/VisualScripting/Utils/LoadDataFromUrl.cs.meta
new file mode 100644
index 00000000..0bd46897
--- /dev/null
+++ b/VisualScripting/Utils/LoadDataFromUrl.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5f30b89f719c97b4eba23044b3dafd1a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From ca193620689a457c526a06972d089b131f52ac17 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Thu, 5 Dec 2024 15:45:51 +0000
Subject: [PATCH 10/15] call update on component

---
 VisualScripting/Utils/BrowserOpenUrl.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/VisualScripting/Utils/BrowserOpenUrl.cs b/VisualScripting/Utils/BrowserOpenUrl.cs
index 29c2dec3..79588003 100644
--- a/VisualScripting/Utils/BrowserOpenUrl.cs
+++ b/VisualScripting/Utils/BrowserOpenUrl.cs
@@ -59,6 +59,7 @@ protected override void Definition()
                 var browser = flow.GetValue<BanterBrowser>(browserComponent);
 
                 browser.url = urlVal;
+                browser.UpdateCallback(new System.Collections.Generic.List<PropertyName>() { PropertyName.url });
 
                 return outputTrigger;
             });

From b2568a70862d03daa41916656794b319700a344c Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Thu, 5 Dec 2024 15:46:10 +0000
Subject: [PATCH 11/15] use banter component, call update

---
 VisualScripting/Space/SetPortalUrl.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/VisualScripting/Space/SetPortalUrl.cs b/VisualScripting/Space/SetPortalUrl.cs
index 83c4fa3f..b7818252 100644
--- a/VisualScripting/Space/SetPortalUrl.cs
+++ b/VisualScripting/Space/SetPortalUrl.cs
@@ -1,5 +1,4 @@
 #if BANTER_VISUAL_SCRIPTING
-using UnityEngine;
 using Unity.VisualScripting;
 using Banter.SDK;
 
@@ -29,13 +28,14 @@ public class SetPortalUrl : Unit
         protected override void Definition()
         {
             url = ValueInput<string>("URL");
-            portal = ValueInput<Portal>("TargetPortal");
+            portal = ValueInput<BanterPortal>("TargetPortal");
             portal.SetDefaultValue(null);
             portal.NullMeansSelf();
 
             input = ControlInput("", (flow) => {
-                var target = flow.GetValue<Portal>(portal);
+                var target = flow.GetValue<BanterPortal>(portal);
                 target.url = flow.GetValue<string>(url);
+                target.UpdateCallback(new System.Collections.Generic.List<PropertyName>() { PropertyName.url });
                 return output;
             });
             output = ControlOutput("");

From 45b2d397d5a4c97d322155081d2503a2e862a1a6 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Thu, 5 Dec 2024 16:34:28 +0000
Subject: [PATCH 12/15] recompile electron for POST fix

BANTS-1079
---
 Editor/banter-link/resources/app.asar | Bin 1108815 -> 1110149 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/Editor/banter-link/resources/app.asar b/Editor/banter-link/resources/app.asar
index b09b3045d5571f71bad72b9deb3b9872319d0673..b059b64457739a09ce9300ef6857221d41e25a04 100644
GIT binary patch
delta 2127
zcmbtUTWnNC81A;SbSb@2dVwyN(}GZ>lrwWKa|W&SLL`6&K^wUg+TA^8+se8N-CYR@
z5YZT84E6Fq)cBw!YJ4Fkcn}kiYmAqKOL+i;2-})SB$_Cpr9f!nKWB>(AAE6>KiQp~
z`M&wS@BiogrPkMmTZ>3ePEL0^C&$Lxa<C|xm#3>L>`m1#Gli~2xMLZbrrS}@ZB>of
zjGJ0S*uu80h%myOMtGEJJYsXoO(u9WM9qk*SvG@aR@?MHF@)Pn0zM)%X1Hto^L>6@
zWt>6Cse*SVT_rkI4H%degnjwfh|V<AO$6rph;9iD_f*1x$yW(i4GQ}TMhKUi_s^<^
z52sus7Bh8sZ{cJgu`HE(n?Ekf5Mf!u+q1t|0-8DuHkU(x$t_|~(}cd#yTmjs3U5xm
zO)ScFc&%*2Z>qx3Vb8QXgj*(uP`DD_F3%9lFu9woDD?S}nOYvl`;|k4QJs4n?^Ru!
zL{+?=Az9vCT?wB|A0m`f-F;(5u8(MjZhiDtHOjXbb0JtNzv2C)vSTwdn3I6PrkQYb
zR)%mU4EKZC#i)l)aD6jp2*q*gaeb|zI3cL}Y0Xrh-%zE9W3?m1P%Q=*nu0JmH$$l4
z!gc2%2s3Eblq-*9@E*cKkRV*1kEW=aaE~sSB3;I#GKt~3Or9Y)!pwxsLgc~y?&(KS
zxT$iU6@Ft8!dqt6-0Srj!kDGH-!H~+HHHCPY#2qqg@AKQWKtr_{*#I}Y8HnRbOimR
zx~Js=!&Q?S?ja5H6B=4_O211CW@+wmW2!G-x2RUTyB-b(r@;*q&C!GoXZV<m#PsaD
zYGsJ7>seV>1j;fs?jBo;hYek)4-WtO7;a;RY^Eys`Eit~XWhy)W~K_&LYCdT>uci)
z+gTiS;O2@dShb-TMxH<uxMsi)%WnIbYE9hx_a;o&z?=q~3sAO(eJP_HX&FX2=-=hm
zJ9sJ1+>6W0eYw)mMbjbg$qX@(32v?pf^P*Ppa}Pu6-5}5m{3!=Qs!c0yDG412<L+G
zY){=L*hCcWtscYpnSjx!?h$SZ2DhFb#V_c9Y}ed1L&UVuf$M8z2XQ8Yt%TyWLwN$J
z<%AWkL(@5B?jP&Q&~%++qvMv~a~Z#;8m4rz8fLT&;k@a>9dDD9h5h6$&wD;Y3?%c0
zDY$-|m=s-@xgqEyCeyQ_wr#|maAI&zHJqy{ge{v8OPIoKX)i~&RF)my)Mku?Qq9BK
zx&^z&v<$F2us?9@p}q4SVO*u|#!#O0m|@=GQ4}YHyD@^@#&wfI)E>*VOwZpPP9{$_
zvTWXT6mz4(g!Nrx*t@bn<oI`Y%U>MP`%0@}PY+Inr5g}>VH}$S-<0sydzdRSb;j@s
z;Hq%jUnJ5-T?0Fg_rVtw!il@sewGd$+s6EiG93C%+sCnKakkof?-LWXy6wqaAKFPx
z29ebLV%*MUhh;x*JUzOM)GHlfH}b`dszA(1DRw9of|}1OVc@fBc;*1<e;MBm*mpQE
zE4?k22-(Z=e`WrBrPtY>c9N-viPip^Qzhl_+tJDj37|A8E$L{~>1_zbVu?td3j0sY
zQKE@nrOx9}648GHNZR3}^E|o&yCED)gxlIyE|+Wa8Y|_w@C5eG9w%liPRxm<dK2*u
z+K_aT$(}^K!FHmdbS(Ak#Lq4#)q*(k%5{H3!oUdy5d$8R--DbW3DiD(_edfh38m^b
z$<_KS`DQ6Zo`#brW<%$ZMKwK9rLL|cjEa$AXUa(~R2mx_m3TT9Q+Dk_YvJUfs>vPU
zhL{uYN_9WbGw;8sCXljZokwaVnRi`ZO}}!gqyl}egVmQxnFrDnSF#~^*(uITPFzWK
zC(>Qr53Tnkm86q`zVDXE`xAK-nh#gNny*R`zZ$C&N`I^Z<@8+m^LPLTPUb`3xuRe+
z)Dv@TC6!Rn&VM2<RUmYFL4K;cH?c#(r|R2!C_O(3UOBVZXTMr@_Vu!}KCE1<JS>9c
g$C`wdj}^e0j8%X&1*;IN2&)*Y<jb<NrH!-y0+<xjE&u=k

delta 1539
zcmbtU?Q4}~7~gZweVo&sz1Z69Y;!r&-puazm&~^&xtb+PR;J6Hx2ZLqa}FY~h!CMj
z23Jt@#iTy;p%2QP^rhBHq6lJbkc8DaX9Wp{P`I->)98Ah&A*@nKX{(QeP7q_`u%>_
zb9}O6>_SJ9R8&;#AF8OxA-c~dd*gAg4NQvF8>z|Uo#RI2xU%WAFlnk4%ebt`XC3dA
zlB*15PUTFmq1j9}&tz6+bCl*3>!o=M^-ET)|9>TX2U!>p;~ewb5~~6ttP^mitqFz~
z6cWN2&f!a!g10IQggeT8|H2h`NGS(r+Zy5Hs$YpR%)m(d)r3^Wu;}!u#Ra0Bp#HV$
zDl9H>-0<{=$s(~zsp!n<ny{jvFuth)-l@Hcodt)Jb+bfqY2eNJX`-#9aD2&BLOIPT
zymH$$qLmQvazmLIE`%Svy*j`~+Cn<t1n)JL2(?T^<=<^8BycFpqWZ&2rwJ97`Zw-~
z1%z`ZKNwC0#7b-Z+s$?O6w(Sgj<ghUY%MibX@<{R3j~`pe`;Ax5Z7j|(Kl@+Vw5mZ
zqp$D8p|mpoqviEMLb{OrNc$8%NgEbP!T5?Ip;{{c$z3%8Va&{_@yp60GSM<>ba54`
zVW{$--Mu)73ne2DChsZ5kjdZMTcCJviC8@C&)-)a#FdlKlV1v#@5j<g%qe<lHNH5h
z{dW(brOcx07uJ+fWUXNA!6~Aw3OhGJfffk%5-`f9Vrbd>tt~LYi>Rq({+vL|EJZoK
zlCwlO>HHU}KByGZxb|bKVIbQ8e`@rXY6{<*na~Lyl`YyrOrYKyTi|C`BtlT(M;^kf
zl2LQ(>gBbe?QAYSzdc+clFrLiT89h_wmZMRKD351_-Vs*oZ+Y;!7CflU5-|aZ(4*F
zQVd<_SNV}iVuTiOvEv#MOjv(mb3=HY(TG&y(a=HZU=;0)ZNVCfbN|PdBr2pM;*F4e
zEEJ#51*huq624e5pPNQ#>OztXUHzwP26N&ROmDqTv``kNo+#r3lW^t9X`&R)dubcy
z#0VSNSGyfOQ*>^Fk~?rbVXXga#}eenq=@*pJXK6^$3+-}6r^^R!hKTy-<{}!wm4V#
z_sVCAM9TSHX?gZ0!Dunxx~n;eOUK}JYco9kT#;zp38bBZvE|jUcXx?sWa&HhpdL))
zxv<nwH>S=Q7me5Vd>L(04Dx%Y2)0$w-E*BVp^e|2j^i!-I6)>;#@V#;yR#T8&A5Sm
zIka6w3OB+_c^vFk)`xm=HLT{aYu^m6EkkX>{XVcie3RJVWL*kgJ%Ah(V~}~_CgBzn
zn0@g&!4DmWbRX`xFv@oyB;l8XI>;YFN(vK`?VrW4DGEJ@XA;a=-0eLBH!-5PL)}Mi
z5G6JD-Gi|p!L8*Maz}5}O2tI`v0J|ie`u(@Ay^9+fA4~W-`2s_ACvxvb7vZ1bo@l^
zk^I0=e(>m;p~HRs>D=bmJ10(bP6UV;B90)41Y!ZA60s0bg;<1GjHpH=5jBX~Pdg{-
H)-C%F$f*FX


From e29215ac5c2ee1716bce13bcd29a7e5001ce8d42 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Thu, 5 Dec 2024 17:05:24 +0000
Subject: [PATCH 13/15] browser initial values

---
 Runtime/Scripts/Scene/Components/BanterBrowser.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Runtime/Scripts/Scene/Components/BanterBrowser.cs b/Runtime/Scripts/Scene/Components/BanterBrowser.cs
index 11f13513..00b27f40 100644
--- a/Runtime/Scripts/Scene/Components/BanterBrowser.cs
+++ b/Runtime/Scripts/Scene/Components/BanterBrowser.cs
@@ -80,10 +80,10 @@ A browser component that can be added to a GameObject to display a webpage.
     public class BanterBrowser : BanterComponentBase
     {
         [See(initial = "")] public string url;
-        [See(initial = "4")] public int mipMaps;
-        [See(initial = "1200")] public float pixelsPerUnit;
-        [See(initial = "1024")] public float pageWidth;
-        [See(initial = "576")] public float pageHeight;
+        [See(initial = "4")] public int mipMaps = 4;
+        [See(initial = "1200")] public float pixelsPerUnit = 1200;
+        [See(initial = "1024")] public float pageWidth = 1024;
+        [See(initial = "576")] public float pageHeight = 576;
         [See(initial = "")] public string actions;
         public UnityEvent<string> OnReceiveBrowserMessage = new UnityEvent<string>();
         [Method]

From 71deaa8ece3f0788c42b664769f2a6d9a06f53cc Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Thu, 5 Dec 2024 17:12:02 +0000
Subject: [PATCH 14/15] Fix emulator tag

---
 Runtime/Resources/Prefabs/BanterPlayer.prefab | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Runtime/Resources/Prefabs/BanterPlayer.prefab b/Runtime/Resources/Prefabs/BanterPlayer.prefab
index fc5500fa..10be5b3b 100644
--- a/Runtime/Resources/Prefabs/BanterPlayer.prefab
+++ b/Runtime/Resources/Prefabs/BanterPlayer.prefab
@@ -1296,7 +1296,7 @@ GameObject:
   - component: {fileID: 5427251782582913572}
   m_Layer: 23
   m_Name: Head
-  m_TagString: __BA_PlayerHead
+  m_TagString: MainCamera
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0

From 33fb9527d7a6e98b821f5142b811ee951f7fe735 Mon Sep 17 00:00:00 2001
From: Mike Nisbet <mike@side.quest>
Date: Wed, 11 Dec 2024 10:40:32 +0000
Subject: [PATCH 15/15] version

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9f87fbbd..623e4f31 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "com.sidequest.banter",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "displayName": "Banter SDK",
   "description": "This Module contains the Banter SDK used for building spaces in the bantaverse.",
   "unity": "2022.3",