use integral_geometry::Size;

    common::{

        GearId,

        GearData,

        GearDataAggregator,

        GearDataProcessor

    },

macro_rules! processor_map {

    ( $data_type: ident => $field: ident ) => {

        impl GearDataAggregator<$data_type> for World {

            fn find_processor(&mut self) -> &mut GearDataProcessor<$data_type> {

                &mut self.$field

            }

        }

    }

}

processor_map!(PhysicsData => physics);

processor_map!(CollisionData => collision);

    pub fn new(world_size: Size) -> Self {

        Self {

            physics: PhysicsProcessor::new(),

            collision: CollisionProcessor::new(world_size)

        }

    }

    pub fn add_gear_data<T>(&mut self, gear_id: GearId, data: T)

        where T: GearData,

              Self: GearDataAggregator<T>

    {

        self.find_processor().add(gear_id, data);

    use crate::{

        World,

        physics::PhysicsData,

        collision::{CollisionData, CircleBounds}

    };

    use fpnum::{FPNum, FPPoint, fp};

    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 = 46631;

        world.add_gear_data(gear_id, PhysicsData {

            position: FPPoint::zero(),

            velocity: 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(fp!(1), &land);

    }