499 lines
19 KiB
Rust
499 lines
19 KiB
Rust
use std::marker::PhantomData;
|
|
|
|
use bevy::prelude::*;
|
|
use bevy_rapier2d::{
|
|
na::{Isometry2, Vector2},
|
|
prelude::*,
|
|
rapier::prelude::AABB,
|
|
};
|
|
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::{Player, PointLike},
|
|
exploration::{ExplorationType, Mappable},
|
|
log::Log,
|
|
utils::target_and_other,
|
|
visibility::Visible,
|
|
};
|
|
|
|
#[derive(Component, Copy, Clone, Debug, Deref, DerefMut, PartialEq)]
|
|
pub struct Area(pub AABB);
|
|
|
|
#[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, Default, Deref, DerefMut, Reflect)]
|
|
#[reflect(Component)]
|
|
pub struct SpawnColliderPerTile(pub bool);
|
|
|
|
impl From<bool> for SpawnColliderPerTile {
|
|
fn from(v: bool) -> Self {
|
|
Self(v)
|
|
}
|
|
}
|
|
|
|
#[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)
|
|
}
|
|
}
|
|
|
|
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(Clone, Debug)]
|
|
pub struct MapConfig {
|
|
pub describe_undescribed_areas: bool,
|
|
pub speak_area_descriptions: bool,
|
|
pub start_revealed: bool,
|
|
}
|
|
|
|
impl Default for MapConfig {
|
|
fn default() -> Self {
|
|
Self {
|
|
describe_undescribed_areas: false,
|
|
speak_area_descriptions: true,
|
|
start_revealed: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Bundle)]
|
|
pub struct PortalBundle {
|
|
pub portal: Portal,
|
|
pub exploration_type: ExplorationType,
|
|
pub mappable: Mappable,
|
|
pub transform: Transform,
|
|
pub global_transform: GlobalTransform,
|
|
}
|
|
|
|
impl Default for PortalBundle {
|
|
fn default() -> Self {
|
|
Self {
|
|
portal: Default::default(),
|
|
exploration_type: ExplorationType::Portal,
|
|
mappable: Default::default(),
|
|
transform: Default::default(),
|
|
global_transform: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Bundle, Clone, Default)]
|
|
pub struct MapBundle<D: 'static + Clone + Default + Send + Sync> {
|
|
pub map: Map<D>,
|
|
pub spawn_colliders: SpawnColliders,
|
|
pub spawn_collider_per_tile: SpawnColliderPerTile,
|
|
pub spawn_portals: SpawnPortals,
|
|
pub transform: Transform,
|
|
pub global_transform: GlobalTransform,
|
|
}
|
|
|
|
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 + 1) * 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 * (self.room_height + 1)) - self.room_height - 2;
|
|
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 as usize, y as usize, Tile::floor());
|
|
}
|
|
if field.has_passage(&South) {
|
|
let x = x_offset + half_width;
|
|
let y = y_offset;
|
|
map.set_tile(x as usize, y as usize, Tile::floor());
|
|
}
|
|
if field.has_passage(&East) {
|
|
let x = x_offset + self.room_width;
|
|
let y = y_offset + half_height;
|
|
map.set_tile(x as usize, y as usize, Tile::floor());
|
|
}
|
|
if field.has_passage(&West) {
|
|
let x = x_offset;
|
|
let y = y_offset + half_height;
|
|
map.set_tile(x as usize, y as usize, 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, &SpawnColliderPerTile), Changed<SpawnColliders>>,
|
|
) {
|
|
for (map_entity, map, spawn_colliders, spawn_collider_per_tile) in maps.iter() {
|
|
if **spawn_colliders {
|
|
commands
|
|
.entity(map_entity)
|
|
.remove::<SpawnColliders>()
|
|
.remove::<SpawnColliderPerTile>()
|
|
.insert(RigidBody::Fixed);
|
|
if **spawn_collider_per_tile {
|
|
for y in 0..map.height {
|
|
for x in 0..map.width {
|
|
let tile = map.at(x, y);
|
|
if tile.blocks_motion() {
|
|
let id = commands
|
|
.spawn()
|
|
.insert(Collider::cuboid(0.5, 0.5))
|
|
.insert(Transform::from_xyz(x as f32 + 0.5, y as f32 + 0.5, 0.))
|
|
.insert(MapObstruction)
|
|
.id();
|
|
if tile.blocks_visibility() {
|
|
commands.entity(id).insert(Visible::opaque());
|
|
}
|
|
commands.entity(map_entity).push_children(&[id]);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
let mut has_body =
|
|
vec![vec![false; map.height as usize + 1]; map.width as usize + 1];
|
|
let mut bottom_left = None;
|
|
let mut bottom_right = None;
|
|
for y in 0..map.height {
|
|
for x in 0..map.width {
|
|
trace!("Checking ({x}, {y})");
|
|
if bottom_left.is_some() {
|
|
if has_body[x][y] {
|
|
trace!("Hit another body, setting bottom right");
|
|
bottom_right = Some((x, y));
|
|
} else if map.at(x, y).is_walkable() {
|
|
trace!("Hit an empty tile, setting bottom right to ({x}, {y})",);
|
|
bottom_right = Some((x, y));
|
|
}
|
|
}
|
|
if map.at(x, y).is_blocked() && !has_body[x][y] {
|
|
trace!("Blocked, setting has_body");
|
|
has_body[x][y] = true;
|
|
if bottom_left.is_none() {
|
|
trace!("Setting bottom left");
|
|
bottom_left = Some((x, y));
|
|
}
|
|
if bottom_left.is_some() && x == map.width - 1 {
|
|
trace!("Hit right edge, setting bottom right");
|
|
bottom_right = Some((x, y));
|
|
}
|
|
}
|
|
if let (Some(bl), Some(br)) = (bottom_left, bottom_right) {
|
|
trace!("Got bottom, checking if can extend up");
|
|
let mut top_left = (bl.0, bl.1 + 1);
|
|
let mut top_right = (br.0, br.1 + 1);
|
|
if y != map.height - 1 {
|
|
let mut can_extend_up = true;
|
|
for y in bl.1 + 1..map.height {
|
|
for x in bl.0..br.0 {
|
|
trace!("Extension check: ({x}, {y})");
|
|
if map.at(x, y).is_walkable() {
|
|
trace!("Can't, empty tile");
|
|
can_extend_up = false;
|
|
break;
|
|
}
|
|
}
|
|
if can_extend_up {
|
|
trace!("Can extend up, setting has_body");
|
|
for x in top_left.0..=top_right.0 {
|
|
has_body[x][top_left.1] = true;
|
|
}
|
|
top_left.1 += 1;
|
|
top_right.1 += 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
let width = br.0 as f32 - bl.0 as f32;
|
|
let half_width = width / 2.;
|
|
let height = top_left.1 as f32 - bl.1 as f32;
|
|
let half_height = height / 2.;
|
|
trace!(
|
|
"Top left: {:?}\ntop right: {:?}\nbottom left: {:?}\nbottom right: {:?}",
|
|
top_left, top_right, bl, br
|
|
);
|
|
let center = (bl.0 as f32 + half_width, br.1 as f32 + half_height);
|
|
trace!(
|
|
"Create shape at {:?} of width {:?} and height {:?}",
|
|
center,
|
|
width,
|
|
height
|
|
);
|
|
let id = commands
|
|
.spawn()
|
|
.insert(Collider::cuboid(half_width, half_height))
|
|
.insert(Transform::from_xyz(center.x(), center.y(), 0.))
|
|
.insert(MapObstruction)
|
|
.id();
|
|
if map.at(x as usize, y as usize).blocks_visibility() {
|
|
commands.entity(id).insert(Visible::opaque());
|
|
}
|
|
commands.entity(map_entity).push_children(&[id]);
|
|
bottom_left = None;
|
|
bottom_right = None;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for room in &map.rooms {
|
|
let shape = Collider::cuboid((room.width() / 2) as f32, (room.height() / 2) as f32);
|
|
let position =
|
|
Isometry2::new(Vector2::new(room.center().x(), room.center().y()), 0.);
|
|
let aabb = shape.raw.compute_aabb(&position);
|
|
let id = commands
|
|
.spawn()
|
|
.insert(shape)
|
|
.insert(Sensor(true))
|
|
.insert(ActiveEvents::COLLISION_EVENTS)
|
|
.insert(Transform::from_xyz(
|
|
position.translation.x,
|
|
position.translation.y,
|
|
0.,
|
|
))
|
|
.insert(Area(aabb))
|
|
.id();
|
|
commands.entity(map_entity).push_children(&[id]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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.iter() {
|
|
if **spawn_portals {
|
|
commands.entity(map_entity).remove::<SpawnPortals>();
|
|
let mut portals: Vec<(f32, f32)> = vec![];
|
|
for x in 1..map.width {
|
|
for y in 1..map.height {
|
|
let mut spawn_portal = false;
|
|
if map.get_available_exits(x, y).len() > 2 {
|
|
let idx = (x, y).to_index(map.width);
|
|
if map.tiles[idx].is_walkable()
|
|
&& (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 map.tiles[idx].is_walkable()
|
|
&& (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;
|
|
let y = y as f32;
|
|
if !portals.contains(&(x, y)) {
|
|
portals.push((x, y));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for portal in portals {
|
|
let x = portal.0 as f32;
|
|
let y = portal.1 as f32;
|
|
let portal = commands
|
|
.spawn_bundle(PortalBundle {
|
|
transform: Transform::from_translation(Vec3::new(x, y, 0.)),
|
|
..default()
|
|
})
|
|
.id();
|
|
commands.entity(map_entity).push_children(&[portal]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn spawn_portal_colliders<D: 'static + Clone + Default + Send + Sync>(
|
|
mut commands: Commands,
|
|
map: Query<&SpawnColliders, With<Map<D>>>,
|
|
portals: Query<(Entity, &Transform), (With<Portal>, Without<Collider>)>,
|
|
) {
|
|
for spawn_colliders in map.iter() {
|
|
if **spawn_colliders {
|
|
for (portal_entity, coordinates) in portals.iter() {
|
|
let position = Vec2::new(coordinates.x() + 0.5, coordinates.y() + 0.5);
|
|
commands
|
|
.entity(portal_entity)
|
|
.insert(Transform::from_xyz(position.x(), position.y(), 0.))
|
|
.insert(Collider::cuboid(0.5, 0.5))
|
|
.insert(Sensor(true))
|
|
.insert(ActiveEvents::COLLISION_EVENTS);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn area_description(
|
|
mut events: EventReader<CollisionEvent>,
|
|
areas: Query<(&Area, Option<&Name>)>,
|
|
players: Query<&Player>,
|
|
config: Res<MapConfig>,
|
|
mut log: Query<&mut Log>,
|
|
) {
|
|
for event in events.iter() {
|
|
let (entity1, entity2, started) = match event {
|
|
CollisionEvent::Started(collider1, collider2, _) => (collider1, collider2, true),
|
|
CollisionEvent::Stopped(collider1, collider2, _) => (collider1, collider2, false),
|
|
};
|
|
if let Some((area, other)) = target_and_other(*entity1, *entity2, &|v| areas.get(v).is_ok())
|
|
{
|
|
if players.get(other).is_ok() {
|
|
if let Ok((aabb, area_name)) = areas.get(area) {
|
|
let name = if let Some(name) = area_name {
|
|
Some(name.to_string())
|
|
} else if config.describe_undescribed_areas {
|
|
Some(format!("{}-by-{} area", aabb.extents().x, aabb.extents().y))
|
|
} else {
|
|
None
|
|
};
|
|
if let Some(name) = name {
|
|
if let Ok(mut log) = log.get_single_mut() {
|
|
if started {
|
|
log.push(format!("Entering {name}."));
|
|
} else {
|
|
log.push(format!("Leaving {name}."));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct MapPlugin<D: 'static + Clone + Default + Send + Sync>(PhantomData<D>);
|
|
|
|
impl<D: 'static + Clone + Default + Send + Sync> Default for MapPlugin<D> {
|
|
fn default() -> Self {
|
|
Self(Default::default())
|
|
}
|
|
}
|
|
|
|
impl<D: 'static + Clone + Default + Send + Sync> Plugin for MapPlugin<D> {
|
|
fn build(&self, app: &mut App) {
|
|
if !app.world.contains_resource::<MapConfig>() {
|
|
app.insert_resource(MapConfig::default());
|
|
}
|
|
let config = app.world.get_resource::<MapConfig>().unwrap().clone();
|
|
app.register_type::<Portal>()
|
|
.add_system(spawn_colliders::<D>)
|
|
.add_system(spawn_portals::<D>)
|
|
.add_system(spawn_portal_colliders::<D>);
|
|
if config.speak_area_descriptions {
|
|
app.add_system_to_stage(CoreStage::PostUpdate, area_description);
|
|
}
|
|
}
|
|
}
|