blackout/src/core.rs

use std::{
    cmp::{max, min},
    f32::consts::PI,
    fmt::Display,
    sync::RwLock,
};

use bevy::{
    app::PluginGroupBuilder,
    math::{CompassOctant, CompassQuadrant, FloatOrd},
    prelude::*,
};
use bevy_rapier2d::{
    parry::query::{closest_points, distance, ClosestPoints},
    prelude::*,
    rapier::{math::Isometry, prelude::Aabb},
};
use once_cell::sync::Lazy;
use rand::prelude::*;
use serde::{Deserialize, Serialize};

fn relative_desc(rot: &Rot2) -> String {
    let mode = RELATIVE_DIRECTION_MODE.read().unwrap();
    match rot.as_radians() {
        v if v <= PI / 12. && v > -PI / 12. => "ahead",
        v if v <= PI / 4. && v > PI / 12. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "11:00"
            } else {
                "ahead and left"
            }
        }
        v if v <= 3. * PI / 8. && v > PI / 4. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "10:00"
            } else {
                "left and ahead"
            }
        }
        v if v <= 5. * PI / 8. && v > 3. * PI / 8. => "left",
        v if v <= 3. * PI / 4. && v > 5. * PI / 8. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "8:00"
            } else {
                "left and behind"
            }
        }
        v if v <= 11. * PI / 12. && v > 3. * PI / 4. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "7:00"
            } else {
                "behind and left"
            }
        }
        v if v <= PI && v > 11. * PI / 12. || v > -PI && v <= -11. * PI / 12. => "behind",
        v if v <= -3. * PI / 4. && v > -11. * PI / 12. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "5:00"
            } else {
                "behind and right"
            }
        }
        v if v <= -5. * PI / 8. && v > -3. * PI / 4. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "4:00"
            } else {
                "right and behind"
            }
        }
        v if v <= -3. * PI / 8. && v > -5. * PI / 8. => "right",
        v if v <= -PI / 4. && v > -3. * PI / 8. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "2:00"
            } else {
                "right and ahead"
            }
        }
        v if v <= -PI / 12. && v > -PI / 4. => {
            if *mode == RelativeDirectionMode::ClockFacing {
                "1:00"
            } else {
                "ahead and right"
            }
        }
        _ => "ahead",
    }
    .into()
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
pub struct MovementDirection(CompassOctant);

impl From<Rot2> for MovementDirection {
    fn from(rot: Rot2) -> Self {
        use CompassOctant::*;
        MovementDirection(match rot.as_radians() {
            h if h > -PI / 8. && h <= PI / 8. => East,
            h if h > PI / 8. && h <= 3. * PI / 8. => NorthEast,
            h if h > 3. * PI / 8. && h <= 5. * PI / 8. => North,
            h if h > 5. * PI / 8. && h <= 7. * PI / 8. => NorthWest,
            h if h > 7. * PI / 8. || h <= -7. * PI / 8. => East,
            h if h > -7. * PI / 8. && h <= -5. * PI / 8. => SouthEast,
            h if h > -5. * PI / 8. && h <= -3. * PI / 8. => South,
            h if h > -3. * PI / 8. && h <= -PI / 8. => SouthWest,
            _ => West,
        })
    }
}

// Converting from strings into directions doesn't make sense.
#[allow(clippy::from_over_into)]
impl Into<String> for MovementDirection {
    fn into(self) -> String {
        use CompassOctant::*;
        match self.0 {
            North => "north",
            NorthEast => "northeast",
            East => "east",
            SouthEast => "southeast",
            South => "south",
            SouthWest => "southwest",
            West => "west",
            NorthWest => "northwest",
        }
        .into()
    }
}

impl Display for MovementDirection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str: String = (*self).into();
        write!(f, "{}", str)
    }
}

#[derive(Component, Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
#[reflect(Component)]
pub struct CardinalDirection(pub CompassQuadrant);

impl Default for CardinalDirection {
    fn default() -> Self {
        Self(CompassQuadrant::East)
    }
}

