Wild beasts: cave bears and giant beetles in dens, tamed when beaten while a prison has room

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/beasts.rs

@@ -0,0 +1,113 @@
+// Wild beasts: cave bears and giant beetles live in the open caverns of random maps. They defend
+// their den like the dwarves defend their cave (they never stray far) and count for nobody. A
+// master with room in a prison tames a beast he beats: instead of dying it gives in and joins.
+
+use crate::game::*;
+use crate::map::*;
+
+pub fn beast(k: EK) -> bool {
+    matches!(k, EK::CaveBear | EK::Beetle)
+}
+
+impl Game {
+    // a few dens in the caverns of a random map (deterministic, from the seed)
+    pub fn place_beasts(&mut self, seed: u32) {
+        let mut rng = Rng(seed.wrapping_mul(0x85eb_ca6b) ^ 0x27d4_eb2f | 1);
+        let (cx, cy) = (self.map.core.0 + 1, self.map.core.1 + 1);
+        let area = (mw() * mh()) as f32;
+        // none on small maps (no room), one per ~95x95 tiles on bigger ones
+        let dens = (area / 9000.0) as usize;
+        let open: Vec<usize> = (0..self.map.t.len())
+            .filter(|&i| {
+                let (x, y) = xy(i);
+                let t = &self.map.t[i];
+                t.kind == Kind::Floor && t.owner == Owner::None && !self.map.sky(i) && (x - cx).abs().max((y - cy).abs()) > 18
+                    && DIR8.iter().all(|&(dx, dy)| self.map.walk(x + dx, y + dy))
+                    && !self.dwarf_caves.iter().any(|c| (c.at.0 - x).abs() + (c.at.1 - y).abs() < 12)
+            })
+            .collect();
+        if open.is_empty() {
+            return;
+        }
+        let mut placed: Vec<(i32, i32)> = Vec::new();
+        for _ in 0..dens * 6 {
+            if placed.len() >= dens {
+                break;
+            }
+            let i = open[(rng.next() as usize) % open.len()];
+            let (x, y) = xy(i);
+            if placed.iter().any(|&(px, py)| (px - x).abs() + (py - y).abs() < 20) {
+                continue;
+            }
+            placed.push((x, y));
+            let kind = if rng.f() < 0.5 { EK::CaveBear } else { EK::Beetle };
+            let n = 1 + (rng.next() % 2) as usize;
+            for k in 0..n {
+                let level = 2 + rng.next() % 3;
+                let id = self.spawn(kind, false, x as f32 + 0.5 + k as f32 * 0.6, y as f32 + 0.5, level);
+                if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
+                    e.side = crate::dwarves::DWARF_SIDE;
+                    e.home = Some((x as f32 + 0.5, y as f32 + 0.5));
+                    e.settled = true;
+                }
+            }
+        }
+    }
+
+    // a beaten wild beast: with room in a prison it is tamed instead of killed (true)
+    pub(crate) fn try_tame(&mut self, j: usize) -> bool {
+        let e = &self.ents[j];
+        if !beast(e.kind) || e.side != crate::dwarves::DWARF_SIDE || self.prison_space() == 0 {
+            return false;
+        }
+        let side = self.me_side;
+        let e = &mut self.ents[j];
+        e.side = side;
+        e.home = None;
+        e.guard = false;
+        e.hp = e.max_hp * 0.4;
+        e.happy = 0.6;
+        e.hunger = 0.5;
+        e.energy = 0.5;
+        e.job = Job::None;
+        e.path.clear();
+        e.bed = None;
+        e.settled = false;
+        let (x, y, kind) = (e.x, e.y, e.kind);
+        self.fx(7, x, y, 0.0, 0.0, 1.0, 0xff40c0ff);
+        self.sfx(Sfx::Convert, x, y);
+        self.msg("msg.beast_tamed", vec![format!("@{}", st(kind).name)]);
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn beasts_live_in_caverns_and_can_be_tamed() {
+        let g0 = Game::new(9, 128, 96);
+        let beasts: Vec<&Ent> = g0.ents.iter().filter(|e| e.alive && beast(e.kind)).collect();
+        assert!(!beasts.is_empty(), "a den on a bigger map");
+        assert!(beasts.iter().all(|e| e.dwarf() && e.home.is_some()), "neutral, at home");
+        let mut g = g0;
+        let j = g.ents.iter().position(|e| e.alive && beast(e.kind)).unwrap();
+        // without a prison the beast dies
+        assert!(!g.try_tame(j));
+        // a prison: the beaten beast joins
+        let (cx, cy) = g.map.core;
+        g.build_rect(9, cx - 6, cy - 6, cx - 3, cy - 4);
+        g.gold = 99999.0;
+        let t = &mut g.map.t[idx(cx - 5, cy - 5)];
+        if t.kind != Kind::Prison {
+            t.kind = Kind::Prison;
+            t.owner = Owner::Player;
+        }
+        g.recount();
+        assert!(g.prison_space() > 0);
+        g.ents[j].hp = 0.0;
+        g.kill(j);
+        assert!(g.ents[j].alive && g.ents[j].side == 0 && !g.ents[j].dwarf(), "tamed");
+    }
+}