Deep Child CoherenceSyncs
CoherenceSync parent-child relationships on complex hierarchies
While the basic case of direct parent-child relationships between CoherenceSync entities is handled automatically by coherence, more complex hierarchies (with multiple levels) need a little extra work.
An example of such a hierarchy would be a synced Player Prefab with a hierarchical bone structure, where you want to place an item (e.g. a flashlight) in the hand:
Player > Shoulder > Arm > Hand
A Prefab can only have a single
CoherenceSyncscript on it (and only on its root node), so you can't add an additional one to the hand. Instead, you need to add the
CoherenceNodecomponent to another Prefab so that it can be parented. Please note that this parenting relationship can only be set up in the scene or at runtime; you can't store it in the parent Prefab since that would break the rule of only one
To prepare the child Prefab that you want to place in the hierarchy, add the
CoherenceNodecomponent to it (it also has to have a
CoherenceSync). In the example above, that would be the flashlight you want your player to be able to pick up. You don't need to make any changes to the Player Prefab, just make sure it has a
CoherenceSyncscript in the root.
This setup allows you to place instances of the flashlight Prefab anywhere in the hierarchy of the Player (you could even move it from one hand to the other, and it will work).
The one important constraint is that the hierarchies have to be identical on all Clients.
To recap, for CoherenceNode to work you need two things:
- 1.One or more Prefabs with
CoherenceSyncthat have some kind of hierarchy of child transforms (the child transforms can't have CoherenceSyncs on them).
- 2.Another Prefab with
CoherenceNode. Instances of this Prefab can now be parented to any transform of the Prefabs with just CoherenceSync (in step 1).
CoherenceNodeworks using two public fields which are automatically set to sync using the
[Sync] public string path;
[Sync] public int pathDirtyCounter;
pathvariable describes where in the parent's hierarchy the child object should be located. It is a string consisting of comma-separated indexes. Every one of these indexes designates a specific child index in the hierarchy. The child object which has the
CoherenceNodecomponent will be placed in the resulting place in the hierarchy.
pathDirtyCountervariable is a helper variable used to keep track of the applied hierarchy changes. In case the object's position in the parent's hierarchy changes, this variable will be used to help settle and properly sync those changes.
Note: This is simply an example solution for a particular case which uses other tools coherence provides. Your project's needs might be different and require a different custom solution.