pub mod collision;
pub mod common;
mod data;
mod grid;
pub mod physics;
use integral_geometry::Size;
use land2d::Land2D;
use crate::{
collision::CollisionProcessor,
common::{GearAllocator, GearId, Millis},
data::{DataIterator, GearDataManager, TypeIter},
physics::PhysicsProcessor,
};
pub struct World {
allocator: GearAllocator,
data: GearDataManager,
physics: PhysicsProcessor,
collision: CollisionProcessor,
}
impl World {
pub fn new(world_size: Size) -> Self {
let mut data = GearDataManager::new();
PhysicsProcessor::register_components(&mut data);
CollisionProcessor::register_components(&mut data);
Self {
data,
allocator: GearAllocator::new(),
physics: PhysicsProcessor::new(),
collision: CollisionProcessor::new(world_size),
}
}
#[inline]
pub fn new_gear(&mut self) -> Option<GearId> {
self.allocator.alloc()
}
#[inline]
pub fn delete_gear(&mut self, gear_id: GearId) {
self.data.remove_all(gear_id);
self.collision.remove(gear_id);
self.allocator.free(gear_id)
}
pub fn step(&mut self, time_step: Millis, land: &Land2D<u32>) {
let updates = if time_step == Millis::new(1) {
self.physics.process_single_tick(&mut self.data)
} else {
self.physics
.process_multiple_ticks(&mut self.data, time_step)
};
let collisions = self.collision.process(land, &updates);
}
#[inline]
pub fn add_gear_data<T: Clone + 'static>(&mut self, gear_id: GearId, data: &T) {
self.data.add(gear_id, data);
}
#[inline]
pub fn iter_data<T: TypeIter + 'static>(&mut self) -> DataIterator<T> {
self.data.iter()
}
}
#[cfg(test)]
mod tests {
use crate::{
collision::{CircleBounds, CollisionData},
common::Millis,
physics::{PositionData, VelocityData},
World,
};
use fpnum::{fp, FPNum, FPPoint};
use integral_geometry::Size;
use land2d::Land2D;
#[test]
fn data_flow() {
let world_size = Size::new(2048, 2048);
let mut world = World::new(world_size);
let gear_id = world.new_gear().unwrap();
world.add_gear_data(gear_id, &PositionData(FPPoint::zero()));
world.add_gear_data(gear_id, &VelocityData(FPPoint::unit_y()));
world.add_gear_data(
gear_id,
&CollisionData {
bounds: CircleBounds {
center: FPPoint::zero(),
radius: fp!(10),
},
},
);
let land = Land2D::new(Size::new(world_size.width - 2, world_size.height - 2), 0);
world.step(Millis::new(1), &land);
}
}