Orders: attack (fighting creatures nearby go for an enemy or enemy tower) and guard (up to three creatures hold a room for two minutes); right click with an order tool cancels

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

src/orders.rs

@@ -0,0 +1,161 @@
+// Orders from the hand: "attack" sends the fighting creatures nearby at an enemy unit or tower,
+// "guard" posts a few creatures in a room. Right click with an order tool cancels the orders.
+
+use crate::game::*;
+use crate::map::*;
+
+const ORDER_RADIUS: f32 = 18.0;
+const GUARDS: usize = 3;
+
+fn ready(e: &Ent) -> bool {
+    e.alive && !e.held && e.creature() && !matches!(e.job, Job::Leave | Job::Register | Job::MakeBed(_)) && e.hp > e.max_hp * 0.25
+}
+
+impl Game {
+    // attack: the enemy (unit, or tower) at (wx, wy)
+    pub fn order_attack(&mut self, picked: Option<usize>, wx: f32, wy: f32) {
+        let unit = picked.filter(|&j| j < self.ents.len() && self.ents[j].alive && self.ents[j].side() != 0 && self.ents[j].captive == 0).or_else(|| {
+            self.ents.iter().position(|e| e.alive && !e.held && e.side() != 0 && e.captive == 0 && !e.chained && (e.x - wx).powi(2) + (e.y - wy).powi(2) < 1.5 * 1.5)
+        });
+        let tower = if unit.is_none() {
+            self.towers.iter().find(|t| t.hero && (t.pos().0 - wx).powi(2) + (t.pos().1 - wy).powi(2) < 1.2 * 1.2).map(|t| (t.id, t.pos()))
+        } else {
+            None
+        };
+        let (tx, ty) = match (unit, tower) {
+            (Some(j), _) => (self.ents[j].x, self.ents[j].y),
+            (None, Some((_, p))) => p,
+            _ => {
+                self.hint(31, "hint.order_attack");
+                self.sfx_ui(Sfx::Error);
+                return;
+            }
+        };
+        let mut n = 0;
+        for e in self.ents.iter_mut().filter(|e| ready(e) && (e.x - tx).powi(2) + (e.y - ty).powi(2) < ORDER_RADIUS * ORDER_RADIUS) {
+            e.job = match (unit, tower) {
+                (Some(_), _) => Job::Attack(0),
+                (None, Some((id, _))) => Job::AttackTower(id),
+                _ => continue,
+            };
+            e.path.clear();
+            e.repath = 0.0;
+            n += 1;
+        }
+        if let Some(j) = unit {
+            let id = self.ents[j].id;
+            for e in self.ents.iter_mut() {
+                if e.job == Job::Attack(0) {
+                    e.job = Job::Attack(id);
+                }
+            }
+        }
+        if n == 0 {
+            self.hint(31, "hint.order_nobody");
+            return;
+        }
+        self.fx(7, tx, ty, 0.0, 0.0, 0.6, 0xff3040ff);
+        self.sfx_ui(Sfx::FlagSet);
+        self.msg("msg.order_attack", vec![n.to_string()]);
+    }
+
+    // guard: a few creatures take positions in the room at (x, y)
+    pub fn order_guard(&mut self, x: i32, y: i32) {
+        if !inb(x, y) {
+            return;
+        }
+        let i = idx(x, y);
+        let kind = self.map.t[i].kind;
+        if self.map.t[i].owner != Owner::Player || room_index(kind).is_none() && kind != Kind::Floor {
+            self.hint(31, "hint.order_guard");
+            self.sfx_ui(Sfx::Error);
+            return;
+        }
+        // the spots: tiles of the same room (or floor) around the click
+        let mut spots: Vec<usize> = Vec::new();
+        for dy in -3..=3 {
+            for dx in -3..=3 {
+                if let Some(t) = self.map.get(x + dx, y + dy) {
+                    let j = idx(x + dx, y + dy);
+                    if t.kind == kind && t.owner == Owner::Player && t.reserved == 0 && !self.ents.iter().any(|e| e.job == Job::Guard(j)) {
+                        spots.push(j);
+                    }
+                }
+            }
+        }
+        spots.sort_by_key(|&j| {
+            let (sx, sy) = xy(j);
+            (sx - x).pow(2) + (sy - y).pow(2)
+        });
+        let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
+        let mut cands: Vec<usize> = (0..self.ents.len()).filter(|&j| ready(&self.ents[j]) && !matches!(self.ents[j].job, Job::Attack(_) | Job::Guard(_))).collect();
+        cands.sort_by(|&a, &b| {
+            let da = (self.ents[a].x - fx).powi(2) + (self.ents[a].y - fy).powi(2);
+            let db = (self.ents[b].x - fx).powi(2) + (self.ents[b].y - fy).powi(2);
+            da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
+        });
+        let mut n = 0;
+        for (&j, &spot) in cands.iter().zip(spots.iter()).take(GUARDS) {
+            let cur = self.ents[j].tile();
+            let Some(p) = self.map.path_to(cur, spot) else { continue };
+            let me = self.ents[j].id + 1;
+            self.unreserve(me);
+            self.map.t[spot].reserved = me;
+            let e = &mut self.ents[j];
+            e.job = Job::Guard(spot);
+            e.path = p;
+            e.timer = 120.0;
+            n += 1;
+        }
+        if n == 0 {
+            self.hint(31, "hint.order_nobody");
+            return;
+        }
+        self.fx(8, fx, fy, 0.0, 0.0, 0.6, 0xff40d0ff);
+        self.sfx_ui(Sfx::FlagSet);
+        self.msg("msg.order_guard", vec![n.to_string()]);
+    }
+
+    // right click with an order tool: everybody stands down
+    pub fn cancel_orders(&mut self) {
+        let mut n = 0;
+        for k in 0..self.ents.len() {
+            if matches!(self.ents[k].job, Job::Guard(_)) && self.ents[k].creature() {
+                let me = self.ents[k].id + 1;
+                self.unreserve(me);
+                self.ents[k].job = Job::None;
+                n += 1;
+            }
+        }
+        if n > 0 {
+            self.msg("msg.orders_cancelled", vec![]);
+            self.sfx_ui(Sfx::Click);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn creatures_follow_attack_and_guard_orders() {
+        let mut g = Game::new(14, 64, 64);
+        let (cx, cy) = g.map.core;
+        let ids: Vec<u32> = (0..4).map(|k| g.spawn(EK::Ogre, false, cx as f32 - 0.5, cy as f32 + 0.5 + k as f32 * 0.3, 2)).collect();
+        let knight = g.spawn(EK::Knight, true, cx as f32 + 2.5, cy as f32 - 1.5, 1);
+        let j = g.find(knight).unwrap();
+        g.order_attack(Some(j), 0.0, 0.0);
+        assert!(ids.iter().all(|&id| g.ents[g.find(id).unwrap()].job == Job::Attack(knight)));
+        // guard the treasury ring around the core
+        for &id in &ids {
+            let j = g.find(id).unwrap();
+            g.ents[j].job = Job::None;
+        }
+        g.order_guard(cx - 1, cy - 1);
+        let guards = g.ents.iter().filter(|e| matches!(e.job, Job::Guard(_))).count();
+        assert_eq!(guards, 3);
+        g.cancel_orders();
+        assert_eq!(g.ents.iter().filter(|e| matches!(e.job, Job::Guard(_))).count(), 0);
+    }
+}