Get Entity from scene hierarchy

[Fidius-jko]

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

For example i have player with sprite, and player have Hp and HpBar. I use separate entity for render HpBar . And when i update hpbar, i am getting player children and get first child. This is not comfortable.

What solution would you like?

Add functions for world:

impl World {
     fn get_entity_from_path(&self, path: &str) -> Entity {...}
     fn get_path_from_entity(&self, entity: &Entity) -> String {...}
     ...
}

Path will be like "EntityId or Name/EntityId or Name/...."

Example:

fn update_hp_bar(world: World) {
     ... Get Player entity
     let hpbar_entity = world.get_entity_from_path(world.get_path_from_entity(&player_entity) + "/hpbar");
     ... Process hpbar
}

[MacTrissy]

I will try to implement it

[mockersf]

Instead of working on string, it should probably work on a vec of components

fn get_entity_from_path<C: Component>(&self, path: &[C]) -> Entity {...}
fn get_path_from_entity<C: Component>(&self, entity: &Entity) -> Vec<C> {...}

If not generic, on Name, but there are plans to maybe change it, I think.

String is bad because you would have to introduce a character that can't be used in a name, and there's no reason to do that

[MacTrissy]

I agree, was about to ask about that now ^^. Thanks for the generics hint, I did not know Name was about to change.

Another thing I want to talk about is:

When used in the main world instead of a subworld like in a scene, the path is not necessarily unique nor even defined (unnamed entities or entities with their own id as name which can change between program executions [or generic: missing components]).
To make it usable in this scenario we could introduce a new type EntityNamePath or a tuple that contains an optional root entity and the Component list as path relative to this entity. If no entity is given, the root entities of this world will be used.
We could also use it directly in the functions like

get_entity_from_path<C: Component>(&self, root: Option<Entity>, path: &[C]) -> Option<Entity>
get_path_from_entity<C: Component>(&self, root: Option<Entity>, entity: &Entity) -> Option<Vec<C>>

I like the way without the new type because of the growing code base for such a small use case. Also, we make sure the user quickly understands that a path is relative to a root and only valid in its context or a certain scene.

What do you think about that?

[Fidius-jko]

Instead of working on string, it should probably work on a vec of components

fn get_entity_from_path<C: Component>(&self, path: &[C]) -> Entity {...}
fn get_path_from_entity<C: Component>(&self, entity: &Entity) -> Vec<C> {...}

If not generic, on Name, but there are plans to maybe change it, I think.

String is bad because you would have to introduce a character that can't be used in a name, and there's no reason to do that

It sounds good. Anyone will can create their own "Name" component if they want
It is more versatile.