Newbie question about mutable queries and lifetimes

[nussera]

Hello!

Let me start by saying that I really think that bevy is a great game engine in the making. I'm not new to programming, but new to rust and was searching for a project to develop my rust skills. Trying to write a small game with bevy is exactly what I needed to keep me motivated.

That said, I'm still struggling with some of the ways Rust forces one write the code. One such thing is the borrow checker, lifetimes and mutability. With some patience and effort I was able to decipher and solve most of my problems, but now I'm stuck.

I have a system, that gets a mutable query to lookup the visibility of some entities and modify it. The following code is a simplification of the actual code.

pub struct ParentEntitis {
    a: Entity,
    b: Entity
}

#[derive(Component)]
pub struct Hover;

pub fn test_system(
    parents: Res<ParentEntitis>,
    mut query: Query<(&mut Visibility, &Hover)>,
) {
    let a = get_visibility(parents.a, query);
    if let Some(a) = a {
        let mut visibility = a.0;
        let show = a.1;
        visibility.is_visible = show;
    }
    let b = get_visibility(parents.b, query);
    if let Some(b) = b {
        let mut visibility = b.0;
        let show = b.1;
        visibility.is_visible = show;
    }
}

fn get_visibility(lookup: Entity, mut query: Query<(&Parent, &mut Visibility, &Hover)>) -> Option<(Mut<Visibility>, bool)> {
    let hover = query.iter().find(|(parent, _, _)|{
        parent.id() == lookup.id()
    }).map(|(visibility, hover)| hover);
    
    let mut visibility = query.iter_mut().find(|(parent, _, _)|{
        parent.id() == lookup.id()
    }).map(|(visibility, hover)| visibility);

    if let Some(visibility) = visibility {
        Some((visibility, hover.is_some()))
    } else {
        None
    }
}

As you may notice, the code doesn't compile because of missing lifetime specifiers. But even when I was able to somehow get rid of the lifetime specifier errors, it would not let me call the get_visibility() function a second time. It would state that the "query" was already moved. Funnily enough: If I inline the function get_visibility() I don't have any of the mentioned problems.

I tried to use query.get_component_mut::<Visibility>(parent_entity), but I need the Visibility of the child that has the Hover component. Not the parents Visibility. A possible solution I came across, was to have a second query of kind query2: Query<&Children, With<ParentMarker>>. There I could lookup the Children component, iterate over all children and retrieve the Visibility from the first query. Somehow this doesn't look bette to me.

So I came to the conclusion, that I need help on how to fix the code snipped above. Maybe this is the wrong forum to ask this question. In this case I would humbly ask for directions to the correct forum and offer my apologies.

Nevertheless, I would like to thank you for your great work and help in advance.

• Andreas

[colepoirier]

Fortunately this has an easy solution! Instead of searching using .iter().find() you should use query.get(entity). Let me know if this solves tour problem! :)

[nussera]

But with query.get_mut(parent_entity) I would get the components of the parent_entity. The parent_entity doesn't have the Hover component, so the query won't find it. This is because I don't want to change the visibility of the parent entity but of some of it's children.

[nussera]

The idea is: A player hovers over a sprite and instead of manipulating the sprite, I toggle the visibility of a child entity to display different decorations.

[colepoirier]

Ah in that case, add Children to your query, and then do query.get_component_mut::<Visibility>(child_entity).

[nussera]

Yes! It is alive! Thank you soo much. This is the resulting code.

pub fn hover_star_system(
    mouse_over: Res<MouseOver>,
    mut last_hover: ResMut<LastHover>,
    parent_query: Query<&Children, With<MouseInteractible>>,
    mut hover_query: Query<(&mut Visibility, &Hover)>
){
    // ... here is some additional logic to prevent the code from running when nothing has changed.

    let last_children =last_hover.entity.map_or(None, |entity| parent_query.get_component::<Children>(entity).ok());
    toggle_visibility(last_children, &mut hover_query, false);
    
    let current_children =mouse_over.entity.map_or(None, |entity| parent_query.get_component::<Children>(entity).ok());
    toggle_visibility(current_children, &mut hover_query, true);

    last_hover.entity = mouse_over.entity.clone()
}

fn toggle_visibility(children: Option<&Children>, hover_query: &mut Query<(&mut Visibility, &Hover)>, target_state: bool) {
    if children.is_some() {
        let children = children.unwrap();
        children.iter().for_each(|child| {
            let visibility = hover_query.get_component_mut::<Visibility>(*child);
            if visibility.is_ok() {
                let mut tmp = visibility.unwrap();
                tmp.is_visible = target_state;
            }
        });
    }
}

FYI: Both 'mut' for the hover_query are necessary. If I remove the first one, it will not compile. If I remove the second one, it will not find the Visibility component.

Just out of curiosity: Do you see any room for improvement?

Thanks again and have a greet day/night!

[colepoirier]

Happy to help! Yes both mut’s are necessary my bad. No room for improvement IMO. Heads up for the future you can get rust syntax highlighting by using ```rust