blackout/src/map.rs

use std::marker::PhantomData;

use avian2d::prelude::*;
use bevy::prelude::*;
pub use here_be_dragons::Map as MapgenMap;
use here_be_dragons::{geometry::Rect as MRect, MapFilter, Tile};
use maze_generator::{prelude::*, recursive_backtracking::RbGenerator};
use rand::prelude::StdRng;

use crate::{core::PointLike, exploration::Mappable, visibility::Visible};

#[derive(Component, Clone, Default, Deref, DerefMut)]
pub struct Map<D: 'static + Clone + Default + Send + Sync>(pub MapgenMap<D>);

impl<D: Clone + Default + Send + Sync> From<MapgenMap<D>> for Map<D> {
    fn from(v: MapgenMap<D>) -> Self {
        Self(v)
    }
}

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

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

#[derive(Component, Clone, Debug, Deref, DerefMut, Reflect)]
#[reflect(Component)]
pub struct SpawnColliders(pub bool);

impl Default for SpawnColliders {
    fn default() -> Self {
        Self(true)
    }
}

impl From<bool> for SpawnColliders {
    fn from(v: bool) -> Self {
        Self(v)
    }
}

#[derive(Component, Clone, Debug, Deref, DerefMut, Reflect)]
#[reflect(Component)]
pub struct SpawnPortals(pub bool);

impl Default for SpawnPortals {
    fn default() -> Self {
        Self(true)
    }
}

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

pub trait ITileType {
    fn blocks_motion(&self) -> bool;
    fn blocks_visibility(&self) -> bool;
}

impl ITileType for Tile {
    fn blocks_motion(&self) -> bool {
        self.is_blocked()
    }

    fn blocks_visibility(&self) -> bool {
        self.is_blocked()
    }
}

#[derive(Bundle, Default)]
pub struct PortalBundle {
    pub transform: TransformBundle,
    pub portal: Portal,
    pub mappable: Mappable,
}

#[derive(Bundle, Clone, Default)]
pub struct MapBundle<D: 'static + Clone + Default + Send + Sync> {
    pub map: Map<D>,
    pub spawn_colliders: SpawnColliders,
    pub spawn_portals: SpawnPortals,
    pub transform: TransformBundle,
}

#[derive(Bundle, Clone, Debug)]
pub struct TileBundle {
    pub transform: TransformBundle,
    pub collider: Collider,
    pub rigid_body: RigidBody,
    pub map_obstruction: MapObstruction,
}

impl Default for TileBundle {
    fn default() -> Self {
        Self {
            transform: default(),
            collider: Collider::rectangle(1., 1.),
            rigid_body: RigidBody::Static,
            map_obstruction: default(),
        }
    }
}

impl TileBundle {
    pub fn new(x: i32, y: i32) -> Self {
        Self {
            transform: Transform::from_xyz(x as f32 + 0.5, y as f32 + 0.5, 0.).into(),
            ..default()
        }
    }
}

#[derive(Bundle, Clone, Debug)]
pub struct ZoneBundle {
    pub collider: Collider,
    pub transform: TransformBundle,
    pub zone: Zone,
    pub sensor: Sensor,
}

impl ZoneBundle {
    fn new(collider: Collider, position: Vec2) -> Self {
        Self {
            collider,
            transform: Transform::from_translation(position.extend(0.)).into(),
            zone: default(),
            sensor: default(),
        }
    }
}

impl From<&MRect> for ZoneBundle {
    fn from(rect: &MRect) -> Self {
        let collider = Collider::rectangle(
            rect.width() as f32 + 1.,
            rect.height() as f32 + 0.1,
        );
        let position = Vec2::new(rect.center().x(), rect.center().y());
        Self::new(collider, position)
    }
}

pub struct GridBuilder {
    width_in_rooms: usize,
    height_in_rooms: usize,
    room_width: usize,
    room_height: usize,
}

impl GridBuilder {
    pub fn new(
        width_in_rooms: usize,
        height_in_rooms: usize,
        room_width: usize,
        room_height: usize,
    ) -> Box<GridBuilder> {
        Box::new(GridBuilder {
            width_in_rooms,
            height_in_rooms,
            room_width,
            room_height,
        })
    }
}

impl<D: Clone + Default> MapFilter<D> for GridBuilder {
    fn modify_map(&self, _rng: &mut StdRng, map: &MapgenMap<D>) -> MapgenMap<D> {
        let mut map = map.clone();
        let mut generator = RbGenerator::new(None);
        if let Ok(maze) =
            generator.generate(self.width_in_rooms as i32, self.height_in_rooms as i32)
        {
            let total_height = self.room_height * self.height_in_rooms + self.height_in_rooms + 1;
            let half_width = self.room_width / 2;
            let half_height = self.room_height / 2;
            for y in 0..self.height_in_rooms {
                for x in 0..self.width_in_rooms {
                    let x_offset = x * (self.room_width + 1);
                    let y_offset = total_height - (y + 1) * (self.room_height + 1) - 1;
                    let room = MRect::new_i32(
                        x_offset as i32 + 1,
                        y_offset as i32 + 1,
                        self.room_width as i32,
                        self.room_height as i32,
                    );
                    map.add_room(room);
                    let coords = maze_generator::prelude::Coordinates::new(x as i32, y as i32);
                    if let Some(field) = maze.get_field(&coords) {
                        use maze_generator::prelude::Direction::*;
                        if field.has_passage(&North) {
                            let x = x_offset + half_width;
                            let y = y_offset + self.room_height;
                            map.set_tile(x, y, Tile::floor());
                        }
                        if field.has_passage(&South) {
                            let x = x_offset + half_width;
                            let y = y_offset;
                            map.set_tile(x, y, Tile::floor());
                        }
                        if field.has_passage(&East) {
                            let x = x_offset + self.room_width;
                            let y = y_offset + half_height;
                            map.set_tile(x, y, Tile::floor());
                        }
                        if field.has_passage(&West) {
                            let x = x_offset;
                            let y = y_offset + half_height;
                            map.set_tile(x, y, Tile::floor());
                        }
                    }
                }
            }
            map.starting_point = Some(here_be_dragons::geometry::Point::new(
                maze.start.x as usize + 1,
                maze.start.y as usize + 1,
            ));
            map.exit_point = Some(here_be_dragons::geometry::Point::new(
                (maze.goal.x as usize) * self.room_width + half_width,
                (maze.goal.y as usize) * self.room_height + half_height,
            ));
        }
        map
    }
}

