Occlusion attempt 1

src/tile.rs

@@ -1,16 +1,23 @@
 use crate::item::Item;
 use crate::{constants::*, game};
+use bevy::math::vec2;
 use bevy::prelude::*;
+use std::collections::HashMap;
+use std::process::exit;
 
 #[derive(Component)]
 #[require(Sprite)]
 pub struct Tile {
     pub id: u32,
+    pub opaque: bool,
 }
 
 impl Default for Tile {
     fn default() -> Self {
-        Self { id: 1 }
+        Self {
+            id: 1,
+            opaque: true,
+        }
     }
 }
 
@@ -51,22 +58,32 @@ pub struct DoorTile {
     pub locked: bool,
 }
 
-pub fn tile_sprite_visibility_update(
-    mut query: Query<(&mut Visibility, &Transform), With<Tile>>,
+pub fn tile_sprite_occlusion_update(
+    mut query: Query<(&mut Visibility, &Transform, &Tile), With<Tile>>,
     tile_query: Query<(&Transform, &Tile)>,
 ) {
-    for (mut visibility, transform) in query.iter_mut() {
+    let mut z_map: HashMap<(i32, i32), i32> = HashMap::new();
+
+    for (mut visibility, transform, tile) in query.iter_mut() {
         *visibility = Visibility::Hidden;
 
         if transform.translation.z > game::Z_INDEX {
             continue;
         }
+        if let Some(z_val) = z_map.get(&(
+            transform.translation.x.round() as i32,
+            transform.translation.y.round() as i32,
+        )) {
+            if *z_val >= transform.translation.z as i32 {
+                continue;
+            }
+        }
 
         for x_offset in -1..=1 {
             for y_offset in -1..=1 {
-                for z_offset in -1..=0 {
+                for z_offset in -1..=1 {
                     if x_offset == 0 && y_offset == 0 && z_offset == 0 {
-                        continue; // Skip the current tile
+                        continue; // don't check against itself
                     }
                     let neighbor_position = transform.translation
                         + Vec3::new(
@@ -75,13 +92,24 @@ pub fn tile_sprite_visibility_update(
                             z_offset as f32 * TILE_SIZE,
                         );
 
-                    if let Some((neighbor_transform, neighbor_tile)) =
+                    if let Some((_, neighbor_tile)) =
                         tile_query.iter().find(|(neighbor_transform, _)| {
                             neighbor_transform.translation == neighbor_position
                         })
                     {
+                        // id == 0 is sky. So if bordering a sky tile (i.e. not deep underground)
                         if neighbor_tile.id == 0 {
                             *visibility = Visibility::Visible;
+                            // if opaque, do not look deeper on this X,Y
+                            if tile.opaque {
+                                z_map.insert(
+                                    (
+                                        transform.translation.x.round() as i32,
+                                        transform.translation.y.round() as i32,
+                                    ),
+                                    transform.translation.z.round() as i32,
+                                );
+                            }
                             break;
                         }
                     }