Multiplayer step B: every player order is a command (dig, build, cast, hand, orders) and the simulation runs in fixed 50 ms steps, so single player and a match take the same path

src/commands.rs

@@ -0,0 +1,275 @@
+// Multiplayer step B: everything a master orders becomes a Command. The simulation only changes
+// through Game::apply_turn (commands, then a fixed number of steps), so a single player game and a
+// network match run exactly the same path. Commands are applied at step boundaries on every client,
+// in the order the server confirmed them.
+
+use crate::game::{Game, TowerKind};
+use crate::spells::Spell;
+use crate::traps::TrapKind;
+use serde::{Deserialize, Serialize};
+
+// a rectangle of tiles, as dragged with the dig, room, sell, bridge and steel tools
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Rect {
+    pub x0: i32,
+    pub y0: i32,
+    pub x1: i32,
+    pub y1: i32,
+}
+
+impl Rect {
+    pub fn new(x0: i32, y0: i32, x1: i32, y1: i32) -> Rect {
+        Rect { x0, y0, x1, y1 }
+    }
+}
+
+// one ordered action of a master; entity targets are ids, so they mean the same on every client
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub enum Act {
+    Dig(Rect),
+    Room {
+        room: u8,
+        r: Rect,
+    },
+    Sell(Rect),
+    Bridge(Rect),
+    Steel(Rect),
+    Tower {
+        kind: TowerKind,
+        x: i32,
+        y: i32,
+    },
+    Trap {
+        kind: TrapKind,
+        x: i32,
+        y: i32,
+    },
+    Cast {
+        spell: Spell,
+        x: f32,
+        y: f32,
+    },
+    Lightning {
+        x: f32,
+        y: f32,
+    },
+    Heal {
+        x: f32,
+        y: f32,
+    },
+    Summon {
+        x: f32,
+        y: f32,
+    },
+    Flag {
+        x: i32,
+        y: i32,
+    },
+    Pickup {
+        ent: u32,
+    },
+    Drop {
+        x: f32,
+        y: f32,
+    },
+    Slap {
+        ent: u32,
+    },
+    Attack {
+        ent: Option<u32>,
+        x: f32,
+        y: f32,
+    },
+    Guard {
+        x: i32,
+        y: i32,
+    },
+    CancelOrders,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Command {
+    pub side: u8, // the master who gave the order
+    pub seq: u32, // order within that master's commands (the server numbers them)
+    pub act: Act,
+}
+
+impl Game {
+    // the local master orders something: queued until the next step boundary
+    pub fn queue(&mut self, act: Act) {
+        if self.state != 0 || self.paused || self.demo.is_some() || !self.is_master(self.local_side) {
+            return;
+        }
+        let seq = self.cmd_seq;
+        self.cmd_seq = self.cmd_seq.wrapping_add(1);
+        self.pending.push(Command { side: self.local_side, seq, act });
+    }
+
+    // one command of one master: that master's state is switched in, the action runs, the local
+    // master's state is switched back. Messages, hints and sounds only come from the local master.
+    pub fn apply(&mut self, c: &Command) {
+        if !self.is_master(c.side) {
+            return;
+        }
+        self.switch_to(c.side);
+        self.run_act(c.act);
+        let local = self.local_side;
+        self.switch_to(local);
+    }
+
+    // a turn: the commands of all masters, then a fixed number of simulation steps
+    pub fn apply_turn(&mut self, cmds: &[Command], steps: usize) {
+        for c in cmds {
+            self.apply(c);
+        }
+        for _ in 0..steps {
+            self.step_fixed();
+        }
+    }
+
+    fn run_act(&mut self, act: Act) {
+        match act {
+            Act::Dig(r) => {
+                let on = !self.map.get(r.x0, r.y0).map_or(true, |t| t.marked);
+                self.mark_rect(r.x0, r.y0, r.x1, r.y1, on);
+            }
+            Act::Room { room, r } => self.build_rect(room as usize, r.x0, r.y0, r.x1, r.y1),
+            Act::Sell(r) => self.sell_rect(r.x0, r.y0, r.x1, r.y1),
+            Act::Bridge(r) => self.build_bridges(r.x0, r.y0, r.x1, r.y1),
+            Act::Steel(r) => self.build_steel(r.x0, r.y0, r.x1, r.y1),
+            Act::Tower { kind, x, y } => self.build_tower(kind, x, y),
+            Act::Trap { kind, x, y } => self.place_trap(kind, x, y),
+            Act::Cast { spell, x, y } => self.cast(spell, x, y),
+            Act::Lightning { x, y } => self.lightning(x, y),
+            Act::Heal { x, y } => self.heal(x, y),
+            Act::Summon { x, y } => self.summon(x, y),
+            Act::Flag { x, y } => self.set_flag(x, y),
+            Act::Pickup { ent } => {
+                let j = self.find(ent);
+                self.pickup(j);
+            }
+            Act::Drop { x, y } => {
+                self.drop(x, y);
+            }
+            Act::Slap { ent } => {
+                let j = self.find(ent);
+                self.slap(j);
+            }
+            Act::Attack { ent, x, y } => {
+                let j = ent.and_then(|id| self.find(id));
+                self.order_attack(j, x, y);
+            }
+            Act::Guard { x, y } => self.order_guard(x, y),
+            Act::CancelOrders => self.cancel_orders(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::game::{EK, Job, STEP};
+    use crate::map::idx;
+
+    fn game(seed: u32) -> Game {
+        let mut g = Game::new(seed, 64, 64);
+        g.init_fog();
+        g
+    }
+
+    #[test]
+    fn a_queued_command_is_applied_at_the_next_step() {
+        let mut g = game(7);
+        let (cx, cy) = g.map.core;
+        let (x, y) = (cx + 6, cy); // outside the treasury ring: rock that can be marked
+        g.queue(Act::Dig(Rect::new(x, y, x + 1, y + 1)));
+        assert!(!g.map.t[idx(x, y)].marked, "queued, not applied yet");
+        g.update(STEP);
+        assert!(g.map.t[idx(x, y)].marked, "applied at the step boundary");
+        assert!(g.pending.is_empty());
+    }
+
+    #[test]
+    fn a_command_of_another_master_leaves_the_local_one_alone() {
+        let mut g = game(8);
+        let (cx, cy) = g.map.core;
+        g.add_master(2, (cx + 20, cy + 20));
+        let (gold, hand) = (g.gold, g.hand.len());
+        let (msgs, events) = (g.msgs.len(), g.events.len());
+        // an order far away, given by another master, reaches his state only
+        g.apply(&Command { side: 2, seq: 0, act: Act::Attack { ent: None, x: (cx + 21) as f32, y: (cy + 21) as f32 } });
+        assert_eq!(g.gold, gold, "his gold, not mine");
+        assert_eq!(g.hand.len(), hand);
+        assert_eq!(g.msgs.len(), msgs, "he hears his own order, not I");
+        assert_eq!(g.events.len(), events, "and it makes no sound here");
+        assert_eq!(g.me_side, g.local_side, "I am back in the saddle");
+        assert_eq!(g.map.core, (cx, cy), "my heart is still mine");
+        // while it was in the saddle, that master had his own heart and his own ground
+        g.switch_to(2);
+        assert_eq!(g.map.core, (cx + 20, cy + 20));
+        assert_eq!(g.me, crate::map::Owner::of_side(2));
+        g.switch_to(0);
+        // the same order from the local master is heard here
+        g.apply(&Command { side: 0, seq: 1, act: Act::Attack { ent: None, x: (cx + 21) as f32, y: (cy + 21) as f32 } });
+        assert!(g.msgs.len() > msgs, "my own orders speak to me");
+        assert!(g.master_sides().contains(&2));
+    }
+
+    #[test]
+    fn unknown_sides_cannot_order_anything() {
+        let mut g = game(9);
+        let (cx, cy) = g.map.core;
+        let (x, y) = (cx + 6, cy);
+        g.apply(&Command { side: 3, seq: 0, act: Act::Dig(Rect::new(x, y, x, y)) });
+        g.update(STEP);
+        assert!(!g.map.t[idx(x, y)].marked);
+    }
+
+    #[test]
+    fn the_same_actions_on_both_paths_build_the_same_world() {
+        let dig = Rect::new(20, 20, 22, 22);
+        let room = Act::Room { room: 0, r: Rect::new(30, 30, 31, 31) };
+        let drop_at = (21.4f32, 22.6f32);
+
+        // one game driven like a single player session (queue + update)
+        let mut a = game(11);
+        let ogre = a.spawn(EK::Ogre, false, 21.5, 21.5, 3);
+        a.queue(Act::Dig(dig));
+        a.queue(room);
+        a.queue(Act::Pickup { ent: ogre });
+        a.queue(Act::Drop { x: drop_at.0, y: drop_at.1 });
+        for _ in 0..20 {
+            a.update(0.05);
+        }
+
+        // the same game driven like a match (one turn with all commands, then the same steps)
+        let mut b = game(11);
+        assert_eq!(b.spawn(EK::Ogre, false, 21.5, 21.5, 3), ogre);
+        let turn = vec![
+            Command { side: 0, seq: 0, act: Act::Dig(dig) },
+            Command { side: 0, seq: 1, act: room },
+            Command { side: 0, seq: 2, act: Act::Pickup { ent: ogre } },
+            Command { side: 0, seq: 3, act: Act::Drop { x: drop_at.0, y: drop_at.1 } },
+        ];
+        b.apply_turn(&turn, 20);
+
+        assert_eq!(a.time, b.time, "the same number of fixed steps");
+        assert_eq!(a.sim_steps, b.sim_steps);
+        assert_eq!(a.gold, b.gold);
+        assert_eq!(a.hand, b.hand);
+        assert!(a.map.t.iter().zip(b.map.t.iter()).all(|(x, y)| x.kind == y.kind && x.owner == y.owner && x.marked == y.marked && x.hp == y.hp && x.gold == y.gold && x.reserved == y.reserved), "the maps diverged");
+        assert_eq!(fingerprint(&a), fingerprint(&b), "the creatures diverged");
+    }
+
+    // what the simulation has to agree on for two clients of one match
+    fn fingerprint(g: &Game) -> Vec<(u32, EK, bool, u8, f32, f32, f32, Job)> {
+        g.ents.iter().map(|e| (e.id, e.kind, e.alive, e.side, e.x, e.y, e.hp, e.job)).collect()
+    }
+
+    #[test]
+    fn commands_survive_a_savegame_round_trip() {
+        let c = Command { side: 1, seq: 4, act: Act::Attack { ent: Some(9), x: 3.5, y: 4.5 } };
+        let json = serde_json::to_string(&c).unwrap();
+        assert_eq!(serde_json::from_str::<Command>(&json).unwrap(), c);
+    }
+}

src/fog.rs

@@ -80,7 +80,7 @@ impl Game {
         let (w, h) = (mw() as i32, mh() as i32);
         // own ground and everything around it
         for i in 0..n {
-            if self.map.t[i].owner == Owner::Player {
+            if self.map.t[i].owner == self.me {
                 let (x, y) = xy(i);
                 for dy in -1..=1 {
                     for dx in -1..=1 {

src/game.rs

@@ -1,5 +1,6 @@
 // Game logic: units, AI, economy, hero waves.
 
+use crate::commands::Command;
 use crate::map::*;
 use serde::{Deserialize, Serialize};
 
@@ -359,7 +360,7 @@ impl Ent {
     }
     // the player's creatures (not imps, heroes or the rivals' units)
     pub fn creature(&self) -> bool {
-        !self.hero && self.side == 0 && self.kind != EK::Worker && !self.chained
+        !self.hero && self.side == me_side() && self.kind != EK::Worker && !self.chained
     }
     // 0 player, 1 humans, 2 and 3 rival masters
     pub fn side(&self) -> u8 {
@@ -426,6 +427,50 @@ pub struct Fx {
     pub style: u8, // projectiles: arrow, cannonball, fireball, ... (see particles.rs)
 }
 
+thread_local! {
+    // the master whose turn it is in the simulation (see Game::switch_to)
+    static ME_SIDE: std::cell::Cell<u8> = std::cell::Cell::new(0);
+}
+
+pub fn me_side() -> u8 {
+    ME_SIDE.with(|s| s.get())
+}
+
+fn player_owner() -> Owner {
+    Owner::Player
+}
+
+// The state of a dungeon master that is not being processed right now. The Game's own fields
+// (gold, mana, hand, ...) always belong to the master whose side is `me_side`; switching swaps
+// them with the stored ones. A single player game has no stored masters at all.
+#[derive(Clone, Debug, Default)]
+pub struct MasterState {
+    pub side: u8,
+    pub owner: Option<Owner>,
+    pub core: (i32, i32),
+    pub core_hp: f32,
+    pub gold: f32,
+    pub mana: f32,
+    pub payday: f32,
+    pub payday_warned: bool,
+    pub hand: Vec<u32>,
+    pub flag: Option<usize>,
+    pub reserve: f32,
+    pub incoming: Vec<(u8, f32, Option<usize>)>,
+    pub training_bill: f32,
+    pub counts: [usize; N_ROOMS],
+    pub springs: usize,
+    pub known: Vec<bool>,
+    pub researchable: Vec<bool>,
+    pub research: f32,
+    pub forge_work: f32,
+    pub rune_free: u32,
+    pub rune_final: u32,
+    pub rune_next: u32,
+    pub portal_timer: f32,
+    pub punch_ready: f32,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct Game {
     pub map: Map,
@@ -532,6 +577,22 @@ pub struct Game {
     pub rune_next: u32, // sold rune forge towers: back as a chest in the next mission
     #[serde(default)]
     pub freed: u32, // chained creatures freed // tiles next to fighting heroes: knight ground there cannot be claimed
+    #[serde(skip, default = "player_owner")]
+    pub me: Owner, // owner of the ground of the master being processed
+    #[serde(skip)]
+    pub me_side: u8, // that master's side (0 = the first player)
+    #[serde(skip)]
+    pub local_side: u8, // the master who plays at this computer
+    #[serde(skip)]
+    pub masters: Vec<MasterState>, // the other masters (multiplayer)
+    #[serde(skip)]
+    pub pending: Vec<Command>, // orders of this master, applied at the next step boundary
+    #[serde(skip)]
+    pub cmd_seq: u32, // number of the next command queued here
+    #[serde(skip)]
+    pub sim_steps: u64, // fixed simulation steps done so far (the lockstep clock)
+    #[serde(skip)]
+    step_acc: f32, // real time not yet paid for with a step
     #[serde(skip)]
     pub hints: bool, // show hint messages (setting)
     #[serde(skip, default = "hint_times")]
@@ -542,6 +603,12 @@ fn hint_times() -> [f32; 32] {
     [-1000.0; 32]
 }
 
+// every simulation step has the same length: on every client of a match the same commands are
+// applied and then the same number of steps runs, so the worlds stay identical
+pub const STEP: f32 = 0.05;
+// one frame never runs away into the future (a lagging tab catches up at most this much)
+const MAX_STEPS_PER_FRAME: usize = 4;
+
 // torch on a wall face: wall tile + direction (index into DIR4) towards the open side
 #[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Torch {
@@ -699,6 +766,14 @@ impl Game {
             entry_history: Vec::new(),
             planned_entries: Vec::new(),
             hints: true,
+            me: Owner::Player,
+            me_side: 0,
+            local_side: 0,
+            masters: Vec::new(),
+            pending: Vec::new(),
+            cmd_seq: 0,
+            sim_steps: 0,
+            step_acc: 0.0,
             hint_t: hint_times(),
             reserve: 0.0,
             incoming: Vec::new(),
@@ -758,7 +833,7 @@ impl Game {
         let map = &self.map;
         self.torches.retain(|t| map.t[t.wall].solid());
         for i in 0..n() {
-            if self.map.t[i].owner == Owner::Player {
+            if self.map.t[i].owner == self.me {
                 self.place_torches(i);
             }
         }
@@ -800,7 +875,16 @@ impl Game {
         self.mission.as_ref().map_or(self.gate_on, |m| m.heart)
     }
 
+    // messages, hints and sounds are meant for the master who plays at this computer: while
+    // another master is being simulated (his economy, his orders) nothing of that reaches the screen
+    fn speaking(&self) -> bool {
+        self.me_side == self.local_side
+    }
+
     pub fn msg(&mut self, key: &'static str, args: Vec<String>) {
+        if !self.speaking() {
+            return; // a foreign master ordered something: only he hears about it
+        }
         self.msgs.push(Msg { key, args });
         if self.msgs.len() > 50 {
             self.msgs.remove(0);
@@ -808,12 +892,18 @@ impl Game {
     }
 
     pub fn sfx(&mut self, sfx: Sfx, x: f32, y: f32) {
+        if !self.speaking() {
+            return;
+        }
         if self.events.len() < 64 {
             self.events.push(SfxEvent { sfx, pos: Some((x, y)) });
         }
     }
 
     pub fn sfx_ui(&mut self, sfx: Sfx) {
+        if !self.speaking() {
+            return;
+        }
         if self.events.len() < 64 {
             self.events.push(SfxEvent { sfx, pos: None });
         }
@@ -862,6 +952,9 @@ impl Game {
     }
 
     pub(crate) fn hint(&mut self, slot: usize, key: &'static str) {
+        if !self.speaking() {
+            return; // another master ordered something: he keeps his hints for himself
+        }
         if self.hints && self.time - self.hint_t[slot] > 30.0 {
             self.hint_t[slot] = self.time;
             self.msg(key, vec![]);
@@ -870,9 +963,9 @@ impl Game {
 
     pub fn recount(&mut self) {
         let mut c = [0usize; N_ROOMS];
-        self.springs = self.map.t.iter().filter(|t| t.kind == Kind::ManaSpring && t.owner == Owner::Player).count();
+        self.springs = self.map.t.iter().filter(|t| t.kind == Kind::ManaSpring && t.owner == self.me).count();
         for t in &self.map.t {
-            if t.owner == Owner::Player {
+            if t.owner == self.me {
                 if let Some(r) = room_index(t.kind) {
                     c[r] += 1;
                 }
@@ -923,7 +1016,7 @@ impl Game {
         let mut stored = 0.0;
         for i in 0..self.map.t.len() {
             let t = &mut self.map.t[i];
-            if t.kind == Kind::Treasury && t.owner == Owner::Player {
+            if t.kind == Kind::Treasury && t.owner == self.me {
                 tiles.push(i);
                 stored += t.gold as f32;
             } else if t.gold != 0 && t.vein().is_none() && t.kind != Kind::Treasury {
@@ -1010,7 +1103,7 @@ impl Game {
     #[allow(dead_code)]
     pub fn portal_owned(&self) -> bool {
         let Some(&(px, py)) = self.map.portals.first() else { return false };
-        self.map.t[idx(px, py)].owner == Owner::Player
+        self.map.t[idx(px, py)].owner == self.me
     }
 
     pub fn creature_count(&self) -> usize {
@@ -1083,11 +1176,15 @@ impl Game {
     // ---------------------------------------------------------------- update
 
     pub fn update(&mut self, dt: f32) {
-        let dt = dt.min(0.1);
-        if self.state == 0 && !self.paused {
-            self.step(dt);
+        self.step_acc = (self.step_acc + dt).min(STEP * MAX_STEPS_PER_FRAME as f32);
+        let mut steps = 0usize;
+        while self.step_acc >= STEP {
+            self.step_acc -= STEP;
+            steps += 1;
         }
-        self.sync_treasury();
+        let cmds = std::mem::take(&mut self.pending);
+        self.apply_turn(&cmds, steps);
+        // what only the camera cares about runs in real time: it is not part of the shared state
         self.update_particles(dt);
         for f in self.fx.iter_mut() {
             f.t += dt;
@@ -1095,11 +1192,134 @@ impl Game {
         self.fx.retain(|f| f.t < f.max);
     }
 
+    // one fixed step: the world of every master, then the shared bookkeeping
+    pub(crate) fn step_fixed(&mut self) {
+        self.sim_steps += 1;
+        if self.state == 0 && !self.paused {
+            self.step(STEP);
+        }
+        for side in self.master_sides() {
+            self.switch_to(side);
+            self.sync_treasury();
+        }
+        let local = self.local_side;
+        self.switch_to(local);
+    }
+
+    // ---------------------------------------------------------------- masters
+
+    pub fn master_sides(&self) -> Vec<u8> {
+        let mut v: Vec<u8> = std::iter::once(self.me_side).chain(self.masters.iter().map(|m| m.side)).collect();
+        v.sort_unstable();
+        v
+    }
+
+    pub fn is_master(&self, side: u8) -> bool {
+        side == self.me_side || self.masters.iter().any(|m| m.side == side)
+    }
+
+    fn take_active(&mut self) -> MasterState {
+        MasterState {
+            side: self.me_side,
+            owner: Some(self.me),
+            core: self.map.core,
+            core_hp: self.core_hp,
+            gold: self.gold,
+            mana: self.mana,
+            payday: self.payday,
+            payday_warned: self.payday_warned,
+            hand: std::mem::take(&mut self.hand),
+            flag: self.flag,
+            reserve: self.reserve,
+            incoming: std::mem::take(&mut self.incoming),
+            training_bill: self.training_bill,
+            counts: self.counts,
+            springs: self.springs,
+            known: std::mem::take(&mut self.known),
+            researchable: std::mem::take(&mut self.researchable),
+            research: self.research,
+            forge_work: self.forge_work,
+            rune_free: self.rune_free,
+            rune_final: self.rune_final,
+            rune_next: self.rune_next,
+            portal_timer: self.portal_timer,
+            punch_ready: self.punch_ready,
+        }
+    }
+
+    fn put_active(&mut self, m: MasterState) {
+        self.me_side = m.side;
+        self.me = m.owner.unwrap_or(Owner::of_side(m.side));
+        ME_SIDE.with(|s| s.set(m.side));
+        self.map.core = m.core;
+        self.core_hp = m.core_hp;
+        self.gold = m.gold;
+        self.mana = m.mana;
+        self.payday = m.payday;
+        self.payday_warned = m.payday_warned;
+        self.hand = m.hand;
+        self.flag = m.flag;
+        self.reserve = m.reserve;
+        self.incoming = m.incoming;
+        self.training_bill = m.training_bill;
+        self.counts = m.counts;
+        self.springs = m.springs;
+        self.known = m.known;
+        self.researchable = m.researchable;
+        self.research = m.research;
+        self.forge_work = m.forge_work;
+        self.rune_free = m.rune_free;
+        self.rune_final = m.rune_final;
+        self.rune_next = m.rune_next;
+        self.portal_timer = m.portal_timer;
+        self.punch_ready = m.punch_ready;
+    }
+
+    // make `side` the master being processed (no-op for sides that are no masters)
+    pub fn switch_to(&mut self, side: u8) {
+        if side == self.me_side {
+            return;
+        }
+        let Some(k) = self.masters.iter().position(|m| m.side == side) else { return };
+        let target = self.masters.swap_remove(k);
+        let cur = self.take_active();
+        self.masters.push(cur);
+        self.put_active(target);
+    }
+
+    // a new master on `side` with its core at (cx, cy) (top-left of the 3x3 core). Used by the
+    // multiplayer lobby (and its tests); single player games have no stored masters.
+    #[allow(dead_code)]
+    pub fn add_master(&mut self, side: u8, core: (i32, i32)) {
+        let mut m = self.take_active();
+        let me = std::mem::replace(&mut m, MasterState::default());
+        // the copy keeps the economy settings; the new one starts fresh
+        let fresh = MasterState {
+            side,
+            owner: Some(Owner::of_side(side)),
+            core,
+            core_hp: CORE_HP,
+            gold: 1500.0,
+            mana: 100.0,
+            payday: PAYDAY,
+            known: me.known.clone(),
+            researchable: me.researchable.clone(),
+            portal_timer: 10.0,
+            ..MasterState::default()
+        };
+        self.put_active(me);
+        self.masters.push(fresh);
+    }
+
     pub(crate) fn update_units(&mut self, dt: f32) {
         for i in 0..self.ents.len() {
             if !self.ents[i].alive || self.ents[i].held {
                 continue;
             }
+            let side = self.ents[i].side;
+            if !self.ents[i].hero && side != self.me_side && !self.masters.is_empty() {
+                self.switch_to(side);
+            }
             let mut e = std::mem::replace(&mut self.ents[i], Ent::dummy());
             let (x0, y0) = (e.x, e.y);
             self.update_ent(&mut e, dt);
@@ -1121,14 +1341,23 @@ impl Game {
             return;
         }
         self.time += dt;
-        self.recount();
-        self.mana = (self.mana + (1.0 + SPRING_MANA * self.springs as f32) * dt).min(self.mana_max());
-        self.core_hp = (self.core_hp + 0.5 * dt).min(CORE_HP);
         for t in self.map.t.iter_mut() {
             if t.kind == Kind::Farm {
                 t.food = (t.food + dt / 18.0).min(3.0);
             }
         }
+        for side in self.master_sides() {
+            self.switch_to(side);
+            self.economy(dt);
+        }
+        self.after_economy(dt);
+    }
+
+    // a master's household: mana, core, portals, payday
+    fn economy(&mut self, dt: f32) {
+        self.recount();
+        self.mana = (self.mana + (1.0 + SPRING_MANA * self.springs as f32) * dt).min(self.mana_max());
+        self.core_hp = (self.core_hp + 0.5 * dt).min(CORE_HP);
 
         let owned = self.portals_owned();
         if owned > 0 {
@@ -1156,7 +1385,18 @@ impl Game {
             self.payday_warned = false;
             self.do_payday();
         }
+        // every two seconds: corners between reinforced walls are closed
+        if (self.time / 2.0).floor() != ((self.time - dt) / 2.0).floor() {
+            self.reinforce_corners();
+        }
+        self.update_forge(dt);
+        self.update_research();
+    }
 
+    fn after_economy(&mut self, dt: f32) {
+        // from here on it is about the local master and the humans: that side is switched in first
+        let local = self.local_side;
+        self.switch_to(local);
         if self.waves_on() {
             self.wave_tick(dt);
         }
@@ -1164,23 +1404,18 @@ impl Game {
             self.gate_hp = (self.gate_hp + 8.0 * dt).min(GATE_HP);
         }
 
-        // every two seconds: corners between reinforced walls are closed
-        if (self.time / 2.0).floor() != ((self.time - dt) / 2.0).floor() {
-            self.reinforce_corners();
-        }
         self.update_contested();
         self.update_units(dt);
+        self.switch_to(local); // update_units worked master by master
         self.update_towers(dt);
-        self.update_forge(dt);
-        self.update_research();
         self.update_reveals(dt);
         self.update_graves(dt);
-        self.update_fog(dt);
         if !self.rivals.is_empty() {
             self.update_rivals(dt);
         }
         self.update_dwarves(dt);
         self.check_end();
+        self.update_fog(dt);
     }
 
     fn check_end(&mut self) {
@@ -1313,7 +1548,7 @@ impl Game {
         let (px, py) = self.map.portals[0];
         for y in 0..3 {
             for x in 0..3 {
-                self.map.t[idx(px + x, py + y)].owner = Owner::Player;
+                self.map.t[idx(px + x, py + y)].owner = self.me;
             }
         }
         self.try_portal();
@@ -1455,7 +1690,7 @@ impl Game {
         let cur = e.tile();
         let goal = |i: usize| {
             let t = &self.map.t[i];
-            (t.kind == Kind::Treasury && t.owner == Owner::Player && t.gold > 0) || (self.counts[0] == 0 && self.map.adj_core(i))
+            (t.kind == Kind::Treasury && t.owner == self.me && t.gold > 0) || (self.counts[0] == 0 && self.map.adj_core(i))
         };
         let found = if flies(e.kind) { self.map.search(cur, self.map.fly_cost(), goal, true) } else { self.map.search(cur, self.map.walk_cost(), goal, true) };
         match found {
@@ -1760,7 +1995,7 @@ impl Game {
             // waits in chains until the player's imps claim its cave
             e.moving = false;
             let (x, y) = xy(e.tile());
-            let reached = std::iter::once((0, 0)).chain(DIR8.iter().copied()).any(|(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |t| t.owner == Owner::Player));
+            let reached = std::iter::once((0, 0)).chain(DIR8.iter().copied()).any(|(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |t| t.owner == self.me));
             if reached {
                 e.chained = false;
                 e.settled = false;
@@ -2314,7 +2549,7 @@ impl Game {
                 if t.kind != Kind::Earth || t.owner == Owner::Hero {
                     continue;
                 }
-                let own = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == Owner::Player && n.walkable()));
+                let own = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == self.me && n.walkable()));
                 if !own {
                     continue;
                 }
@@ -2354,7 +2589,7 @@ impl Game {
                         continue;
                     }
                     any_river = true;
-                    let own = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == Owner::Player && n.walkable()));
+                    let own = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == self.me && n.walkable()));
                     if own {
                         add.push(idx(x, y));
                     }
@@ -2374,7 +2609,7 @@ impl Game {
                 self.gold -= cost;
                 let t = &mut self.map.t[i];
                 t.kind = if lava { Kind::LavaBridge } else { Kind::Bridge };
-                t.owner = Owner::Player;
+                t.owner = self.me;
                 built += 1;
                 progress = true;
                 let (x, y) = xy(i);
@@ -2401,7 +2636,7 @@ impl Game {
     pub fn reinforce_corners(&mut self) {
         let (w, h) = (mw() as i32, mh() as i32);
         let wall = |m: &Map, x: i32, y: i32| m.get(x, y).map_or(false, |n| n.kind == Kind::Earth && n.reinforced && n.owner != Owner::Hero);
-        let floor = |m: &Map, x: i32, y: i32| m.get(x, y).map_or(false, |n| n.owner == Owner::Player && n.walkable());
+        let floor = |m: &Map, x: i32, y: i32| m.get(x, y).map_or(false, |n| n.owner == self.me && n.walkable());
         let mut add = Vec::new();
         for y in 1..h - 1 {
             for x in 1..w - 1 {
@@ -2514,7 +2749,7 @@ impl Game {
                         continue;
                     }
                     if let Some(t) = self.map.get(cx + dx, cy + dy) {
-                        if t.bridge() && t.owner == Owner::Player {
+                        if t.bridge() && t.owner == self.me {
                             return Some(idx(cx + dx, cy + dy));
                         }
                     }
@@ -2527,7 +2762,7 @@ impl Game {
     // a knight walks next to the bridge tile and tears it down
     fn tear_bridge(&mut self, e: &mut Ent, i: usize, dt: f32) -> bool {
         let t = self.map.t[i];
-        if !t.bridge() || t.owner != Owner::Player {
+        if !t.bridge() || t.owner != self.me {
             return false;
         }
         let (bx, by) = xy(i);
@@ -2596,7 +2831,7 @@ impl Game {
 
     // an earth wall next to own floor that can be reinforced from tile i
     fn reinforce_neighbor(&self, i: usize, me: u32) -> Option<usize> {
-        if self.map.t[i].owner != Owner::Player {
+        if self.map.t[i].owner != self.me {
             return None;
         }
         let (x, y) = xy(i);
@@ -2612,14 +2847,13 @@ impl Game {
 
     fn claimable(&self, i: usize, me: u32) -> bool {
         let t = &self.map.t[i];
-        let ok = match t.owner {
-            Owner::None => matches!(t.kind, Kind::Floor | Kind::Portal | Kind::Bridge | Kind::LavaBridge | Kind::Shard | Kind::Treasury | Kind::ManaSpring | Kind::RuneChest),
-            // knight ground (also vaults and shard chambers), but not while heroes fight there
-            // knight and rival ground (also vaults and shard chambers), but not while enemies fight there
-            Owner::Hero | Owner::Rival1 | Owner::Rival2 => {
-                matches!(t.kind, Kind::Floor | Kind::Treasury | Kind::Bridge | Kind::LavaBridge | Kind::Shard | Kind::Lair | Kind::Training) && !self.contested.get(i).copied().unwrap_or(false)
-            }
-            Owner::Player => false,
+        let ok = if t.owner == self.me {
+            false
+        } else if t.owner == Owner::None {
+            matches!(t.kind, Kind::Floor | Kind::Portal | Kind::Bridge | Kind::LavaBridge | Kind::Shard | Kind::Treasury | Kind::ManaSpring | Kind::RuneChest)
+        } else {
+            // knight and other masters' ground (also vaults and shard chambers), but not while enemies fight there
+            matches!(t.kind, Kind::Floor | Kind::Treasury | Kind::Bridge | Kind::LavaBridge | Kind::Shard | Kind::Lair | Kind::Training) && !self.contested.get(i).copied().unwrap_or(false)
         };
         if !ok {
             return false;
@@ -2628,12 +2862,12 @@ impl Game {
             return false;
         }
         let (x, y) = xy(i);
-        DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == Owner::Player))
+        DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner == self.me))
     }
 
     fn is_deposit(&self, i: usize) -> bool {
         let t = &self.map.t[i];
-        (t.kind == Kind::Treasury && t.owner == Owner::Player) || (self.counts[0] == 0 && self.map.adj_core(i))
+        (t.kind == Kind::Treasury && t.owner == self.me) || (self.counts[0] == 0 && self.map.adj_core(i))
     }
 
     fn start_deliver(&mut self, e: &mut Ent) -> bool {
@@ -2683,7 +2917,7 @@ impl Game {
         for _ in 0..6 {
             let nx = x + self.rng.range(-radius, radius);
             let ny = y + self.rng.range(-radius, radius);
-            if self.map.walk(nx, ny) && self.map.t[idx(nx, ny)].owner == Owner::Player {
+            if self.map.walk(nx, ny) && self.map.t[idx(nx, ny)].owner == self.me {
                 if let Some(p) = self.map.path_to(e.tile(), idx(nx, ny)) {
                     if p.len() as i32 <= radius * 2 + 2 {
                         e.path = p;
@@ -2840,13 +3074,13 @@ impl Game {
                         let (px, py) = self.map.portals[pk];
                         for y in 0..3 {
                             for x in 0..3 {
-                                self.map.t[idx(px + x, py + y)].owner = Owner::Player;
+                                self.map.t[idx(px + x, py + y)].owner = self.me;
                             }
                         }
                         self.msg("msg.portal_claimed", vec![]);
                         self.fx(7, px as f32 + 1.5, py as f32 + 1.5, 0.0, 0.0, 1.0, 0xffff66cc);
                     } else {
-                        self.map.t[t].owner = Owner::Player;
+                        self.map.t[t].owner = self.me;
                     }
                     self.place_torches(t);
                     let (x, y) = xy(t);
@@ -2982,7 +3216,7 @@ impl Game {
             self.map.walk_cost(),
             |i| {
                 let t = &self.map.t[i];
-                t.kind == kind && t.owner == Owner::Player && (t.reserved == 0 || t.reserved == me) && (!need_food || t.food >= 1.0)
+                t.kind == kind && t.owner == self.me && (t.reserved == 0 || t.reserved == me) && (!need_food || t.food >= 1.0)
             },
             true,
         )
@@ -3213,7 +3447,7 @@ impl Game {
             Job::Guard(t) => {
                 // a guard post, or a guard order in any room
                 e.timer -= dt;
-                if cur != t || !self.map.t[t].walkable() || self.map.t[t].owner != Owner::Player || e.timer <= 0.0 {
+                if cur != t || !self.map.t[t].walkable() || self.map.t[t].owner != self.me || e.timer <= 0.0 {
                     self.unreserve(me);
                     e.job = Job::None;
                 }
@@ -3979,11 +4213,11 @@ impl Game {
         let mut cands = Vec::new();
         for i in 0..self.map.t.len() {
             let t = &self.map.t[i];
-            if t.owner != Owner::Player || !t.walkable() {
+            if t.owner != self.me || !t.walkable() {
                 continue;
             }
             let (x, y) = xy(i);
-            let border = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner != Owner::Player));
+            let border = DIR4.iter().any(|&(dx, dy)| self.map.get(x + dx, y + dy).map_or(false, |n| n.owner != self.me));
             if !border {
                 continue;
             }
@@ -4061,7 +4295,7 @@ impl Game {
                 }
                 let i = idx(x, y);
                 let t = self.map.t[i];
-                if t.kind == Kind::Floor && t.owner == Owner::Player {
+                if t.kind == Kind::Floor && t.owner == self.me {
                     if self.gold < cost {
                         broke = true;
                         continue;
@@ -4124,7 +4358,7 @@ impl Game {
                     refund += STEEL_COST[1] as f32 * 0.5;
                     continue;
                 }
-                if t.owner == Owner::Player && t.bridge() {
+                if t.owner == self.me && t.bridge() {
                     let lava = t.kind == Kind::LavaBridge;
                     t.kind = if lava { Kind::Lava } else { Kind::Water };
                     t.owner = Owner::None;
@@ -4134,7 +4368,7 @@ impl Game {
                     continue;
                 }
                 let t = &mut self.map.t[i];
-                if t.owner == Owner::Player {
+                if t.owner == self.me {
                     if let Some(r) = room_index(t.kind) {
                         t.kind = Kind::Floor;
                         t.bed = 0;
@@ -4197,7 +4431,7 @@ impl Game {
             return;
         }
         let t = self.map.t[i];
-        if t.kind != Kind::Floor || t.owner != Owner::Player {
+        if t.kind != Kind::Floor || t.owner != self.me {
             self.hint(16, "hint.tower_where");
             self.sfx_ui(Sfx::Error);
             return;
@@ -4626,7 +4860,7 @@ impl Game {
     }
 
     fn on_own_ground(&self, x: f32, y: f32) -> bool {
-        self.map.get(x as i32, y as i32).map_or(false, |t| t.owner == Owner::Player)
+        self.map.get(x as i32, y as i32).map_or(false, |t| t.owner == self.me)
     }
 
     // Left click with the hand: own units anywhere, unconscious heroes only on own ground
@@ -4685,7 +4919,7 @@ impl Game {
         }
         let i = idx(x, y);
         let t = self.map.t[i];
-        if !t.walkable() || t.owner != Owner::Player {
+        if !t.walkable() || t.owner != self.me {
             self.hint(9, "hint.drop_where");
             self.sfx_ui(Sfx::Error);
             return false;
@@ -4829,7 +5063,7 @@ impl Game {
     pub fn summon(&mut self, wx: f32, wy: f32) {
         let cost = self.summon_cost();
         let (x, y) = (wx as i32, wy as i32);
-        if !self.map.walk(x, y) || self.map.t[idx(x, y)].owner != Owner::Player {
+        if !self.map.walk(x, y) || self.map.t[idx(x, y)].owner != self.me {
             self.hint(13, "hint.summon_where");
             return;
         }
@@ -5137,23 +5371,23 @@ mod tests {
     #[test]
     fn treasury_shows_its_treasures() {
         let mut g = Game::new(3, 64, 64);
-        g.update(0.01);
+        g.update(STEP);
         // the starting gold lies in the treasury ring
         assert!((treasury_total(&g) - g.gold).abs() < 2.0);
         assert_eq!(g.reserve, 0.0);
         // rubies fill their own tiles
         g.add_res(1200.0, 2);
-        g.update(0.01);
+        g.update(STEP);
         let rubies: i32 = g.map.t.iter().filter(|t| t.kind == Kind::Treasury && t.owner == Owner::Player && t.res == 2).map(|t| t.gold).sum();
         assert_eq!(rubies, 1200);
         assert!(g.map.t.iter().all(|t| t.gold <= TREASURY_TILE as i32 || t.vein().is_some()));
         // spending empties tiles (randomly), the total always matches the gold counter
         g.gold -= 1700.0;
-        g.update(0.01);
+        g.update(STEP);
         assert!((treasury_total(&g) - g.gold).abs() < 2.0);
         // more than the treasury holds: the core keeps the rest
         g.gold = g.gold_cap();
-        g.update(0.01);
+        g.update(STEP);
         assert!((treasury_total(&g) - g.gold).abs() < 2.0);
         // (tiles partly filled with rubies take no gold, so the core may hold a little more)
         let gem_room: f32 = g.map.t.iter().filter(|t| t.kind == Kind::Treasury && t.owner == Owner::Player && t.res != 0).map(|t| TREASURY_TILE - t.gold as f32).sum();
@@ -5174,12 +5408,12 @@ mod tests {
             }
         }
         g.recount();
-        g.update(0.01);
+        g.update(STEP);
         let far = |g: &Game| -> i32 { (cy - 9..=cy - 7).flat_map(|y| (cx + 10..=cx + 12).map(move |x| (x, y))).map(|(x, y)| g.map.t[idx(x, y)].gold).sum() };
         let before = far(&g);
         let at = idx(cx + 11, cy - 8);
         g.add_res_at(900.0, 2, Some(at));
-        g.update(0.01);
+        g.update(STEP);
         assert_eq!(far(&g) - before, 900, "the rubies lie where they were delivered");
     }
 

src/main.rs

@@ -3,6 +3,7 @@
 mod audio;
 mod campaign;
 mod cloud;
+mod commands;
 mod demo;
 mod dwarves;
 mod fog;
@@ -35,10 +36,11 @@ mod wilds;
 mod xm;
 
 use cloud::{Cloud, CloudEvent};
+use commands::Act;
 use game::{Game, Msg};
 use gfx::Gfx;
 use macroquad::prelude::*;
-use map::{idx, inb, mh, mw};
+use map::{inb, mh, mw};
 use menu::{Menu, MenuAction, Page};
 use render3d::{Cam, Overlay, R3d};
 use settings::{bindable_keys, Action, Settings};
@@ -110,27 +112,32 @@ fn world_action(app: &mut App, ui: &mut Ui, r3d: &R3d, inp: &mut Input, mx: f32,
         (Tool::Dig | Tool::Room(_) | Tool::Sell | Tool::Bridge | Tool::Steel, Some(t)) => inp.ldown = Some(t),
         (Tool::Hand, _) => {
             let j = r3d.pick_ent(&app.game, &app.cam, mx, my, false);
+            let Some(j) = j else { return };
+            let (id, hero, dwarf) = (app.game.ents[j].id, app.game.ents[j].hero, app.game.ents[j].dwarf());
+            if dwarf {
+                return;
+            }
             if slap {
-                let kind = app.game.slap(j);
-                if kind > 0 {
-                    ui.hand_anim = Some((kind, now));
-                }
+                // the punch/backhand animation at the pointer starts at once, the order follows at the next step
+                ui.hand_anim = Some((if hero { 2 } else { 1 }, now));
+                app.game.queue(Act::Slap { ent: id });
             } else {
-                app.game.pickup(j);
+                app.game.queue(Act::Pickup { ent: id });
             }
         }
-        (Tool::Flag, Some((x, z))) => app.game.set_flag(x, z),
-        (Tool::Lightning, _) => app.game.lightning(wx, wy),
-        (Tool::Heal, _) => app.game.heal(wx, wy),
-        (Tool::Summon, _) => app.game.summon(wx, wy),
-        (Tool::Tower(k), Some((x, z))) => app.game.build_tower(k, x, z),
-        (Tool::Trap(k), Some((x, z))) => app.game.place_trap(k, x, z),
-        (Tool::Spell(sp), _) => app.game.cast(sp, wx, wy),
+        (Tool::Flag, Some((x, z))) => app.game.queue(Act::Flag { x, y: z }),
+        (Tool::Lightning, _) => app.game.queue(Act::Lightning { x: wx, y: wy }),
+        (Tool::Heal, _) => app.game.queue(Act::Heal { x: wx, y: wy }),
+        (Tool::Summon, _) => app.game.queue(Act::Summon { x: wx, y: wy }),
+        (Tool::Tower(k), Some((x, z))) => app.game.queue(Act::Tower { kind: k, x, y: z }),
+        (Tool::Trap(k), Some((x, z))) => app.game.queue(Act::Trap { kind: k, x, y: z }),
+        (Tool::Spell(sp), _) => app.game.queue(Act::Cast { spell: sp, x: wx, y: wy }),
         (Tool::Order(0), _) => {
             let j = r3d.pick_ent(&app.game, &app.cam, mx, my, false);
-            app.game.order_attack(j, wx, wy);
+            let ent = j.filter(|&j| j < app.game.ents.len()).map(|j| app.game.ents[j].id);
+            app.game.queue(Act::Attack { ent, x: wx, y: wy });
         }
-        (Tool::Order(_), Some((x, z))) => app.game.order_guard(x, z),
+        (Tool::Order(_), Some((x, z))) => app.game.queue(Act::Guard { x, y: z }),
         _ => {}
     }
 }
@@ -139,15 +146,13 @@ fn world_action(app: &mut App, ui: &mut Ui, r3d: &R3d, inp: &mut Input, mx: f32,
 fn finish_rect(app: &mut App, tool: Tool, start: (i32, i32), mx: f32, my: f32) {
     let Some((ex, ey)) = tool_tile(&app.cam, &app.game.map, tool, mx, my) else { return };
     let (sx, sy) = start;
+    let r = commands::Rect::new(sx, sy, ex, ey);
     match tool {
-        Tool::Dig => {
-            let on = !app.game.map.t[idx(sx, sy)].marked;
-            app.game.mark_rect(sx, sy, ex, ey, on);
-        }
-        Tool::Room(r) => app.game.build_rect(r, sx, sy, ex, ey),
-        Tool::Sell => app.game.sell_rect(sx, sy, ex, ey),
-        Tool::Bridge => app.game.build_bridges(sx, sy, ex, ey),
-        Tool::Steel => app.game.build_steel(sx, sy, ex, ey),
+        Tool::Dig => app.game.queue(Act::Dig(r)),
+        Tool::Room(room) => app.game.queue(Act::Room { room: room as u8, r }),
+        Tool::Sell => app.game.queue(Act::Sell(r)),
+        Tool::Bridge => app.game.queue(Act::Bridge(r)),
+        Tool::Steel => app.game.queue(Act::Steel(r)),
         _ => {}
     }
 }
@@ -731,9 +736,9 @@ async fn main() {
                     if inp.ldown.is_some() {
                         inp.ldown = None;
                     } else if app.game.hand.is_empty() && matches!(ui.tool, Tool::Order(_)) {
-                        app.game.cancel_orders();
+                        app.game.queue(Act::CancelOrders);
                     } else {
-                        app.game.drop(wx, wy);
+                        app.game.queue(Act::Drop { x: wx, y: wy });
                     }
                 }
                 inp.rdown = None;
@@ -929,7 +934,7 @@ async fn main() {
                         inp.ldown = None;
                         if ui.tool == Tool::Hand && !app.game.hand.is_empty() {
                             let gp = app.cam.ground_point(p.x / d, p.y / d);
-                            app.game.drop(gp.x, gp.y);
+                            app.game.queue(Act::Drop { x: gp.x, y: gp.y });
                         } else {
                             inp.inspect = Some((p.x / d, p.y / d, now));
                         }
@@ -983,9 +988,8 @@ async fn main() {
             app.game.events.retain(|ev| ev.pos.is_none());
         }
         if playing {
-            for _ in 0..(app.settings.game_speed.round().max(1.0) as usize) {
-                app.game.update(dt);
-            }
+            // the world runs in fixed steps: the speed setting only feeds more time into them
+            app.game.update(dt * app.settings.game_speed.max(1.0));
             // autosave: snapshot for leaving the tab + regular autosave
             if app.game.state == 0 {
                 cache_t += dt;

src/orders.rs

@@ -66,7 +66,7 @@ impl Game {
         }
         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 {
+        if self.map.t[i].owner != self.me || room_index(kind).is_none() && kind != Kind::Floor {
             self.hint(31, "hint.order_guard");
             self.sfx_ui(Sfx::Error);
             return;
@@ -77,7 +77,7 @@ impl Game {
             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)) {
+                    if t.kind == kind && t.owner == self.me && t.reserved == 0 && !self.ents.iter().any(|e| e.job == Job::Guard(j)) {
                         spots.push(j);
                     }
                 }

src/rooms.rs

@@ -36,7 +36,7 @@ impl Game {
     // ---- prison
     pub(crate) fn free_cell(&self, i: usize) -> bool {
         let t = &self.map.t[i];
-        matches!(t.kind, Kind::Torture | Kind::Prison) && t.owner == Owner::Player && t.bed == 0
+        matches!(t.kind, Kind::Torture | Kind::Prison) && t.owner == self.me && t.bed == 0
     }
 
     // ---- graveyard: a fallen unit is buried in a free grave
@@ -50,7 +50,7 @@ impl Game {
             .t
             .iter()
             .enumerate()
-            .filter(|(i, t)| t.kind == Kind::Graveyard && t.owner == Owner::Player && !taken.contains(i))
+            .filter(|(i, t)| t.kind == Kind::Graveyard && t.owner == self.me && !taken.contains(i))
             .min_by_key(|(i, _)| {
                 let (tx, ty) = xy(*i);
                 ((tx as f32 - x).powi(2) + (ty as f32 - y).powi(2)) as i32
@@ -96,7 +96,7 @@ impl Game {
     // ---- guard post: a free post for a creature
     pub(crate) fn free_post(&self, i: usize, me: u32) -> bool {
         let t = &self.map.t[i];
-        t.kind == Kind::GuardPost && t.owner == Owner::Player && (t.reserved == 0 || t.reserved == me)
+        t.kind == Kind::GuardPost && t.owner == self.me && (t.reserved == 0 || t.reserved == me)
     }
 
     // ---- arena: sparring with a partner nearby; fast experience, some bruises

src/traps.rs

@@ -166,7 +166,7 @@ impl Game {
             return;
         }
         let t = self.map.t[i];
-        if t.kind != Kind::Floor || t.owner != Owner::Player {
+        if t.kind != Kind::Floor || t.owner != self.me {
             self.hint(25, "hint.trap_where");
             self.sfx_ui(Sfx::Error);
             return;
@@ -201,7 +201,7 @@ impl Game {
             self.traps[k].progress += work;
             if self.traps[k].progress >= self.traps[k].kind.work() {
                 // finished: a crate on a forge tile
-                let spot = self.map.t.iter().enumerate().filter(|(_, t)| t.kind == Kind::Forge && t.owner == Owner::Player).map(|(i, _)| i).nth(self.traps[k].id as usize % self.forge_tiles().max(1));
+                let spot = self.map.t.iter().enumerate().filter(|(_, t)| t.kind == Kind::Forge && t.owner == self.me).map(|(i, _)| i).nth(self.traps[k].id as usize % self.forge_tiles().max(1));
                 match spot {
                     Some(s) => {
                         let t = &mut self.traps[k];
@@ -219,7 +219,7 @@ impl Game {
         }
         // orders on lost ground are dropped
         let map = &self.map;
-        self.traps.retain(|t| t.stage == ARMED || map.t[t.tile].owner == Owner::Player);
+        self.traps.retain(|t| t.stage == ARMED || map.t[t.tile].owner == self.me);
         for t in self.traps.iter_mut() {
             t.fired += dt;
             t.cd -= dt;