318 lines
11 KiB
Rust
318 lines
11 KiB
Rust
use crate::constants::{ITILE_SIZE, TILE_SIZE};
|
|
use crate::tile::{self, FixtureTile, FloorTile, NeedsOccluded, TileMap};
|
|
use crate::tiles::{self, FixtureTilePrefab, FloorTilePrefab, Textures};
|
|
use bevy::prelude::*;
|
|
use noise::{NoiseFn, Perlin};
|
|
use std::collections::HashMap;
|
|
|
|
pub const CHUNK_SIZE: i32 = 8;
|
|
|
|
#[derive(Resource)]
|
|
pub struct ChunkMap {
|
|
pub loaded_chunks: HashMap<IVec2, bool>,
|
|
}
|
|
|
|
impl Default for ChunkMap {
|
|
fn default() -> Self {
|
|
Self {
|
|
loaded_chunks: HashMap::new(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Event)]
|
|
pub struct LoadChunkEvent {
|
|
pub chunk_position: IVec2,
|
|
}
|
|
|
|
fn setup_chunk_system(mut commands: Commands) {
|
|
commands.insert_resource(TileMap::default());
|
|
commands.insert_resource(ChunkMap::default());
|
|
}
|
|
|
|
pub fn handle_tile_occlusion_updates(
|
|
mut commands: Commands,
|
|
tilemap: Res<TileMap>,
|
|
mut query_set: ParamSet<(
|
|
Query<(&mut FloorTile, &Transform, &mut NeedsOccluded)>,
|
|
Query<(&mut FixtureTile, &Transform, &mut NeedsOccluded)>,
|
|
Query<(Entity, &mut NeedsOccluded)>,
|
|
)>,
|
|
mut cwss: ResMut<tiles::CurrentWorldSpriteState>,
|
|
) {
|
|
query_set
|
|
.p0()
|
|
.par_iter_mut()
|
|
.for_each(|(mut tile, transform, mut needs_occluded)| {
|
|
if needs_occluded.has_been_occluded {
|
|
return;
|
|
}
|
|
tile.visible_range = calculate_visibility(transform.translation.as_ivec3(), &tilemap);
|
|
needs_occluded.has_been_occluded = true;
|
|
});
|
|
query_set
|
|
.p1()
|
|
.par_iter_mut()
|
|
.for_each(|(mut fixture, transform, mut needs_occluded)| {
|
|
if needs_occluded.has_been_occluded {
|
|
return;
|
|
}
|
|
fixture.visible_range = calculate_visibility(
|
|
transform.translation.as_ivec3() - IVec3::new(0, 0, 1),
|
|
&tilemap,
|
|
);
|
|
needs_occluded.has_been_occluded = true;
|
|
});
|
|
|
|
for (entity, occ) in query_set.p2().iter_mut() {
|
|
if occ.has_been_occluded {
|
|
commands.entity(entity).remove::<NeedsOccluded>();
|
|
}
|
|
}
|
|
cwss.state = tiles::WorldSpriteState::WaitingForRender;
|
|
}
|
|
|
|
pub fn calculate_visibility(pos: IVec3, tilemap: &TileMap) -> [u32; 8] {
|
|
let mut visible_range = [0u32; 8];
|
|
|
|
for mut camera_z in -15..=5 {
|
|
camera_z *= ITILE_SIZE;
|
|
let mut is_visible = false;
|
|
|
|
if pos.z > camera_z {
|
|
continue;
|
|
}
|
|
|
|
let mut is_occluded = false;
|
|
|
|
'vertical_check: for z_offset in 1..10 {
|
|
let above_pos = IVec3::new(pos.x, pos.y, pos.z + (z_offset * ITILE_SIZE));
|
|
if above_pos.z <= camera_z {
|
|
if let Some(&(_, opaque, _, _, _)) = tilemap.floor_tiles.get(&above_pos) {
|
|
if opaque {
|
|
is_occluded = true;
|
|
break 'vertical_check;
|
|
}
|
|
}
|
|
// if z_offset >= 4 {
|
|
// is_occluded = true;
|
|
// break 'vertical_check;
|
|
// }
|
|
// if let Some(&(_, solid, _)) = tilemap.fixtures.get(&above_pos) {
|
|
// if solid {
|
|
// is_occluded = true;
|
|
// break 'vertical_check;
|
|
// }
|
|
// }
|
|
} else {
|
|
break 'vertical_check;
|
|
}
|
|
}
|
|
if !is_occluded {
|
|
'neighbor_check: for x_offset in -1..=1 {
|
|
for y_offset in -1..=1 {
|
|
for z_offset in 0..=1 {
|
|
if x_offset == 0 && y_offset == 0 && z_offset == 0 {
|
|
continue;
|
|
}
|
|
let neighbor_pos = IVec3::new(
|
|
pos.x + x_offset * ITILE_SIZE,
|
|
pos.y + y_offset * ITILE_SIZE,
|
|
pos.z + z_offset * ITILE_SIZE,
|
|
);
|
|
|
|
if let Some(&(id, _, _, _, _)) = tilemap.floor_tiles.get(&neighbor_pos) {
|
|
if id == 0 {
|
|
is_visible = true;
|
|
break 'neighbor_check;
|
|
}
|
|
}
|
|
// if let Some(&(id, _, _)) = tilemap.fixtures.get(&neighbor_pos) {
|
|
// if id == 0 {
|
|
// is_visible = true;
|
|
// break 'neighbor_check;
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if is_visible {
|
|
let z2 = ((camera_z / ITILE_SIZE) + 150) as usize;
|
|
visible_range[z2 / 32] |= 1 << ((z2 % 32) as u32);
|
|
}
|
|
}
|
|
|
|
visible_range
|
|
}
|
|
|
|
pub fn generate_surface_noise(x: i32, y: i32) -> f32 {
|
|
let noise = Perlin::new(0);
|
|
let mut noise_value = 0.0;
|
|
let mut amplitude = 1.0;
|
|
let mut frequency = 0.008;
|
|
|
|
for _ in 0..6 {
|
|
noise_value += noise.get([x as f64 * frequency, y as f64 * frequency]) * amplitude;
|
|
amplitude *= 0.6;
|
|
frequency *= 1.8;
|
|
}
|
|
|
|
(noise_value * 2.5) as f32
|
|
}
|
|
|
|
fn handle_chunk_loading(
|
|
mut commands: Commands,
|
|
textures: Res<Textures>,
|
|
mut events: EventReader<LoadChunkEvent>,
|
|
mut chunk_map: ResMut<ChunkMap>,
|
|
mut tilemap: ResMut<TileMap>,
|
|
) {
|
|
let noise = Perlin::new(0);
|
|
|
|
for event in events.read() {
|
|
println!("Loading chunk {}", event.chunk_position);
|
|
let chunk_pos = event.chunk_position;
|
|
if chunk_map.loaded_chunks.contains_key(&chunk_pos) {
|
|
continue;
|
|
}
|
|
|
|
chunk_map.loaded_chunks.insert(chunk_pos, true);
|
|
|
|
let start_x = chunk_pos.x * CHUNK_SIZE;
|
|
let start_y = chunk_pos.y * CHUNK_SIZE;
|
|
|
|
let mut floor_positions = Vec::new();
|
|
|
|
// Generate tiles for this chunk
|
|
for local_y in 0..CHUNK_SIZE {
|
|
for local_x in 0..CHUNK_SIZE {
|
|
let world_x = start_x + local_x;
|
|
let world_y = start_y + local_y;
|
|
|
|
let noise_position = Vec3::new(
|
|
(world_x as f32 * TILE_SIZE).round(),
|
|
(world_y as f32 * TILE_SIZE).round(),
|
|
(generate_surface_noise(world_x, world_y) * TILE_SIZE).round(),
|
|
);
|
|
|
|
// Spawn tiles and add them to tilemap
|
|
for z in -10..=5 {
|
|
let position = Vec3::new(
|
|
(world_x as f32 * TILE_SIZE).round(),
|
|
(world_y as f32 * TILE_SIZE).round(),
|
|
(z as f32 * TILE_SIZE).round(),
|
|
);
|
|
let pos_ivec = position.as_ivec3();
|
|
|
|
if z < -8 {
|
|
let noise_value = noise.get([
|
|
world_x as f64 * 0.05,
|
|
world_y as f64 * 0.05,
|
|
z as f64 * 0.05,
|
|
]);
|
|
if noise_value < -0.5 {
|
|
FloorTilePrefab::air(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (0, false, true, 0, [0; 8])); // Air tile
|
|
floor_positions.push((position, "air"));
|
|
} else if noise_value < 0.8 {
|
|
FloorTilePrefab::rock(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (2, true, false, 50, [0; 8])); // Rock tile
|
|
floor_positions.push((position, "rock"));
|
|
} else {
|
|
FloorTilePrefab::dirt(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (1, true, true, 85, [0; 8])); // Dirt tile
|
|
floor_positions.push((position, "dirt"));
|
|
}
|
|
} else if noise_position.z > position.z {
|
|
if (generate_surface_noise(world_x, world_y) * TILE_SIZE).round()
|
|
<= position.z + TILE_SIZE
|
|
{
|
|
FloorTilePrefab::grass(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (1, true, true, 100, [0; 8])); // Dirt tile (grass)
|
|
floor_positions.push((position, "dirt"));
|
|
} else {
|
|
FloorTilePrefab::dirt(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (1, true, true, 85, [0; 8])); // Dirt tile
|
|
floor_positions.push((position, "dirt"));
|
|
}
|
|
} else {
|
|
FloorTilePrefab::air(position).spawn(&mut commands);
|
|
tilemap
|
|
.floor_tiles
|
|
.insert(pos_ivec, (0, false, true, 0, [0; 8])); // Air tile
|
|
floor_positions.push((position, "air"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Generate fixtures and add them to tilemap
|
|
for (position, floor_type) in floor_positions.iter() {
|
|
let above_pos = *position + Vec3::new(0.0, 0.0, TILE_SIZE);
|
|
let above_ivec = above_pos.as_ivec3();
|
|
|
|
match *floor_type {
|
|
"dirt" => {
|
|
FixtureTilePrefab::dirt_wall(above_pos).spawn(&mut commands);
|
|
tilemap.fixture_tiles.insert(above_ivec, (1, true, [0; 8]));
|
|
// Dirt wall
|
|
}
|
|
"rock" => {
|
|
FixtureTilePrefab::rock_wall(above_pos).spawn(&mut commands);
|
|
tilemap.fixture_tiles.insert(above_ivec, (2, true, [0; 8]));
|
|
// Rock wall
|
|
}
|
|
"bedrock" => {
|
|
FixtureTilePrefab::bedrock_wall(above_pos).spawn(&mut commands);
|
|
tilemap.fixture_tiles.insert(above_ivec, (3, true, [0; 8]));
|
|
// Bedrock wall
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn setup_initial_chunks(mut event_writer: EventWriter<LoadChunkEvent>) {
|
|
println!("setup_initial_chunks");
|
|
for x in -7..=7 {
|
|
for y in -7..=7 {
|
|
event_writer.send(LoadChunkEvent {
|
|
chunk_position: IVec2::new(x, y),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct TilemapPlugin;
|
|
|
|
impl Plugin for TilemapPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.init_resource::<ChunkMap>()
|
|
.add_event::<LoadChunkEvent>()
|
|
.add_systems(Startup, (setup_chunk_system, setup_initial_chunks))
|
|
.add_systems(
|
|
PostStartup,
|
|
(
|
|
handle_chunk_loading,
|
|
handle_tile_occlusion_updates,
|
|
tile::update_tile_visibility,
|
|
)
|
|
.chain(),
|
|
)
|
|
.add_systems(FixedUpdate, (handle_chunk_loading).chain());
|
|
}
|
|
}
|