krabmaga 0.6.0

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use bevy::prelude::{Commands, Resource, Sprite};

use crate::bevy::prelude::{Quat, Transform, Vec3};
use crate::engine::{agent::Agent, schedule::Schedule, state::State};

use crate::visualization::{
    agent_render::{AgentRender, AgentRenderComponent, SpriteType},
    asset_handle_factory::AssetHandleFactoryResource,
    simulation_descriptor::SimulationDescriptor,
    wrappers::SimulationRenderEntity,
};

// A simple trait which lets the developer set up the visualization components of his simulation.
// This method will be called in a Bevy startup system.
pub trait VisualizationState<S: State>: Send + Sync + Resource {
    fn on_init(
        &self,
        commands: &mut Commands,
        sprite_render_factory: &mut AssetHandleFactoryResource,
        state: &mut S,
        schedule: &mut Schedule,
        sim: &mut SimulationDescriptor,
    );

    fn setup_graphics(
        &self,
        schedule: &mut Schedule,
        commands: &mut Commands,
        state: &mut S,
        mut sprite_render_factory: AssetHandleFactoryResource,
    ) {
        for (agent_impl, _) in schedule.events.iter() {
            let agent_render = self.get_agent_render(&agent_impl.agent, state);
            match agent_render {
                Some(agent_render) => {
                    let boxed_state = Box::new(state.as_state());
                    let SpriteType::Emoji(emoji_code) =
                        agent_render.sprite(&agent_impl.agent, &boxed_state);
                    let sprite_render = sprite_render_factory.get_emoji_loader(emoji_code);
                    self.setup_agent_graphics(
                        &agent_impl.agent,
                        agent_render,
                        sprite_render,
                        commands,
                        &boxed_state,
                    );
                }
                None => {}
            }
        }
    }

    fn setup_agent_graphics(
        &self,
        agent: &Box<dyn Agent>,
        agent_render: Box<dyn AgentRender>,
        sprite: Sprite,
        commands: &mut Commands,
        state: &Box<&dyn State>,
    ) {
        // AgentVis separate object which accepts an agent reference
        let (x, y, z) = agent_render.location(agent, state);
        let (scale_x, scale_y) = agent_render.scale(agent, state);
        let rotation = agent_render.rotation(agent, state);

        let mut transform = Transform::from_translation(Vec3::new(x, y + 0.5, z));
        transform.scale.x = scale_x;
        transform.scale.y = scale_y;
        transform.rotation = Quat::from_rotation_z(rotation);

        commands
            .spawn((sprite, transform))
            .insert(AgentRenderComponent(agent_render))
            .insert(SimulationRenderEntity);
    }

    // The user must specify which AgentRender is associated to which Agent through this method
    // TODO: how can the developer connect the two? Type string identifier?
    fn get_agent_render(&self, agent: &Box<dyn Agent>, state: &S) -> Option<Box<dyn AgentRender>>;

    fn get_agent(
        &self,
        agent_render: &dyn AgentRender,
        state: &Box<&dyn State>,
    ) -> Option<Box<dyn Agent>>;

    fn before_render(
        &mut self,
        _state: &mut S,
        _schedule: &Schedule,
        _commands: &mut Commands,
        _sprite_factory: &mut AssetHandleFactoryResource,
    ) {
    }
}