|
- use glc::{
- math::{linear_step, sqr},
- matrix::Matrix3f,
- vector::{Vector2f, Vector3f},
- };
- use rand::random;
- use shrev::ReaderId;
- use specs::{
- hibitset::BitSet, prelude::*, world::Index, ParJoin, Read, ReadStorage, System, WriteStorage,
- };
-
- use crate::{
- components::{Fleet, FleetOwned, Position, Ship, Velocity},
- constants::{
- SHIP_ORBIT_AGILITY, SHIP_ORBIT_ANGLE_DELTA_MIN, SHIP_ORBIT_ANGLE_DELTA_RND,
- SHIP_ORBIT_DISTANCE_MAX, VECTOR_2F_POS_X,
- },
- misc::ComponentEvent,
- resources::Global,
- return_if_none,
- };
-
- pub struct Ships {
- need_update: BitSet,
- fleet_owned_id: ReaderId<ComponentEvent<FleetOwned>>,
- }
-
- #[derive(SystemData)]
- pub struct ShipsData<'a> {
- global: Read<'a, Global>,
- ships: WriteStorage<'a, Ship>,
- velocities: WriteStorage<'a, Velocity>,
- fleet_owned: ReadStorage<'a, FleetOwned>,
- positions: ReadStorage<'a, Position>,
- fleets: ReadStorage<'a, Fleet>,
- }
-
- struct Processor<'a> {
- need_update: &'a BitSet,
- positions: &'a ReadStorage<'a, Position>,
- fleets: &'a ReadStorage<'a, Fleet>,
- delta: f32,
- }
-
- impl Ships {
- pub fn new(world: &mut World) -> Self {
- let need_update = BitSet::new();
- let fleet_owned_id = unsafe {
- WriteStorage::<FleetOwned>::setup(world);
-
- let mut fleet_owned = world.system_data::<WriteStorage<FleetOwned>>();
- fleet_owned
- .unprotected_storage_mut()
- .channel_mut()
- .register_reader()
- };
-
- Self {
- need_update,
- fleet_owned_id,
- }
- }
-
- fn progress_events(&mut self, fleet_owned: &ReadStorage<'_, FleetOwned>) {
- self.need_update.clear();
- let events = fleet_owned
- .unprotected_storage()
- .channel()
- .read(&mut self.fleet_owned_id);
- for event in events {
- let id = match event {
- ComponentEvent::Inserted(id) => id,
- ComponentEvent::Modified(id, _) => id,
- ComponentEvent::Removed(id, _) => id,
- };
-
- self.need_update.add(*id);
- }
- }
- }
-
- impl<'a> System<'a> for Ships {
- type SystemData = ShipsData<'a>;
-
- fn run(&mut self, data: Self::SystemData) {
- let ShipsData {
- global,
- mut ships,
- mut velocities,
- fleet_owned,
- positions,
- fleets,
- } = data;
-
- self.progress_events(&fleet_owned);
-
- /* update ships */
- let processor = Processor {
- need_update: &self.need_update,
- positions: &positions,
- fleets: &fleets,
- delta: global.delta,
- };
- (
- positions.mask(),
- &mut ships,
- &mut velocities,
- &positions,
- &fleet_owned,
- )
- .par_join()
- .for_each(|(id, ship, velocity, position, fleet_owned)| {
- processor.progress_ship(id, ship, velocity, position, fleet_owned);
- });
- }
- }
-
- impl Processor<'_> {
- fn progress_ship(
- &self,
- id: Index,
- ship: &mut Ship,
- velocity: &mut Velocity,
- position: &Position,
- fleet_owned: &FleetOwned,
- ) {
- let fleet_id = fleet_owned.owner;
- let fleet = return_if_none!(self.fleets.get(fleet_id));
- let orbit_pos = return_if_none!(self.positions.get(fleet_id)).pos;
- let ship_pos = position.pos;
- let target_pos = ship.target_pos;
- let target_dir = ship.target_dir;
-
- let orbit_to_target = target_pos - orbit_pos;
- let orbit_to_ship = position.pos - orbit_pos;
- let ship_to_target = target_pos - position.pos;
-
- let r_ship = orbit_to_ship.length_sqr();
- let r_target = orbit_to_target.length_sqr();
-
- let orbit_min = fleet.orbit_min;
- let orbit_max = fleet.orbit_max;
-
- let target_in_orbit = (r_target <= sqr(fleet.orbit_max)) && (r_target >= sqr(orbit_min));
- let ship_in_orbit = r_ship < sqr(SHIP_ORBIT_DISTANCE_MAX * orbit_max);
-
- let need_update = self.need_update.contains(id);
- let has_target = target_dir.length_sqr() != 0.0;
- let passed_target = target_dir * ship_to_target <= 0.0;
-
- /* check and update target posistion */
- if need_update || !has_target || passed_target || ship_in_orbit != target_in_orbit {
- let target_pos = if ship_in_orbit && fleet.orbit_max > 0.0 {
- let orbit_to_ship_vec3 = Vector3f::new(orbit_to_ship.x, orbit_to_ship.y, 0.0);
- let ship_dir_vec3 = Vector3f::new(velocity.dir.x, velocity.dir.y, 0.0);
-
- let dir = if orbit_to_ship_vec3.cross(&ship_dir_vec3).z > 0.0 {
- 1.0
- } else {
- -1.0
- };
-
- let angle = orbit_to_ship.angle2(&VECTOR_2F_POS_X);
- let angle = angle
- + (SHIP_ORBIT_ANGLE_DELTA_MIN + SHIP_ORBIT_ANGLE_DELTA_RND * random()) * dir
- / fleet.orbit_max;
- let radius =
- fleet.orbit_min + (fleet.orbit_max - fleet.orbit_min) * random::<f32>();
-
- Vector2f::new(
- orbit_pos.x + radius * angle.cos(),
- orbit_pos.y + radius * angle.sin(),
- )
- } else {
- orbit_pos
- };
-
- ship.target_pos = target_pos;
- ship.target_dir = (target_pos - ship_pos).normalize();
- }
-
- /* update ship direction */
- let angle = ship_to_target.angle2(&velocity.dir);
- if angle.into_inner().abs() > 0.0001 {
- let dir = angle.into_inner() / angle.abs().into_inner();
- let agility = if ship_in_orbit {
- SHIP_ORBIT_AGILITY
- } else {
- ship.agility
- };
- let rot_speed = agility * linear_step(0.0, 45.0, angle.abs().into_deg().into_inner());
-
- let m = Matrix3f::new(
- Vector3f::new(velocity.dir.y, -velocity.dir.x, 0.0),
- Vector3f::new(velocity.dir.x, velocity.dir.y, 0.0),
- Vector3f::new(0.0, 0.0, 1.0),
- );
- let m = m * Matrix3f::rotate(rot_speed * -dir * self.delta);
-
- velocity.dir = Vector2f::new(m.axis_y.x, m.axis_y.y);
- }
- }
- }
|