impl From<Rot2> for CardinalDirection {
    fn from(rot: Rot2) -> Self {
        use CompassQuadrant::*;
        CardinalDirection(match rot.as_radians() {
            h if h > -PI / 4. && h <= PI / 4. => East,
            h if h > PI / 4. && h <= 3. * PI / 4. => North,
            h if h > 3. * PI / 4. || h <= -3. * PI / 4. => West,
            _ => South,
        })
    }
}

impl From<&CardinalDirection> for Rot2 {
    fn from(direction: &CardinalDirection) -> Self {
        use CompassQuadrant::*;
        match direction.0 {
            North => Rot2::radians(PI / 2.),
            East => Rot2::radians(0.),
            South => Rot2::radians(-PI / 2.),
            West => Rot2::radians(PI),
        }
    }
}

// Converting from strings into directions doesn't make sense.
#[allow(clippy::from_over_into)]
impl Into<String> for CardinalDirection {
    fn into(self) -> String {
        use CompassQuadrant::*;
        match self.0 {
            North => "north".to_string(),
            East => "east".to_string(),
            South => "south".to_string(),
            West => "west".to_string(),
        }
    }
}

impl Display for CardinalDirection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str: String = (*self).into();
        write!(f, "{}", str)
    }
}

#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum RelativeDirectionMode {
    ClockFacing,
    Directional,
}

static RELATIVE_DIRECTION_MODE: Lazy<RwLock<RelativeDirectionMode>> = Lazy::new(|| {
    let v = RelativeDirectionMode::Directional;
    RwLock::new(v)
});

static PHYSICS_SCALE: Lazy<RwLock<f32>> = Lazy::new(|| RwLock::new(1.));

pub trait PointLike {
    fn x(&self) -> f32;

    fn y(&self) -> f32;

    fn x_i32(&self) -> i32 {
        self.x().trunc() as i32
    }

    fn y_i32(&self) -> i32 {
        self.y().trunc() as i32
    }

    fn x_usize(&self) -> usize {
        self.x().trunc() as usize
    }

    fn y_usize(&self) -> usize {
        self.y().trunc() as usize
    }

    fn f32(&self) -> (f32, f32) {
        (self.x(), self.y())
    }

    fn i32(&self) -> (i32, i32) {
        (self.x_i32(), self.y_i32())
    }

    fn trunc(&self) -> (f32, f32) {
        (self.x().trunc(), self.y().trunc())
    }

    fn to_index(&self, width: usize) -> usize {
        (self.y_usize() * width) + self.x_usize()
    }

    fn distance_squared(&self, other: &dyn PointLike) -> f32 {
        let x1 = FloatOrd(self.x());
        let y1 = FloatOrd(self.y());
        let x2 = FloatOrd(other.x());
        let y2 = FloatOrd(other.y());
        let dx = max(x1, x2).0 - min(x1, x2).0;
        let dy = max(y1, y2).0 - min(y1, y2).0;
        (dx * dx) + (dy * dy)
    }

    fn distance(&self, other: &dyn PointLike) -> f32 {
        self.distance_squared(other).sqrt()
    }

    fn bearing(&self, other: &dyn PointLike) -> Rot2 {
        let y = other.y() - self.y();
        let x = other.x() - self.x();
        Rot2::radians(y.atan2(x))
    }

    fn direction(&self, other: &dyn PointLike) -> MovementDirection {
        self.bearing(other).into()
    }

    fn direction_and_distance(&self, other: &dyn PointLike, yaw: Option<Rot2>) -> String {
        let mut tokens: Vec<String> = vec![];
        let distance = self.distance(other).round() as i32;
        if distance > 0 {
            let tile_or_tiles = if distance == 1 { "tile" } else { "tiles" };
            let direction: String = if let Some(yaw) = yaw {
                let yaw = yaw.as_radians();
                let bearing = self.bearing(other).as_radians();
                let rot = Rot2::radians(bearing - yaw);
                relative_desc(&rot)
            } else {
                self.direction(other).into()
            };
            tokens.push(format!("{direction} {distance} {tile_or_tiles}"));
        }
        tokens.join(" ")
    }
}

