# 4. Parenting entities

Every now and then it makes sense to parent network entities to each other, for instance when creating vehicles or an elevator. In this sample scene we'll see what are the implications of that, and how **coherence** uses this to optimize network traffic.

### **Controls**

* **WASD** or **Left stick**: Move character
* Hold **Shift** or **Shoulder button left**: Run
* **Spacebar** or **Joypad button down**: Jump

### Topics covered

Moving platforms | [Local positions](/0.10/coherence-sdk-for-unity/networking-state-changes/hierarchies-and-child-objects/parent-child.md) | Parenting at runtime | [Optimization](/0.10/coherence-sdk-for-unity/optimization.md)

## In this scene...

This wintery setting contains 2 moving platforms running along splines. Players can jump on them and they will receive the platform's movement and rotation, while still being able to move relative to the platform itself.

<figure><img src="/files/AYsfNWg9R7inmEsp5j76" alt=""><figcaption><p>A player is riding a moving platform, and its Prefab gets parented to it.</p></figcaption></figure>

### How it's set up

This scene doesn't require anything special in terms of network setup to work.

Direct parenting of network entities in **coherence** happens exactly like usual, with a simple `transform.SetParent()`, or even just dragging one GameObject onto another in the Unity Editor's *Hierarchy* window. The player's `Move` script is set to recognize the moving platforms when it lands on them, and it just parents itself to it.

As for the platforms, they are just moving themselves as kinematic rigid bodies, following the path of their spline (see the `FloatingPlatform` script). Their position and rotation is synced on the network, and the first Client to connect assumes authority over them.

<figure><img src="/files/tYgUaQ4rnlgrFxYamzdD" alt=""><figcaption><p>As usual, hitting Tab shows authority. The Client named "player" is currently simulating the platforms.</p></figcaption></figure>

### Effects of parenting entities

Once directly parented, **coherence** automatically switches to sync the child's position and rotation as local, rather than in world space. This means that when child entities don't move within their parent, no data about them is being sent across the network.

Imagine for instance a situation where 3 players are riding one of the platforms and not moving, only the coordinates of the platform are being synced every frame.

### Limitations of simple parenting

You might have noticed we always mentioned "direct" parenting. One limitation of this simple setup is that the parented network entity has to be a first-level child of the parent one. This doesn't exclude that the parent can have other child GameObjects (and other networked entities!), but networked entities have to be a direct child.

A hierarchy could look like this:

* **Platform**
  * **Player**
    * Character graphics
    * Bones
    * ...
  * Platform's graphics
  * ...

(In bold is the root of each Prefab, which has a `CoherenceSync` component)

You can even parent multiple network entities to each other. For example, a networked character holding a networked crate, riding a networked elevator, on a networked spaceship. In that case:

* **Spaceship**
  * **Elevator1**
    * Elevator graphics
  * **Elevator2**
    * **Player**
      * **Crate**
      * Character graphics
    * Elevator graphics
  * Spaceship graphics
  * ...

For cases like these, **coherence** takes care of them automatically. More complex hierarchies require a different handling, and we cover them in [another lesson](/0.10/learning-coherence/first-steps-tutorial/5-complex-hierarchies.md).

{% hint style="warning" %}
One final note: re-parenting *has* to happen at runtime. Currently, **coherence** doesn't support the authoring of Prefabs with more than one `CoherenceSync` nested inside each other, but this will come in a future version.
{% endhint %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.coherence.io/0.10/learning-coherence/first-steps-tutorial/4-parenting-entities.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
