|
- use glc::{
- math::{linear_step, sqr},
- matrix::Matrix3f,
- vector::{Angle, Vector2f, Vector3f},
- };
- use rand::random;
- use shrev::ReaderId;
- use specs::{
- hibitset::BitSet, prelude::*, world::Index, Entities, ParJoin, Read, ReadStorage, System,
- WriteStorage,
- };
-
- use crate::{
- components::{FleetOwned, Obstacle, Orbit, OrbitOwned, Position, Ship, ShipObstacle, 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>,
- entities: Entities<'a>,
- ships: WriteStorage<'a, Ship>,
- velocities: WriteStorage<'a, Velocity>,
- fleet_owned: ReadStorage<'a, FleetOwned>,
- orbit_owned: ReadStorage<'a, OrbitOwned>,
- positions: ReadStorage<'a, Position>,
- obstacles: ReadStorage<'a, Obstacle>,
- orbits: ReadStorage<'a, Orbit>,
- }
-
- struct Processor<'a> {
- need_update: &'a BitSet,
- entities: &'a Entities<'a>,
- positions: &'a ReadStorage<'a, Position>,
- obstacles: &'a ReadStorage<'a, Obstacle>,
- orbits: &'a ReadStorage<'a, Orbit>,
- orbit_owned: &'a ReadStorage<'a, OrbitOwned>,
- 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,
- entities,
- mut ships,
- mut velocities,
- fleet_owned,
- orbit_owned,
- positions,
- obstacles,
- orbits,
- } = data;
-
- self.progress_events(&fleet_owned);
-
- /* update ships */
- let processor = Processor {
- need_update: &self.need_update,
- entities: &entities,
- positions: &positions,
- obstacles: &obstacles,
- orbit_owned: &orbit_owned,
- orbits: &orbits,
- delta: global.delta * global.world_speed,
- };
-
- let data = (
- positions.mask(),
- &mut ships,
- &mut velocities,
- &positions,
- &fleet_owned,
- );
-
- data.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 orbit_owned = return_if_none!(self.orbit_owned.get(fleet_id));
- let orbit_id = orbit_owned.owner();
- let orbit = return_if_none!(self.orbits.get(orbit_id));
- let orbit_pos = return_if_none!(self.positions.get(orbit_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 = ship_pos - orbit_pos;
- let mut ship_to_target = target_pos - ship_pos;
-
- let r_ship = orbit_to_ship.length_sqr();
- let r_target = orbit_to_target.length_sqr();
-
- let orbit_min = orbit.min();
- let orbit_max = orbit.max();
-
- let target_in_orbit = (r_target <= sqr(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 && 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 = velocity.dir().into_vec3();
-
- let dir = if orbit_to_ship_vec3.cross(&ship_dir_vec3).z > 0.0 {
- 1.0
- } else {
- -1.0
- };
-
- let orbit_min = orbit.min();
- let orbit_max = orbit.max();
-
- let add = SHIP_ORBIT_ANGLE_DELTA_MIN + SHIP_ORBIT_ANGLE_DELTA_RND * random::<f32>();
- let angle = orbit_to_ship.angle2(&VECTOR_2F_POS_X) + (add * dir / orbit_max);
- let radius = orbit_min + (orbit_max - orbit_min) * random::<f32>();
-
- Vector2f::new(
- orbit_pos.x + radius * angle.cos(),
- orbit_pos.y + radius * angle.sin(),
- )
- } else {
- ship.set_obstacle(ShipObstacle::Search);
-
- *orbit_pos
- };
-
- ship.set_target(target_pos, (target_pos - ship_pos).normalize());
-
- ship_to_target = target_pos - ship_pos;
- }
-
- /* check if obstacle is still valid */
- if ship_in_orbit {
- ship.set_obstacle(ShipObstacle::Done);
- } else if let ShipObstacle::Known(obstacle) = ship.obstacle() {
- if let Some(position) = self.positions.get(obstacle) {
- let obstacle_orbit = self.orbits.get(obstacle).unwrap();
- let obstacle_pos = position.pos();
- let ship_to_obstacle = obstacle_pos - ship_pos;
-
- let obstacle_angle = ship_to_target
- .angle2(&ship_to_obstacle)
- .into_deg()
- .into_inner()
- .abs();
-
- let orbit_sqr = obstacle_orbit.max() * obstacle_orbit.max();
- if (obstacle_angle > 90.0 && ship_to_obstacle.length_sqr() > orbit_sqr)
- || obstacle_angle > 170.0
- {
- ship.set_obstacle(ShipObstacle::Search);
- }
- } else {
- ship.set_obstacle(ShipObstacle::Search);
- }
- }
-
- /* find obstacle */
- if !ship_in_orbit && ship.obstacle() == ShipObstacle::Search {
- let mut dist_sqr = f32::MAX;
- for (e, position, _) in (self.entities, self.positions, self.obstacles).join() {
- let obstacle_pos = position.pos();
- let ship_to_obstacle = obstacle_pos - ship_pos;
-
- if ship_to_target * ship_to_obstacle < 0.0 {
- continue; // obstacle is behind the ship
- }
-
- let len_sqr = ship_to_obstacle.length_sqr();
- if len_sqr < dist_sqr {
- dist_sqr = len_sqr;
- ship.set_obstacle(ShipObstacle::Known(e));
- }
- }
-
- if let ShipObstacle::Known(e) = ship.obstacle() {
- if e == fleet_owned.owner() {
- ship.set_obstacle(ShipObstacle::Done);
- }
- }
- }
-
- /* check the obstacle */
- let mut expected_dir = ship_to_target;
- if let ShipObstacle::Known(obstacle) = ship.obstacle() {
- let obstacle_pos = self.positions.get(obstacle).unwrap();
- let obstacle_orbit = self.orbits.get(obstacle).unwrap();
- let ship_to_obstacle = obstacle_pos.pos() - ship_pos;
-
- let orbit_min = obstacle_orbit.min();
- let orbit_max = obstacle_orbit.max();
-
- let orbit = ship_to_obstacle.length();
- if orbit < orbit_max {
- let mut tangent = Vector2f::new(-ship_to_obstacle.y, ship_to_obstacle.x);
-
- let radius = obstacle_pos.shape().radius();
- let mut adjust_low = linear_step(orbit_min, radius, orbit);
- let adjust_high = 1.0 - linear_step(orbit_max, orbit_min, orbit);
-
- if ship_to_target * tangent < 0.0 {
- tangent = -tangent;
- } else {
- adjust_low = -adjust_low;
- }
-
- let a_low = Angle::Deg(45.0);
- let a_high = tangent.angle2(&ship_to_target);
- let mat = Matrix3f::rotate(a_low * adjust_low + a_high * adjust_high);
- expected_dir = mat.transform(tangent);
- }
- }
-
- /* update ship direction */
- let angle = expected_dir.angle2(&velocity.dir());
- if angle.into_inner().abs() > 0.0001 {
- let dir = angle.into_inner() / angle.abs().into_inner();
- let agility = SHIP_ORBIT_AGILITY;
- let rot_speed = agility * linear_step(0.0, 45.0, angle.abs().into_deg().into_inner());
-
- *velocity.dir_mut() *= Matrix3f::rotate(rot_speed * -dir * self.delta);
- }
- }
- }
|