impl PointLike for Transform {
    fn x(&self) -> f32 {
        self.translation.x
    }

    fn y(&self) -> f32 {
        self.translation.y
    }
}

impl PointLike for &Transform {
    fn x(&self) -> f32 {
        self.translation.x
    }

    fn y(&self) -> f32 {
        self.translation.y
    }
}

impl PointLike for GlobalTransform {
    fn x(&self) -> f32 {
        self.translation().x
    }

    fn y(&self) -> f32 {
        self.translation().y
    }
}

impl PointLike for &GlobalTransform {
    fn x(&self) -> f32 {
        self.translation().x
    }

    fn y(&self) -> f32 {
        self.translation().y
    }
}

impl PointLike for Vec2 {
    fn x(&self) -> f32 {
        self.x
    }

    fn y(&self) -> f32 {
        self.y
    }
}

impl PointLike for (i32, i32) {
    fn x(&self) -> f32 {
        self.0 as f32
    }

    fn y(&self) -> f32 {
        self.1 as f32
    }
}

impl PointLike for (f32, f32) {
    fn x(&self) -> f32 {
        self.0
    }

    fn y(&self) -> f32 {
        self.1
    }
}

impl PointLike for (usize, usize) {
    fn x(&self) -> f32 {
        self.0 as f32
    }

    fn y(&self) -> f32 {
        self.1 as f32
    }
}

impl PointLike for here_be_dragons::geometry::Point {
    fn x(&self) -> f32 {
        self.x as f32
    }

    fn y(&self) -> f32 {
        self.y as f32
    }
}

#[macro_export]
macro_rules! impl_pointlike_for_tuple_component {
    ($source:ty) => {
        impl PointLike for $source {
            fn x(&self) -> f32 {
                self.0 .0 as f32
            }

            fn y(&self) -> f32 {
                self.0 .1 as f32
            }
        }
    };
}

impl From<&dyn PointLike> for (i32, i32) {
    fn from(val: &dyn PointLike) -> Self {
        val.i32()
    }
}

pub trait TransformExt {
    fn yaw(&self) -> Rot2;
}

impl TransformExt for Transform {
    fn yaw(&self) -> Rot2 {
        let forward = self.right();
        Rot2::radians(forward.y.atan2(forward.x))
    }
}

pub trait GlobalTransformExt {
    fn yaw(&self) -> Rot2;

    fn closest_points(
        &self,
        collider: &Collider,
        other: &GlobalTransform,
        other_collider: &Collider,
    ) -> ClosestPoints;

    fn collider_direction_and_distance(
        &self,
        collider: &Collider,
        other: &GlobalTransform,
        other_collider: &Collider,
    ) -> String;
}

impl GlobalTransformExt for GlobalTransform {
    fn yaw(&self) -> Rot2 {
        let forward = self.right();
        Rot2::radians(forward.y.atan2(forward.x))
    }

    fn closest_points(
        &self,
        collider: &Collider,
        other: &GlobalTransform,
        other_collider: &Collider,
    ) -> ClosestPoints {
        let scale = PHYSICS_SCALE.read().unwrap();
        let pos1 = Isometry::new(
            (self.translation() / *scale).xy().into(),
            self.yaw().as_radians(),
        );
        let pos2 = Isometry::new(
            (other.translation() / *scale).xy().into(),
            other.yaw().as_radians(),
        );
        closest_points(&pos1, &*collider.raw, &pos2, &*other_collider.raw, f32::MAX).unwrap()
    }