fn spawn_colliders<D: 'static + Clone + Default + Send + Sync>(
    mut commands: Commands,
    maps: Query<(Entity, &Map<D>, &SpawnColliders), Changed<SpawnColliders>>,
) {
    for (map_entity, map, spawn_colliders) in &maps {
        if **spawn_colliders {
            commands.entity(map_entity).remove::<SpawnColliders>();
            for y in 0..map.height {
                for x in 0..map.width {
                    if let Some(tile) = map.at(x, y) {
                        if tile.blocks_motion() {
                            let id = commands.spawn(TileBundle::new(x as i32, y as i32)).id();
                            if tile.blocks_visibility() {
                                commands.entity(id).insert(Visible::opaque());
                            }
                            commands.entity(map_entity).push_children(&[id]);
                        }
                    }
                }
            }
            for room in &map.rooms {
                commands.entity(map_entity).with_children(|parent| {
                    parent.spawn(ZoneBundle::from(room));
                });
            }
        }
    }
}

fn spawn_portals<D: 'static + Clone + Default + Send + Sync>(
    mut commands: Commands,
    map: Query<(Entity, &Map<D>, &SpawnPortals), Changed<SpawnPortals>>,
) {
    for (map_entity, map, spawn_portals) in &map {
        if **spawn_portals {
            commands.entity(map_entity).remove::<SpawnPortals>();
            let mut portals: Vec<(f32, f32)> = vec![];
            for x in 0..map.width {
                for y in 0..map.height {
                    let idx = (x, y).to_index(map.width);
                    let mut spawn_portal = false;
                    if map.get_available_exits(x, y).len() > 2 && map.tiles[idx].is_walkable() {
                        if (x > 1 && map.tiles[idx - 1].is_walkable())
                            && (x < map.width - 2 && map.tiles[idx + 1].is_walkable())
                            && (y > 1 && map.tiles[idx - map.width].is_blocked())
                            && (y < map.height - 2 && map.tiles[idx + map.width].is_blocked())
                        {
                            spawn_portal = true;
                        }
                        if (x > 1 && map.tiles[idx - 1].is_blocked())
                            && (x < map.width - 2 && map.tiles[idx + 1].is_blocked())
                            && (y > 1 && map.tiles[idx - map.width].is_walkable())
                            && (y < map.height - 2 && map.tiles[idx + map.width].is_walkable())
                        {
                            spawn_portal = true;
                        }
                    }
                    if spawn_portal {
                        let x = x as f32 + 0.5;
                        let y = y as f32 + 0.5;
                        if !portals.contains(&(x, y)) {
                            portals.push((x, y));
                        }
                    }
                }
            }
            for (x, y) in portals {
                commands.entity(map_entity).with_children(|parent| {
                    parent.spawn(PortalBundle {
                        transform: Transform::from_translation(Vec3::new(x, y, 0.)).into(),
                        ..default()
                    });
                });
            }
        }
    }
}

fn spawn_portal_colliders<D: 'static + Clone + Default + Send + Sync>(
    mut commands: Commands,
    map: Query<(Entity, &SpawnColliders), With<Map<D>>>,
    portals: Query<Entity, (With<Portal>, Without<Collider>)>,
) {
    for (entity, spawn_colliders) in &map {
        if **spawn_colliders {
            for portal_entity in &portals {
                commands
                    .entity(portal_entity)
                    .insert((Collider::rectangle(1., 1.), Sensor));
            }
            commands.entity(entity).remove::<SpawnColliders>();
        }
    }
}

#[derive(Resource, Clone, Copy, Debug)]
pub struct MapPlugin<MapData: 'static + Clone + Default + Send + Sync> {
    pub start_revealed: bool,
    pub map_data: PhantomData<MapData>,
}

impl<MapData: 'static + Clone + Default + Send + Sync> Default for MapPlugin<MapData> {
    fn default() -> Self {
        Self {
            start_revealed: default(),
            map_data: default(),
        }
    }
}

impl<MapData: 'static + Clone + Default + Send + Sync> Plugin for MapPlugin<MapData> {
    fn build(&self, app: &mut App) {
        app.insert_resource(self.clone())
            .register_type::<Portal>()
            .add_systems(
                PreUpdate,
                (
                    spawn_colliders::<MapData>,
                    spawn_portals::<MapData>,
                    spawn_portal_colliders::<MapData>,
                ),
            );
    }
}