rustsim-core 0.0.1

use rand::rngs::StdRng;
use rand::SeedableRng;
use rustsim_core::{
    prelude::{Agent, Fastest, HashMapStore, StandardModel, StepContext},
    store::AgentStore,
    types::AgentId,
};
mod support;
use support::NothingSpace;

#[derive(Debug, Clone)]
struct Pedestrian {
    id: AgentId,
    position: i32,
    speed: i32,
}

impl Agent for Pedestrian {
    fn id(&self) -> AgentId {
        self.id
    }
}

type PedestrianModel =
    StandardModel<NothingSpace, Pedestrian, HashMapStore<Pedestrian>, (), StdRng, Fastest>;

fn pedestrian_step(
    agent: &mut Pedestrian,
    _ctx: &mut StepContext<'_, NothingSpace, Pedestrian, (), StdRng, Fastest>,
) {
    agent.position += agent.speed;
}

fn model_step(_model: &mut PedestrianModel) {}

#[test]
fn pedestrians_walk_at_different_speeds() {
    let mut store = HashMapStore::new();
    store.insert(Pedestrian {
        id: 1,
        position: 0,
        speed: 1,
    });
    store.insert(Pedestrian {
        id: 2,
        position: 0,
        speed: 2,
    });
    store.insert(Pedestrian {
        id: 3,
        position: 0,
        speed: 3,
    });

    let space = NothingSpace;
    let scheduler = Fastest::new();
    let properties = ();
    let rng = StdRng::seed_from_u64(42);

    let mut model = PedestrianModel::new(
        store,
        space,
        scheduler,
        properties,
        rng,
        Some(Box::new(pedestrian_step)),
        Some(model_step),
        true,
    );

    model.step_n(2);

    assert_eq!(model.agent(1).unwrap().position, 2);
    assert_eq!(model.agent(2).unwrap().position, 4);
    assert_eq!(model.agent(3).unwrap().position, 6);
}