From b72add4e81ed85cff430837bb1eebb7c6b6a65a8 Mon Sep 17 00:00:00 2001 From: Aaro Varis Date: Sun, 30 Mar 2025 15:45:22 +0300 Subject: [PATCH] adjust sync --- BoneSync/BoneSync.csproj | 2 + BoneSync/Data/ByteEncoder.cs | 5 +- .../Messages/SimpleSyncableEventMessage.cs | 5 ++ BoneSync/Patching/ButtonTogglePatches.cs | 76 +--------------- BoneSync/Patching/CallPatchedMethod.cs | 38 +++++++- BoneSync/Patching/CartPatches.cs | 55 ++++++++++++ BoneSync/Patching/UnityEventPatching.cs | 88 +++++++++++++++++++ BoneSync/Patching/ZonePatches.cs | 25 ++++-- BoneSync/Player/PlayerRig.cs | 2 + BoneSync/Sync/Components/SyncableAI.cs | 2 - BoneSync/Sync/Components/SyncableBase.cs | 8 +- .../Sync/Components/SyncableNetworking.cs | 22 +++-- BoneSync/Sync/Components/SyncablePhysics.cs | 40 ++++++--- BoneSync/Sync/Components/SyncablePlugs.cs | 2 - BoneSync/Sync/ObjectSync.cs | 43 ++++++--- 15 files changed, 293 insertions(+), 120 deletions(-) create mode 100644 BoneSync/Patching/CartPatches.cs create mode 100644 BoneSync/Patching/UnityEventPatching.cs diff --git a/BoneSync/BoneSync.csproj b/BoneSync/BoneSync.csproj index e21ad40..0a19516 100644 --- a/BoneSync/BoneSync.csproj +++ b/BoneSync/BoneSync.csproj @@ -116,6 +116,7 @@ + @@ -134,6 +135,7 @@ + diff --git a/BoneSync/Data/ByteEncoder.cs b/BoneSync/Data/ByteEncoder.cs index b5e1101..799a09e 100644 --- a/BoneSync/Data/ByteEncoder.cs +++ b/BoneSync/Data/ByteEncoder.cs @@ -3,6 +3,7 @@ using StressLevelZero; using StressLevelZero.Combat; using System; using System.Collections.Generic; +using System.IO; using System.Linq; using System.Text; using System.Threading.Tasks; @@ -46,7 +47,9 @@ namespace BoneSync.Data } internal class ByteEncoder { - + //public BinaryWriter writer; + //public BinaryReader reader; + public List Data; public ByteEncoder() { diff --git a/BoneSync/Networking/Messages/SimpleSyncableEventMessage.cs b/BoneSync/Networking/Messages/SimpleSyncableEventMessage.cs index 474960b..cbe217a 100644 --- a/BoneSync/Networking/Messages/SimpleSyncableEventMessage.cs +++ b/BoneSync/Networking/Messages/SimpleSyncableEventMessage.cs @@ -16,6 +16,11 @@ namespace BoneSync.Networking.Messages OnButtonPress = 3, OnButtonRelease = 4, OnButtonOneShot = 5, + CartGo = 6, + CartGoBackwards = 7, + CartLaunch = 8, + CartGoForward = 9, + CartDrop = 10, } public struct SimpleSyncableEvent { diff --git a/BoneSync/Patching/ButtonTogglePatches.cs b/BoneSync/Patching/ButtonTogglePatches.cs index c4543bb..414e11e 100644 --- a/BoneSync/Patching/ButtonTogglePatches.cs +++ b/BoneSync/Patching/ButtonTogglePatches.cs @@ -7,71 +7,13 @@ using BoneSync.Sync; using BoneSync.Sync.Components; using HarmonyLib; using MelonLoader; +using StressLevelZero.Environment; using StressLevelZero.Interaction; using UnityEngine; using UnityEngine.Events; namespace BoneSync.Patching { - public class UnityEventPatch - { - private static Dictionary> patches = new Dictionary>(); - - private T arg; - private UnityEvent unityEvent; - private Func handler; - //private UnityAction listener; - //private float lastInvokeTime = 0f; - //private float invokeCooldown = 0.05f; - private UnityEventPatch(T arg, UnityEvent unityEvent, Func handler) - { - this.arg = arg; - this.unityEvent = unityEvent; - this.handler = handler; - - //listener = (UnityAction)Listener; - } - - public bool TryInvoke() - { - bool allowInvokeResult = handler(arg); - Debug.Log("TryInvoke " + allowInvokeResult); - return allowInvokeResult; - } - - private void PatchUnityEvent() - { - if (unityEvent == null) return; - patches[unityEvent.GetHashCode()] = this; - //unityEvent.AddListener(listener); - - } - - private void UnpatchUnityEvent() - { - if (unityEvent == null) return; - patches.Remove(unityEvent.GetHashCode()); - } - - public static UnityEventPatch Patch(T arg, UnityEvent unityEvent, Func handler) - { - if (patches.TryGetValue(unityEvent.GetHashCode(), out UnityEventPatch oldPatch)) - { - oldPatch.UnpatchUnityEvent(); - } - UnityEventPatch patch = new UnityEventPatch(arg, unityEvent, handler); - patch.PatchUnityEvent(); - - return patch; - } - - public static UnityEventPatch TryGetPatch(UnityEvent unityEvent) - { - if (!patches.ContainsKey(unityEvent.GetHashCode())) return null; - return patches[unityEvent.GetHashCode()]; - } - } - [HarmonyPatch(typeof(ButtonToggle))] internal class ButtonTogglePatches { @@ -81,20 +23,4 @@ namespace BoneSync.Patching Syncable syncable = ObjectSync.MakeOrGetSyncable(__instance); } } - - /*[HarmonyPatch(typeof(UnityEvent))] - internal class UnityEventPatches - { - [HarmonyPatch(nameof(UnityEvent.Invoke)), HarmonyPrefix] - private static bool InvokePrefix(UnityEvent __instance) - { - if (CallPatchedMethods.allowPatchedMethodCall) return true; - UnityEventPatch patch = UnityEventPatch.TryGetPatch(__instance); - if (patch != null) - { - return patch.TryInvoke(); - } - return true; - } - }*/ } diff --git a/BoneSync/Patching/CallPatchedMethod.cs b/BoneSync/Patching/CallPatchedMethod.cs index 95606bd..baaeeaf 100644 --- a/BoneSync/Patching/CallPatchedMethod.cs +++ b/BoneSync/Patching/CallPatchedMethod.cs @@ -1,4 +1,6 @@ -using StressLevelZero.Combat; +using BoneSync.Data; +using StressLevelZero.Combat; +using StressLevelZero.Environment; using StressLevelZero.Pool; using StressLevelZero.Props; using StressLevelZero.Props.Weapons; @@ -9,6 +11,7 @@ using System.Text; using System.Threading.Tasks; using UnityEngine; using UnityEngine.Events; +using Cart = StressLevelZero.Environment.Cart; namespace BoneSync.Patching { @@ -40,8 +43,41 @@ namespace BoneSync.Patching allowPatchedMethodCall = false; } + public static void CartGo(Cart __instance) + { + if (__instance == null) return; + allowPatchedMethodCall = true; + __instance.Go(); + allowPatchedMethodCall = false; + } + + public static void CartLaunch(Cart __instance) + { + if (__instance == null) return; + allowPatchedMethodCall = true; + __instance.Launch(); + allowPatchedMethodCall = false; + } + + public static void CartGoBackward(Cart __instance) + { + if (__instance == null) return; + allowPatchedMethodCall = true; + __instance.GoBackward(); + allowPatchedMethodCall = false; + } + + public static void CartGoForward(Cart __instance) + { + if (__instance == null) return; + allowPatchedMethodCall = true; + __instance.GoForward(); + allowPatchedMethodCall = false; + } + public static void BypassPatchInvoke(this UnityEvent e) { + SyncLogger.Msg("BypassPatchInvoke "+ e.GetHashCode()); allowPatchedMethodCall = true; e.Invoke(); allowPatchedMethodCall = false; diff --git a/BoneSync/Patching/CartPatches.cs b/BoneSync/Patching/CartPatches.cs new file mode 100644 index 0000000..2912ca5 --- /dev/null +++ b/BoneSync/Patching/CartPatches.cs @@ -0,0 +1,55 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using BoneSync.Data; +using BoneSync.Networking.Messages; +using BoneSync.Sync; +using BoneSync.Sync.Components; +using HarmonyLib; +using StressLevelZero.Environment; + +namespace BoneSync.Patching +{ + [HarmonyPatch(typeof(Cart))] + public class CartPatches + { + public static bool CartEvent(Cart cart, SimpleEventType eventType) + { + if (CallPatchedMethods.allowPatchedMethodCall) return true; + SyncLogger.Msg("CartEvent: " + cart.transform.GetPath() + " " + eventType); + Syncable syncable = ObjectSync.MakeOrGetSyncable(cart); + if (syncable == null) + { + SyncLogger.Error("CartEvent: syncable is null"); + return false; + } + return syncable.AddSimpleEventToQueue(eventType); + } + + [HarmonyPatch(nameof(Cart.Go)), HarmonyPrefix] + public static bool CartStartPostfix(Cart __instance) + { + return CartEvent(__instance, SimpleEventType.CartGo); + } + + [HarmonyPatch(nameof(Cart.Launch)), HarmonyPrefix] + public static bool CartStopPostfix(Cart __instance) + { + return CartEvent(__instance, SimpleEventType.CartLaunch); + } + + [HarmonyPatch(nameof(Cart.GoBackward)), HarmonyPrefix] + public static bool CartGoBackwardPostfix(Cart __instance) + { + return CartEvent(__instance, SimpleEventType.CartGoBackwards); + } + + [HarmonyPatch(nameof(Cart.GoForward)), HarmonyPrefix] + public static bool CartGoForwardPostfix(Cart __instance) + { + return CartEvent(__instance, SimpleEventType.CartGoForward); + } + } +} diff --git a/BoneSync/Patching/UnityEventPatching.cs b/BoneSync/Patching/UnityEventPatching.cs new file mode 100644 index 0000000..0f59f15 --- /dev/null +++ b/BoneSync/Patching/UnityEventPatching.cs @@ -0,0 +1,88 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using BoneSync.Data; +using HarmonyLib; +using StressLevelZero.Interaction; +using UnityEngine; +using UnityEngine.Events; + +namespace BoneSync.Patching +{ + public class UnityEventPatch + { + private static Dictionary> patches = new Dictionary>(); + + private T arg; + private UnityEvent unityEvent; + private Func handler; + //private UnityAction listener; + //private float lastInvokeTime = 0f; + //private float invokeCooldown = 0.05f; + private UnityEventPatch(T arg, UnityEvent unityEvent, Func handler) + { + this.arg = arg; + this.unityEvent = unityEvent; + this.handler = handler; + + //listener = (UnityAction)Listener; + } + + public bool TryInvoke() + { + bool allowInvokeResult = handler(arg); + SyncLogger.Debug("TryInvoke " + allowInvokeResult); + return allowInvokeResult; + } + + private void PatchUnityEvent() + { + if (unityEvent == null) return; + patches[unityEvent.GetHashCode()] = this; + //unityEvent.AddListener(listener); + + } + + private void UnpatchUnityEvent() + { + if (unityEvent == null) return; + patches.Remove(unityEvent.GetHashCode()); + } + + public static UnityEventPatch Patch(T arg, UnityEvent unityEvent, Func handler) + { + if (patches.TryGetValue(unityEvent.GetHashCode(), out UnityEventPatch oldPatch)) + { + oldPatch.UnpatchUnityEvent(); + } + UnityEventPatch patch = new UnityEventPatch(arg, unityEvent, handler); + patch.PatchUnityEvent(); + + return patch; + } + + public static UnityEventPatch TryGetPatch(UnityEvent unityEvent) + { + if (!patches.ContainsKey(unityEvent.GetHashCode())) return null; + return patches[unityEvent.GetHashCode()]; + } + } + + [HarmonyPatch(typeof(UnityEvent))] + internal class UnityEventPatches + { + [HarmonyPatch(nameof(UnityEvent.Invoke)), HarmonyPrefix] + private static bool InvokePrefix(UnityEvent __instance) + { + if (CallPatchedMethods.allowPatchedMethodCall) return true; + UnityEventPatch patch = UnityEventPatch.TryGetPatch(__instance); + if (patch != null) + { + return patch.TryInvoke(); + } + return true; + } + } +} diff --git a/BoneSync/Patching/ZonePatches.cs b/BoneSync/Patching/ZonePatches.cs index ceb2180..b284f62 100644 --- a/BoneSync/Patching/ZonePatches.cs +++ b/BoneSync/Patching/ZonePatches.cs @@ -59,17 +59,32 @@ namespace BoneSync.Patching [HarmonyPatch(typeof(SceneZone))] public static class SceneZonePatch { - public static bool IsChildOfLocalRigRoot(Transform transform) + public static bool IsChildOfLocalRig(Transform transform) { if (PlayerRig.localRigWorldRoot == null) return false; return transform.root == PlayerRig.localRigWorldRoot; } + + public static bool IsChildOfHostRig(Transform transform) + { + if (!BoneSync.IsConnected|| BoneSync.lobby.IsHost) + { + return IsChildOfLocalRig(transform); + } + else + { + PlayerRig hostRig = PlayerRig.GetPlayerRig(BoneSync.lobby.GetHostId()); + Transform hostRoot = hostRig?.transform.root; + return hostRoot != null && transform.root == hostRoot; + } + } + [HarmonyPatch(nameof(SceneZone.OnTriggerEnter)), HarmonyPrefix] public static bool EnterPrefix(SceneZone __instance, Collider other) { if (other.CompareTag("Player")) { - return IsChildOfLocalRigRoot(other.transform); + return IsChildOfLocalRig(other.transform); } return true; @@ -80,7 +95,7 @@ namespace BoneSync.Patching { if (other.CompareTag("Player")) { - return IsChildOfLocalRigRoot(other.transform); + return IsChildOfLocalRig(other.transform); } return true; @@ -97,7 +112,7 @@ namespace BoneSync.Patching if (other.CompareTag("Player")) { - return SceneZonePatch.IsChildOfLocalRigRoot(other.transform); + return SceneZonePatch.IsChildOfLocalRig(other.transform); } return true; @@ -110,7 +125,7 @@ namespace BoneSync.Patching { if (other.CompareTag("Player")) { - return SceneZonePatch.IsChildOfLocalRigRoot(other.transform); + return SceneZonePatch.IsChildOfLocalRig(other.transform); } return true; diff --git a/BoneSync/Player/PlayerRig.cs b/BoneSync/Player/PlayerRig.cs index 99ef383..951baaf 100644 --- a/BoneSync/Player/PlayerRig.cs +++ b/BoneSync/Player/PlayerRig.cs @@ -42,6 +42,8 @@ namespace BoneSync.Player private Transform leftHandTransform; private Transform rightHandTransform; + public Transform transform => playerRig.transform; + public static void LoadBundle() { rigBundle = EmebeddedAssetBundle.LoadFromAssembly("BoneSync.playerrep.eres"); diff --git a/BoneSync/Sync/Components/SyncableAI.cs b/BoneSync/Sync/Components/SyncableAI.cs index 1278725..af2e9d9 100644 --- a/BoneSync/Sync/Components/SyncableAI.cs +++ b/BoneSync/Sync/Components/SyncableAI.cs @@ -16,8 +16,6 @@ namespace BoneSync.Sync.Components private void TrySendAISync() { - if (!Registered) return; - if (!isOwner) return; if (!aiBrain) return; if (Time.realtimeSinceStartup - _lastAISyncTime > 1 / AI_SYNC_FPS) { diff --git a/BoneSync/Sync/Components/SyncableBase.cs b/BoneSync/Sync/Components/SyncableBase.cs index 640d108..eb3b9da 100644 --- a/BoneSync/Sync/Components/SyncableBase.cs +++ b/BoneSync/Sync/Components/SyncableBase.cs @@ -19,6 +19,7 @@ using StressLevelZero.AI; using PuppetMasta; using UnityEngine.SceneManagement; using BoneSync.Data; +using StressLevelZero.Environment; namespace BoneSync.Sync.Components @@ -142,6 +143,9 @@ namespace BoneSync.Sync.Components private SpawnFragment spawnFragment; + private Powerable powerable; + private Cart physicsCart; + private void CheckAutoSync() { if (!isValid) return; @@ -182,6 +186,7 @@ namespace BoneSync.Sync.Components return true; } if (buttonToggles.Length > 0) return true; + if (physicsCart != null) return true; return false; } @@ -222,6 +227,7 @@ namespace BoneSync.Sync.Components sockets = GetComponentsInChildren(); aiBrain = GetComponent(); buttonToggles = GetComponentsInChildren(); + physicsCart = GetComponent(); if (sockets.Length == 0) { plugs = GetComponentsInChildren(); @@ -259,8 +265,8 @@ namespace BoneSync.Sync.Components if (spawnFragment) return false; // if has spawn fragment, don't sync FindAndUpdateComponents(); - if (buttonToggles?.Length > 0) return true; if (rigidbodies?.Length > 0) return true; + if (ShouldAutoSync()) return true; return false; } diff --git a/BoneSync/Sync/Components/SyncableNetworking.cs b/BoneSync/Sync/Components/SyncableNetworking.cs index 8dbdfa7..f84c3c6 100644 --- a/BoneSync/Sync/Components/SyncableNetworking.cs +++ b/BoneSync/Sync/Components/SyncableNetworking.cs @@ -23,31 +23,31 @@ namespace BoneSync.Sync.Components ObjectSync.SendObjectSyncMessage(this); } - private void TrySendObjectSync() - { - if (ShouldSendSync()) SendObjectSync(); - } public IEnumerator SyncCoroutineAsync() { SyncLogger.Msg("Running sync coroutine for: " + transform.GetPath()); if (_syncCoroutineRunning) yield break; _syncCoroutineRunning = true; - while (isOwner) + while (ShouldSendSync()) { TrySendAISync(); - TrySendObjectSync(); + SendObjectSync(); TrySendPlugSync(); - yield return new WaitForSeconds(!Registered ? 1 : 1 / OBJECT_SYNC_FPS); + yield return new WaitForSeconds( 1 / OBJECT_SYNC_FPS ); } _syncCoroutineRunning = false; yield break; } + private void RunSyncLoop() + { + MelonCoroutines.Start(SyncCoroutineAsync()); + } public void SetOwner(ulong ownerId) { SyncLogger.Msg("Setting owner for " + _syncId + " to " + ownerId); _ownerId = ownerId; FindAndUpdateComponents(); - MelonCoroutines.Start(SyncCoroutineAsync()); + RunSyncLoop(); UpdateKinematic(); TryCatchUpSimpleEvents(); } @@ -123,6 +123,7 @@ namespace BoneSync.Sync.Components SetOwner(localId); } } + RunSyncLoop(); } public bool ShouldSendSync() @@ -135,10 +136,13 @@ namespace BoneSync.Sync.Components return true; } - private void AddSimpleEventToQueue(SimpleEventType eType, byte index = 0, byte len = 0) + public bool AddSimpleEventToQueue(SimpleEventType eType, byte index = 0, byte len = 0) { + RegisterSyncable(); + if (!isOwner && Registered) { return false; } _simpleEventQueue.Enqueue(new byte[] { (byte)eType, index, len }); TryCatchUpSimpleEvents(); + return true; } private void TryCatchUpSimpleEvents() diff --git a/BoneSync/Sync/Components/SyncablePhysics.cs b/BoneSync/Sync/Components/SyncablePhysics.cs index 1355c35..c7f1c99 100644 --- a/BoneSync/Sync/Components/SyncablePhysics.cs +++ b/BoneSync/Sync/Components/SyncablePhysics.cs @@ -23,10 +23,7 @@ namespace BoneSync.Sync.Components { SyncLogger.Msg("ButtonToggle:" + eventType + " " + toggle.transform.GetPath()); byte index = (byte)Array.IndexOf(buttonToggles, toggle); - RegisterSyncable(); - if (!isOwner && Registered) return false; - AddSimpleEventToQueue(eventType, index, (byte)buttonToggles.Length); - return true; + return AddSimpleEventToQueue(eventType, index, (byte)buttonToggles.Length); } bool ButtonOnPress(ButtonToggle toggle) { @@ -44,15 +41,11 @@ namespace BoneSync.Sync.Components bool DeviceOnPull(PullDevice device) { - if (!isOwner && Registered) { return false; } - AddSimpleEventToQueue(SimpleEventType.OnDevicePull); - return true; + return AddSimpleEventToQueue(SimpleEventType.OnDevicePull); } bool DeviceOnRelease(PullDevice device) { - if (!isOwner && Registered) { return false; } - AddSimpleEventToQueue(SimpleEventType.OnDeviceRelease); - return true; + return AddSimpleEventToQueue(SimpleEventType.OnDeviceRelease); } private void TryPatchUnityEvents() @@ -160,10 +153,11 @@ namespace BoneSync.Sync.Components for (int i = 0; i < objectSyncTransforms.Length; i++) { ObjectSyncTransform objectSyncTransform = objectSyncTransforms[i]; - rigidbodies[i].angularVelocity = objectSyncTransform.angularVelocity; - rigidbodies[i].velocity = objectSyncTransform.velocity; - rigidbodies[i].position = objectSyncTransform.transform.position; - rigidbodies[i].rotation = objectSyncTransform.transform.rotation; + Rigidbody rb = rigidbodies[i]; + rb.angularVelocity = objectSyncTransform.angularVelocity; + rb.velocity = objectSyncTransform.velocity; + rb.MovePosition(objectSyncTransform.transform.position); + rb.MoveRotation(objectSyncTransform.transform.rotation); _transforms[i].localScale = objectSyncTransform.transform.scale; //_transforms[i].ApplySimpleTransform(objectSyncTransform.transform); } @@ -248,6 +242,24 @@ namespace BoneSync.Sync.Components buttonToggles[index]?.onPressOneShot.BypassPatchInvoke(); } break; + case SimpleEventType.CartGo: + CallPatchedMethods.CartGo(physicsCart); + break; + case SimpleEventType.CartGoBackwards: + CallPatchedMethods.CartGoBackward(physicsCart); + break; + case SimpleEventType.CartLaunch: + CallPatchedMethods.CartLaunch(physicsCart); + break; + case SimpleEventType.CartGoForward: + CallPatchedMethods.CartGoForward(physicsCart); + break; + case SimpleEventType.CartDrop: + //CallPatchedMethods.Drop(); + break; + default: + SyncLogger.Warning("Unknown SimpleEventType: " + eType); + break; } } // on collision diff --git a/BoneSync/Sync/Components/SyncablePlugs.cs b/BoneSync/Sync/Components/SyncablePlugs.cs index 4a09502..083a1ae 100644 --- a/BoneSync/Sync/Components/SyncablePlugs.cs +++ b/BoneSync/Sync/Components/SyncablePlugs.cs @@ -71,8 +71,6 @@ namespace BoneSync.Sync.Components private const float PLUG_SYNC_FPS = 1f; private void TrySendPlugSync() { - if (!Registered) return; - if (!isOwner) return; if (Time.realtimeSinceStartup - _lastPlugSyncTime > 1 / PLUG_SYNC_FPS) { _SendPlugSync(); diff --git a/BoneSync/Sync/ObjectSync.cs b/BoneSync/Sync/ObjectSync.cs index b370e14..e1a4af4 100644 --- a/BoneSync/Sync/ObjectSync.cs +++ b/BoneSync/Sync/ObjectSync.cs @@ -5,6 +5,7 @@ using BoneSync.Patching; using BoneSync.Sync.Components; using MelonLoader; using StressLevelZero.Data; +using StressLevelZero.Environment; using StressLevelZero.Interaction; using StressLevelZero.Pool; using System; @@ -109,7 +110,22 @@ namespace BoneSync.Sync ObjectSyncMessage message = new ObjectSyncMessage(data); message.Broadcast(); } - private static Syncable _MakeOrGetSyncable(GameObject gameObject, bool deleteSubSyncabled = true) + private static Transform _GetPerferredParentTransform(Transform t) + { + if (t == null) return null; + Transform parent = t.parent; + if (parent == null) return t; + + Cart cart = parent.GetComponentInParent(); + if (cart) return cart.transform; + + InteractableHostManager manager = parent.GetComponentInParent(); + if (manager) return manager.transform; + + return parent; + + } + private static Syncable _MakeOrGetSyncable(GameObject gameObject, bool deleteSubSyncables = true) { //Scene scene = gameObject.scene; //SyncLogger.Msg("Making or getting syncable for: " + gameObject.name); @@ -120,7 +136,7 @@ namespace BoneSync.Sync Syncable syncable = gameObject.GetComponent(); // delete all sub syncables - if (deleteSubSyncabled) + if (deleteSubSyncables) { try { @@ -146,8 +162,9 @@ namespace BoneSync.Sync if (syncable == null) { - syncable = gameObject.AddComponent(); - // SyncLogger.Msg("Created syncable for: " + gameObject.name); + Transform perferredObjectParent = _GetPerferredParentTransform(gameObject.transform); + syncable = _MakeOrGetSyncable(perferredObjectParent.gameObject, deleteSubSyncables); + } return syncable; } @@ -169,31 +186,31 @@ namespace BoneSync.Sync { return parentSyncable; } - return _MakeOrGetSyncable(buttonToggle.gameObject); + return MakeOrGetSyncable(buttonToggle.gameObject); } - public static Syncable MakeOrGetSyncable(GameObject gameObject) + public static Syncable MakeOrGetSyncable(GameObject gameObject, bool deleteSubSyncables = true) { Syncable syncable = _GetSyncableFromCache(gameObject); if (syncable == null) { - syncable = _MakeOrGetSyncable(gameObject); + syncable = _MakeOrGetSyncable(gameObject, deleteSubSyncables); } return syncable; } public static Syncable MakeOrGetSyncable(Poolee poolee) { - return _MakeOrGetSyncable(poolee.gameObject); + return MakeOrGetSyncable(poolee.gameObject); } public static Syncable MakeOrGetSyncable(InteractableHost interactableHost) { if (interactableHost.manager) return MakeOrGetSyncable(interactableHost.manager); - return _MakeOrGetSyncable(interactableHost.gameObject); + return MakeOrGetSyncable(interactableHost.gameObject); } public static Syncable MakeOrGetSyncable(InteractableHostManager interactableHostManager) { - return _MakeOrGetSyncable(interactableHostManager.gameObject, true); + return MakeOrGetSyncable(interactableHostManager.gameObject, true); } public static Syncable SpawnPooleeAndMakeSyncable(SpawnPoolableInfo spawnInfo) @@ -350,5 +367,11 @@ namespace BoneSync.Sync syncable.OnOwnershipTransferRequest(newOwnerId); } } + + internal static Syncable MakeOrGetSyncable(Cart instance) + { + Syncable syncable = MakeOrGetSyncable(instance.gameObject); + return syncable; + } } }