Migrate Observers to use Relationships

[viridia]

What problem does this solve or what need does it fill?

Currently the .observe() method on an entity creates a hidden satellite entity to hold the observer. This satellite entity is linked to the parent via a bespoke mechanism, so that the observer is despawned when the parent is. This mechanism should instead be replaced by the new Relationship mechanism recently introduced.

This has a number of advantages, the main one being that it allows observers to be defined declaratively, using a syntax that is consistent with the way child entities are defined.

When combined with the new spawning PR, this would permit syntax like the following:

commands.spawn((
    Node::default(),
    children![
        // Children go here
    ],
    observers![
        Observer::new(|trigger: Trigger<Pointer<Click>>, mut commands: Commands| {
            // etc.
        }),
        Observer::new(|trigger: Trigger<Pointer<Down>>, mut commands: Commands| {
            // etc.
        }),
    ]
)

What solution would you like?

We would define a new Relationship, Observers and it's counterpart ObserverOf (or Observing if you want to get cute). This is essentially a cut & paste of Children with the names changed.

The existing .observe() method would be changed to insert an ObserverOf component, for backwards compatibility.

What alternative(s) have you considered?

Technically, a third-party crate could define it's own Observers relationship and things would work. However, it would be best if this was centralized within Bevy so that multiple authors didn't end up defining their own observer solutions.

Additional context

Backwards compatibility considerations: Ideally, there should be little or no migration required for "ordinary" users of observers. However, there are two classes of advanced users which might be affected:

• Inspectors that display a hierarchy of children and filter out observers (currently observers appear at the root level since they have no parents)
• Code that iterates through the components of an entity (since now there will be an Observers component)

[viridia]

Note that merely spawning an Observer with a relationship to the observed entity is insufficient, because the observer also has a separate variable which contains the list of entities it is observing.

[eckz]

I've tried to dive a little bit into this issue, and the main problem is that Observer can track between 0 (which means all) and N entities, and any entity can be observed by 0..N entities, making it a ManyToMany relationship, which is not currently supported.

One possible solution would be to split Observer into different type of Observers, like ObserveOne, ObserveMany, ObserveAll, but I doubt that's any close to an ideal solution.

Note: ObservedBy already exists to kind of fulfil the ManyToMany relationship end