krabmaga 0.6.1

A modern developing art for reliable and efficient Agent-based Model (ABM) simulation with the Rust language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use bevy::prelude::{Commands, Query, Res, ResMut, Sprite, Transform, Visibility};

use crate::engine::state::State;

use crate::visualization::{
    agent_render::{AgentRenderComponent, SpriteType},
    asset_handle_factory::AssetHandleFactoryResource,
    simulation_descriptor::SimulationDescriptor,
    visualization_state::VisualizationState,
    wrappers::{ActiveSchedule, ActiveState},
};

// The system that updates the visual representation of each agent of our simulation.
pub fn renderer_system<
    I: VisualizationState<S> + Clone + 'static + bevy::prelude::Resource,
    S: State,
>(
    mut query: Query<(
        &mut AgentRenderComponent,
        &mut Transform,
        &mut Visibility,
        &mut Sprite,
    )>,
    state_wrapper: ResMut<ActiveState<S>>,
    schedule_wrapper: Res<ActiveSchedule>,
    mut sprite_factory: AssetHandleFactoryResource,
    mut commands: Commands,
    mut vis_state: ResMut<I>,
    sim_data: Res<SimulationDescriptor>,
) {
    if !sim_data.paused {
        vis_state.before_render(
            &mut state_wrapper.0.lock().expect("error on lock"),
            &schedule_wrapper.0.lock().expect("error on lock"),
            &mut commands,
            &mut sprite_factory,
        );

        for (mut agent_render_component, mut transform, mut visible, mut sprite) in query.iter_mut()
        {
            let agent_render = &mut agent_render_component.0;
            let state = state_wrapper.0.lock().expect("error on lock");
            if let Some(agent) =
                vis_state.get_agent(agent_render.as_ref(), &Box::new(state.as_state()))
            {
                agent_render.update(
                    &agent,
                    &mut *transform,
                    &Box::new(state.as_state()),
                    &mut *visible,
                );
                *visible = Visibility::Visible;
                // transform.translation.x = 0.5;
                transform.translation.y += 0.5;
                let SpriteType::Emoji(emoji_code) =
                    agent_render.sprite(&agent, &Box::new(state.as_state()));
                let new_material = sprite_factory.get_material_handle(emoji_code);
                if sprite.image != new_material {
                    sprite.image = new_material;
                }
            } else {
                let schedule = schedule_wrapper.0.lock().expect("error on lock");
                let step = schedule.step;
                if step != 0 {
                    *visible = Visibility::Hidden;
                }
            }
        }
    }
}