switch to rust 2024

2 files changed, 23 insertions, 23 deletions

diff --git a/src/game.rs b/src/game.rs
index ca30207..a17526b 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -91,16 +91,16 @@ impl Maze {
                 break;
             }
 
-            let rw = rng.gen_range(3usize..=6);
-            let rh = rng.gen_range(3usize..=6);
+            let rw = rng.random_range(3usize..=6);
+            let rh = rng.random_range(3usize..=6);
 
             // Keep rooms away from the outer border by at least 2 cells
             // so corridors have room to connect to them.
             if rw + 2 >= w || rh + 2 >= h {
                 continue;
             }
-            let rx = rng.gen_range(2..(w - rw - 2));
-            let ry = rng.gen_range(2..(h - rh - 2));
+            let rx = rng.random_range(2..(w - rw - 2));
+            let ry = rng.random_range(2..(h - rh - 2));
 
             // Check overlap with 1-cell buffer.
             let mut overlaps = false;
@@ -193,7 +193,7 @@ impl Maze {
 
             edges.sort_by_key(|e| e.0);
             // Pick from the nearest few for variety.
-            let pick = rng.gen_range(0..(edges.len().min(3)));
+            let pick = rng.random_range(0..(edges.len().min(3)));
             let (_dist, from, to) = edges[pick];
 
             carve_corridor(
@@ -211,8 +211,8 @@ impl Maze {
         // ---- Phase 3: add a few extra connections for loops ----
         let extra_connections = (rooms.len() / 5).max(1);
         for _ in 0..extra_connections {
-            let a = rng.gen_range(0..rooms.len());
-            let b = rng.gen_range(0..rooms.len());
+            let a = rng.random_range(0..rooms.len());
+            let b = rng.random_range(0..rooms.len());
             if a != b {
                 let dist = manhattan(
                     rooms[a].cx as isize,
@@ -404,9 +404,9 @@ fn carve_corridor(
     let tx = x2 as isize;
     let ty = y2 as isize;
 
-    let wide = rng.gen_bool(0.3); // 30% chance of 2-wide corridor
+    let wide = rng.random_bool(0.3); // 30% chance of 2-wide corridor
 
-    if rng.gen_bool(0.5) {
+    if rng.random_bool(0.5) {
         // Horizontal, then vertical.
         carve_line(cells, grid_w, cx, cy, tx, cy, wide);
         carve_line(cells, grid_w, tx, cy, tx, ty, wide);
@@ -493,11 +493,11 @@ fn place_entities(
         next += 1;
 
         let (hp_range, damage) = enemy_stats_for_depth(depth);
-        let max_hp = rng.gen_range(hp_range.0..=hp_range.1);
+        let max_hp = rng.random_range(hp_range.0..=hp_range.1);
         let dmg = if damage.0 == damage.1 {
             damage.0
         } else {
-            rng.gen_range(damage.0..=damage.1)
+            rng.random_range(damage.0..=damage.1)
         };
 
         entities[y * w + x] = Some(Entity::Enemy {
@@ -508,7 +508,7 @@ fn place_entities(
     }
 
     // --- hallucinations (1-2 per level) ---
-    let hall_count = rng.gen_range(1..=2);
+    let hall_count = rng.random_range(1..=2);
     for _ in 0..hall_count {
         if next >= candidates.len() {
             break;
@@ -544,7 +544,7 @@ fn place_entities(
     }
 
     // --- hallucinated pickups ---
-    let fake_count = if depth >= 3 { rng.gen_range(1..=2) } else { 0 };
+    let fake_count = if depth >= 3 { rng.random_range(1..=2) } else { 0 };
     for _ in 0..fake_count {
         if next >= candidates.len() {
             break;
@@ -567,10 +567,10 @@ fn enemy_stats_for_depth(depth: u64) -> ((u32, u32), (u32, u32)) {
 }
 
 fn random_pickup_type(rng: &mut impl Rng, include_weapon: bool) -> PickupType {
-    let roll = rng.gen_range(0..100);
+    let roll = rng.random_range(0..100);
     if include_weapon && roll < 15 {
         PickupType::Weapon {
-            base_damage: rng.gen_range(2..=4),
+            base_damage: rng.random_range(2..=4),
         }
     } else if roll < 45 {
         PickupType::Food
@@ -584,7 +584,7 @@ fn random_pickup_type(rng: &mut impl Rng, include_weapon: bool) -> PickupType {
 /// Fisher-Yates shuffle on a slice.
 fn shuffle_slice<T>(slice: &mut [T], rng: &mut impl Rng) {
     for i in (1..slice.len()).rev() {
-        let j = rng.gen_range(0..=i);
+        let j = rng.random_range(0..=i);
         slice.swap(i, j);
     }
 }
@@ -681,7 +681,7 @@ fn smoothstep(t: f64) -> f64 {
 
 impl Game {
     pub fn new() -> Self {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let depth = 1;
         let (maze, (start_x, start_y)) = Maze::generate(depth, &mut rng);
         let player = Player::new(start_x, start_y, 0.0); // facing east
@@ -943,7 +943,7 @@ impl Game {
     /// Roll bonus damage: 30% chance for +1, repeat on success.
     fn roll_bonus_damage(&self, rng: &mut impl Rng) -> u32 {
         let mut bonus = 0u32;
-        while rng.gen_bool(0.30) {
+        while rng.random_bool(0.30) {
             bonus += 1;
         }
         bonus
@@ -963,7 +963,7 @@ impl Game {
 
         match entity {
             Some(Entity::Enemy { hp, damage, .. }) => {
-                let mut rng = rand::thread_rng();
+                let mut rng = rand::rng();
                 let bonus = self.roll_bonus_damage(&mut rng);
                 let total_dmg = self.weapon_base_damage + bonus;
                 let new_hp = hp.saturating_sub(total_dmg);
@@ -974,7 +974,7 @@ impl Game {
                     self.set_message(&format!("You slay the enemy! ({} dmg)", total_dmg));
                 } else {
                     self.maze.entity_at_mut(fx, fy).map(|e| {
-                        if let Entity::Enemy { hp: ref mut h, .. } = e {
+                        if let Entity::Enemy { hp: h, .. } = e {
                             *h = new_hp;
                         }
                     });
@@ -1002,7 +1002,7 @@ impl Game {
                     self.set_message("The hallucination dissipates.");
                 } else {
                     self.maze.entity_at_mut(fx, fy).map(|e| {
-                        if let Entity::Hallucination { hp: ref mut h, .. } = e {
+                        if let Entity::Hallucination { hp: h, .. } = e {
                             *h = new_hp;
                         }
                     });
diff --git a/src/texture.rs b/src/texture.rs
index e5720c0..4df38b8 100644
--- a/src/texture.rs
+++ b/src/texture.rs
@@ -14,7 +14,7 @@ fn hash(x: u32, y: u32, seed: u64) -> u64 {
 
 /// Brown cracked wall texture — 64×64, brick pattern with mortar lines and fissures.
 pub fn generate_wall_texture(rng: &mut impl Rng) -> Vec<u32> {
-    let seed = rng.gen::<u64>();
+    let seed = rng.random::<u64>();
     let mut tex = vec![0u32; TEX_SIZE * TEX_SIZE];
 
     for y in 0..TEX_SIZE {
@@ -105,7 +105,7 @@ pub fn generate_exit_texture(rng: &mut impl Rng) -> Vec<u32> {
 
 /// Gray stone-tile floor — 64×64, checkerboard with grout and subtle colour tint.
 pub fn generate_floor_texture(rng: &mut impl Rng) -> Vec<u32> {
-    let seed = rng.gen::<u64>();
+    let seed = rng.random::<u64>();
     let mut tex = vec![0u32; TEX_SIZE * TEX_SIZE];
 
     for y in 0..TEX_SIZE {