Struct swarm_it::Swarm

pub struct Swarm<T: PartialEq + Eq + Hash + Copy> { /* fields omitted */ }

Main struct that allow you to talk to the library

Methods

impl<T: PartialEq + Eq + Hash + Copy> Swarm<T>

pub fn new() -> Swarm<T>

Constructs a new Swarm.

T - the type of cargo that your carriers will carry around. The Copy bound is going to be removed in future versions.

Example

let game = swarm_it::Swarm::<char>::new();

pub fn add_carrier(&mut self, carrier: Carrier<T>) -> usize

Adds new carrier. Returns the index of the new carrier.

Example

use swarm_it::*;
let mut game = Swarm::<char>::new();
game.add_carrier(Carrier::new(100.0, 200.0));

pub fn add_slot(&mut self, slot: Slot<T>) -> usize

Adds new slot. Returns the index of the new slot.

Example

use swarm_it::*;
let mut game = Swarm::<char>::new();
game.add_slot(Slot::new(100.0, 100.0, None, Some(Payload::new('X')), swarm_it::SlotKind::CLASSIC));

pub fn get_carriers(&self) -> &Vec<Carrier<T>>

Returns all carriers

pub fn get_carriers_mut(&mut self) -> &mut Vec<Carrier<T>>

Returns all carriers

pub fn get_slots(&self) -> &Vec<Slot<T>>

Returns all slots

pub fn get_slots_mut(&mut self) -> &mut Vec<Slot<T>>

Returns all slots

pub fn tick(&mut self) -> bool

The engine must be regularly ticked by the outside world by invoking this function. At each tick swarm will perform calculation of the internal state logic, move carriers around, etc.

Returns true if there were no more action required, meaning that carriers have finished tranferring the layout to target position.

Example

use swarm_it::*;
let mut game = Swarm::<char>::new();
if game.tick() { println!("Job finished, yay!"); };

pub fn slot_data_changed(&mut self)

Initiates some precalculation in order for the carriers to be aware of modified slots. Call this function each time you finished adding new slots or manually manipulating their data through get_slots_mut().

In the future I might eventually remove this obligation, but I need to come up with some clever way of deciding whether a precalc is needed or not. Invoking precalc after each single change is an overkill, since one might want to add 100k slots and do the precalc only once at the end.

Example

use swarm_it::*;
let mut game = Swarm::<char>::new();
game.slot_data_changed();

TODO

Different kind of that may change. Provide additional parameter in order NOT to precalculate everything

1. Slot payload => recalculate cargo balance
2. Slots added/removed => recalculate slot distances

Trait Implementations

impl<T: Default + PartialEq + Eq + Hash + Copy> Default for Swarm<T>

fn default() -> Swarm<T>

Returns the "default value" for a type.