Panic happened when borrow the component as mutable by ECS World using RefCell?

[cmanlh]

The panic happened in the cost_system function. Does it not allowed to borrow mutable component by world? Thanks.

use std::cell::RefCell;

use bevy::{prelude::*, sprite::MaterialMesh2dBundle};

#[derive(Component)]
struct Storage {
    balance: f64,
}

#[derive(Component)]
struct Consumer {
    consumption: f64,
}

#[derive(Resource)]
struct Registers {
    entities: Vec<Entity>,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(Registers { entities: vec![] })
        .add_systems(Startup, startup_system)
        .add_systems(Update, cost_system)
        .run();
}

fn cost_system(world: &mut World) {
    let ref_world = RefCell::new(world);

    if let Some(registers) = ref_world.borrow().get_resource::<Registers>() {
        for ele in &registers.entities {
            if let Some(consumer) = ref_world.borrow().get::<Consumer>(*ele) {
                if let Some(mut storage) = ref_world.borrow_mut().get_mut::<Storage>(*ele) {
                    if storage.balance > 0.0 {
                        storage.balance -= consumer.consumption;
                    }
                }
            }
        }
    };
}

fn startup_system(
    mut registers: ResMut<Registers>,
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<ColorMaterial>>,
) {
    commands.spawn(Camera2dBundle::default());

    registers.entities.push(
        commands
            .spawn((
                Storage { balance: 100. },
                Consumer { consumption: 13.5 },
                MaterialMesh2dBundle {
                    mesh: meshes.add(shape::Circle::new(12.).into()).into(),
                    material: materials.add(ColorMaterial::from(Color::RED)),
                    transform: Transform::from_translation(Vec3::new(-128., 0., 0.)),
                    ..default()
                },
            ))
            .id(),
    );

    registers.entities.push(
        commands
            .spawn((
                Storage { balance: 300. },
                Consumer { consumption: 36.5 },
                MaterialMesh2dBundle {
                    mesh: meshes.add(shape::Circle::new(12.).into()).into(),
                    material: materials.add(ColorMaterial::from(Color::BLUE)),
                    transform: Transform::from_translation(Vec3::new(-64., 0., 0.)),
                    ..default()
                },
            ))
            .id(),
    );

    registers.entities.push(
        commands
            .spawn((
                Storage { balance: 130. },
                Consumer { consumption: 3.5 },
                MaterialMesh2dBundle {
                    mesh: meshes.add(shape::Circle::new(12.).into()).into(),
                    material: materials.add(ColorMaterial::from(Color::WHITE)),
                    transform: Transform::from_translation(Vec3::new(256., 64., 0.)),
                    ..default()
                },
            ))
            .id(),
    );
}

[tim-blackbird]

You cannot mutably borrow a value while it is already borrowed, even through a RefCell.
The panic here is coming from RefCell::borrow_mut.

Is there a reason you're trying to do this via &mut World?
If not, doing this via a regular system with a Query would be a lot simpler.

[cmanlh]

Thanks a lot.

In my case, there would be many systems to process different relationship case between a target entity with other entities which are binding to the target entity. (The binding is dynamic, would be changed every frame.)

Finding the binding data is high costs operation, so I think putting the data in cache (Resource in Bevy ECS) for each frame, and reused by all systems.

Above is my reason to do this via &mut World.

I am newbie to Rust and Bevy. I guess I didn't have the correct way to achieve my appeal.