    fn collider_direction_and_distance(
        &self,
        collider: &Collider,
        other: &GlobalTransform,
        other_collider: &Collider,
    ) -> String {
        let scale = PHYSICS_SCALE.read().unwrap();
        let pos1 = Isometry::new(
            (self.translation() / *scale).xy().into(),
            self.yaw().as_radians(),
        );
        let pos2 = Isometry::new(
            (other.translation() / *scale).xy().into(),
            other.yaw().as_radians(),
        );
        let closest = self.closest_points(collider, other, other_collider);
        let distance = distance(&pos1, &*collider.raw, &pos2, &*other_collider.raw).unwrap() as u32;
        let tile_or_tiles = if distance == 1 { "tile" } else { "tiles" };
        if distance > 0 {
            if let ClosestPoints::WithinMargin(p1, p2) = closest {
                let p1 = (p1.x, p1.y);
                let p2 = (p2.x, p2.y);
                let bearing = p1.bearing(&p2).as_radians();
                let yaw = self.yaw().as_radians();
                let rot = Rot2::radians(bearing - yaw);
                let direction = relative_desc(&rot);
                format!("{direction} {distance} {tile_or_tiles}")
            } else {
                format!("{} {}", distance, tile_or_tiles)
            }
        } else {
            format!("{} {}", distance, tile_or_tiles)
        }
    }
}

#[derive(Component, Copy, Clone, Debug, Deref, DerefMut, PartialEq)]
pub struct Area(pub Aabb);

#[derive(Component, Clone, Copy, Debug, Default, Reflect)]
#[reflect(Component)]
pub struct Player;

#[derive(Clone, Copy, Debug)]
pub struct Pool<T> {
    pub value: T,
    pub max: T,
}

impl<T> Default for Pool<T>
where
    T: Default,
{
    fn default() -> Self {
        Self {
            value: Default::default(),
            max: Default::default(),
        }
    }
}

#[derive(Clone, Debug)]
pub struct RandomTable<T>(Vec<T>)
where
    T: Clone;

impl<T> RandomTable<T>
where
    T: Clone,
{
    pub fn add(&mut self, value: T, weight: i32) -> &mut Self {
        if weight > 0 {
            for _ in 0..weight {
                self.0.push(value.clone());
            }
        }
        self
    }
}

impl<T> Default for RandomTable<T>
where
    T: Clone,
{
    fn default() -> Self {
        Self(vec![])
    }
}

impl<T> Iterator for RandomTable<T>
where
    T: Clone,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        let mut rng = thread_rng();
        self.0.shuffle(&mut rng);
        self.0.first().cloned()
    }
}

fn setup(core_config: Res<CoreConfig>) {
    let mut scale = PHYSICS_SCALE.write().unwrap();
    *scale = core_config.pixels_per_unit as f32;
    let mut mode = RELATIVE_DIRECTION_MODE.write().unwrap();
    *mode = core_config.relative_direction_mode;
}

#[derive(Resource, Clone, Copy, Debug)]
pub struct CoreConfig {
    pub relative_direction_mode: RelativeDirectionMode,
    pub pixels_per_unit: u8,
}

fn sync_config(config: Res<CoreConfig>) {
    if config.is_changed() {
        let mut mode = RELATIVE_DIRECTION_MODE.write().unwrap();
        *mode = config.relative_direction_mode;
    }
}

pub struct CorePlugin {
    pub relative_direction_mode: RelativeDirectionMode,
    pub pixels_per_unit: u8,
}

impl Default for CorePlugin {
    fn default() -> Self {
        Self {
            relative_direction_mode: RelativeDirectionMode::Directional,
            pixels_per_unit: 1,
        }
    }
}

impl Plugin for CorePlugin {
    fn build(&self, app: &mut App) {
        let config = CoreConfig {
            relative_direction_mode: self.relative_direction_mode,
            pixels_per_unit: self.pixels_per_unit,
        };
        app.insert_resource(config)
            .register_type::<CardinalDirection>()
            .add_plugins(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(
                config.pixels_per_unit as f32,
            ))
            .add_systems(Startup, setup)
            .add_systems(Update, sync_config);
    }
}

pub struct CorePlugins;

impl PluginGroup for CorePlugins {
    fn build(self) -> PluginGroupBuilder {
        PluginGroupBuilder::start::<Self>()
            .add(crate::bevy_tts::TtsPlugin)
            .add(crate::bevy_synthizer::SynthizerPlugin::default())
            .add(crate::navigation::NavigationPlugin::default())
            .add(CorePlugin::default())
    }
}