// Game logic: units, AI, economy, hero waves.

use crate::commands::Command;
use crate::map::*;
use serde::{Deserialize, Serialize};

pub const CORE_HP: f32 = 2000.0;
pub const GATE_HP: f32 = 3000.0;
pub const PAYDAY: f32 = 150.0;
pub const PAYDAY_WARN: f32 = 20.0; // the payday is announced this many seconds before
pub const TREASURY_TILE: f32 = 500.0; // value one treasury tile holds
pub const CORE_STORE: f32 = 2000.0; // value the soul core holds without any treasury
pub const TRAIN_COST: f32 = 1.5;
pub const HELPERS_MAX: usize = 4; // up to five imps at one task (one worker + four helpers) // gold per second of training (billed on payday)
pub const FIRST_WAVE: f32 = 300.0;
pub const WAVE_GAP: f32 = 180.0;
pub const MAX_SQUAD: usize = 18;

// Sound events. The game logic reports them, the sound module plays them.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Sfx {
    Dig,
    GoldDig,
    DigDone,
    Claim,
    Deposit,
    Build,
    Sell,
    MeleeHit,
    Shoot,
    Death,
    HeroDeath,
    Lightning,
    Heal,
    Summon,
    PortalArrive,
    WaveAlarm,
    WaveStart,
    CoreHit,
    GateHit,
    GateDefenders,
    LevelUp,
    Pickup,
    Drop,
    Payday,
    FlagSet,
    Victory,
    Defeat,
    Click,
    Error,
    Reinforce,
    Cannon,
    Magic,
    Capture,
    Convert,
    Slap,
    Punch,
    // Crookfinger's voice: squeaky syllables
    Voice1,
    Voice2,
    Voice3,
    Voice4,
    Voice5,
    Voice6,
    // weather, rogues and groves
    Thunder,
    Steal,
    Snare,
    Sermon,
    Rain,
    Wind,
    Spores,
}

pub const VOICE_SYLLABLES: [Sfx; 6] = [Sfx::Voice1, Sfx::Voice2, Sfx::Voice3, Sfx::Voice4, Sfx::Voice5, Sfx::Voice6];

pub const SFX_ALL: [Sfx; 49] = [
    Sfx::Dig, Sfx::GoldDig, Sfx::DigDone, Sfx::Claim, Sfx::Deposit, Sfx::Build, Sfx::Sell, Sfx::MeleeHit,
    Sfx::Shoot, Sfx::Death, Sfx::HeroDeath, Sfx::Lightning, Sfx::Heal, Sfx::Summon, Sfx::PortalArrive,
    Sfx::WaveAlarm, Sfx::WaveStart, Sfx::CoreHit, Sfx::GateHit, Sfx::GateDefenders, Sfx::LevelUp,
    Sfx::Pickup, Sfx::Drop, Sfx::Payday, Sfx::FlagSet, Sfx::Victory, Sfx::Defeat, Sfx::Click, Sfx::Error,
    Sfx::Reinforce, Sfx::Cannon, Sfx::Magic, Sfx::Capture, Sfx::Convert, Sfx::Slap, Sfx::Punch,
    Sfx::Voice1, Sfx::Voice2, Sfx::Voice3, Sfx::Voice4, Sfx::Voice5, Sfx::Voice6,
    Sfx::Thunder, Sfx::Steal, Sfx::Snare, Sfx::Sermon, Sfx::Rain, Sfx::Wind, Sfx::Spores,
];

impl Sfx {
    pub fn index(self) -> usize {
        self as usize
    }
}

// A game message: language key + arguments (arguments starting with '@' are keys too)
#[derive(Clone, Debug)]
pub struct Msg {
    pub key: &'static str,
    pub args: Vec<String>,
}

#[derive(Clone, Copy)]
pub struct SfxEvent {
    pub sfx: Sfx,
    pub pos: Option<(f32, f32)>, // world position (for distance-based volume), None = UI
}
pub const MANA_MAX: f32 = 400.0;
pub const MAX_CREATURES: usize = 100; // creatures of one master (the beds decide below that)
pub const SPRING_MANA: f32 = 0.6; // mana per second of each claimed mana spring
pub const SPRING_MAX: f32 = 150.0; // more mana maximum per claimed spring
pub const CARRY_MAX: i32 = 300;

#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
pub enum EK {
    Worker,
    Kobold,
    Spider,
    Mage,
    Ogre,
    Knight,
    Archer,
    Priest,
    Dwarf,
    Paladin,
    Jailer,    // attracted by the torture chamber
    Priestess, // attracted by the temple
    Chainbreaker, // rare and very strong
    // flying creatures, attracted by the aerie
    Bat,      // fast and weak
    Gargoyle, // aerie + torture chamber: stone, tough
    Owl,      // aerie + library: arcane bolts from afar
    Wyrm,     // big aerie + treasury: rare, very strong, fire breath
    Cogling,  // forge: a sooty little tinkerer, builds traps and doors fastest
    Revenant, // rises from the graveyard: undead, needs no food and no bed
    // more heroes
    Giant,      // slow, huge, smashes doors and traps
    Fairy,      // flies, finds the dungeon's traps and heals heroes a little
    BattleMage, // blasts reinforced walls from afar, throws fireballs
    // siege engines (heroes bring them; a master can build his own, see siege.rs)
    Ram,      // smashes doors, walls and towers, ignores creatures
    Catapult, // hurls stones at towers from afar
    // wild beasts of the caverns (beasts.rs): neutral until tamed
    CaveBear, // strong and shaggy, likes the mushroom garden
    Beetle,   // a giant armoured beetle, likes the lair
    Trader,   // a merchant visiting through the portal (traders.rs)
    // heroes of the later waves (rogues.rs)
    Thief,      // fast, sneaks to a treasury, steals gold and runs off with it
    Monk,       // fists and faith: spells do not touch him
    Ranger,     // a bow from afar, lays snares in the dungeon's corridors
    Inquisitor, // fragile; now and then turns one of the weakest creatures to the heroes' side
}

pub struct St {
    pub name: &'static str,
    pub hp: f32,
    pub atk: f32,
    pub range: f32,
    pub speed: f32,
    pub interval: f32,
    pub wage: i32,
    pub bounty: i32,
}

pub const RUNE_TOOL: usize = 20; // index of the rune forge tower in ui::TOOLS
pub const SUMMON_TOOL: usize = 11; // index of summoning in ui::TOOLS

pub fn st(k: EK) -> St {
    let s = |name, hp, atk, range, speed, interval, wage, bounty| St { name, hp, atk, range, speed, interval, wage, bounty };
    match k {
        EK::Worker => s("unit.worker", 45.0, 3.0, 1.0, 3.2, 1.0, 0, 0),
        EK::Kobold => s("unit.kobold", 75.0, 8.0, 1.0, 2.6, 0.9, 40, 0),
        EK::Spider => s("unit.spider", 95.0, 10.0, 1.0, 2.9, 1.0, 60, 0),
        EK::Mage => s("unit.mage", 60.0, 13.0, 4.5, 2.0, 1.4, 110, 0),
        EK::Ogre => s("unit.ogre", 230.0, 20.0, 1.0, 1.8, 1.4, 150, 0),
        // heroes: the wage applies when they defected to the player
        EK::Knight => s("unit.knight", 140.0, 11.0, 1.0, 1.9, 1.1, 70, 120),
        EK::Archer => s("unit.archer", 75.0, 9.0, 4.5, 2.1, 1.3, 60, 100),
        EK::Priest => s("unit.priest", 80.0, 5.0, 3.5, 1.9, 1.5, 60, 120),
        EK::Dwarf => s("unit.dwarf", 110.0, 9.0, 1.0, 2.0, 1.0, 60, 100),
        EK::Paladin => s("unit.paladin", 700.0, 26.0, 1.0, 1.7, 1.2, 220, 1000),
        EK::Jailer => s("unit.jailer", 260.0, 16.0, 1.0, 1.6, 1.3, 140, 0),
        EK::Priestess => s("unit.priestess", 70.0, 14.0, 5.0, 2.0, 1.6, 120, 0),
        EK::Chainbreaker => s("unit.chainbreaker", 600.0, 36.0, 1.1, 2.3, 1.1, 400, 0),
        EK::Bat => s("unit.bat", 55.0, 6.0, 1.0, 3.6, 0.7, 30, 0),
        EK::Gargoyle => s("unit.gargoyle", 260.0, 15.0, 1.0, 2.2, 1.2, 120, 0),
        EK::Owl => s("unit.owl", 70.0, 12.0, 4.5, 2.8, 1.3, 100, 0),
        EK::Wyrm => s("unit.wyrm", 650.0, 30.0, 3.0, 2.5, 1.4, 380, 0),
        EK::Cogling => s("unit.cogling", 90.0, 9.0, 1.0, 2.4, 0.9, 70, 0),
        EK::Revenant => s("unit.revenant", 160.0, 14.0, 1.0, 1.9, 1.2, 30, 0),
        EK::Giant => s("unit.giant", 900.0, 34.0, 1.1, 1.3, 1.6, 200, 600),
        EK::Fairy => s("unit.fairy", 70.0, 5.0, 3.5, 3.2, 1.2, 60, 150),
        EK::BattleMage => s("unit.battlemage", 120.0, 18.0, 5.0, 1.8, 1.8, 120, 250),
        EK::Ram => s("unit.ram", 900.0, 45.0, 1.1, 1.0, 1.8, 0, 200),
        EK::Catapult => s("unit.catapult", 320.0, 40.0, 7.5, 0.9, 3.5, 0, 200),
        EK::CaveBear => s("unit.cavebear", 420.0, 24.0, 1.0, 1.9, 1.4, 110, 0),
        EK::Beetle => s("unit.beetle", 300.0, 13.0, 1.0, 1.7, 1.1, 70, 0),
        EK::Trader => s("unit.trader", 200.0, 1.0, 1.0, 1.5, 2.0, 0, 0),
        EK::Thief => s("unit.thief", 60.0, 6.0, 1.0, 3.1, 0.9, 50, 120),
        EK::Monk => s("unit.monk", 150.0, 12.0, 1.0, 2.3, 0.7, 80, 180),
        EK::Ranger => s("unit.ranger", 90.0, 11.0, 5.0, 2.2, 1.4, 80, 160),
        EK::Inquisitor => s("unit.inquisitor", 70.0, 7.0, 3.5, 1.8, 1.6, 90, 250),
    }
}

// flying creatures cross water and lava and sleep in the aerie
pub fn flies(k: EK) -> bool {
    matches!(k, EK::Bat | EK::Gargoyle | EK::Owl | EK::Wyrm | EK::Fairy)
}

#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
pub enum Job {
    None,
    Dig(usize),
    Claim(usize),
    Deliver,
    Wander,
    Sleep(usize),
    Eat(usize),
    Train(usize),
    Study(usize),
    Attack(u32),
    AttackCore,
    Leave,
    Rally,
    Reinforce(usize), // wall tile
    Repair(u32),      // tower id
    AttackTower(u32), // tower id
    Carry(u32),       // imp carries an unconscious hero (id) to the torture chamber
    Pray(usize),      // temple tile
    HealCore,         // flame priestess heals the soul core
    TearBridge(usize), // knight tears down a bridge of the player
    Rest(usize),       // flying creature recovers in the aerie (flees when badly hurt)
    Torment(u32),      // the jailer works on a prisoner in the torture chamber
    Register,          // new creature: reports at the portal
    MakeBed(usize),    // new creature: sets up its bed
    FetchWage(usize),  // payday: walks to the treasury (or the core) for the wage
    Help(usize),       // imp with nothing else to do helps another imp at this tile
    Forge(usize),      // creature works in the forge (traps and doors)
    Install(u32),      // imp carries a finished trap or door (id) to its spot and installs it
    Brawl(u32),        // two creatures that cannot stand each other scuffle (never to the death)
    Guard(usize),      // holds a guard post
    Spar(usize),       // sparring in the arena
    MendBridge(usize), // imp mends a worn bridge tile
    RaiseWall(usize),  // imp raises a planned wall on own floor
    March(usize),      // creature follows an attack marker (sword) at this tile
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Ent {
    pub id: u32,
    pub kind: EK,
    pub hero: bool,
    pub x: f32,
    pub y: f32,
    pub hp: f32,
    pub max_hp: f32,
    pub level: u32,
    pub xp: f32,
    pub job: Job,
    pub path: Vec<usize>,
    pub timer: f32,
    pub cd: f32,
    pub think: f32,
    pub repath: f32,
    pub carry: i32,
    #[serde(default)]
    pub carry_res: u8, // treasure the imp carries (see map::RES_GOLD)
    pub hunger: f32,
    pub energy: f32,
    pub happy: f32,
    pub bed: Option<usize>,
    pub alive: bool,
    pub held: bool,
    pub anim: f32,
    pub flash: f32,
    pub face: f32,
    #[serde(default)]
    pub dir: f32, // facing direction on the map (radians, 0 = +x), for the eight sprite views
    pub moving: bool,
    pub working: bool,
    #[serde(default)]
    pub slow: f32, // seconds of slowdown left (magic tower)
    #[serde(default)]
    pub captive: u8, // heroes: 0 free, 1 unconscious, 2 carried, 3 in the torture chamber
    #[serde(default)]
    pub carrier: u32, // imp that has taken care of this captive
    #[serde(default)]
    pub torture_t: f32,
    #[serde(default)]
    pub skill_cd: f32, // special abilities (jailer pull, priestess heal)
    #[serde(default)]
    pub waypoint: Option<(i32, i32)>, // heroes: entry point into the player's realm
    #[serde(default)]
    pub boost: f32, // seconds of "slapped" speed-up left
    #[serde(default)]
    pub stun: f32, // seconds of stun left (punched)
    #[serde(default)]
    pub haste: f32, // spell: seconds of haste left
    #[serde(default)]
    pub shield: f32, // spell: seconds of stoneskin left (half damage)
    #[serde(default)]
    pub invis: f32, // spell: seconds of invisibility left (until it attacks)
    #[serde(default)]
    pub plague: f32, // spell: seconds of plague left (poison that spreads)
    #[serde(default)]
    pub name: u32, // seed of the creature's name (names.rs), 0: none (heroes, siege engines)
    #[serde(default)]
    pub kills: u32, // heroes this creature has slain (names.rs: the hall of the fallen)
    #[serde(default)]
    pub bane: u8, // what hurt it last: sprite index + 1 of a unit kind, or names::BANE_*
    #[serde(default)]
    pub ab_cd: f32, // cooldown of the learned ability
    #[serde(default)]
    pub mood_t: f32, // seconds until the next mood check (likes and hatreds)
    pub guard: bool, // stays at its home (gate defenders, treasure guards)
    #[serde(default)]
    pub home: Option<(f32, f32)>, // guard post
    #[serde(default)]
    pub patrol: Vec<(i32, i32)>, // fortress patrol: route of tiles, walked in a loop
    #[serde(default)]
    pub patrol_k: usize, // next point of the route
    #[serde(default = "yes")]
    pub settled: bool, // creatures: reported at the portal and set up their bed
    #[serde(default)]
    pub pay_due: f32, // wage of the last payday not fetched yet
    #[serde(default)]
    pub pay_t: f32, // seconds until the creature goes for its wage
    #[serde(default)]
    pub side: u8, // 0 player, 2..=4 the other masters, 6 dwarves (heroes: see side())
    #[serde(default)]
    pub target: Option<u8>, // attackers: side whose core (or gate) they march on
    #[serde(default)]
    pub chained: bool, // a lone creature chained in a sealed cave: joins when the cave is claimed
    #[serde(default)]
    pub boss: u8, // a champion of the Order leading a wave (see bosses.rs), 0: none
    #[serde(default)]
    pub gear: u8, // equipment from the forge: 0 none, 1 iron, 2 steel, 3 rune (armory.rs)
    #[serde(skip, default = "zero_f32")]
    pub disp_x: f32, // smoothed screen position (not part of the saved or synced world state)
    #[serde(skip, default = "zero_f32")]
    pub disp_y: f32,
}

// units of the neutral dwarves count for nobody
fn e_is_dwarf_side(side: u8) -> bool {
    side == crate::dwarves::DWARF_SIDE
}

fn yes() -> bool {
    true
}

fn zero_f32() -> f32 {
    0.0
}

impl Ent {
    fn dummy() -> Ent {
        Ent {
            id: 0,
            kind: EK::Worker,
            hero: false,
            x: 0.0,
            y: 0.0,
            hp: 0.0,
            max_hp: 1.0,
            level: 1,
            xp: 0.0,
            job: Job::None,
            path: Vec::new(),
            timer: 0.0,
            cd: 0.0,
            think: 0.0,
            repath: 0.0,
            carry: 0,
            carry_res: 0,
            hunger: 0.0,
            energy: 1.0,
            happy: 1.0,
            bed: None,
            alive: false,
            held: false,
            anim: 0.0,
            flash: 0.0,
            face: 1.0,
            dir: std::f32::consts::FRAC_PI_2,
            moving: false,
            working: false,
            slow: 0.0,
            captive: 0,
            carrier: 0,
            torture_t: 0.0,
            skill_cd: 0.0,
            waypoint: None,
            boost: 0.0,
            stun: 0.0,
            haste: 0.0,
            shield: 0.0,
            invis: 0.0,
            plague: 0.0,
            name: 0,
            kills: 0,
            bane: 0,
            ab_cd: 0.0,
            mood_t: 0.0,
            guard: false,
            home: None,
            patrol: Vec::new(),
            patrol_k: 0,
            settled: true,
            pay_due: 0.0,
            pay_t: 0.0,
            side: 0,
            target: None,
            chained: false,
            boss: 0,
            gear: 0,
            disp_x: 0.0,
            disp_y: 0.0,
        }
    }
    pub fn tile(&self) -> usize {
        idx((self.x as i32).clamp(0, mw() as i32 - 1), (self.y as i32).clamp(0, mh() as i32 - 1))
    }
    pub fn atk(&self) -> f32 {
        st(self.kind).atk * (1.0 + 0.12 * (self.level - 1) as f32) * crate::armory::gear_factor(self.gear)
    }
    // the player's creatures (not imps, heroes or the rivals' units)
    pub fn creature(&self) -> bool {
        !self.hero && self.side == me_side() && self.kind != EK::Worker && self.kind != EK::Trader && !self.chained
    }
    // 0 player, 1 humans, 2 and 3 rival masters
    pub fn side(&self) -> u8 {
        if self.hero {
            1
        } else {
            self.side
        }
    }
    // a unit of a rival master
    pub fn rival(&self) -> bool {
        !self.hero && (2..=4).contains(&self.side)
    }
    // a dwarf of a dwarf cave (neutral, never an opponent for victory)
    pub fn dwarf(&self) -> bool {
        !self.hero && self.side == crate::dwarves::DWARF_SIDE
    }
    // a hero that is still fighting (not a prisoner)
    pub fn active_hero(&self) -> bool {
        self.hero && self.captive == 0
    }
}

// Goals of a campaign mission (all must be reached)
#[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize)]
pub enum Goal {
    Shards,       // take back all shards of the soul core
    Heart,        // destroy the gate of the order
    KillAll,      // defeat every knight (prisoners count as defeated)
    Loot(u32),    // take treasure worth this much from knight vaults
    Towers,       // raze all knight towers
    Survive(u32), // beat this many waves
    Rivals,       // destroy the soul cores of all rival masters
    Springs(u32), // claim this many mana springs
    Freed(u32),   // free this many chained creatures
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MissionState {
    pub index: usize, // number of the mission in the campaign
    pub goals: Vec<Goal>,
    pub tools: Vec<bool>, // allowed tools (ui::TOOLS order)
    pub waves: bool,
    pub wave_limit: u32, // 0 = endless
    pub gate_defenders: bool,
    pub heart: bool,     // the map has a gate of the order
    pub time_limit: f32, // seconds, 0 = none
    pub shards: u32,     // shards on the map
}

#[derive(Clone, Copy)]
pub struct Fx {
    pub kind: u8, // 0 projectile, 1 lightning, 2 hit, 3 smoke, 4 heal, 5 gold, 6 dust, 7 level up, 8 claim
    pub x: f32,
    pub y: f32,
    pub x2: f32,
    pub y2: f32,
    pub t: f32,
    pub max: f32,
    pub col: u32,
    pub h: f32,  // height of the start point (3D)
    pub h2: f32, // height of the end point (projectiles)
    pub size: f32, // 1 = normal; attacks of higher levels look bigger
    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, Serialize, Deserialize)]
#[serde(default)]
pub struct MasterState {
    pub side: u8,
    pub owner: Option<Owner>,
    pub core: (i32, i32),
    pub core_hp: f32,
    pub gold: f32,
    pub wood: 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 room_level: Vec<u8>,
    pub gear_stock: Vec<u16>,
    pub gear_work: f32,
    pub guard_marks: Vec<usize>,
    pub attack_marks: Vec<usize>,
    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,
    #[serde(default)]
    pub talents: crate::talents::Talents,
}

#[derive(Serialize, Deserialize)]
pub struct Game {
    pub map: Map,
    pub ents: Vec<Ent>,
    pub next_id: u32,
    pub rng: Rng,
    pub gold: f32,
    pub mana: f32,
    pub core_hp: f32,
    pub time: f32,
    pub wave: u32,
    pub wave_timer: f32,
    pub warned: bool,
    pub portal_timer: f32,
    pub payday: f32,
    #[serde(skip)]
    pub fx: Vec<Fx>,
    #[serde(skip)]
    pub msgs: Vec<Msg>,
    pub state: u8, // 0 running, 1 victory, 2 defeat
    pub paused: bool,
    pub hand: Vec<u32>,
    #[serde(skip)]
    pub counts: [usize; N_ROOMS], // room tiles per room kind (ROOM_KINDS order, recounted)
    #[serde(default)]
    pub gear_stock: Vec<u16>, // finished equipment waiting for a creature, per tier (armory.rs)
    #[serde(default)]
    pub gear_work: f32, // forge work on the next piece
    #[serde(default)]
    pub room_level: Vec<u8>, // level of every room kind (ROOM_KINDS order; 1 when missing), researched
    pub gate_hp: f32,
    pub gate_hit_t: f32,
    pub gate_stage: u32, // defender thresholds triggered (0..3)
    pub flag: Option<usize>,
    #[serde(skip)]
    pub events: Vec<SfxEvent>,
    pub last_wave_value: f32,
    pub torches: Vec<Torch>,
    #[serde(default)]
    pub towers: Vec<Tower>,
    #[serde(default)]
    pub punch_ready: f32, // game time when the hand can punch again
    #[serde(default)]
    pub entry_history: Vec<(i32, i32)>, // entry points of recent waves
    #[serde(default)]
    pub planned_entries: Vec<(i32, i32)>, // entry points of the coming/current wave (minimap)
    #[serde(default)]
    pub reserve: f32, // value stored in the soul core (the rest lies in the treasury tiles)
    #[serde(skip)]
    pub incoming: Vec<(u8, f32, Option<usize>)>, // treasures added since the last treasury update (kind, value, delivered at)
    #[serde(default)]
    pub training_bill: f32, // training costs, paid on the next payday
    #[serde(default)]
    pub payday_warned: bool,
    #[serde(default)]
    pub loot: f32, // value taken from knight vaults
    #[serde(default)]
    pub shards_taken: u32,
    #[serde(default)]
    pub towers_razed: u32, // knight towers destroyed
    #[serde(skip)]
    pub contested: Vec<bool>,
    #[serde(default)]
    pub mission: Option<MissionState>, // campaign mission (None: free game)
    #[serde(default)]
    pub script: Option<crate::mscript::ScriptState>, // block scripts of an editor mission
    #[serde(default)]
    pub objective: Option<String>, // the objective a mission script set
    #[serde(default)]
    pub rivals: Vec<crate::rival::Rival>, // AI dungeon masters
    #[serde(default = "yes")]
    pub gate_on: bool, // free game: the humans' gate exists
    #[serde(skip)]
    pub springs: usize, // claimed mana springs (recounted)
    #[serde(skip)]
    pub parts: Vec<crate::particles::Part>, // visual particles (never saved)
    #[serde(skip)]
    pub stuck: Vec<crate::particles::Part>, // arrows stuck in walls and floors, scorch marks
    #[serde(skip, default = "crate::particles::vrng")]
    pub vrng: Rng, // random numbers for the particles only
    #[serde(default)]
    pub traps: Vec<crate::traps::Trap>, // traps and doors (ordered, in the forge, carried, armed)
    #[serde(default)]
    pub rollers: Vec<crate::traps::Roller>,
    #[serde(default)]
    pub clouds: Vec<crate::traps::Cloud>,
    #[serde(default)]
    pub known: Vec<bool>, // tools known (ui::TOOLS order; empty = old savegame: everything)
    #[serde(default)]
    pub researchable: Vec<bool>, // tools that can be researched in the library
    #[serde(default)]
    pub research: f32, // research points towards the current item
    #[serde(default)]
    pub reveals: Vec<(f32, f32, f32)>, // seer's eye: x, y, seconds left
    #[serde(default)]
    pub graves: Vec<crate::rooms::Grave>,
    #[serde(default)]
    pub altar_last: Option<EK>, // the last sacrifice that waits for its pair
    #[serde(skip)]
    pub fog_t: f32, // fog of war: seconds until the next update
    #[serde(skip)]
    pub forge_work: f32, // work done in the forge this frame
    #[serde(skip)]
    pub demo: Option<crate::demo::Demo>, // the endless bridge battle behind the title menu
    #[serde(default)]
    pub dwarf_caves: Vec<crate::dwarves::DwarfCave>,
    #[serde(default)]
    pub bridgework: crate::bridges::BridgeWork, // burning and worn bridges
    #[serde(default)]
    pub weather: crate::weather::Weather, // above ground (weather.rs)
    #[serde(default)]
    pub memorials: Vec<crate::names::Memorial>, // stones for fallen creatures (names.rs)
    #[serde(default)]
    pub hall: Vec<crate::names::Fallen>, // the local master's fallen of this game (names.rs)
    #[serde(default)]
    pub trading: crate::traders::Trading, // the visiting trader (traders.rs)
    #[serde(default)]
    pub happenings: Option<crate::events::Events>, // random events (free games and versus), see events.rs
    #[serde(default)]
    pub snares: Vec<usize>, // tiles with a ranger's snare (rogues.rs)
    #[serde(default)]
    pub talents: crate::talents::Talents, // of the master being processed (talents.rs)
    #[serde(default)]
    pub guard_marks: Vec<usize>, // guard markers (shields) of the master being processed (orders.rs)
    #[serde(default)]
    pub attack_marks: Vec<usize>, // attack markers (swords)
    #[serde(default)]
    pub marks_t: f32,
    #[serde(default)]
    pub stats: crate::stats::GameStats, // statistics of the master at this computer (see stats.rs)
    #[serde(default)]
    pub wall_plans: Vec<(usize, u8)>, // walls to raise: tile, master side (see walls.rs)
    #[serde(default)]
    pub wood: f32, // the second resource (see wood.rs)
    #[serde(default)]
    pub woodwork: crate::wood::WoodWork, // felled mushrooms growing back
    #[serde(default)]
    pub dwarf_t: f32,
    #[serde(default)]
    pub rune_free: u32, // rune forge towers that can be built for free (from chests)
    #[serde(default)]
    pub rune_final: u32, // the same, but given back for a sold tower: no second refund
    #[serde(default)]
    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(default)]
    pub masters: Vec<MasterState>, // the other masters (multiplayer, AI masters), saved with the game
    #[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 netplay: Option<crate::netplay::Netplay>, // a match: turns come in, the world steps per turn
    #[serde(skip)]
    pub ai_sides: Vec<u8>, // match sides whose human master left: AI keeps them playing
    #[serde(skip)]
    pub ai_difficulty: u8, // difficulty used when a left side becomes an AI rival
    #[serde(skip)]
    pub coop: bool, // co-op match: the playable master sides are on one side against the heroes
    #[serde(skip)]
    pub teams: Vec<(u8, u8)>, // (side, team) of a versus match; a side without an entry is its own team
    #[serde(skip)]
    pub out_sides: Vec<u8>, // masters of a match whose soul core fell (their creatures fight on)
    #[serde(skip)]
    pub marks: Vec<Mark>, // short-lived markers for commands given by the masters
    #[serde(skip)]
    pub hints: bool, // show hint messages (setting)
    #[serde(skip)]
    pub debug_markers: bool, // show debug-only command markers
    #[serde(skip, default = "hint_times")]
    hint_t: [f32; 48], // last time each hint slot was shown
}

pub const MARK_DIG: u8 = 0;
pub const MARK_ROOM: u8 = 1;
pub const MARK_SELL: u8 = 2;
pub const MARK_BRIDGE: u8 = 3;
pub const MARK_STEEL: u8 = 4;
pub const MARK_TOWER: u8 = 5;
pub const MARK_TRAP: u8 = 6;
pub const MARK_SPELL: u8 = 7;
pub const MARK_LIGHTNING: u8 = 8;
pub const MARK_HEAL: u8 = 9;
pub const MARK_SUMMON: u8 = 10;
pub const MARK_FLAG: u8 = 11;
pub const MARK_PICKUP: u8 = 12;
pub const MARK_DROP: u8 = 13;
pub const MARK_SLAP: u8 = 14;
pub const MARK_ATTACK: u8 = 15;
pub const MARK_GUARD: u8 = 16;
pub const MARK_CANCEL: u8 = 17;

#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Mark {
    pub x: f32,
    pub y: f32,
    pub kind: u8,
    pub side: u8,
    pub until: u64,
    #[serde(default)]
    pub fixed: bool, // guard/attack/gather order flags are shown without the debug setting
}

fn hint_times() -> [f32; 48] {
    [-1000.0; 48]
}

// 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 = 1.0 / 50.0; // 50 steps a second
// one frame never runs away into the future (a lagging tab catches up at most this much)
const MAX_STEPS_PER_FRAME: usize = 12;

// torch on a wall face: wall tile + direction (index into DIR4) towards the open side;
// or a torch on a little stand in the middle of a floor tile (stand: wall = that tile)
#[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Torch {
    pub wall: usize,
    pub dir: usize,
    #[serde(default)]
    pub stand: bool,
}

// rooms where imps may set up a torch stand (no beds, hoards, mushrooms or crates in the way)
pub fn stand_ground(k: Kind) -> bool {
    matches!(k, Kind::Floor | Kind::Training | Kind::Library | Kind::Torture | Kind::Temple | Kind::Prison | Kind::Graveyard | Kind::GuardPost | Kind::Arena | Kind::Altar)
}

// a torch stand goes where no torch shines closer than this (tiles)
pub const STAND_GAP: f32 = 4.5;

impl Torch {
    // world position of the flame (x, z) on the ground plane
    pub fn pos(&self) -> (f32, f32) {
        let (x, y) = xy(self.wall);
        if self.stand {
            return (x as f32 + 0.5, y as f32 + 0.5);
        }
        let (dx, dy) = DIR4[self.dir];
        (x as f32 + 0.5 + dx as f32 * 0.58, y as f32 + 0.5 + dy as f32 * 0.58)
    }

    // height of the bottom of the flame
    pub fn flame_h(&self) -> f32 {
        if self.stand {
            0.62
        } else {
            0.72
        }
    }
}

pub const N_ROOMS: usize = 14;
pub const ROOM_FORGE: usize = 8;
pub const ROOM_KINDS: [Kind; N_ROOMS] = [
    Kind::Treasury,
    Kind::Lair,
    Kind::Farm,
    Kind::Training,
    Kind::Library,
    Kind::Torture,
    Kind::Temple,
    Kind::Aerie,
    Kind::Forge,
    Kind::Prison,
    Kind::Graveyard,
    Kind::GuardPost,
    Kind::Arena,
    Kind::Altar,
];
pub const ROOM_COST: [i32; N_ROOMS] = [60, 80, 100, 140, 160, 200, 180, 120, 150, 160, 140, 90, 180, 250];
pub const ROOM_NAMES: [&str; N_ROOMS] = [
    "room.treasury",
    "room.lair",
    "room.farm",
    "room.training",
    "room.library",
    "room.torture",
    "room.temple",
    "room.aerie",
    "room.forge",
    "room.prison",
    "room.graveyard",
    "room.guardpost",
    "room.arena",
    "room.altar",
];

// bridge cost per tile: over water, over lava
pub const BRIDGE_COST: [i32; 2] = [10, 75];
// a drawbridge tile: over water (and wood, see wood.rs), over lava
pub const DRAWBRIDGE_COST: [i32; 2] = [120, 150];
// steel wall cost per tile: from earth, from a reinforced wall
pub const STEEL_COST: [i32; 2] = [80, 40];
pub const STEEL_HP: f32 = 40.0;

pub fn room_index(k: Kind) -> Option<usize> {
    ROOM_KINDS.iter().position(|&r| r == k)
}

impl Game {
    // the researched level of a room kind of the master being processed (1, 2 or 3)
    pub fn room_level_of(&self, k: Kind) -> u8 {
        room_index(k).and_then(|r| self.room_level.get(r).copied()).unwrap_or(1).max(1)
    }

    // how much better a room works at its level: +25% per level above the first
    pub fn room_bonus(&self, k: Kind) -> f32 {
        1.0 + 0.25 * (self.room_level_of(k) - 1) as f32
    }
}

pub(crate) fn adj4(a: usize, b: usize) -> bool {
    let (ax, ay) = xy(a);
    let (bx, by) = xy(b);
    (ax - bx).abs() + (ay - by).abs() == 1
}

fn norm(x: f32, y: f32) -> (f32, f32) {
    let l = (x * x + y * y).sqrt();
    if l < 1e-6 {
        (0.0, 0.0)
    } else {
        (x / l, y / l)
    }
}

pub(crate) fn sgn(v: f32) -> f32 {
    if v < 0.0 {
        -1.0
    } else {
        1.0
    }
}

impl Game {
    // free game with the humans' gate only (tests; the menu uses new_free)
    #[cfg_attr(not(test), allow(dead_code))]
    pub fn new(seed: u32, w: usize, h: usize) -> Game {
        let mut g = Game::from_map(Map::generate(seed, w, h), seed);
        // heroes take longer to reach the core on big maps: longer grace period
        let (cx, cy) = g.map.core;
        let (gx, gy) = g.map.gate;
        let dist = ((gx - cx).abs() + (gy - cy).abs()) as f32;
        g.wave_timer = FIRST_WAVE + ((dist - 45.0) * 1.5).clamp(0.0, 300.0);
        g.guard_treasures();
        g.place_dwarf_caves(seed);
        g.add_wilds(seed, true);
        g.init_research(None);
        g.init_fog();
        g.msg("msg.welcome1", vec![]);
        g.msg("msg.welcome2", vec![]);
        g.msg("msg.welcome3", vec![]);
        g.msg("msg.welcome4", vec![]);
        g
    }

    // treasure caves are guarded by heroes
    pub fn guard_treasures(&mut self) {
        for k in 0..self.map.treasures.len() {
            let (tx, ty) = self.map.treasures[k];
            let squad = [EK::Knight, EK::Archer, EK::Dwarf, if k % 2 == 0 { EK::Priest } else { EK::Knight }];
            for (j, &kind) in squad.iter().enumerate() {
                let x = tx as f32 + 0.5 + (j as f32 - 1.5) * 0.6;
                let id = self.spawn(kind, true, x, ty as f32 + 0.5, 2);
                if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
                    e.guard = true;
                    e.home = Some((tx as f32 + 0.5, ty as f32 + 0.5));
                }
            }
        }
    }

    // game state around a generated map: treasury ring around the core, four imps, torches
    pub fn from_map(map: Map, seed: u32) -> Game {
        let mut g = Game {
            map,
            ents: Vec::new(),
            next_id: 1,
            rng: Rng(seed.wrapping_mul(2654435761) | 1),
            gold: 1500.0,
            mana: 100.0,
            core_hp: CORE_HP,
            time: 0.0,
            wave: 0,
            wave_timer: FIRST_WAVE,
            warned: false,
            portal_timer: 10.0,
            payday: PAYDAY,
            fx: Vec::new(),
            msgs: Vec::new(),
            state: 0,
            paused: false,
            hand: Vec::new(),
            counts: [0; N_ROOMS],
            room_level: Vec::new(),
            gear_stock: Vec::new(),
            gear_work: 0.0,
            gate_hp: GATE_HP,
            gate_hit_t: -100.0,
            gate_stage: 0,
            flag: None,
            events: Vec::new(),
            last_wave_value: 0.0,
            torches: Vec::new(),
            towers: Vec::new(),
            punch_ready: 0.0,
            entry_history: Vec::new(),
            planned_entries: Vec::new(),
            hints: true,
            debug_markers: false,
            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,
            netplay: None,
            ai_sides: Vec::new(),
            ai_difficulty: 1,
            coop: false,
            teams: Vec::new(),
            out_sides: Vec::new(),
            marks: Vec::new(),
            hint_t: hint_times(),
            reserve: 0.0,
            incoming: Vec::new(),
            training_bill: 0.0,
            payday_warned: false,
            loot: 0.0,
            shards_taken: 0,
            towers_razed: 0,
            contested: Vec::new(),
            mission: None,
            script: None,
            objective: None,
            rivals: Vec::new(),
            gate_on: true,
            springs: 0,
            freed: 0,
            demo: None,
            traps: Vec::new(),
            rollers: Vec::new(),
            clouds: Vec::new(),
            forge_work: 0.0,
            fog_t: 0.0,
            graves: Vec::new(),
            altar_last: None,
            reveals: Vec::new(),
            known: Vec::new(),
            researchable: Vec::new(),
            research: 0.0,
            parts: Vec::new(),
            stuck: Vec::new(),
            vrng: crate::particles::vrng(),
            dwarf_caves: Vec::new(),
            bridgework: Default::default(),
            weather: Default::default(),
            memorials: Vec::new(),
            hall: Vec::new(),
            trading: Default::default(),
            happenings: None,
            snares: Vec::new(),
            talents: Default::default(),
            guard_marks: Vec::new(),
            attack_marks: Vec::new(),
            marks_t: 0.0,
            stats: Default::default(),
            wall_plans: Vec::new(),
            wood: crate::wood::WOOD_START,
            woodwork: Default::default(),
            dwarf_t: 30.0,
            rune_free: 0,
            rune_final: 0,
            rune_next: 0,
        };
        let (cx, cy) = g.map.core;
        // the soul core starts surrounded by a one tile wide ring of treasury
        for y in cy - 1..=cy + 3 {
            for x in cx - 1..=cx + 3 {
                let t = &mut g.map.t[idx(x, y)];
                if t.kind == Kind::Floor {
                    t.kind = Kind::Treasury;
                    t.owner = Owner::Player;
                }
            }
        }
        for k in 0..4 {
            g.spawn(EK::Worker, false, cx as f32 - 0.5, cy as f32 + k as f32 * 0.7 + 0.3, 1);
        }
        g.recount();
        g.place_all_torches();
        g
    }

    pub fn place_all_torches(&mut self) {
        // torches on walls that are gone (rivers, fortresses) are removed
        let map = &self.map;
        self.torches.retain(|t| if t.stand { stand_ground(map.t[t.wall].kind) } else { map.t[t.wall].solid() });
        for i in 0..n() {
            if self.map.t[i].owner == self.me {
                self.place_torches(i);
            }
        }
    }

    // ---------------------------------------------------------------- campaign missions

    // the rune forge tower only shows up in the build menu once there is one to build or upgrade
    pub fn tool_visible(&self, tool: usize) -> bool {
        tool != RUNE_TOOL || self.rune_available() > 0 || self.towers.iter().any(|t| !t.hero && t.kind == TowerKind::Rune)
    }

    pub fn tool_allowed(&self, tool: usize) -> bool {
        if !self.known.is_empty() {
            return self.known(tool);
        }
        self.mission.as_ref().map_or(true, |m| m.tools.get(tool).copied().unwrap_or(true))
    }

    pub fn goal_done(&self, goal: Goal) -> bool {
        match goal {
            Goal::Shards => self.shards_taken >= self.mission.as_ref().map_or(0, |m| m.shards),
            Goal::Heart => self.gate_hp <= 0.0,
            Goal::KillAll => !self.ents.iter().any(|e| e.alive && e.active_hero()),
            Goal::Loot(n) => self.loot >= n as f32,
            Goal::Towers => !self.towers.iter().any(|t| t.hero),
            Goal::Survive(n) => self.wave >= n && !self.ents.iter().any(|e| e.alive && e.active_hero() && !e.guard && e.patrol.is_empty()),
            Goal::Rivals => self.rivals.iter().all(|r| !r.alive),
            Goal::Springs(n) => self.springs >= n as usize,
            Goal::Freed(n) => self.freed >= n,
        }
    }

    pub fn waves_on(&self) -> bool {
        self.mission.as_ref().map_or(self.gate_on, |m| m.waves && (m.wave_limit == 0 || self.wave < m.wave_limit))
    }

    pub fn has_gate(&self) -> bool {
        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);
        }
    }

    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 });
        }
    }

    pub fn gate_center(&self) -> (f32, f32) {
        (self.map.gate.0 as f32 + 1.5, self.map.gate.1 as f32 + 1.5)
    }

    // Army value: sqrt(sum of HP * sum of damage/s) of all own creatures.
    pub fn army_value(&self) -> f32 {
        let (mut h, mut d) = (0.0, 0.0);
        for e in &self.ents {
            if e.alive && e.creature() {
                h += e.max_hp;
                d += e.atk() / st(e.kind).interval;
            }
        }
        // towers count with half their combat value
        for t in self.towers.iter().filter(|t| !t.hero) {
            h += 0.5 * t.max_hp();
            d += 0.5 * t.dmg() / tower_stats(t.kind).interval;
        }
        (h * d).sqrt()
    }

    // imps hang torches on walls next to claimed floor (min. distance 3.5 tiles)
    pub fn place_torches(&mut self, i: usize) {
        let (x, y) = xy(i);
        for (d, &(dx, dy)) in DIR4.iter().enumerate() {
            let (wx, wy) = (x + dx, y + dy);
            if !inb(wx, wy) || !self.map.t[idx(wx, wy)].solid() {
                continue;
            }
            // the direction from the wall to the floor is the opposite one
            let t = Torch { wall: idx(wx, wy), dir: (d + 2) % 4, stand: false };
            let (px, pz) = t.pos();
            let near = self.torches.iter().any(|o| {
                let (ox, oz) = o.pos();
                (ox - px).powi(2) + (oz - pz).powi(2) < 3.5 * 3.5
            });
            if !near {
                self.torches.push(t);
            }
        }
        // a big room the wall torches do not light: a torch on a stand in the middle of it,
        // on the master's own ground only (never neutral or foreign ground) and not next to a wall
        let tile = self.map.t[i];
        let open_around = (-1..=1).all(|dy| (-1..=1).all(|dx| self.map.get(x + dx, y + dy).map_or(false, |t| !t.solid())));
        if tile.owner == self.me && stand_ground(tile.kind) && open_around {
            let (px, pz) = (x as f32 + 0.5, y as f32 + 0.5);
            let near = self.torches.iter().any(|o| {
                let (ox, oz) = o.pos();
                (ox - px).powi(2) + (oz - pz).powi(2) < STAND_GAP * STAND_GAP
            });
            if !near {
                self.torches.push(Torch { wall: i, dir: 0, stand: true });
            }
        }
    }

    // torch stands go when their ground is lost or becomes a room they do not fit in
    fn tidy_torch_stands(&mut self) {
        let map = &self.map;
        self.torches.retain(|t| !t.stand || (stand_ground(map.t[t.wall].kind) && !matches!(map.t[t.wall].owner, Owner::None | Owner::Hero)));
    }

    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![]);
        }
    }

    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 == self.me).count();
        for t in &self.map.t {
            if t.owner == self.me {
                if let Some(r) = room_index(t.kind) {
                    c[r] += 1;
                }
            }
        }
        self.counts = c;
    }

    pub fn mana_max(&self) -> f32 {
        MANA_MAX + SPRING_MAX * self.springs as f32
    }

    pub fn gold_cap(&self) -> f32 {
        CORE_STORE + TREASURY_TILE * self.counts[0] as f32 * self.room_bonus(Kind::Treasury)
    }

    pub fn add_gold(&mut self, amount: f32) -> f32 {
        self.add_res(amount, RES_GOLD)
    }

    // adds treasure of one kind (as far as there is room); returns the value accepted
    pub fn add_res(&mut self, amount: f32, res: u8) -> f32 {
        self.add_res_at(amount, res, None)
    }

    // treasure delivered at a tile: it fills the treasury tiles nearest to that place
    pub fn add_res_at(&mut self, amount: f32, res: u8, at: Option<usize>) -> f32 {
        let cap = self.gold_cap();
        let acc = amount.min((cap - self.gold).max(0.0));
        self.gold += acc;
        if acc > 0.0 {
            self.incoming.push((res, acc, at));
            self.count(crate::stats::GOLD, acc);
        }
        acc
    }

    // what the next payday costs: wages of all creatures plus the training bill
    pub fn next_payday_cost(&self) -> f32 {
        let wages: f32 = self.ents.iter().filter(|e| e.alive && e.creature()).map(|e| st(e.kind).wage as f32 * (1.0 + 0.1 * (e.level - 1) as f32)).sum::<f32>() * self.talents.wages();
        wages + self.training_bill
    }

    // The gold counter is the truth; the treasury tiles show where it lies. Added treasure fills
    // tiles of the same kind first, then empty ones, the rest goes into the core. Spending takes
    // from random treasury tiles first, then from the core.
    pub fn sync_treasury(&mut self) {
        let mut tiles = Vec::new();
        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 == self.me {
                tiles.push(i);
                stored += t.gold as f32;
            } else if t.gold != 0 && t.vein().is_none() && t.kind != Kind::Treasury {
                t.gold = 0; // a sold treasury tile loses its content
                t.res = 0;
            }
        }
        let diff = self.gold - (self.reserve + stored);
        let incoming = std::mem::take(&mut self.incoming);
        if diff < -0.5 {
            let mut need = -diff;
            while need > 0.5 {
                let full: Vec<usize> = tiles.iter().copied().filter(|&i| self.map.t[i].gold > 0).collect();
                if full.is_empty() {
                    break;
                }
                let i = full[(self.rng.next() as usize) % full.len()];
                let t = &mut self.map.t[i];
                let take = (t.gold as f32).min(need.ceil());
                t.gold -= take as i32;
                need -= take;
            }
            self.reserve = (self.reserve - need.max(0.0)).max(0.0);
        } else if diff > 0.5 {
            let mut left = diff;
            let mut parts: Vec<(u8, f32, Option<usize>)> = incoming;
            let typed: f32 = parts.iter().map(|p| p.1).sum();
            if typed < left {
                parts.push((RES_GOLD, left - typed, None));
            }
            for (res, amount, at) in parts {
                let mut a = amount.min(left);
                left -= a;
                // delivered treasure goes to the treasury tiles nearest to the place of delivery
                let mut order = tiles.clone();
                if let Some(at) = at {
                    let (ax, ay) = xy(at);
                    order.sort_by_key(|&i| {
                        let (x, y) = xy(i);
                        (x - ax).pow(2) + (y - ay).pow(2)
                    });
                }
                // without a place: tiles holding this treasure first, then empty tiles;
                // with a place: strictly the nearest tiles that can take it
                let passes: &[u8] = if at.is_some() { &[2] } else { &[0, 1] };
                for &pass in passes {
                    for &i in &order {
                        if a <= 0.5 {
                            break;
                        }
                        let t = &mut self.map.t[i];
                        let fits = match pass {
                            0 => t.gold > 0 && t.res == res,
                            1 => t.gold <= 0,
                            _ => (t.gold > 0 && t.res == res && (t.gold as f32) < TREASURY_TILE) || t.gold <= 0,
                        };
                        if !fits {
                            continue;
                        }
                        let room = TREASURY_TILE - t.gold as f32;
                        let put = a.min(room).floor();
                        if put >= 1.0 {
                            t.gold += put as i32;
                            t.res = res;
                            a -= put;
                        }
                    }
                }
                self.reserve += a.max(0.0);
            }
        }
    }

    pub fn portals_owned(&self) -> usize {
        (0..self.map.portals.len()).filter(|&k| self.map.portal_owner(k) == self.me).count()
    }

    // gate defenders alive (not the treasure guards)
    pub fn gate_defenders_alive(&self) -> bool {
        let (gx, gy) = self.gate_center();
        self.ents.iter().any(|e| e.alive && e.guard && e.captive == 0 && e.home.map_or(false, |(x, y)| (x - gx).abs() < 1.0 && (y - gy).abs() < 1.0))
    }

    #[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 == self.me
    }

    pub fn creature_count(&self) -> usize {
        self.ents.iter().filter(|e| e.alive && e.creature()).count()
    }
    pub fn worker_count(&self) -> usize {
        self.ents.iter().filter(|e| e.alive && !e.hero && e.kind == EK::Worker && e.side == self.me_side && !e.chained).count()
    }
    pub fn summon_cost(&self) -> f32 {
        80.0 + 20.0 * (self.worker_count() as f32 - 4.0).max(0.0)
    }

    pub fn spawn(&mut self, kind: EK, hero: bool, x: f32, y: f32, level: u32) -> u32 {
        let s = st(kind);
        let id = self.next_id;
        self.next_id += 1;
        let mut e = Ent::dummy();
        e.id = id;
        e.kind = kind;
        e.hero = hero;
        e.side = self.me_side;
        e.x = x;
        e.y = y;
        e.disp_x = x;
        e.disp_y = y;
        e.level = level;
        if !hero && !matches!(kind, EK::Ram | EK::Catapult | EK::Trader) {
            e.name = crate::names::seed_for(id);
        }
        e.max_hp = s.hp * (1.0 + 0.15 * (level - 1) as f32);
        e.hp = e.max_hp;
        e.alive = true;
        e.think = self.rng.f();
        e.energy = 0.7 + self.rng.f() * 0.3;
        e.hunger = self.rng.f() * 0.3;
        e.anim = self.rng.f() * 10.0;
        self.ents.push(e);
        id
    }

    pub fn fx(&mut self, kind: u8, x: f32, y: f32, x2: f32, y2: f32, max: f32, col: u32) {
        let h = if kind == 0 { 0.45 } else { 0.4 };
        self.fx_particles(kind, x, y, h, col);
        if self.fx.len() < 400 {
            self.fx.push(Fx { kind, x, y, x2, y2, t: 0.0, max, col, h, h2: 0.45, size: 1.0, style: 0 });
        }
    }

    // projectile from (x, y) at height h to (x2, y2) at height h2
    #[allow(clippy::too_many_arguments)]
    pub fn shot(&mut self, x: f32, y: f32, h: f32, x2: f32, y2: f32, h2: f32, max: f32, col: u32) {
        if self.fx.len() < 400 {
            self.fx.push(Fx { kind: 0, x, y, x2, y2, t: 0.0, max, col, h, h2, size: 1.0, style: 0 });
        }
    }

    // the last effect gets bigger (attacks of experienced units)
    fn grow_last_fx(&mut self, size: f32) {
        if let Some(f) = self.fx.last_mut() {
            f.size = size;
        }
    }

    // effect at a given height
    pub fn fx_at(&mut self, kind: u8, x: f32, y: f32, h: f32, max: f32, col: u32) {
        self.fx_particles(kind, x, y, h, col);
        if self.fx.len() < 400 {
            self.fx.push(Fx { kind, x, y, x2: 0.0, y2: 0.0, t: 0.0, max, col, h, h2: h, size: 1.0, style: 0 });
        }
    }

    pub fn find(&self, id: u32) -> Option<usize> {
        self.ents.iter().position(|e| e.id == id && e.alive && !e.held)
    }

    // ---------------------------------------------------------------- update

    // smoothed positions for the screen only: the simulation stays fixed-step and deterministic
    pub fn smooth_display(&mut self, dt: f32) {
        if dt <= 0.0 {
            return;
        }
        let k = (1.0 - (-22.0 * dt).exp()).clamp(0.0, 1.0);
        for e in self.ents.iter_mut() {
            if e.disp_x == 0.0 && e.disp_y == 0.0 {
                e.disp_x = e.x;
                e.disp_y = e.y;
                continue;
            }
            let dx = e.x - e.disp_x;
            let dy = e.y - e.disp_y;
            if dx * dx + dy * dy > 4.0 {
                e.disp_x = e.x;
                e.disp_y = e.y;
            } else {
                e.disp_x += dx * k;
                e.disp_y += dy * k;
            }
        }
    }

    pub fn update(&mut self, dt: f32) {
        let mut steps = 0usize;
        let cmds = if self.netplay.is_some() {
            // a match runs turn by turn (see netplay.rs): without the next turn the world stands still,
            // and local orders are not applied here - they travel to the server first
            Vec::new()
        } else {
            self.step_acc = (self.step_acc + dt).min(STEP * MAX_STEPS_PER_FRAME as f32);
            while self.step_acc >= STEP {
                self.step_acc -= STEP;
                steps += 1;
            }
            std::mem::take(&mut self.pending)
        };
        self.apply_turn(&cmds, steps);
        if !self.marks.is_empty() {
            self.marks.retain(|m| self.sim_steps < m.until);
        }
        // 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;
        }
        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();
        }
        // mission scripts: always from the first player's side, the same on every computer
        if self.script.is_some() {
            self.switch_to(0);
            self.run_scripts();
        }
        let local = self.local_side;
        self.switch_to(local);
        self.sample_stats(STEP);
    }

    // ---------------------------------------------------------------- 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)
    }

    pub(crate) fn is_hostile(&self, e: &Ent) -> bool {
        e.alive && !e.held && e.captive == 0 && !e.chained && e.side() != self.me_side && !self.allied(self.me_side, e.side())
    }

    pub fn is_rival_side(&self, side: u8) -> bool {
        self.rivals.iter().any(|r| r.alive && r.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,
            wood: self.wood,
            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,
            room_level: self.room_level.clone(),
            gear_stock: self.gear_stock.clone(),
            gear_work: self.gear_work,
            guard_marks: std::mem::take(&mut self.guard_marks),
            attack_marks: std::mem::take(&mut self.attack_marks),
            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,
            talents: self.talents.clone(),
        }
    }

    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.wood = m.wood;
        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.room_level = m.room_level;
        self.gear_stock = m.gear_stock;
        self.gear_work = m.gear_work;
        self.guard_marks = m.guard_marks;
        self.attack_marks = m.attack_marks;
        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;
        self.talents = m.talents;
    }

    // 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 his core at (cx, cy) (top-left of the 3x3 core); single player
    // games have no stored masters
    #[allow(dead_code)] // used by the tests; the *Multiplayer* menu (step D) will call it
    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);
    }

    // A match: `sides` (out of 0, 2, 3, 4 - side 1 is the heroes') play against each other and
    // `local` is the master who plays at this computer. Side 0 keeps the core of the generated map
    // (that is where the hero gate path leads); the other masters get their cores at fixed places
    // worked out from the map size alone, so every client of a match puts them in the same spots.
    #[allow(dead_code)] // used by the tests; the *Multiplayer* menu (step D) will call it
    pub fn start_masters(&mut self, sides: &[u8], local: u8) -> bool {
        let sides: Vec<u8> = sides.iter().copied().filter(|s| Owner::MASTER_SIDES.contains(s)).collect();
        if sides.is_empty() || !sides.contains(&0) || !sides.contains(&local) {
            return false;
        }
        if sides.len() < 2 && !self.coop {
            return false;
        }
        let (w, h) = (mw() as i32, mh() as i32);
        if w < 72 || h < 72 {
            return false; // the master areas need room
        }
        let cores: Vec<(i32, i32)> = sides.iter().map(|&s| match s { 0 => self.map.core, 2 => (w - 30, 12), 3 => (w - 30, h - 16), _ => (14, h - 16) }).collect();
        for (k, side) in sides.iter().enumerate() {
            if *side == self.me_side {
                continue;
            }
            self.carve_master_area(*side, cores[k]);
            // every master gets a portal of his own (side 0 has the map's portal)
            self.add_master_portal(*side, cores[k]);
            self.add_master(*side, cores[k]);
            self.switch_to(*side);
            let (cx, cy) = cores[k];
            // a new master needs the same starting crew side 0 already has
            for j in 0..4 {
                self.spawn(EK::Worker, false, cx as f32 - 0.5, cy as f32 + j as f32 * 0.7 + 0.3, 1);
            }
        }
        self.local_side = local;
        self.switch_to(local);
        true
    }

    // a master's own portal right beside his starting area (if there is room)
    pub(crate) fn add_master_portal(&mut self, side: u8, core: (i32, i32)) {
        let owner = Owner::of_side(side);
        let (px, py) = (core.0 + 6, core.1);
        if px + 3 >= mw() as i32 - 2 || py < 2 || py + 3 >= mh() as i32 - 2 {
            return;
        }
        for y in py..py + 3 {
            for x in px..px + 3 {
                let t = &mut self.map.t[idx(x, y)];
                if !matches!(t.kind, Kind::Core | Kind::Gate) {
                    t.kind = Kind::Portal;
                    t.owner = owner;
                    t.gold = 0;
                    t.marked = false;
                    t.reinforced = false;
                }
            }
        }
        if !self.map.portals.contains(&(px, py)) {
            self.map.portals.push((px, py));
        }
    }

    // the starting area of a master: a 9x9 room of his own floor and his 3x3 soul core
    pub(crate) fn carve_master_area(&mut self, side: u8, core: (i32, i32)) {
        let owner = Owner::of_side(side);
        for y in core.1 - 3..core.1 + 6 {
            for x in core.0 - 3..core.0 + 6 {
                if x < 2 || y < 2 || x >= mw() as i32 - 2 || y >= mh() as i32 - 2 {
                    continue;
                }
                let t = &mut self.map.t[idx(x, y)];
                if matches!(t.kind, Kind::Portal | Kind::Gate | Kind::Core) {
                    continue;
                }
                t.kind = Kind::Floor;
                t.owner = owner;
                t.gold = 0;
                t.marked = false;
                t.reinforced = false;
            }
        }
        for y in 0..3 {
            for x in 0..3 {
                let t = &mut self.map.t[idx(core.0 + x, core.1 + y)];
                t.kind = Kind::Core;
                t.owner = owner;
            }
        }
    }

    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);
            self.turn(&mut e, x0, y0);
            self.ents[i] = e;
        }
        // units that wasted away (plague)
        for j in 0..self.ents.len() {
            if self.ents[j].alive && !self.ents[j].held && self.ents[j].hp <= 0.0 {
                self.kill(j);
            }
        }
        self.ents.retain(|e| e.alive);
    }

    fn step(&mut self, dt: f32) {
        if self.demo.is_some() {
            self.demo_step(dt);
            return;
        }
        self.time += dt;
        // mushroom gardens grow faster at a higher level (of the master who owns them)
        let farm = Kind::Farm;
        let lv: Vec<(Owner, f32)> = self.master_sides().into_iter().map(|s| (Owner::of_side(s), {
            let r = room_index(farm).unwrap_or(0);
            let l = if s == self.me_side { self.room_level.get(r).copied() } else { self.masters.iter().find(|m| m.side == s).and_then(|m| m.room_level.get(r).copied()) };
            1.0 + 0.25 * (l.unwrap_or(1).max(1) - 1) as f32
        })).collect();
        for t in self.map.t.iter_mut() {
            if t.kind == Kind::Farm {
                let f = lv.iter().find(|x| x.0 == t.owner).map_or(1.0, |x| x.1);
                t.food = (t.food + dt * f / 18.0).min(3.0);
            }
        }
        for side in self.master_sides() {
            // a master whose heart fell has no household any more: no mana, no new creatures, no payday
            if self.is_out(side) {
                continue;
            }
            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) * self.talents.mana_rate() * 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 {
            self.portal_timer -= dt;
            if self.portal_timer <= 0.0 {
                self.portal_timer = (20.0 + self.rng.f() * 14.0) / (owned as f32).sqrt() * self.lair_factor();
                self.try_portal();
            }
        }

        self.payday -= dt;
        if !self.payday_warned && self.payday <= PAYDAY_WARN {
            self.payday_warned = true;
            let cost = self.next_payday_cost();
            if cost >= 1.0 {
                self.msg("msg.payday_soon", vec![(self.payday.ceil() as i32).to_string(), (cost.ceil() as i32).to_string()]);
                self.sfx_ui(Sfx::FlagSet);
                if cost > self.gold {
                    self.hint(22, "hint.payday_short");
                }
            }
        }
        if self.payday <= 0.0 {
            self.payday = PAYDAY;
            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.tidy_torch_stands();
            self.tidy_memorials();
        }
        self.update_forge(dt);
        self.update_research();
        self.update_marks(dt);
    }

    fn after_economy(&mut self, dt: f32) {
        // the shared world (waves, units, towers, rivals ...) runs from the first master's side: the
        // same on every computer of a match, whichever master plays at this one. Single-player
        // games only have that one side.
        let local = self.local_side;
        let first = self.master_sides().first().copied().unwrap_or(local);
        self.switch_to(first);
        if self.waves_on() {
            self.wave_tick(dt);
        }
        if self.time - self.gate_hit_t > 10.0 && self.has_gate() {
            self.gate_hp = (self.gate_hp + 8.0 * dt).min(GATE_HP);
        }

        self.update_contested();
        self.update_units(dt);
        self.switch_to(first); // update_units worked master by master
        self.update_snares();
        self.update_towers(dt);
        self.update_reveals(dt);
        self.update_graves(dt);
        if !self.rivals.is_empty() {
            self.update_rivals(dt);
        }
        self.update_dwarves(dt);
        self.update_weather(dt);
        self.update_bridges(dt);
        self.update_wood(dt);
        self.update_events(dt);
        self.update_traders(dt);
        // fallen hearts of a match are shared state: every client marks them in the same step
        self.update_fallen_masters();
        // the end of the game and the fog are about the master at this computer
        self.switch_to(local);
        if self.netplay.is_some() {
            self.check_match_end();
        } else {
            self.check_end();
        }
        self.update_fog(dt);
    }

    fn check_end(&mut self) {
        if self.core_hp <= 0.0 {
            self.core_hp = 0.0;
            self.state = 2;
            self.msg("msg.defeat", vec![]);
            self.sfx_ui(Sfx::Defeat);
            return;
        }
        if let Some(m) = &self.mission {
            if m.time_limit > 0.0 && self.time > m.time_limit {
                self.state = 2;
                self.msg("msg.time_up", vec![]);
                self.sfx_ui(Sfx::Defeat);
                return;
            }
            let goals = m.goals.clone();
            if !goals.is_empty() && goals.iter().all(|&g| self.goal_done(g)) {
                self.state = 1;
                self.msg("msg.mission_won", vec![]);
                self.sfx_ui(Sfx::Victory);
            }
            return;
        }
        // free game: every opponent (rival masters and the humans' gate) must fall
        let rivals_out = self.rivals.iter().all(|r| !r.alive);
        let gate_out = !self.gate_on || self.gate_hp <= 0.0;
        if rivals_out && gate_out {
            self.gate_hp = self.gate_hp.max(0.0);
            self.state = 1;
            self.msg("msg.victory", vec![]);
            self.sfx_ui(Sfx::Victory);
        }
    }

    fn wave_tick(&mut self, dt: f32) {
        self.wave_timer -= dt;
        if !self.warned && self.wave_timer < 30.0 {
            self.warned = true;
            let goal = self.wave_goal();
            if goal != self.me_side {
                // the wave will march on another master: no entry markers in this dungeon
                self.planned_entries.clear();
                self.announce_wave("msg.wave_warn", "msg.wave_warn_on_master", vec![(self.wave + 1).to_string()], goal, Sfx::WaveAlarm);
                return;
            }
            self.plan_entries();
            if self.planned_entries.is_empty() {
                self.msg("msg.wave_warn", vec![(self.wave + 1).to_string()]);
            } else {
                let dirs: Vec<String> = self.planned_entries.iter().map(|&p| format!("@{}", self.direction_key(p))).collect();
                if dirs.len() >= 2 {
                    self.msg("msg.wave_warn_two", vec![(self.wave + 1).to_string(), dirs[0].clone(), dirs[1].clone()]);
                } else {
                    self.msg("msg.wave_warn_dir", vec![(self.wave + 1).to_string(), dirs[0].clone()]);
                }
            }
            self.sfx_ui(Sfx::WaveAlarm);
        }
        // markers disappear when no hero is on the way to an entry point any more
        if !self.planned_entries.is_empty() && self.wave_timer > 30.0 && !self.ents.iter().any(|e| e.alive && e.waypoint.is_some()) {
            self.planned_entries.clear();
        }
        if self.wave_timer <= 0.0 {
            self.spawn_wave();
            self.wave += 1;
            self.wave_timer = WAVE_GAP + self.rng.f() * 40.0;
            self.warned = false;
        }
    }

    // the imp working on tile t (dig, claim or reinforce)
    fn task_worker(&self, t: usize) -> Option<usize> {
        self.ents.iter().position(|o| o.alive && !o.hero && o.kind == EK::Worker && matches!(o.job, Job::Dig(x) | Job::Claim(x) | Job::Reinforce(x) if x == t))
    }

    // imps helping at tile t (standing next to it)
    fn helpers(&self, t: usize) -> usize {
        let (tx, ty) = xy(t);
        self.ents
            .iter()
            .filter(|o| o.alive && o.kind == EK::Worker && o.job == Job::Help(t) && o.path.is_empty() && (o.x - tx as f32 - 0.5).abs() < 1.6 && (o.y - ty as f32 - 0.5).abs() < 1.6)
            .count()
    }

    // working speed at a tile: +25% per helper, at most 200% (five imps)
    pub(crate) fn help_speed(&self, t: usize) -> f32 {
        1.0 + 0.25 * self.helpers(t).min(HELPERS_MAX) as f32
    }

    // an idle imp walks to the nearest task with room for another helper
    fn start_help(&mut self, e: &mut Ent) -> bool {
        let tasks: Vec<usize> = self
            .ents
            .iter()
            .filter(|o| o.alive && !o.hero && o.kind == EK::Worker)
            .filter_map(|o| match o.job {
                Job::Dig(t) | Job::Claim(t) | Job::Reinforce(t) => Some(t),
                _ => None,
            })
            .filter(|&t| self.ents.iter().filter(|o| o.alive && o.job == Job::Help(t)).count() < HELPERS_MAX)
            .collect();
        if tasks.is_empty() {
            return false;
        }
        let cur = e.tile();
        let near = |i: usize| tasks.iter().copied().find(|&t| i != t && adj4(i, t) || (i == t && self.map.t[t].walkable()));
        let Some(p) = self.map.search(cur, self.map.creature_cost(flies(e.kind)), |i| near(i).is_some(), true) else { return false };
        let end = p.last().copied().unwrap_or(cur);
        let Some(t) = near(end) else { return false };
        e.path = p;
        e.job = Job::Help(t);
        e.think = 1.5;
        true
    }

    // free beds in the lairs: much room lets creatures arrive faster, little room slower
    pub fn free_beds(&self) -> usize {
        let (lair, aerie) = self.free_lair_aerie();
        lair + aerie
    }

    // free places in the lairs (walking creatures) and in the aerie (flying creatures)
    pub fn free_lair_aerie(&self) -> (usize, usize) {
        let flyers = self.ents.iter().filter(|e| e.alive && e.creature() && flies(e.kind)).count();
        let walkers = self.creature_count() - flyers;
        // a bed per lair tile (aerie: per aerie tile), never more than MAX_CREATURES in all
        let room = MAX_CREATURES.saturating_sub(walkers + flyers);
        (self.counts[1].saturating_sub(walkers).min(room), self.counts[7].saturating_sub(flyers).min(room))
    }

    // how many creatures this master can house: his beds, at most MAX_CREATURES
    pub fn creature_cap(&self) -> usize {
        (self.counts[1] + self.counts[7]).min(MAX_CREATURES)
    }

    pub fn lair_factor(&self) -> f32 {
        (8.0 / (self.free_beds() as f32 + 2.0)).clamp(0.35, 3.0)
    }

    #[cfg(test)]
    pub fn try_portal_for_test(&mut self) {
        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 = self.me;
            }
        }
        self.try_portal();
    }

    fn try_portal(&mut self) {
        let lair = self.counts[1];
        let aerie = self.counts[7];
        let farm = self.counts[2];
        if lair == 0 && aerie == 0 {
            self.hint(0, "hint.portal_no_lair");
            return;
        }
        if farm == 0 {
            self.hint(1, "hint.no_farm");
            return;
        }
        if self.creature_count() >= MAX_CREATURES {
            self.hint(35, "hint.creature_max");
            return;
        }
        let (free_lair, free_aerie) = self.free_lair_aerie();
        if free_lair == 0 && free_aerie == 0 {
            self.hint(2, "hint.lair_full");
            return;
        }
        let mut opts: Vec<(EK, u32)> = Vec::new();
        // flying creatures need room in the aerie
        if free_aerie > 0 {
            if aerie >= 4 {
                opts.push((EK::Bat, 4));
            }
            if aerie >= 6 && self.counts[5] >= 4 {
                opts.push((EK::Gargoyle, 2));
            }
            if aerie >= 6 && self.counts[4] >= 6 {
                opts.push((EK::Owl, 2));
            }
            let has_wyrm = self.ents.iter().any(|e| e.alive && e.kind == EK::Wyrm && !e.hero);
            if aerie >= 16 && self.counts[0] >= 16 && !has_wyrm {
                opts.push((EK::Wyrm, 1));
            }
        }
        if free_lair == 0 {
            if opts.is_empty() {
                self.hint(2, "hint.lair_full");
                return;
            }
        } else {
            self.portal_walkers(&mut opts);
        }
        if opts.is_empty() {
            return;
        }
        self.portal_arrival(opts);
    }

    // walking creatures that the rooms attract
    fn portal_walkers(&mut self, opts: &mut Vec<(EK, u32)>) {
        let farm = self.counts[2];
        opts.push((EK::Kobold, 4));
        if farm >= 6 {
            opts.push((EK::Spider, 3));
        }
        if self.counts[4] >= 6 {
            opts.push((EK::Mage, 3));
        }
        if self.counts[3] >= 9 {
            opts.push((EK::Ogre, 2));
        }
        if self.counts[5] >= 6 {
            opts.push((EK::Jailer, 2));
        }
        if self.counts[6] >= 6 {
            opts.push((EK::Priestess, 2));
        }
        if self.counts[ROOM_FORGE] >= 6 {
            opts.push((EK::Cogling, 3));
        }
        // the Chainbreaker only visits big dungeons with experienced creatures and a rich treasury
        let room_tiles: usize = self.counts.iter().sum();
        let veteran = self.ents.iter().any(|e| e.alive && e.creature() && e.level >= 5);
        let has_one = self.ents.iter().any(|e| e.alive && e.kind == EK::Chainbreaker && !e.hero);
        if room_tiles >= 40 && veteran && self.gold >= 4000.0 && !has_one {
            opts.push((EK::Chainbreaker, 1));
        }
    }

    fn portal_arrival(&mut self, opts: Vec<(EK, u32)>) {
        let total: u32 = opts.iter().map(|o| o.1).sum();
        let mut r = self.rng.next() % total;
        let mut kind = EK::Kobold;
        for (k, w) in opts {
            if r < w {
                kind = k;
                break;
            }
            r -= w;
        }
        let owned: Vec<usize> = (0..self.map.portals.len()).filter(|&k| self.map.portal_owner(k) == self.me).collect();
        let pk = owned[(self.rng.next() as usize) % owned.len()];
        let (px, py) = self.map.portals[pk];
        let id = self.spawn(kind, false, px as f32 + 1.5, py as f32 + 1.5, 1);
        // new creatures report at the portal and set up their bed first
        if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
            e.settled = false;
            e.job = Job::Register;
            e.timer = 2.0;
        }
        self.fx(3, px as f32 + 1.5, py as f32 + 1.5, 0.0, 0.0, 0.8, 0xffcc44ff);
        self.sfx(Sfx::PortalArrive, px as f32 + 1.5, py as f32 + 1.5);
        self.msg("msg.creature_arrived", vec![format!("@{}", st(kind).name)]);
    }

    // Payday: the training bill is paid at once; every creature fetches its wage from a
    // treasury itself, at a random moment within about a minute
    fn do_payday(&mut self) {
        let bill = self.training_bill.min(self.gold).max(0.0);
        self.gold -= bill;
        self.training_bill = 0.0;
        let mut n = 0;
        let mut total = bill;
        let merchant = self.talents.wages();
        for i in 0..self.ents.len() {
            if !self.ents[i].alive || !self.ents[i].creature() {
                continue;
            }
            let r = self.rng.f();
            let e = &mut self.ents[i];
            let w = st(e.kind).wage as f32 * (1.0 + 0.1 * (e.level - 1) as f32) * merchant;
            e.pay_due += w;
            e.pay_t = r * 55.0;
            n += 1;
            total += w;
        }
        if n > 0 || bill > 0.0 {
            self.sfx_ui(Sfx::Payday);
            self.msg("msg.payday_walk", vec![n.to_string(), (total as i32).to_string()]);
        }
    }

    // a creature goes for its wage: the nearest treasury tile holding treasure, else the core
    fn start_fetch_wage(&mut self, e: &mut Ent) {
        let cur = e.tile();
        let goal = |i: usize| {
            let t = &self.map.t[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 {
            Some(p) => {
                let t = p.last().copied().unwrap_or(cur);
                e.path = p;
                e.job = Job::FetchWage(t);
            }
            // no way to a treasury: the wage is paid out anyway
            None => self.take_wage(e, None),
        }
    }

    // takes the wage out of the treasury tile (the rest from elsewhere); unpaid = angry
    fn take_wage(&mut self, e: &mut Ent, at: Option<usize>) {
        let mut need = e.pay_due;
        if let Some(t) = at {
            let tile = &mut self.map.t[t];
            if tile.kind == Kind::Treasury {
                let take = (tile.gold as f32).min(need).floor();
                tile.gold -= take as i32;
                self.gold -= take;
                need -= take;
            }
        }
        let rest = need.min(self.gold.max(0.0));
        self.gold -= rest;
        need -= rest;
        e.pay_due = 0.0;
        if need > 0.5 {
            e.happy -= 0.45;
            self.msg("msg.wage_unpaid", vec![format!("@{}", st(e.kind).name)]);
            self.sfx(Sfx::Error, e.x, e.y);
        } else {
            e.happy = (e.happy + 0.2).min(1.0);
            self.fx(5, e.x, e.y, 0.0, 0.0, 0.8, 0xff30d0ff);
            self.sfx(Sfx::Deposit, e.x, e.y);
        }
    }

    // a new creature: report at the portal, go to the lair (aerie), set up the bed
    fn settle(&mut self, e: &mut Ent, dt: f32) {
        let me = e.id + 1;
        match e.job {
            Job::Register => {
                e.working = true;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    let cur = e.tile();
                    let bed_kind = if flies(e.kind) { Kind::Aerie } else { Kind::Lair };
                    let free = |i: usize| self.map.t[i].kind == bed_kind && self.map.t[i].bed == 0 && self.map.t[i].owner == self.me;
                    let found = if flies(e.kind) { self.map.search(cur, self.map.fly_cost(), free, true) } else { self.map.search(cur, self.map.walk_cost(), free, true) };
                    match found {
                        Some(p) => {
                            let b = p.last().copied().unwrap_or(cur);
                            self.map.t[b].bed = me;
                            e.bed = Some(b);
                            e.path = p;
                            e.job = Job::MakeBed(b);
                            e.timer = 4.0;
                        }
                        None => {
                            e.settled = true;
                            e.job = Job::None;
                        }
                    }
                }
            }
            Job::MakeBed(b) => {
                if self.step_path(e, dt) {
                    return;
                }
                if self.map.t[b].bed != me {
                    e.settled = true;
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    e.settled = true;
                    e.job = Job::None;
                    let (bx, by) = xy(b);
                    self.fx(8, bx as f32 + 0.5, by as f32 + 0.5, 0.0, 0.0, 0.6, 0xff40d0ff);
                    self.sfx(Sfx::Build, bx as f32 + 0.5, by as f32 + 0.5);
                }
            }
            _ => {
                e.job = Job::Register;
                e.timer = 2.0;
            }
        }
    }

    // strength of a squad (same formula as the army value)
    pub(crate) fn squad_value(list: &[(EK, u32)]) -> f32 {
        let (mut h, mut d) = (0.0, 0.0);
        for &(k, l) in list {
            let s = st(k);
            h += s.hp * (1.0 + 0.15 * (l - 1) as f32);
            d += s.atk * (1.0 + 0.12 * (l - 1) as f32) / s.interval;
        }
        (h * d).sqrt()
    }

    // builds a hero squad with at least the target strength
    fn build_squad(&mut self, target: f32, base_level: u32, pool: &[(EK, u32)], boss: Option<EK>, min: usize) -> Vec<(EK, u32)> {
        let total: u32 = pool.iter().map(|p| p.1).sum();
        let mut list = Vec::new();
        for level in base_level.min(10)..=10 {
            list.clear();
            if let Some(b) = boss {
                list.push((b, level));
            }
            while list.len() < MAX_SQUAD && (list.len() < min || Self::squad_value(&list) < target) {
                let mut r = self.rng.next() % total;
                for &(k, w) in pool {
                    if r < w {
                        list.push((k, level));
                        break;
                    }
                    r -= w;
                }
            }
            if Self::squad_value(&list) >= target {
                break;
            }
        }
        list
    }

    fn spawn_squad(&mut self, list: &[(EK, u32)], guard: bool) {
        let (gx, gy) = self.map.gate;
        for &(k, l) in list {
            let x = gx as f32 + 0.5 + self.rng.f() * 2.0;
            let y = gy as f32 + 0.5 + self.rng.f() * 2.0;
            let id = self.spawn(k, true, x, y, l);
            let home = (gx as f32 + 1.5, gy as f32 + 1.5);
            if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
                e.guard = guard;
                if guard {
                    e.home = Some(home);
                }
            }
        }
        self.fx(3, gx as f32 + 1.5, gy as f32 + 1.5, 0.0, 0.0, 1.0, 0xffffeecc);
    }

    // Endless waves: strength 60% -> 100% of the army value, with some randomness, at least 2 knights.
    pub(crate) fn spawn_wave(&mut self) {
        use EK::*;
        let w = self.wave + 1;
        let ratio = (0.6 + 0.05 * (w - 1) as f32).min(1.0) * (0.88 + self.rng.f() * 0.24);
        let min_value = Self::squad_value(&[(Knight, 1), (Knight, 1)]);
        // the humans march on the strongest master; the wave is measured against him
        let goal = self.wave_goal();
        let target = (self.side_army(goal) * ratio).max(min_value);
        let mut pool = vec![(Knight, 4), (Archer, 3)];
        if w >= 2 {
            pool.push((Dwarf, 2));
        }
        if w >= 3 {
            pool.push((Priest, 2));
            pool.push((Fairy, 1));
        }
        if w >= 4 {
            pool.push((BattleMage, 1));
        }
        if w >= 6 {
            pool.push((Giant, 1));
        }
        // the rogues of the later waves (in the campaign only from the later missions on)
        for (k, from_wave, from_mission) in crate::rogues::ROGUES {
            if w >= from_wave && self.mission.as_ref().map_or(true, |m| m.index >= from_mission) {
                pool.push((k, 1));
            }
        }
        // siege engines for the dungeon's doors, walls and towers
        if w >= 4 && self.traps.iter().any(|t| t.kind.door()) {
            pool.push((Ram, 1));
        }
        if w >= 6 && self.towers.iter().any(|t| !t.hero) {
            pool.push((Catapult, 1));
        }
        let boss = if w % 5 == 0 { Some(Paladin) } else { None };
        let base_level = 1 + (w - 1) / 3;
        let list = self.build_squad(target, base_level, &pool, boss, 2);
        self.last_wave_value = Self::squad_value(&list);
        let before = self.ents.len();
        self.spawn_squad(&list, false);
        // the paladin of every fifth wave is one of the Order's champions
        if boss.is_some() {
            if let Some(j) = (before..self.ents.len()).find(|&j| self.ents[j].kind == Paladin) {
                self.make_boss(j, 1 + ((w / 5 - 1) % 4) as u8);
            }
        }
        if goal != self.me_side {
            for e in self.ents[before..].iter_mut() {
                e.target = Some(goal);
                e.waypoint = None;
            }
            self.planned_entries.clear();
            let args = vec![w.to_string(), list.len().to_string()];
            if self.is_master(goal) {
                self.announce_wave("msg.wave", "msg.wave_on_master", args, goal, Sfx::WaveStart);
            } else {
                self.sfx_ui(Sfx::WaveStart);
                self.msg(if goal == 2 { "msg.wave_on_rival1" } else { "msg.wave_on_rival2" }, args);
            }
            return;
        }
        if self.planned_entries.is_empty() {
            self.plan_entries();
        }
        let entries = self.planned_entries.clone();
        if !entries.is_empty() {
            let split = list.len() >= 6 && entries.len() >= 2;
            // the paladin (if any) is spawned first and joins group A, which gets the extra hero
            for (k, e) in self.ents[before..].iter_mut().enumerate() {
                e.waypoint = Some(if split && k % 2 == 1 { entries[1] } else { entries[0] });
            }
            if !split {
                self.planned_entries.truncate(1);
            }
            self.entry_history.extend(self.planned_entries.iter().copied());
            let n = self.entry_history.len();
            if n > 4 {
                self.entry_history.drain(0..n - 4);
            }
        }
        let key = if boss.is_some() { "msg.wave_boss" } else { "msg.wave" };
        let goal = self.me_side;
        self.announce_wave(key, "msg.wave_on_master", vec![w.to_string(), list.len().to_string()], goal, Sfx::WaveStart);
    }

    // The side a hero wave marches on: the strongest master still standing (creatures, towers and
    // gold), players and rival masters alike; ties go to the lower side.
    pub fn wave_goal(&self) -> u8 {
        let mut best = (self.me_side, f32::MIN);
        let mut sides: Vec<u8> = self.master_sides().into_iter().filter(|&s| !self.is_out(s) && self.core_hp_of(s) > 0.0).collect();
        sides.extend(self.rivals.iter().filter(|r| r.alive).map(|r| r.side));
        sides.sort_unstable();
        for s in sides {
            let gold = if self.is_master(s) { self.gold_of(s) } else { 0.0 };
            let score = self.side_army(s) + 0.05 * gold;
            if score > best.1 {
                best = (s, score);
            }
        }
        best.0
    }

    // the fighting strength of one side, like `army_value`: its creatures and (half) its towers
    pub fn side_army(&self, side: u8) -> f32 {
        let owner = Owner::of_side(side);
        let (mut h, mut d) = (0.0, 0.0);
        for e in &self.ents {
            if e.alive && !e.hero && !e.chained && e.kind != EK::Worker && e.side() == side {
                h += e.max_hp;
                d += e.atk() / st(e.kind).interval;
            }
        }
        for t in self.towers.iter().filter(|t| !t.hero && self.map.t[t.tile].owner == owner) {
            h += 0.5 * t.max_hp();
            d += 0.5 * t.dmg() / tower_stats(t.kind).interval;
        }
        (h * d).sqrt()
    }

    // tells about a wave: the attacked master hears `key`; every other player of a match hears
    // `other` (with the attacked master's colour as last argument). A wave on a rival master is
    // told to the player like a normal warning.
    fn announce_wave(&mut self, key: &'static str, other: &'static str, args: Vec<String>, goal: u8, sfx: Sfx) {
        if !self.is_master(goal) || self.netplay.is_none() || self.local_side == goal {
            let me = self.me_side;
            self.switch_to(goal);
            self.msg(key, args);
            self.sfx_ui(sfx);
            self.switch_to(me);
            return;
        }
        let mut a = args;
        a.push(format!("@net.side{goal}"));
        self.tell_local(other, a, Some(sfx));
    }

    // defenders at 75 / 50 / 25 % gate HP
    fn check_gate_stage(&mut self) {
        use EK::*;
        let frac = self.gate_hp / GATE_HP;
        let want = if frac <= 0.25 { 3 } else if frac <= 0.5 { 2 } else if frac <= 0.75 { 1 } else { 0 };
        while self.gate_stage < want {
            self.gate_stage += 1;
            let st_i = self.gate_stage;
            let ratio = [0.5, 0.65, 0.85][(st_i - 1) as usize] * (0.9 + self.rng.f() * 0.2);
            let min_value = Self::squad_value(&[(Knight, 2), (Knight, 2), (Archer, 2)]);
            let target = (self.army_value() * ratio).max(min_value);
            let pool = [(Knight, 4), (Archer, 3), (Priest, 2), (Dwarf, 1)];
            let boss = if st_i == 3 { Some(Paladin) } else { None };
            let base_level = 2 + self.wave / 3 + st_i;
            let list = self.build_squad(target, base_level, &pool, boss, 3);
            self.spawn_squad(&list, true);
            self.sfx_ui(Sfx::GateDefenders);
            if st_i == 3 {
                self.msg("msg.gate_boss", vec![(list.len() - 1).to_string()]);
            } else {
                self.msg("msg.gate_defenders", vec![list.len().to_string()]);
            }
        }
    }

    pub(crate) fn hit_gate(&mut self, e: &mut Ent) {
        let s = st(e.kind);
        e.cd = s.interval;
        let dmg = e.atk() * (0.85 + self.rng.f() * 0.3);
        self.gate_hp -= dmg;
        self.gate_hit_t = self.time;
        e.xp += dmg * 0.3;
        let (gx, gy) = self.gate_center();
        if s.range > 1.5 {
            let col = if e.kind == EK::Mage { 0xffff44cc } else { 0xff70b0d0 };
            self.fx(0, e.x, e.y, gx, gy, 0.25, col);
        } else {
            let fx = (e.x + gx) * 0.5;
            let fy = (e.y + gy) * 0.5;
            self.fx(2, fx, fy, 0.0, 0.0, 0.25, 0xffffffff);
        }
        self.sfx(Sfx::GateHit, gx, gy);
        self.hint(10, "hint.gate_attack");
        if self.mission.as_ref().map_or(true, |m| m.gate_defenders) {
            self.check_gate_stage();
        }
    }

    fn update_ent(&mut self, e: &mut Ent, dt: f32) {
        e.anim += dt;
        e.flash = (e.flash - dt).max(0.0);
        e.slow = (e.slow - dt).max(0.0);
        e.skill_cd -= dt;
        e.boost = (e.boost - dt).max(0.0);
        if e.stun > 0.0 {
            e.stun -= dt;
            e.moving = false;
            return;
        }
        self.tick_effects(e, dt);
        // slapped units work and move faster, hasted ones even more
        let dt = if e.boost > 0.0 { dt * 1.5 } else { dt } * if e.haste > 0.0 { 1.6 } else { 1.0 };
        e.cd -= dt;
        e.think -= dt;
        e.repath -= dt;
        e.moving = false;
        e.working = false;
        let s = st(e.kind);
        while e.level < 10 && e.xp >= 100.0 * e.level as f32 {
            e.xp -= 100.0 * e.level as f32;
            e.level += 1;
            let old = e.max_hp;
            e.max_hp = s.hp * (1.0 + 0.15 * (e.level - 1) as f32) * crate::armory::gear_factor(e.gear);
            e.hp += e.max_hp - old;
            self.fx(7, e.x, e.y, 0.0, 0.0, 0.8, 0xff44ddff);
            if !e.hero {
                self.sfx(Sfx::LevelUp, e.x, e.y);
            }
            if !e.hero && e.level >= 3 {
                self.msg("msg.level_up", vec![crate::names::arg(e), e.level.to_string()]);
            }
        }
        if e.chained {
            // 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 == self.me));
            if reached {
                e.chained = false;
                e.settled = false;
                e.job = Job::Register;
                e.timer = 1.0;
                e.happy = 1.0;
                self.freed += 1;
                self.fx(7, e.x, e.y, 0.0, 0.0, 1.2, 0xff44ddff);
                self.sfx(Sfx::Convert, e.x, e.y);
                self.msg("msg.creature_freed", vec![format!("@{}", st(e.kind).name)]);
            }
        } else if self.demo.is_some() {
            self.demo_ai(e, dt);
        } else if e.hero && e.captive != 0 {
            self.captive_update(e, dt);
        } else if !self.is_master(e.side) && (self.is_rival_side(e.side) || e.rival()) {
            self.rival_ai(e, dt);
        } else if e.kind == EK::Trader {
            self.trader_ai(e, dt);
        } else if e.dwarf() {
            self.dwarf_ai(e, dt);
        } else if e.hero {
            self.hero_ai(e, dt);
        } else if e.kind == EK::Worker {
            self.worker_ai(e, dt);
        } else {
            self.creature_ai(e, dt);
        }
    }

    // the direction a unit faces: where it walks, otherwise what it works on or fights
    fn turn(&self, e: &mut Ent, x0: f32, y0: f32) {
        let (dx, dy) = (e.x - x0, e.y - y0);
        if dx * dx + dy * dy > 1e-8 {
            e.dir = dy.atan2(dx);
            return;
        }
        if !e.working {
            return;
        }
        let tile = |t: usize| {
            let (x, y) = xy(t);
            Some((x as f32 + 0.5, y as f32 + 0.5))
        };
        let target = match e.job {
            Job::Dig(t) | Job::Reinforce(t) | Job::Help(t) | Job::TearBridge(t) | Job::MendBridge(t) | Job::RaiseWall(t) => tile(t),
            Job::Attack(id) | Job::Torment(id) | Job::Carry(id) | Job::Brawl(id) => self.find(id).map(|j| (self.ents[j].x, self.ents[j].y)),
            Job::Repair(id) | Job::AttackTower(id) => self.towers.iter().find(|t| t.id == id).map(|t| t.pos()),
            _ => None,
        };
        if let Some((tx, ty)) = target {
            let (dx, dy) = (tx - e.x, ty - e.y);
            if dx * dx + dy * dy > 0.01 {
                e.dir = dy.atan2(dx);
            }
        }
    }

    // moves a unit along its path; true = still moving
    pub(crate) fn step_path(&mut self, e: &mut Ent, dt: f32) -> bool {
        if e.path.is_empty() {
            return false;
        }
        let next = e.path[0];
        let tile = self.map.t[next];
        if tile.kind == Kind::Door {
            if e.side() != 0 {
                // enemies smash doors on their way
                if self.bash_door(e, next, dt) {
                    return true;
                }
            } else if tile.res & 1 == 1 && e.tile() != next {
                // locked: our own creatures have to find another way
                e.path.clear();
                return false;
            }
        }
        if !tile.walkable() && !(flies(e.kind) && tile.liquid()) {
            if (e.hero || (!self.is_master(e.side) && (self.is_rival_side(e.side) || e.rival()))) && tile.diggable() {
                // heroes dig their way through
                e.working = true;
                let (tx, ty) = xy(next);
                e.face = sgn(tx as f32 + 0.5 - e.x);
                e.timer += dt;
                if e.timer >= 0.5 {
                    e.timer = 0.0;
                    let pow = match e.kind {
                        EK::Dwarf => 3.0,
                        EK::Paladin | EK::Giant => 2.0,
                        EK::Ram => 4.0,
                        _ => 1.0,
                    } * if e.kind == EK::BattleMage && (tile.reinforced || tile.kind == Kind::Steel) {
                        // the battle mage blasts reinforced walls (steel resists better)
                        if tile.kind == Kind::Steel {
                            0.4
                        } else {
                            1.6
                        }
                    } else if tile.kind == Kind::Steel {
                        0.05
                    } else if tile.reinforced {
                        0.2
                    } else {
                        1.0
                    };
                    if e.kind == EK::BattleMage {
                        let (sx, sy) = (e.x, e.y);
                        self.shot(sx, sy, 0.6, tx as f32 + 0.5, ty as f32 + 0.5, 0.5, 0.3, 0xff3080ff);
                        self.style_last_fx(crate::particles::ST_FIRE);
                    }
                    self.fx(6, tx as f32 + 0.5, ty as f32 + 0.5, 0.0, 0.0, 0.4, 0xff3a5a7a);
                    self.sfx(Sfx::Dig, tx as f32 + 0.5, ty as f32 + 0.5);
                    let t = &mut self.map.t[next];
                    t.hp -= pow;
                    if t.hp <= 0.0 {
                        self.dig_out(next);
                    }
                }
                return true;
            }
            e.path.clear();
            return false;
        }
        let (tx, ty) = xy(next);
        let (cx, cy) = (tx as f32 + 0.5, ty as f32 + 0.5);
        let dx = cx - e.x;
        let dy = cy - e.y;
        let d = (dx * dx + dy * dy).sqrt();
        let mut sp = st(e.kind).speed * dt * if e.slow > 0.0 { 0.55 } else { 1.0 };
        if !e.hero && e.creature() && e.hunger > 2.0 {
            sp *= 0.8;
        }
        if d <= sp {
            e.x = cx;
            e.y = cy;
            e.path.remove(0);
        } else {
            e.x += dx / d * sp;
            e.y += dy / d * sp;
        }
        if dx.abs() > 0.01 {
            e.face = sgn(dx);
        }
        e.moving = true;
        true
    }

    pub fn dig_out(&mut self, i: usize) {
        self.torches.retain(|t| t.wall != i);
        let t = &mut self.map.t[i];
        // a grove's mushroom leaves its moss behind
        let grove = t.kind == Kind::Mushroom && t.res & MUSH_GROVE != 0;
        t.kind = if grove { Kind::Grove } else { Kind::Floor };
        if grove {
            t.res = 0;
        }
        t.owner = Owner::None;
        t.marked = false;
        t.reinforced = false;
        t.reserved = 0;
        t.hp = 0.0;
        t.gold = 0;
        let (x, y) = xy(i);
        self.count(crate::stats::DUG, 1.0);
        self.fx(3, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.6, 0xff304a66);
        self.sfx(Sfx::DigDone, x as f32 + 0.5, y as f32 + 0.5);
    }

    pub(crate) fn unreserve(&mut self, me: u32) {
        for t in self.map.t.iter_mut() {
            if t.reserved == me {
                t.reserved = 0;
            }
        }
    }

    pub(crate) fn release_all(&mut self, id: u32) {
        let me = id + 1;
        for t in self.map.t.iter_mut() {
            if t.reserved == me {
                t.reserved = 0;
            }
            if t.bed == me {
                t.bed = 0;
            }
        }
    }

    pub(crate) fn los(&self, x0: f32, y0: f32, x1: f32, y1: f32) -> bool {
        let dx = x1 - x0;
        let dy = y1 - y0;
        let d = (dx * dx + dy * dy).sqrt();
        let n = (d * 4.0) as i32 + 1;
        for k in 1..n {
            let f = k as f32 / n as f32;
            let x = (x0 + dx * f) as i32;
            let y = (y0 + dy * f) as i32;
            if let Some(t) = self.map.get(x, y) {
                if t.solid() || t.kind == Kind::Core {
                    return false;
                }
            }
        }
        true
    }

    pub(crate) fn nearest_enemy(&self, e: &Ent, radius: f32) -> Option<u32> {
        let mut best = None;
        let mut bd = radius * radius;
        for o in &self.ents {
            // every other side is an enemy; co-op partners and team mates fight the heroes, not each other
            let coop_ally = self.allied(e.side(), o.side());
            if !o.alive || o.held || o.side() == e.side() || coop_ally || o.captive != 0 || o.chained || o.invis > 0.0 {
                continue;
            }
            let d = (o.x - e.x).powi(2) + (o.y - e.y).powi(2);
            if d < bd {
                bd = d;
                best = Some(o.id);
            }
        }
        best
    }

    // fight a specific unit; false = target invalid/unreachable
    pub(crate) fn attack_job(&mut self, e: &mut Ent, id: u32, dt: f32) -> bool {
        let Some(j) = self.find(id) else { return false };
        let (tx, ty) = (self.ents[j].x, self.ents[j].y);
        let d = ((tx - e.x).powi(2) + (ty - e.y).powi(2)).sqrt();
        let s = st(e.kind);
        if d > 12.0 {
            return false;
        }
        if e.kind == EK::Jailer && e.skill_cd <= 0.0 && d > 1.4 && d < 4.5 && self.los(e.x, e.y, tx, ty) {
            // jailer: pulls the enemy in with a chain
            let (dx, dy) = norm(tx - e.x, ty - e.y);
            let (nx, ny) = (e.x + dx * 0.9, e.y + dy * 0.9);
            if self.map.walk(nx as i32, ny as i32) {
                self.fx(0, tx, ty, e.x, e.y, 0.3, 0xff8090a0);
                self.sfx(Sfx::Capture, e.x, e.y);
                let t = &mut self.ents[j];
                t.x = nx;
                t.y = ny;
                t.path.clear();
                e.skill_cd = 6.0;
                return true;
            }
        }
        if d <= s.range + 0.45 && (s.range < 1.5 || self.los(e.x, e.y, tx, ty)) {
            e.path.clear();
            e.face = sgn(tx - e.x);
            e.working = true;
            if e.cd <= 0.0 && self.use_ability(e, j) {
                return true;
            }
            if e.cd <= 0.0 {
                e.cd = s.interval;
                self.hit(e, j);
            }
            return true;
        }
        if e.path.is_empty() || e.repath <= 0.0 {
            e.repath = 0.6;
            let tt = idx(tx as i32, ty as i32);
            let p = if flies(e.kind) { self.map.fly_path_to(e.tile(), tt) } else { self.map.path_to(e.tile(), tt) };
            match p {
                Some(p) => e.path = p,
                None => return false,
            }
        }
        if !self.step_path(e, dt) && e.tile() == idx(tx as i32, ty as i32) {
            // same tile: approach directly
            let dx = tx - e.x;
            let dy = ty - e.y;
            let l = (dx * dx + dy * dy).sqrt().max(0.001);
            let sp = s.speed * dt;
            e.x += dx / l * sp.min(l);
            e.y += dy / l * sp.min(l);
        }
        true
    }

    #[cfg(test)]
    pub(crate) fn hit_for_test(&mut self, e: &mut Ent, j: usize) {
        self.hit(e, j);
    }

    fn hit(&mut self, e: &mut Ent, j: usize) {
        // the Warlord talent of the attacker's master
        let boost = if !e.hero && Owner::MASTER_SIDES.contains(&e.side) { self.talents_of(e.side).damage() } else { 1.0 };
        let dmg = e.atk() * (0.85 + self.rng.f() * 0.3) * boost;
        let (tx, ty) = (self.ents[j].x, self.ents[j].y);
        let s = st(e.kind);
        // the higher the level, the bigger the attack looks (up to almost twice at Lv 10)
        let lv = 1.0 + 0.1 * (e.level.max(1) - 1) as f32;
        if s.range > 1.5 {
            let col = match e.kind {
                EK::Mage => 0xffff44cc,
                EK::Priest => 0xff88ffff,
                EK::Priestess => 0xff3080ff,
                EK::Owl => 0xffffa060,
                EK::Wyrm => 0xff2080ff,
                EK::Inquisitor => 0xff40d0ff,
                _ => 0xff70b0d0,
            };
            // flyers shoot from the air
            let h = if flies(e.kind) { 0.8 } else { 0.45 };
            self.shot(e.x, e.y, h, tx, ty, 0.45, 0.25, col);
            self.grow_last_fx(lv);
            use crate::particles::*;
            self.style_last_fx(match e.kind {
                EK::Archer | EK::Ranger => ST_ARROW,
                EK::Inquisitor => ST_HOLY,
                EK::Mage => ST_SHADOW,
                EK::Priest => ST_HOLY,
                EK::Priestess | EK::Wyrm | EK::BattleMage => ST_FIRE,
                EK::Owl => ST_ARCANE,
                _ => ST_PLAIN,
            });
            self.sfx(Sfx::Shoot, e.x, e.y);
        } else {
            self.fx(2, tx, ty, 0.0, 0.0, 0.25, if e.level >= 9 { 0xff60e0ff } else { 0xffffffff });
            self.grow_last_fx(lv);
            self.sfx(Sfx::MeleeHit, tx, ty);
        }
        e.xp += dmg * 0.6;
        if e.kind == EK::Chainbreaker {
            // twin axes: a second enemy next to the Chainbreaker takes half damage
            let me = e.side();
            let second = self
                .ents
                .iter()
                .enumerate()
                .find(|(o, x)| *o != j && x.alive && !x.held && x.side() != me && x.captive == 0 && (x.x - e.x).powi(2) + (x.y - e.y).powi(2) < 2.6)
                .map(|(o, _)| o);
            if let Some(o) = second {
                let (ox, oy) = (self.ents[o].x, self.ents[o].y);
                self.fx(2, ox, oy, 0.0, 0.0, 0.25, 0xff40a0ff);
                self.grow_last_fx(lv);
                self.ents[o].hp -= dmg * 0.5;
                self.ents[o].flash = 0.15;
                if self.ents[o].hp <= 0.0 {
                    self.kill(o);
                }
            }
        }
        if e.kind == EK::Priestess || e.kind == EK::Wyrm || e.kind == EK::BattleMage {
            // fire on a wooden bridge sets it alight now and then
            if self.rng.f() < 0.25 {
                self.ignite_at(tx, ty);
            }
            // fireball / fire breath: half damage to enemies around the target
            let me = e.side();
            let splash: Vec<usize> = self
                .ents
                .iter()
                .enumerate()
                .filter(|(o, x)| *o != j && x.alive && !x.held && x.side() != me && x.captive == 0 && (x.x - tx).powi(2) + (x.y - ty).powi(2) < if crate::personality::knows(e, "inferno") { 6.25 } else { 1.44 })
                .map(|(o, _)| o)
                .collect();
            for o in splash {
                if self.ents[o].alive {
                    self.ents[o].hp -= dmg * 0.5;
                    self.ents[o].flash = 0.15;
                    if self.ents[o].hp <= 0.0 {
                        self.kill(o);
                    }
                }
            }
            if !self.ents[j].alive {
                return;
            }
        }
        // learned abilities that come with a blow
        if crate::personality::knows(e, "drain") {
            e.hp = (e.hp + dmg * 0.3).min(e.max_hp);
        }
        if crate::personality::knows(e, "web") && self.rng.f() < 0.3 {
            self.ents[j].slow = self.ents[j].slow.max(3.0);
        }
        if crate::personality::knows(e, "shackle") && self.rng.f() < 0.2 {
            self.ents[j].stun = self.ents[j].stun.max(2.0);
        }
        if crate::personality::knows(e, "volley") {
            let me = e.side();
            let second = self.ents.iter().enumerate().find(|(o, x)| *o != j && x.alive && !x.held && x.side() != me && x.captive == 0 && (x.x - tx).powi(2) + (x.y - ty).powi(2) < 6.0).map(|(o, _)| o);
            if let Some(o) = second {
                let (ox, oy) = (self.ents[o].x, self.ents[o].y);
                self.shot(e.x, e.y, 0.8, ox, oy, 0.45, 0.25, 0xffffa060);
                self.style_last_fx(crate::particles::ST_ARCANE);
                self.ents[o].hp -= dmg * 0.6;
                self.ents[o].flash = 0.15;
                if self.ents[o].hp <= 0.0 {
                    self.kill(o);
                }
            }
        }
        let my_id = e.id;
        e.invis = 0.0; // attacking breaks invisibility
        let armour = {
            let t = &self.ents[j];
            if !t.hero && Owner::MASTER_SIDES.contains(&t.side) { self.talents_of(t.side).armour() } else { 1.0 }
        };
        let t = &mut self.ents[j];
        t.hp -= if t.shield > 0.0 { dmg * 0.5 } else { dmg } * armour;
        t.flash = 0.15;
        t.bane = crate::gfx::sprite_index(e.kind) as u8 + 1;
        if t.hp <= 0.0 && t.hero && t.captive == 0 {
            e.kills += 1;
        }
        if t.creature() && !matches!(t.job, Job::Attack(_)) {
            t.job = Job::Attack(my_id);
            t.path.clear();
        }
        if t.hp <= 0.0 {
            self.kill(j);
        }
    }

    // free places in the torture chamber (one prisoner per 2 tiles)
    pub fn prison_space(&self) -> usize {
        let cap = self.counts[5] / 2 + self.counts[crate::rooms::ROOM_PRISON];
        let used = self.ents.iter().filter(|e| e.alive && e.hero && e.captive != 0).count();
        cap.saturating_sub(used)
    }

    pub(crate) fn kill(&mut self, j: usize) {
        self.boss_loot(j);
        if self.try_tame(j) {
            return;
        }
        let e = &self.ents[j];
        if e.hero && e.captive == 0 && self.prison_space() > 0 {
            // knocked out instead of killed: imps carry the hero to the torture chamber
            let (kind, x, y) = (e.kind, e.x, e.y);
            let id = e.id;
            self.release_all(id);
            let e = &mut self.ents[j];
            e.captive = 1;
            e.hp = 1.0;
            e.carrier = 0;
            e.torture_t = 0.0;
            e.job = Job::None;
            e.path.clear();
            e.guard = false;
            e.home = None;
            e.patrol.clear();
            let b = st(kind).bounty as f32;
            let got = self.add_gold(b);
            self.count_local(crate::stats::HEROES);
            self.count_local(crate::stats::CAPTURED);
            self.fx(5, x, y, 0.0, 0.0, 1.0, 0xff30d0ff);
            self.sfx(Sfx::Capture, x, y);
            self.msg("msg.hero_captured", vec![format!("@{}", st(kind).name), (got as i32).to_string()]);
            return;
        }
        let e = &mut self.ents[j];
        e.alive = false;
        let (id, kind, hero, x, y, side) = (e.id, e.kind, e.hero, e.x, e.y, e.side);
        // prisoners carried by this unit are dropped
        for o in self.ents.iter_mut() {
            if o.captive == 2 && o.carrier == id {
                o.captive = 1;
                o.carrier = 0;
            }
        }
        self.release_all(id);
        // a named creature of some standing gets a memorial stone
        let dead = self.ents[j].clone();
        let remembered = self.raise_memorial(&dead);
        self.fx(3, x, y, 0.0, 0.0, 0.7, 0xff505070);
        if kind != EK::Worker && kind != EK::Revenant {
            self.bury(x, y);
        }
        let s = st(kind);
        if hero {
            self.count_local(crate::stats::HEROES);
        } else if side == self.local_side && !e_is_dwarf_side(side) {
            let me = self.me_side;
            let local = self.local_side;
            self.switch_to(local);
            self.count(crate::stats::LOST, 1.0);
            self.switch_to(me);
        }
        if hero {
            let b = s.bounty as f32 + if kind == EK::Thief { self.thief_loot(id) } else { 0.0 };
            self.add_master_xp(s.bounty as f32 * crate::talents::HERO_XP);
            let got = self.add_gold(b);
            self.fx(5, x, y, 0.0, 0.0, 1.0, 0xff30d0ff);
            self.sfx(Sfx::HeroDeath, x, y);
            self.msg("msg.hero_slain", vec![format!("@{}", s.name), (got as i32).to_string()]);
        } else if side == crate::dwarves::DWARF_SIDE {
            let got = self.add_gold(s.bounty as f32 * 0.5);
            self.sfx(Sfx::HeroDeath, x, y);
            self.msg("msg.dwarf_slain", vec![(got as i32).to_string()]);
        } else if side >= 2 {
            // a creature of a rival master: half its wage as booty
            let got = self.add_gold(s.wage as f32 * 0.5);
            self.sfx(Sfx::HeroDeath, x, y);
            self.msg("msg.rival_unit_slain", vec![format!("@{}", s.name), (got as i32).to_string()]);
        } else {
            self.sfx(Sfx::Death, x, y);
            if !remembered {
                self.msg("msg.creature_died", vec![crate::names::arg(&dead)]);
            }
        }
    }

    // falls into lava: dies at once (no capture), heroes still pay their bounty
    pub fn burn(&mut self, j: usize) {
        let e = &mut self.ents[j];
        if !e.alive {
            return;
        }
        e.alive = false;
        e.held = false;
        let (id, kind, hero, x, y) = (e.id, e.kind, e.hero, e.x, e.y);
        for o in self.ents.iter_mut() {
            if o.captive == 2 && o.carrier == id {
                o.captive = 1;
                o.carrier = 0;
            }
        }
        self.release_all(id);
        self.hand.retain(|&h| h != id);
        // a named creature lost in lava or water is remembered too
        if !hero {
            let mut dead = self.ents[j].clone();
            let lava = self.map.get(x as i32, y as i32).map_or(false, |t| t.river() == Some(Kind::Lava));
            dead.bane = if lava { crate::names::BANE_LAVA } else { crate::names::BANE_WATER };
            self.raise_memorial(&dead);
        }
        self.fx(3, x, y, 0.0, 0.0, 1.0, 0xff2060ff);
        self.fx(2, x, y, 0.0, 0.0, 0.5, 0xff30a0ff);
        self.sfx(Sfx::Death, x, y);
        let s = st(kind);
        if hero {
            let got = self.add_gold(s.bounty as f32);
            self.msg("msg.hero_burned", vec![format!("@{}", s.name), (got as i32).to_string()]);
        } else {
            self.msg("msg.creature_burned", vec![format!("@{}", s.name)]);
        }
    }

    // pushes a unit; into lava = burnt, never into water or walls
    pub fn knock(&mut self, j: usize, dx: f32, dy: f32) {
        let e = &self.ents[j];
        let (nx, ny) = (e.x + dx, e.y + dy);
        let Some(t) = self.map.get(nx as i32, ny as i32).copied() else { return };
        if flies(self.ents[j].kind) {
            if t.walkable() || t.liquid() {
                let e = &mut self.ents[j];
                e.x = nx;
                e.y = ny;
                e.path.clear();
            }
            return;
        }
        if t.kind == Kind::Lava {
            let e = &mut self.ents[j];
            e.x = nx;
            e.y = ny;
            self.burn(j);
        } else if t.walkable() {
            let e = &mut self.ents[j];
            e.x = nx;
            e.y = ny;
            e.path.clear();
        }
    }

    // the ground of tile i turned into river (bridge removed): units on it fall in
    pub(crate) fn ground_lost(&mut self, i: usize) {
        let lava = self.map.t[i].river() == Some(Kind::Lava);
        let (x, y) = xy(i);
        for j in 0..self.ents.len() {
            let e = &self.ents[j];
            if !e.alive || e.held || e.tile() != i || flies(e.kind) {
                continue;
            }
            if e.hero {
                self.count_local(crate::stats::DROWNED);
            }
            if lava {
                self.burn(j);
                continue;
            }
            // water: swim to the nearest bank, otherwise drown
            let bank = DIR8.iter().map(|&(dx, dy)| (x + dx, y + dy)).find(|&(bx, by)| self.map.walk(bx, by));
            match bank {
                Some((bx, by)) => {
                    let e = &mut self.ents[j];
                    e.x = bx as f32 + 0.5;
                    e.y = by as f32 + 0.5;
                    e.path.clear();
                }
                None => self.burn(j),
            }
        }
    }

    // Bridges grow from own ground into the river: every pass adds the river tiles of the
    // rectangle that touch own walkable ground (including bridges built in the pass before)
    // Earth walls next to own ground become steel walls
    pub fn build_steel(&mut self, x0: i32, y0: i32, x1: i32, y1: i32) {
        let (mut built, mut broke) = (0, false);
        for y in y0.min(y1)..=y0.max(y1) {
            for x in x0.min(x1)..=x0.max(x1) {
                if !inb(x, y) {
                    continue;
                }
                let t = self.map.t[idx(x, y)];
                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 == self.me && n.walkable()));
                if !own {
                    continue;
                }
                let cost = STEEL_COST[t.reinforced as usize] as f32;
                if self.gold < cost {
                    broke = true;
                    continue;
                }
                self.gold -= cost;
                let tl = &mut self.map.t[idx(x, y)];
                tl.kind = Kind::Steel;
                tl.reinforced = true;
                tl.marked = false;
                tl.hp = STEEL_HP;
                built += 1;
                self.fx(8, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.5, 0xffd0d0d0);
                if built == 1 {
                    self.sfx(Sfx::Reinforce, x as f32 + 0.5, y as f32 + 0.5);
                }
            }
        }
        if broke {
            self.msg("msg.no_gold", vec![]);
            self.sfx_ui(Sfx::Error);
        } else if built == 0 {
            self.hint(23, "hint.steel_where");
        }
    }

    pub fn build_bridges(&mut self, x0: i32, y0: i32, x1: i32, y1: i32) {
        self.build_bridges_of(x0, y0, x1, y1, false);
    }

    pub fn build_bridges_of(&mut self, x0: i32, y0: i32, x1: i32, y1: i32, draw: bool) {
        let (mut built, mut broke, mut any_river, mut no_wood) = (0, false, false, false);
        loop {
            let mut add = Vec::new();
            for y in y0.min(y1)..=y0.max(y1) {
                for x in x0.min(x1)..=x0.max(x1) {
                    if !inb(x, y) || !self.map.t[idx(x, y)].liquid() {
                        continue;
                    }
                    any_river = true;
                    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));
                    }
                }
            }
            if add.is_empty() {
                break;
            }
            let mut progress = false;
            for i in add {
                let lava = self.map.t[i].kind == Kind::Lava;
                let cost = if draw { DRAWBRIDGE_COST[lava as usize] } else { BRIDGE_COST[lava as usize] } as f32;
                // wooden bridges also cost wood
                let wood = if lava { 0.0 } else if draw { crate::wood::DRAWBRIDGE_WOOD } else { crate::wood::BRIDGE_WOOD };
                if self.gold < cost {
                    broke = true;
                    continue;
                }
                if self.wood + 1e-3 < wood {
                    no_wood = true;
                    continue;
                }
                self.gold -= cost;
                self.wood -= wood;
                let t = &mut self.map.t[i];
                t.kind = if draw {
                    Kind::Drawbridge
                } else if lava {
                    Kind::LavaBridge
                } else {
                    Kind::Bridge
                };
                t.res = if draw && lava { DB_LAVA } else { 0 };
                t.owner = self.me;
                built += 1;
                progress = true;
                let (x, y) = xy(i);
                self.fx(8, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.5, 0xff40d0ff);
                if built == 1 {
                    self.sfx(Sfx::Build, x as f32 + 0.5, y as f32 + 0.5);
                }
            }
            if !progress {
                break;
            }
        }
        if broke {
            self.msg("msg.no_gold", vec![]);
            self.sfx_ui(Sfx::Error);
        } else if no_wood {
            self.msg("msg.no_wood", vec![]);
            self.sfx_ui(Sfx::Error);
        } else if built == 0 {
            self.hint(21, if any_river { "hint.bridge_where" } else { "hint.bridge_river" });
        }
    }

    // An earth corner between two reinforced walls (and diagonal to own floor) cannot be
    // reached by the imps: it is reinforced together with the walls. The floor condition keeps
    // this from spreading into the earth behind the walls.
    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 == self.me && n.walkable());
        let mut add = Vec::new();
        for y in 1..h - 1 {
            for x in 1..w - 1 {
                let t = &self.map.t[idx(x, y)];
                if t.kind != Kind::Earth || t.reinforced || t.marked || t.owner == Owner::Hero {
                    continue;
                }
                for (ax, by) in [(1, 1), (1, -1), (-1, 1), (-1, -1)] {
                    if wall(&self.map, x + ax, y) && wall(&self.map, x, y + by) && floor(&self.map, x + ax, y + by) {
                        add.push(idx(x, y));
                        break;
                    }
                }
            }
        }
        for i in add {
            let t = &mut self.map.t[i];
            t.reinforced = true;
            t.hp = t.hp.max(12.0);
            let (x, y) = xy(i);
            self.fx(8, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.5, 0xff4040e0);
        }
    }

    // tiles within two of a fighting hero
    fn update_contested(&mut self) {
        let n = self.map.t.len();
        if self.contested.len() != n {
            self.contested = vec![false; n];
        } else {
            self.contested.iter_mut().for_each(|c| *c = false);
        }
        for e in &self.ents {
            // any enemy of the player (heroes and the rivals' units) keeps ground from being claimed.
            // In co-op matches, allied master sides do not block the player's own ground claims.
            if !e.alive || e.held || e.captive != 0 || e.side() == 0 || (self.coop && Owner::MASTER_SIDES.contains(&e.side())) || self.allied(0, e.side()) {
                continue;
            }
            let (x, y) = (e.x as i32, e.y as i32);
            for dy in -2..=2 {
                for dx in -2..=2 {
                    if inb(x + dx, y + dy) {
                        self.contested[idx(x + dx, y + dy)] = true;
                    }
                }
            }
        }
    }

    // a knight tile was claimed: vaults hand over their treasure, shards come back
    fn take_knight_tile(&mut self, i: usize) {
        let t = self.map.t[i];
        let (x, y) = (xy(i).0 as f32 + 0.5, xy(i).1 as f32 + 0.5);
        if t.kind == Kind::Treasury && t.gold > 0 {
            // the content stays in the (now own) treasury tile and counts as own gold
            self.gold += t.gold as f32;
            self.loot += t.gold as f32;
            self.fx(5, x, y, 0.0, 0.0, 1.0, 0xff30d0ff);
            self.sfx(Sfx::Payday, x, y);
            self.msg("msg.vault_taken", vec![t.gold.to_string()]);
        }
        if t.kind == Kind::ManaSpring {
            self.fx(7, x, y, 0.0, 0.0, 1.2, 0xffffe060);
            self.sfx(Sfx::Magic, x, y);
            self.msg("msg.spring_taken", vec![]);
        }
        if t.kind == Kind::RuneChest {
            self.open_rune_chest(i);
        }
        if t.kind == Kind::Shard {
            self.shards_taken += 1;
            self.fx(7, x, y, 0.0, 0.0, 1.2, 0xff6060ff);
            self.sfx(Sfx::LevelUp, x, y);
            self.msg("msg.shard_taken", vec![]);
        }
    }

    // a dwarven chest: the plans of a rune forge tower (one free build)
    pub fn open_rune_chest(&mut self, i: usize) {
        let (x, y) = (xy(i).0 as f32 + 0.5, xy(i).1 as f32 + 0.5);
        self.map.t[i].kind = Kind::Floor;
        self.rune_free += 1;
        self.fx(7, x, y, 0.0, 0.0, 1.4, 0xff40c0ff);
        self.sfx(Sfx::LevelUp, x, y);
        self.msg("msg.rune_chest", vec![]);
    }

    // a fortress unit spotted an enemy: guards and patrols nearby join the fight
    fn alarm(&mut self, x: f32, y: f32, target: u32) {
        for o in self.ents.iter_mut() {
            if !o.alive || o.held || !o.active_hero() || !(o.guard || !o.patrol.is_empty()) {
                continue;
            }
            if matches!(o.job, Job::Attack(_)) || (o.x - x).powi(2) + (o.y - y).powi(2) > 13.0 * 13.0 {
                continue;
            }
            o.job = Job::Attack(target);
            o.path.clear();
            o.repath = 0.0;
        }
    }

    // fortress units: a bridge of the player near the post (None if none)
    fn bridge_to_tear(&self, e: &Ent) -> Option<usize> {
        let (hx, hy) = e.home.unwrap_or((e.x, e.y));
        let (cx, cy) = (hx as i32, hy as i32);
        for r in 0..=9i32 {
            for dy in -r..=r {
                for dx in -r..=r {
                    if dx.abs() != r && dy.abs() != r {
                        continue;
                    }
                    if let Some(t) = self.map.get(cx + dx, cy + dy) {
                        if t.bridge() && !t.raised() && t.owner == self.me {
                            return Some(idx(cx + dx, cy + dy));
                        }
                    }
                }
            }
        }
        None
    }

    // 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.raised() || t.owner != self.me {
            return false;
        }
        let (bx, by) = xy(i);
        let cur = e.tile();
        let (cx, cy) = xy(cur);
        if (cx - bx).abs() + (cy - by).abs() == 1 {
            e.path.clear();
            e.working = true;
            e.face = sgn(bx as f32 + 0.5 - e.x);
            // the bridge wears down step by step; imps can mend it while it stands
            e.timer += dt;
            if e.timer >= 1.0 {
                e.timer -= 1.0;
                self.sfx(Sfx::MeleeHit, bx as f32 + 0.5, by as f32 + 0.5);
                self.fx(2, bx as f32 + 0.5, by as f32 + 0.5, 0.0, 0.0, 0.2, 0xff3a5a7a);
            }
            return self.wear_bridge(i, dt);
        }
        if e.path.is_empty() && e.repath <= 0.0 {
            e.repath = 1.5;
            e.timer = 0.0;
            match self.map.search(cur, self.map.walk_cost(), |j| j != i && adj4(i, j), true) {
                Some(p) => e.path = p,
                None => return false,
            }
        }
        self.step_path(e, dt);
        true
    }

    // ---------------------------------------------------------------- pit imps (workers)

    // a neighbour of tile i that this imp may dig: marked by its own master (side)
    fn dig_neighbor(&self, i: usize, me: u32, side: u8) -> Option<usize> {
        let (x, y) = xy(i);
        let mut found = None;
        for &(dx, dy) in &DIR4 {
            if let Some(t) = self.map.get(x + dx, y + dy) {
                if t.marked && t.mark_by == side && t.diggable() {
                    if t.reserved == me {
                        return Some(idx(x + dx, y + dy));
                    }
                    if t.reserved == 0 && found.is_none() {
                        found = Some(idx(x + dx, y + dy));
                    }
                }
            }
        }
        found
    }

    // a damaged tower next to walkable tile i
    fn damaged_tower_near(&self, i: usize) -> Option<u32> {
        let (x, y) = xy(i);
        self.towers.iter().find(|t| {
            let (tx, ty) = xy(t.tile);
            !t.hero && (tx - x).abs() <= 1 && (ty - y).abs() <= 1 && t.hp < t.max_hp() - 1.0
        }).map(|t| t.id)
    }

    // 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 != self.me {
            return None;
        }
        let (x, y) = xy(i);
        for &(dx, dy) in &DIR4 {
            if let Some(t) = self.map.get(x + dx, y + dy) {
                if t.kind == Kind::Earth && !t.reinforced && !t.marked && (t.reserved == 0 || t.reserved == me) {
                    return Some(idx(x + dx, y + dy));
                }
            }
        }
        None
    }

    pub(crate) fn claimable(&self, i: usize, me: u32) -> bool {
        let t = &self.map.t[i];
        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 if t.owner != Owner::Hero && self.allied(self.me_side, t.owner.side()) {
            false // an ally's ground is never taken
        } else {
            // knight and enemy 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;
        }
        if t.reserved != 0 && t.reserved != me {
            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 == self.me))
    }

    fn is_deposit(&self, i: usize) -> bool {
        let t = &self.map.t[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 {
        let cur = e.tile();
        if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.is_deposit(i), true) {
            e.path = p;
            e.job = Job::Deliver;
            return true;
        }
        false
    }

    // flying creatures patrol far around (also over rivers and the land of the enemy)
    fn patrol_flight(&mut self, e: &mut Ent) {
        let (x, y) = xy(e.tile());
        for _ in 0..8 {
            let nx = x + self.rng.range(-14, 14);
            let ny = y + self.rng.range(-14, 14);
            let ok = self.map.get(nx, ny).map_or(false, |t| t.walkable() || t.liquid());
            if ok {
                if let Some(p) = self.map.fly_path_to(e.tile(), idx(nx, ny)) {
                    if p.len() <= 40 {
                        e.path = p;
                        break;
                    }
                }
            }
        }
        e.job = Job::Wander;
        e.timer = 2.0 + self.rng.f() * 3.0;
    }

    // badly hurt creatures flee to their bed (lair, flyers: aerie), or else next to the soul
    // core, and rest there until they are healed to 75%
    fn start_rest(&mut self, e: &mut Ent) -> bool {
        let cur = e.tile();
        let fly = flies(e.kind);
        let bed_kind = if fly { Kind::Aerie } else { Kind::Lair };
        let me = self.me;
        let target = e
            .bed
            .filter(|&b| self.map.t[b].kind == bed_kind && self.map.t[b].owner == me)
            .or_else(|| self.map.search(cur, self.map.creature_cost(fly), |i| self.map.t[i].kind == bed_kind && self.map.t[i].owner == me, true).map(|p| p.last().copied().unwrap_or(cur)))
            .or_else(|| self.map.search(cur, self.map.creature_cost(fly), |i| self.map.adj_core_of(i, me), true).map(|p| p.last().copied().unwrap_or(cur)));
        let Some(b) = target else { return false };
        e.path = self.map.creature_path(fly, cur, b).unwrap_or_default();
        e.job = Job::Rest(b);
        true
    }

    fn wander(&mut self, e: &mut Ent, radius: i32) {
        let (x, y) = xy(e.tile());
        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 == 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;
                        break;
                    }
                }
            }
        }
        e.job = Job::Wander;
        e.timer = 1.0 + self.rng.f() * 2.0;
    }

    fn worker_ai(&mut self, e: &mut Ent, dt: f32) {
        if self.step_path(e, dt) {
            return;
        }
        let me = e.id + 1;
        let cur = e.tile();
        match e.job {
            Job::Dig(t) => {
                let tile = self.map.t[t];
                if !tile.marked || tile.mark_by != e.side || !tile.diggable() || !adj4(cur, t) {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                // an imp carries one kind of treasure: other loads are delivered first
                if tile.vein().map_or(false, |r| e.carry > 0 && r != e.carry_res) {
                    self.unreserve(me);
                    e.job = Job::None;
                    self.start_deliver(e);
                    return;
                }
                let (tx, ty) = xy(t);
                e.face = sgn(tx as f32 + 0.5 - e.x);
                e.working = true;
                let skilled = if crate::personality::knows(e, "dig") { 1.25 } else { 1.0 };
                e.timer += dt * self.help_speed(t) * skilled * self.talents.dig_speed();
                if e.timer >= 0.45 {
                    e.timer = 0.0;
                    let fxx = (e.x + tx as f32 + 0.5) * 0.5;
                    let fxy = (e.y + ty as f32 + 0.5) * 0.5;
                    let tl = &mut self.map.t[t];
                    let done;
                    if let Some(res) = tl.vein() {
                        let take = tl.gold.min(RES_STRIKE[res as usize]);
                        tl.gold -= take;
                        e.carry += take;
                        e.carry_res = res;
                        done = tl.gold <= 0;
                        self.fx(5, fxx, fxy, 0.0, 0.0, 0.5, 0xff30d0ff);
                        self.sfx(Sfx::GoldDig, fxx, fxy);
                    } else {
                        tl.hp -= 1.0;
                        done = tl.hp <= 0.0;
                        self.fx(6, fxx, fxy, 0.0, 0.0, 0.4, 0xff3a5a7a);
                        self.sfx(Sfx::Dig, fxx, fxy);
                    }
                    if done {
                        if self.map.t[t].plant() {
                            self.felled(t);
                        }
                        self.dig_out(t);
                        e.job = Job::None;
                    }
                    if e.carry >= CARRY_MAX {
                        self.unreserve(me);
                        e.job = Job::None;
                        self.start_deliver(e);
                    }
                }
            }
            Job::Carry(id) => {
                self.carry_job(e, id, dt);
            }
            Job::Install(id) => {
                self.install_job(e, id, dt);
            }
            Job::Repair(id) => {
                let Some(k) = self.towers.iter().position(|t| t.id == id) else {
                    e.job = Job::None;
                    return;
                };
                let (tx, ty) = self.towers[k].pos();
                if (tx - e.x).abs() > 1.6 || (ty - e.y).abs() > 1.6 {
                    e.job = Job::None;
                    return;
                }
                e.face = sgn(tx - e.x);
                e.working = true;
                let t = &mut self.towers[k];
                t.hp = (t.hp + 30.0 * dt).min(t.max_hp());
                if t.hp >= t.max_hp() {
                    e.job = Job::None;
                }
                if (e.anim * 3.0).fract() < dt * 3.0 {
                    self.sfx(Sfx::Reinforce, tx, ty);
                }
            }
            Job::RaiseWall(w) => {
                if !self.raise_wall_job(e, w, dt) {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::MendBridge(b) => {
                let (bx, by) = xy(b);
                let (tx, ty) = (bx as f32 + 0.5, by as f32 + 0.5);
                if (tx - e.x).abs() > 1.6 || (ty - e.y).abs() > 1.6 || self.burning(b) {
                    e.job = Job::None;
                    return;
                }
                e.face = sgn(tx - e.x);
                e.working = true;
                if !self.mend_bridge(b, dt) {
                    e.job = Job::None;
                }
                if (e.anim * 3.0).fract() < dt * 3.0 {
                    self.sfx(Sfx::Reinforce, tx, ty);
                }
            }
            Job::Help(t) => {
                // the task is done or nobody works on it any more: back to thinking
                if self.task_worker(t).is_none() || self.helpers(t) > HELPERS_MAX {
                    e.job = Job::None;
                    e.think = 0.2;
                    return;
                }
                let (tx, _) = xy(t);
                e.face = sgn(tx as f32 + 0.5 - e.x);
                e.working = true;
                if e.think <= 0.0 {
                    // every 1.5 s: is there own work again? (if not, the imp comes back to help)
                    e.job = Job::None;
                }
            }
            Job::Reinforce(w) => {
                let t = self.map.t[w];
                if !adj4(cur, w) || t.kind != Kind::Earth || t.reinforced || t.marked {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                let (wx, wy) = xy(w);
                e.face = sgn(wx as f32 + 0.5 - e.x);
                e.working = true;
                e.timer += dt * self.help_speed(w);
                if e.timer >= 2.5 {
                    self.unreserve(me);
                    e.job = Job::None;
                    let tl = &mut self.map.t[w];
                    tl.reinforced = true;
                    tl.hp = 12.0; // the player's imps need twice as long to dig it out again
                    self.fx(8, wx as f32 + 0.5, wy as f32 + 0.5, 0.0, 0.0, 0.5, 0xff4040e0);
                    self.sfx(Sfx::Reinforce, wx as f32 + 0.5, wy as f32 + 0.5);
                }
            }
            Job::Claim(t) => {
                if cur != t || !self.claimable(t, me) {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                e.timer += dt * self.help_speed(t);
                // knight ground takes longer
                let prev = self.map.t[t].owner;
                let knight = prev == Owner::Hero;
                if e.timer >= if prev != Owner::None { 3.0 } else { 1.0 } {
                    self.unreserve(me);
                    e.job = Job::None;
                    let (tx, ty) = xy(t);
                    if knight {
                        self.alarm(tx as f32 + 0.5, ty as f32 + 0.5, e.id);
                    }
                    // vaults, shards and springs (of the knights, rivals or nobody)
                    self.take_knight_tile(t);
                    if let (Kind::Portal, Some(pk)) = (self.map.t[t].kind, self.map.portal_at(tx, ty)) {
                        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 = 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 = self.me;
                    }
                    self.place_torches(t);
                    let (x, y) = xy(t);
                    self.fx(8, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.5, 0xff4040e0);
                    self.sfx(Sfx::Claim, x as f32 + 0.5, y as f32 + 0.5);
                }
            }
            Job::Deliver => {
                if self.is_deposit(cur) {
                    let amount = e.carry as f32 * self.talents.treasure();
                    let got = self.add_res_at(amount, e.carry_res, Some(cur));
                    if got < amount {
                        self.hint(3, "hint.treasury_full");
                    }
                    if got > 0.0 {
                        self.fx(5, e.x, e.y, 0.0, 0.0, 0.8, 0xff30d0ff);
                        self.sfx(Sfx::Deposit, e.x, e.y);
                    }
                    e.carry = 0;
                    e.job = Job::None;
                } else if !self.start_deliver(e) {
                    e.job = Job::None;
                    e.think = 1.0;
                }
            }
            Job::Wander => {
                e.timer -= dt;
                if e.timer <= 0.0 {
                    e.job = Job::None;
                }
            }
            Job::None => {
                if e.think > 0.0 {
                    return;
                }
                e.think = 0.3 + self.rng.f() * 0.2;
                e.timer = 0.0;
                if e.carry >= CARRY_MAX && self.start_deliver(e) {
                    return;
                }
                // prisoners lying around are carried to the torture chamber first
                let lying = self.ents.iter().any(|o| o.alive && o.captive == 1 && o.carrier == 0);
                if lying && self.map.t.iter().any(|t| t.kind == Kind::Torture && t.bed == 0) {
                    if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.captive_near(i).is_some(), true) {
                        let end = p.last().copied().unwrap_or(cur);
                        if let Some(id) = self.captive_near(end) {
                            if let Some(k) = self.find(id) {
                                self.ents[k].carrier = e.id;
                            }
                            e.path = p;
                            e.job = Job::Carry(id);
                            return;
                        }
                    }
                }
                // at least 10% of the imps (at least one) claim floor while there is floor to claim
                let imps = 1 + self.ents.iter().filter(|o| o.alive && !o.hero && o.kind == EK::Worker).count();
                let claiming = self.ents.iter().filter(|o| o.alive && !o.hero && o.kind == EK::Worker && matches!(o.job, Job::Claim(_))).count();
                let quota = ((imps as f32 * 0.1).ceil() as usize).max(1);
                if claiming < quota {
                    if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.claimable(i, me), true) {
                        let end = p.last().copied().unwrap_or(cur);
                        self.map.t[end].reserved = me;
                        e.path = p;
                        e.job = Job::Claim(end);
                        return;
                    }
                }
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.dig_neighbor(i, me, e.side).is_some(), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    if let Some(t) = self.dig_neighbor(end, me, e.side) {
                        self.map.t[t].reserved = me;
                        e.path = p;
                        e.job = Job::Dig(t);
                        return;
                    }
                }
                if e.carry > 0 && self.start_deliver(e) {
                    return;
                }
                // finished traps and doors are carried to their spots
                if let Some((id, p)) = self.crate_to_carry(cur) {
                    if let Some(k) = self.traps.iter().position(|t| t.id == id) {
                        self.traps[k].carrier = me;
                    }
                    e.path = p;
                    e.job = Job::Install(id);
                    e.timer = 0.0;
                    return;
                }
                // damaged towers are repaired (free of charge) before more ground is claimed
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.damaged_tower_near(i).is_some(), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    if let Some(id) = self.damaged_tower_near(end) {
                        e.path = p;
                        e.job = Job::Repair(id);
                        return;
                    }
                }
                // planned walls are raised
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.planned_wall_near(i, me).is_some(), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    if let Some(w) = self.planned_wall_near(end, me) {
                        self.map.t[w].reserved = me;
                        e.path = p;
                        e.job = Job::RaiseWall(w);
                        e.timer = 0.0;
                        return;
                    }
                }
                // ... and so are bridges the knights worked on
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.worn_bridge_near(i).is_some(), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    if let Some(b) = self.worn_bridge_near(end) {
                        e.path = p;
                        e.job = Job::MendBridge(b);
                        return;
                    }
                }
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.claimable(i, me), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    self.map.t[end].reserved = me;
                    e.path = p;
                    e.job = Job::Claim(end);
                    return;
                }
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.reinforce_neighbor(i, me).is_some(), true) {
                    let end = p.last().copied().unwrap_or(cur);
                    if let Some(w) = self.reinforce_neighbor(end, me) {
                        self.map.t[w].reserved = me;
                        e.path = p;
                        e.job = Job::Reinforce(w);
                        e.timer = 0.0;
                        return;
                    }
                }
                // nothing else to do: help another imp (up to five at one task)
                if self.start_help(e) {
                    return;
                }
                e.think = 1.0;
                self.wander(e, 3);
            }
            _ => e.job = Job::None,
        }
    }

    // ---------------------------------------------------------------- creatures

    fn find_room_tile(&self, e: &Ent, kind: Kind, me: u32, need_food: bool) -> Option<Vec<usize>> {
        self.map.search(
            e.tile(),
            self.map.creature_cost(flies(e.kind)),
            |i| {
                let t = &self.map.t[i];
                t.kind == kind && t.owner == self.me && (t.reserved == 0 || t.reserved == me) && (!need_food || t.food >= 1.0)
            },
            true,
        )
    }

    fn creature_ai(&mut self, e: &mut Ent, dt: f32) {
        if crate::siege::siege(e.kind) {
            // a siege engine has no needs: it only follows the attack flag
            e.hunger = 0.0;
            e.energy = 1.0;
            e.happy = 1.0;
            self.siege_ai(e, dt);
            return;
        }
        let me = e.id + 1;
        if e.kind == EK::Revenant {
            // the undead neither eat nor sleep
            e.hunger = 0.0;
            e.energy = 1.0;
        } else {
            e.hunger += dt / 75.0;
            if !matches!(e.job, Job::Sleep(_)) {
                e.energy -= dt / 110.0;
            }
        }
        if e.hunger > 1.8 {
            e.happy -= dt * 0.004;
        }
        if e.kind == EK::Priestess && e.skill_cd <= 0.0 {
            // flame priestess: heals the most hurt own creature nearby (or herself)
            let mut best: Option<usize> = None;
            let mut worst = if e.hp < e.max_hp * 0.8 { e.hp / e.max_hp } else { 0.8 };
            for (j, o) in self.ents.iter().enumerate() {
                if o.alive && !o.held && o.creature() && (o.x - e.x).powi(2) + (o.y - e.y).powi(2) < 4.5 * 4.5 && o.hp / o.max_hp < worst {
                    worst = o.hp / o.max_hp;
                    best = Some(j);
                }
            }
            if let Some(j) = best {
                let o = &mut self.ents[j];
                o.hp = (o.hp + 20.0).min(o.max_hp);
                let (ox, oy) = (o.x, o.y);
                self.fx(4, ox, oy, 0.0, 0.0, 0.8, 0xff60ff80);
                self.sfx(Sfx::Heal, ox, oy);
                e.skill_cd = 2.5;
            } else if e.hp < e.max_hp * 0.8 {
                e.hp = (e.hp + 20.0).min(e.max_hp);
                self.fx(4, e.x, e.y, 0.0, 0.0, 0.8, 0xff60ff80);
                e.skill_cd = 2.5;
            } else {
                e.skill_cd = 1.0;
            }
        }
        if e.think <= 0.0 {
            e.think = 0.4 + self.rng.f() * 0.3;
            // a new creature builds its own bed in the lair soon after its arrival
            let bed_kind = if flies(e.kind) { Kind::Aerie } else { Kind::Lair };
            let beds = if flies(e.kind) { self.counts[7] } else { self.counts[1] };
            if e.bed.is_none() && beds > 0 && !matches!(e.job, Job::Attack(_) | Job::Leave | Job::Rally | Job::March(_)) && self.rng.f() < 0.15 {
                let cur = e.tile();
                let free = |i: usize| self.map.t[i].kind == bed_kind && self.map.t[i].bed == 0 && self.map.t[i].owner == self.me;
                let found = if flies(e.kind) { self.map.search(cur, self.map.fly_cost(), free, true) } else { self.map.search(cur, self.map.walk_cost(), free, true) };
                if let Some(p) = found {
                    let b = p.last().copied().unwrap_or(cur);
                    self.map.t[b].bed = me;
                    e.bed = Some(b);
                    let (bx, by) = xy(b);
                    self.fx(8, bx as f32 + 0.5, by as f32 + 0.5, 0.0, 0.0, 0.6, 0xff40d0ff);
                }
            }
            // badly hurt creatures may flee before they die (not all of them, and not at once)
            // and come back at 75%
            if e.hp < e.max_hp * 0.25 && !matches!(e.job, Job::Rest(_) | Job::Leave) && self.rng.f() < 0.3 {
                self.unreserve(me);
                if self.start_rest(e) {
                    return;
                }
            }
            if !matches!(e.job, Job::Attack(_) | Job::Leave | Job::Rest(_) | Job::Brawl(_)) {
                let radius = if matches!(e.job, Job::Rally | Job::March(_)) { 8.5 } else if matches!(e.job, Job::Guard(_)) { 10.0 } else if flies(e.kind) { 9.0 } else { 7.0 };
                if let Some(id) = self.nearest_enemy(e, radius) {
                    self.unreserve(me);
                    e.job = Job::Attack(id);
                    e.path.clear();
                    e.repath = 0.0;
                } else if !matches!(e.job, Job::AttackTower(_) | Job::Sleep(_) | Job::Eat(_)) {
                    // knight towers in reach are torn down
                    if let Some(id) = self.enemy_tower_near(e.x, e.y, radius - 1.0) {
                        self.unreserve(me);
                        e.job = Job::AttackTower(id);
                        e.path.clear();
                        e.repath = 0.0;
                    }
                }
            }
        }
        if let Job::AttackTower(id) = e.job {
            if !self.attack_tower(e, id, dt) {
                e.job = Job::None;
                e.path.clear();
            }
            return;
        }
        // arrival: report at the portal and set up the bed before anything else
        if !e.settled {
            self.settle(e, dt);
            return;
        }
        // payday: the wage is fetched from a treasury
        if e.pay_due > 0.0 {
            e.pay_t -= dt;
            if e.pay_t <= 0.0 && !matches!(e.job, Job::FetchWage(_) | Job::Leave | Job::Rest(_)) {
                self.unreserve(me);
                self.start_fetch_wage(e);
                return;
            }
        }
        if let Job::FetchWage(t) = e.job {
            if self.step_path(e, dt) {
                return;
            }
            self.take_wage(e, Some(t));
            e.job = Job::None;
            return;
        }
        if let Job::Rest(b) = e.job {
            if self.step_path(e, dt) {
                return;
            }
            let (bx, by) = xy(b);
            let there = (e.x - bx as f32 - 0.5).abs() < 1.5 && (e.y - by as f32 - 0.5).abs() < 1.5;
            if !there {
                // pushed away on the way: go on, or give up if there is no way
                match self.map.creature_path(flies(e.kind), e.tile(), b) {
                    Some(p) if !p.is_empty() => e.path = p,
                    _ => e.job = Job::None,
                }
                return;
            }
            // resting heals: quickly in a bed room, slower next to the core; back to work at 75%
            let bed_room = matches!(self.map.t[b].kind, Kind::Lair | Kind::Aerie);
            let rest = if bed_room { self.room_bonus(self.map.t[b].kind) } else { 1.0 };
            e.hp = (e.hp + e.max_hp * dt * rest / if bed_room { 12.0 } else { 24.0 }).min(e.max_hp);
            e.energy = (e.energy + dt * rest / 14.0).min(1.0);
            if e.hp >= e.max_hp * 0.75 {
                e.job = Job::None;
            }
            return;
        }
        if e.kind == EK::Chainbreaker {
            // restless: without a fight for two minutes its mood sinks (skill_cd counts down as idle time)
            if matches!(e.job, Job::Attack(_)) {
                e.skill_cd = 0.0;
            } else if e.skill_cd < -120.0 {
                e.happy -= 0.005 * dt;
                self.hint(20, "hint.chainbreaker_restless");
            }
        }
        self.mood_check(e, dt);
        self.passive_abilities(e);
        if let Job::Brawl(id) = e.job {
            self.brawl(e, id, dt);
            return;
        }
        if let Job::Attack(id) = e.job {
            if !self.attack_job(e, id, dt) {
                e.job = Job::None;
                e.path.clear();
            }
            return;
        }
        if e.job == Job::Rally {
            self.rally(e, dt);
            return;
        }
        if let Job::March(f) = e.job {
            if self.attack_marks.contains(&f) {
                self.rally_to(e, f, dt);
            } else {
                e.job = Job::None;
                e.path.clear();
            }
            return;
        }
        if self.step_path(e, dt) {
            return;
        }
        let cur = e.tile();
        match e.job {
            Job::Sleep(_) => {
                e.energy += dt / 14.0;
                e.hp = (e.hp + e.max_hp * dt / 25.0).min(e.max_hp);
                if e.energy >= 1.0 {
                    e.energy = 1.0;
                    e.job = Job::None;
                }
            }
            Job::Eat(t) => {
                if cur != t {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                e.timer += dt;
                if e.timer >= 2.0 {
                    let tl = &mut self.map.t[t];
                    if tl.food >= 1.0 {
                        tl.food -= 1.0;
                        e.hunger = 0.0;
                        e.hp = (e.hp + e.max_hp * 0.2 * self.room_bonus(Kind::Temple)).min(e.max_hp);
                    }
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::Torment(id) => {
                // working on a prisoner: makes it more likely to change sides (see captive_update)
                let Some(k) = self.ents.iter().position(|o| o.id == id && o.alive && o.captive == 3) else {
                    e.job = Job::None;
                    return;
                };
                let px = self.ents[k].x;
                e.face = sgn(px - e.x);
                e.working = true;
                e.xp += 2.0 * dt;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    e.job = Job::None;
                }
            }
            Job::Train(t) => {
                // training is billed on payday; it stops when the bill would exceed the gold
                if cur != t || self.map.t[t].kind != Kind::Training || self.training_bill + 1.0 > self.gold {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                self.training_bill += TRAIN_COST * dt;
                e.xp += 7.0 * dt * self.room_bonus(Kind::Training);
                e.timer -= dt;
                if e.timer <= 0.0 {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            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 != self.me || e.timer <= 0.0 {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::Spar(t) => {
                if !self.spar(e, t, dt) {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::Forge(t) => {
                if cur != t || self.map.t[t].kind != Kind::Forge || !self.forge_orders() {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                let rate = if e.kind == EK::Cogling { 2.5 } else { 1.0 } * (1.0 + 0.1 * (e.level - 1) as f32);
                self.forge_work += rate * dt * self.room_bonus(Kind::Forge);
                e.xp += 2.5 * dt;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::Study(t) => {
                if cur != t || self.map.t[t].kind != Kind::Library {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                let rate = if e.kind == EK::Mage { 1.2 } else { 0.5 };
                self.mana = (self.mana + rate * 0.5 * dt).min(self.mana_max());
                // research: mages and owls are the scholars
                let points = match e.kind {
                    EK::Mage => 1.6,
                    EK::Owl => 1.3,
                    _ => 0.5,
                } * (1.0 + 0.12 * (e.level - 1) as f32);
                self.add_research(points * dt * self.room_bonus(Kind::Library));
                e.xp += 3.0 * dt;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::Pray(t) => {
                if cur != t || self.map.t[t].kind != Kind::Temple {
                    self.unreserve(me);
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                let rate = if e.kind == EK::Priestess { 1.6 } else { 0.9 };
                self.mana = (self.mana + rate * dt).min(self.mana_max());
                e.happy = (e.happy + 0.01 * dt).min(1.0);
                e.xp += 1.0 * dt;
                e.timer -= dt;
                if e.timer <= 0.0 {
                    self.unreserve(me);
                    e.job = Job::None;
                }
            }
            Job::HealCore => {
                if !self.map.adj_core(cur) || self.core_hp >= CORE_HP {
                    e.job = Job::None;
                    return;
                }
                e.working = true;
                let (cx, cy) = self.map.core;
                e.face = sgn(cx as f32 + 1.5 - e.x);
                self.core_hp = (self.core_hp + 8.0 * dt).min(CORE_HP);
                if (e.anim * 1.5).fract() < dt * 1.5 {
                    self.fx(4, cx as f32 + 1.5, cy as f32 + 1.5, 0.0, 0.0, 0.8, 0xff60ff80);
                }
            }
            Job::Wander => {
                e.timer -= dt;
                if e.timer <= 0.0 {
                    e.job = Job::None;
                }
            }
            Job::Leave => {
                if self.map.t[cur].kind == Kind::Portal {
                    e.alive = false;
                    self.release_all(e.id);
                    self.fx(3, e.x, e.y, 0.0, 0.0, 0.8, 0xffcc44ff);
                } else {
                    self.start_leave(e);
                }
            }
            Job::None => self.creature_choose(e),
            _ => e.job = Job::None,
        }
    }

    fn start_leave(&mut self, e: &mut Ent) {
        let cur = e.tile();
        e.job = Job::Leave;
        if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.map.t[i].kind == Kind::Portal, true) {
            e.path = p;
        } else {
            e.alive = false;
            self.release_all(e.id);
            self.fx(3, e.x, e.y, 0.0, 0.0, 0.8, 0xff505070);
        }
    }

    fn wants_rally(&self, e: &Ent) -> bool {
        self.flag.is_some() && e.hp > e.max_hp * 0.5 && e.energy > 0.15 && e.hunger < 1.8 && e.happy > 0.0
    }

    // Attack flag: march to the flag; if the gate is nearby, attack it.
    fn rally(&mut self, e: &mut Ent, dt: f32) {
        let Some(f) = self.flag else {
            e.job = Job::None;
            e.path.clear();
            return;
        };
        self.rally_to(e, f, dt);
    }

    // march to tile f and fight there (the attack flag, or an attack marker)
    pub(crate) fn rally_to(&mut self, e: &mut Ent, f: usize, dt: f32) {
        if e.hp < e.max_hp * 0.3 || e.energy < 0.1 || e.hunger > 2.2 {
            // exhausted or badly hurt: retreat
            e.job = Job::None;
            e.path.clear();
            return;
        }
        let (fx, fy) = xy(f);
        let (fx, fy) = (fx as f32 + 0.5, fy as f32 + 0.5);
        // the flag next to a rival master's core: attack the core
        let rival_near = self.rivals.iter().filter(|r| r.alive && !self.allied(e.side(), r.side)).find(|r| {
            let (cx, cy) = r.centre();
            (fx - cx).powi(2) + (fy - cy).powi(2) <= 8.0 * 8.0
        });
        // in a match the heart of an enemy master counts as well
        let master_near = self.enemy_master_near(e.side(), fx, fy);
        if let Some(side) = rival_near.map(|r| r.side).or(master_near) {
            e.target = Some(side);
            if self.march_on(e, dt) {
                return;
            }
        }
        let (gx, gy) = self.gate_center();
        let gate_near = self.gate_hp > 0.0 && (fx - gx).powi(2) + (fy - gy).powi(2) <= 8.0 * 8.0;
        let s = st(e.kind);
        if gate_near {
            let dg = ((e.x - gx).powi(2) + (e.y - gy).powi(2)).sqrt();
            if dg <= s.range + 1.6 && (s.range < 1.5 || self.los(e.x, e.y, gx, gy)) {
                e.path.clear();
                e.face = sgn(gx - e.x);
                e.working = true;
                if e.cd <= 0.0 {
                    self.hit_gate(e);
                }
                return;
            }
        }
        let (target, tx, ty, near) = if gate_near {
            (idx(gx as i32, gy as i32), gx, gy, s.range + 1.2)
        } else {
            (f, fx, fy, 1.5)
        };
        let d = ((e.x - tx).powi(2) + (e.y - ty).powi(2)).sqrt();
        if d <= near && e.path.is_empty() {
            return; // wait at the flag
        }
        if e.path.is_empty() || e.repath <= 0.0 {
            e.repath = 1.5;
            let p = if flies(e.kind) { self.map.fly_path_to(e.tile(), target) } else { self.map.path_to(e.tile(), target) };
            match p {
                Some(p) => e.path = p,
                None => {
                    self.hint(11, "hint.flag_unreachable");
                    e.job = Job::Wander;
                    e.timer = 3.0;
                    return;
                }
            }
        }
        self.step_path(e, dt);
    }

    pub fn set_flag(&mut self, x: i32, y: i32) {
        if !inb(x, y) {
            return;
        }
        let i = idx(x, y);
        if self.flag == Some(i) {
            self.flag = None;
            self.msg("msg.flag_removed", vec![]);
            self.sfx_ui(Sfx::Click);
            for e in self.ents.iter_mut() {
                if e.alive && e.creature() && e.job == Job::Rally {
                    e.job = Job::None;
                    e.path.clear();
                }
            }
            return;
        }
        if !self.map.t[i].walkable() {
            self.hint(12, "hint.flag_ground");
            self.sfx_ui(Sfx::Error);
            return;
        }
        self.flag = Some(i);
        self.sfx(Sfx::FlagSet, x as f32 + 0.5, y as f32 + 0.5);
        self.msg("msg.flag_set", vec![]);
        let mut ids = Vec::new();
        for e in self.ents.iter() {
            if e.alive && !e.held && e.creature() && matches!(e.job, Job::None | Job::Wander | Job::Train(_) | Job::Study(_) | Job::Rally) {
                ids.push(e.id);
            }
        }
        for id in ids {
            self.unreserve(id + 1);
            if let Some(e) = self.ents.iter_mut().find(|e| e.id == id) {
                e.job = Job::None;
                e.path.clear();
            }
        }
    }

    pub fn add_mark(&mut self, x: f32, y: f32, kind: u8, side: u8, duration: f32, fixed: bool) {
        // the shields, swords and the flag show themselves; these markers are for debugging only
        let _ = fixed;
        if !self.debug_markers || duration <= 0.0 || !x.is_finite() || !y.is_finite() {
            return;
        }
        let until = self.sim_steps + (duration / STEP).ceil() as u64;
        if let Some(m) = self.marks.iter_mut().find(|m| (m.x - x).abs() < 0.75 && (m.y - y).abs() < 0.75 && m.kind == kind && m.side == side && m.fixed == fixed) {
            m.until = m.until.max(until);
            return;
        }
        if self.marks.len() >= 80 {
            self.marks.remove(0);
        }
        self.marks.push(Mark { x, y, kind, side, until, fixed });
    }

    fn creature_choose(&mut self, e: &mut Ent) {
        let me = e.id + 1;
        let cur = e.tile();
        let name = st(e.kind).name;
        if e.happy <= 0.0 {
            self.msg("msg.creature_leaves", vec![format!("@{}", name)]);
            self.start_leave(e);
            return;
        }
        if e.energy < 0.25 {
            // flying creatures sleep in the aerie
            let bed_kind = if flies(e.kind) { Kind::Aerie } else { Kind::Lair };
            if let Some(b) = e.bed {
                let t = &self.map.t[b];
                // a bed in somebody else's lair (an ally's, or ground that changed hands) is given up
                if t.kind != bed_kind || t.bed != me || t.owner != self.me {
                    if t.bed == me {
                        self.map.t[b].bed = 0;
                    }
                    e.bed = None;
                }
            }
            if e.bed.is_none() {
                let free = |i: usize| {
                    let t = &self.map.t[i];
                    t.kind == bed_kind && t.bed == 0 && t.owner == self.me
                };
                let found = if flies(e.kind) { self.map.search(cur, self.map.fly_cost(), free, true) } else { self.map.search(cur, self.map.walk_cost(), free, true) };
                if let Some(p) = found {
                    let b = p.last().copied().unwrap_or(cur);
                    self.map.t[b].bed = me;
                    e.bed = Some(b);
                }
            }
            if let Some(b) = e.bed {
                let way = if flies(e.kind) { self.map.fly_path_to(cur, b) } else { self.map.path_to(cur, b) };
                if let Some(p) = way {
                    e.path = p;
                    e.job = Job::Sleep(b);
                    return;
                }
            }
            e.happy -= 0.1;
            self.hint(4, "hint.no_beds");
            e.job = Job::Sleep(cur);
            return;
        }
        if e.hunger > 1.0 && !(self.flag.is_some() && e.hunger < 1.5) {
            if let Some(p) = self.find_room_tile(e, Kind::Farm, me, true) {
                let t = p.last().copied().unwrap_or(cur);
                self.map.t[t].reserved = me;
                e.path = p;
                e.job = Job::Eat(t);
                e.timer = 0.0;
                return;
            }
            if e.hunger > 1.8 {
                self.hint(5, "hint.hungry");
            }
        }
        if self.wants_rally(e) {
            e.job = Job::Rally;
            e.path.clear();
            e.repath = 0.0;
            return;
        }
        if e.hp < e.max_hp * 0.5 && e.energy >= 0.25 && self.counts[1] > 0 {
            // hurt: rest in the lair
            e.energy = e.energy.min(0.2);
            self.creature_choose(e);
            return;
        }
        if e.kind == EK::Priestess && self.core_hp < CORE_HP * 0.9 && self.nearest_enemy(e, 8.0).is_none() {
            if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.map.adj_core(i), true) {
                e.path = p;
                e.job = Job::HealCore;
                return;
            }
        }
        if self.counts[6] > 0 {
            let r2 = self.rng.f();
            if r2 < 0.3 || (e.kind == EK::Priestess && r2 < 0.7) {
                if let Some(p) = self.find_room_tile(e, Kind::Temple, me, false) {
                    let t = p.last().copied().unwrap_or(cur);
                    self.map.t[t].reserved = me;
                    e.path = p;
                    e.job = Job::Pray(t);
                    e.timer = 8.0 + self.rng.f() * 6.0;
                    return;
                }
            }
        }
        // the jailer's favourite work: prisoners nobody is working on yet
        if e.kind == EK::Jailer && self.rng.f() < 0.85 {
            let busy: Vec<u32> = self.ents.iter().filter_map(|o| if let Job::Torment(p) = o.job { Some(p) } else { None }).collect();
            let prisoner = self.ents.iter().filter(|o| o.alive && o.captive == 3 && !busy.contains(&o.id)).map(|o| (o.id, o.tile())).next();
            if let Some((id, pt)) = prisoner {
                if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| i != pt && adj4(i, pt) || i == pt, true) {
                    e.path = p;
                    e.job = Job::Torment(id);
                    e.timer = 12.0 + self.rng.f() * 8.0;
                    return;
                }
            }
        }
        // guard posts and the arena
        if self.counts[crate::rooms::ROOM_GUARD] > 0 && self.rng.f() < 0.2 {
            if let Some(p) = self.map.search(cur, self.map.walk_cost(), |i| self.free_post(i, me), true) {
                let t = p.last().copied().unwrap_or(cur);
                self.map.t[t].reserved = me;
                e.path = p;
                e.job = Job::Guard(t);
                e.timer = 35.0 + self.rng.f() * 20.0;
                return;
            }
        }
        if self.counts[crate::rooms::ROOM_ARENA] > 0 && e.hp > e.max_hp * 0.8 && self.rng.f() < 0.25 {
            if let Some(p) = self.find_room_tile(e, Kind::Arena, me, false) {
                let t = p.last().copied().unwrap_or(cur);
                self.map.t[t].reserved = me;
                e.path = p;
                e.job = Job::Spar(t);
                e.timer = 14.0 + self.rng.f() * 6.0;
                return;
            }
        }
        // the forge: orders waiting (coglings love it, others lend a hand now and then)
        if self.forge_orders() && self.counts[ROOM_FORGE] > 0 {
            let r = self.rng.f();
            if (e.kind == EK::Cogling && r < 0.9) || r < 0.25 {
                if let Some(p) = self.find_room_tile(e, Kind::Forge, me, false) {
                    let t = p.last().copied().unwrap_or(cur);
                    self.map.t[t].reserved = me;
                    e.path = p;
                    e.job = Job::Forge(t);
                    e.timer = 10.0 + self.rng.f() * 6.0;
                    return;
                }
            }
        }
        let r = self.rng.f();
        if (e.kind == EK::Mage && r < 0.8) || r < 0.2 {
            if let Some(p) = self.find_room_tile(e, Kind::Library, me, false) {
                let t = p.last().copied().unwrap_or(cur);
                self.map.t[t].reserved = me;
                e.path = p;
                e.job = Job::Study(t);
                e.timer = 8.0 + self.rng.f() * 6.0;
                return;
            }
        }
        if r < 0.8 && self.gold >= 5.0 {
            if let Some(p) = self.find_room_tile(e, Kind::Training, me, false) {
                let t = p.last().copied().unwrap_or(cur);
                self.map.t[t].reserved = me;
                e.path = p;
                e.job = Job::Train(t);
                e.timer = 8.0 + self.rng.f() * 6.0;
                return;
            }
        }
        if flies(e.kind) {
            self.patrol_flight(e);
        } else {
            self.wander(e, 4);
        }
    }

    // ---------------------------------------------------------------- prisoners

    fn captive_update(&mut self, e: &mut Ent, dt: f32) {
        e.moving = false;
        match e.captive {
            1 => {
                // unconscious: bleeds out if nobody carries the hero away
                e.torture_t += dt;
                if e.torture_t > 60.0 {
                    e.alive = false;
                    self.release_all(e.id);
                    self.fx(3, e.x, e.y, 0.0, 0.0, 0.7, 0xff505070);
                }
            }
            2 => {
                // carried: follows the imp
                match self.find(e.carrier) {
                    Some(k) => {
                        e.x = self.ents[k].x;
                        e.y = self.ents[k].y;
                    }
                    None => {
                        e.captive = 1;
                        e.carrier = 0;
                    }
                }
            }
            _ if self.map.t[e.tile()].kind == Kind::Prison => {
                // in prison: no torture, but hunger wears the prisoner down
                e.hp -= e.max_hp / 180.0 * dt;
                if e.hp <= 0.0 {
                    e.alive = false;
                    self.release_all(e.id);
                    self.fx(3, e.x, e.y, 0.0, 0.0, 0.7, 0xff505070);
                    self.msg("msg.prisoner_starved", vec![format!("@{}", st(e.kind).name)]);
                    self.bury(e.x, e.y);
                }
            }
            _ => {
                let t = e.tile();
                if self.map.t[t].kind != Kind::Torture {
                    // the chamber is gone: the prisoner breaks free
                    e.captive = 0;
                    e.hp = e.max_hp * 0.3;
                    self.release_all(e.id);
                    return;
                }
                e.working = true;
                e.hp -= e.max_hp / 100.0 * dt;
                e.torture_t += dt;
                if e.torture_t >= 5.0 {
                    e.torture_t -= 5.0;
                    // ~40% defect over the whole torture (paladins ~25%); a jailer working on
                    // the prisoner makes it 2.5 times as likely
                    let tormented = self.ents.iter().any(|o| o.alive && o.kind == EK::Jailer && o.job == Job::Torment(e.id) && o.path.is_empty() && (o.x - e.x).abs() < 1.6 && (o.y - e.y).abs() < 1.6);
                    let p = if e.kind == EK::Paladin { 0.0143 } else { 0.0252 } * if tormented { 2.5 } else { 1.0 };
                    if tormented {
                        self.fx(2, e.x, e.y, 0.0, 0.0, 0.3, 0xff3040ff);
                    }
                    if self.rng.f() < p {
                        self.defect(e);
                        return;
                    }
                }
                if e.hp <= 0.0 {
                    e.alive = false;
                    self.release_all(e.id);
                    self.fx(3, e.x, e.y, 0.0, 0.0, 0.7, 0xff505070);
                    self.sfx(Sfx::HeroDeath, e.x, e.y);
                    self.msg("msg.prisoner_died", vec![format!("@{}", st(e.kind).name)]);
                    self.bury(e.x, e.y);
                }
            }
        }
    }

    // a prisoner joins the player's side
    fn defect(&mut self, e: &mut Ent) {
        self.release_all(e.id);
        e.hero = false;
        e.captive = 0;
        e.carrier = 0;
        e.guard = false;
        e.home = None;
        e.hp = e.max_hp * 0.5;
        e.happy = 0.6;
        e.hunger = 0.5;
        e.energy = 0.4;
        e.job = Job::None;
        e.path.clear();
        e.bed = None;
        self.fx(7, e.x, e.y, 0.0, 0.0, 1.0, 0xff4040e0);
        self.sfx(Sfx::Convert, e.x, e.y);
        self.msg("msg.defected", vec![format!("@{}", st(e.kind).name)]);
    }

    // unconscious hero lying next to tile i that no imp takes care of yet
    fn captive_near(&self, i: usize) -> Option<u32> {
        let (x, y) = xy(i);
        self.ents.iter().find(|o| {
            o.alive && o.hero && o.captive == 1 && o.carrier == 0 && (o.x as i32 - x).abs() <= 1 && (o.y as i32 - y).abs() <= 1
        }).map(|o| o.id)
    }

    fn carry_job(&mut self, e: &mut Ent, id: u32, dt: f32) {
        let Some(k) = self.find(id) else {
            e.job = Job::None;
            return;
        };
        let cur = e.tile();
        match self.ents[k].captive {
            1 => {
                let (cx, cy) = (self.ents[k].x, self.ents[k].y);
                if (cx - e.x).abs() < 1.2 && (cy - e.y).abs() < 1.2 {
                    // pick up and look for a free place in the torture chamber
                    match self.map.search(cur, self.map.walk_cost(), |i| self.free_cell(i), true) {
                        Some(p) => {
                            let target = p.last().copied().unwrap_or(cur);
                            self.map.t[target].bed = id + 1;
                            let c = &mut self.ents[k];
                            c.captive = 2;
                            c.carrier = e.id;
                            e.path = p;
                        }
                        None => {
                            self.ents[k].carrier = 0;
                            e.job = Job::None;
                        }
                    }
                } else if e.path.is_empty() {
                    match self.map.path_to(cur, idx(cx as i32, cy as i32)) {
                        Some(p) if !p.is_empty() => e.path = p,
                        _ => {
                            self.ents[k].carrier = 0;
                            e.job = Job::None;
                        }
                    }
                }
            }
            2 if self.ents[k].carrier == e.id => {
                if !self.step_path(e, dt) {
                    // arrived (or blocked): put the prisoner down on the reserved torture tile
                    let target = self.map.t.iter().position(|t| t.bed == id + 1);
                    match target {
                        Some(t) if t == cur || adj4(t, cur) || t == e.tile() => {
                            let (tx, ty) = xy(t);
                            let c = &mut self.ents[k];
                            c.captive = 3;
                            c.carrier = 0;
                            c.hp = c.max_hp; // the torture drains it over ~100 s
                            c.x = tx as f32 + 0.5;
                            c.y = ty as f32 + 0.5;
                            c.torture_t = 0.0;
                            self.sfx(Sfx::Capture, tx as f32 + 0.5, ty as f32 + 0.5);
                            e.job = Job::None;
                        }
                        Some(t) => {
                            if let Some(p) = self.map.path_to(cur, t) {
                                e.path = p;
                            } else {
                                self.ents[k].captive = 1;
                                self.ents[k].carrier = 0;
                                e.job = Job::None;
                            }
                        }
                        None => {
                            self.ents[k].captive = 1;
                            self.ents[k].carrier = 0;
                            e.job = Job::None;
                        }
                    }
                }
                return;
            }
            _ => {
                e.job = Job::None;
                return;
            }
        }
        self.step_path(e, dt);
    }

    // ---------------------------------------------------------------- heroes

    fn hero_ai(&mut self, e: &mut Ent, dt: f32) {
        if e.boss > 0 {
            self.boss_ability(e, dt);
        }
        // the rogues' tricks: a thief who is busy stealing or running does nothing else
        if self.rogue_ai(e, dt) {
            return;
        }
        if e.kind == EK::Fairy {
            // fairy dust: the heroes around are healed a little all the time
            for o in self.ents.iter_mut() {
                if o.alive && o.active_hero() && o.hp < o.max_hp && (o.x - e.x).powi(2) + (o.y - e.y).powi(2) < 9.0 {
                    o.hp = (o.hp + 6.0 * dt).min(o.max_hp);
                }
            }
            if self.vrng.f() < 5.0 * dt {
                let vx = self.vrng.f() * 0.6 - 0.3;
                self.part(crate::particles::EMBER, (e.x, e.y, 0.9), (vx, 0.0, 0.2), 1.0, crate::particles::abgr(255, 240, 180), 0.03);
            }
        }
        if e.think <= 0.0 {
            e.think = 0.5;
            if e.kind == EK::Priest && e.cd <= 0.0 {
                let mut best: Option<usize> = None;
                let mut worst = 0.95;
                for (j, o) in self.ents.iter().enumerate() {
                    if o.alive && o.hero {
                        let d = (o.x - e.x).powi(2) + (o.y - e.y).powi(2);
                        let r = o.hp / o.max_hp;
                        if d < 16.0 && r < worst {
                            worst = r;
                            best = Some(j);
                        }
                    }
                }
                if e.hp / e.max_hp < worst {
                    e.hp = (e.hp + 25.0).min(e.max_hp);
                    self.fx(4, e.x, e.y, 0.0, 0.0, 0.8, 0xff60ff80);
                    e.cd = 2.5;
                } else if let Some(j) = best {
                    let o = &mut self.ents[j];
                    o.hp = (o.hp + 25.0).min(o.max_hp);
                    let (ox, oy) = (o.x, o.y);
                    self.fx(4, ox, oy, 0.0, 0.0, 0.8, 0xff60ff80);
                    e.cd = 2.5;
                }
            }
            let fort = e.guard || !e.patrol.is_empty();
            // a catapult aims at towers first
            if e.kind == EK::Catapult && !matches!(e.job, Job::AttackTower(_)) {
                let reach = st(e.kind).range + 1.0;
                let near = self.towers.iter().filter(|t| !t.hero).map(|t| (t.id, (t.pos().0 - e.x).powi(2) + (t.pos().1 - e.y).powi(2))).filter(|&(_, d2)| d2 < reach * reach).min_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal)).map(|t| t.0);
                if let Some(id) = near {
                    e.job = Job::AttackTower(id);
                    e.path.clear();
                    e.repath = 0.0;
                }
            }
            if !matches!(e.job, Job::Attack(_)) && !matches!((e.kind, e.job), (EK::Catapult, Job::AttackTower(_))) {
                let radius = if fort { 8.0 } else { 6.5 };
                // a ram does not fight creatures
                let foe = if e.kind == EK::Ram { None } else { self.nearest_enemy(e, radius) };
                if let Some(id) = foe {
                    e.job = Job::Attack(id);
                    e.path.clear();
                    e.repath = 0.0;
                    if fort {
                        self.alarm(e.x, e.y, id);
                    }
                } else if e.guard && !matches!(e.job, Job::TearBridge(_)) && matches!(e.kind, EK::Knight | EK::Dwarf | EK::Paladin) && self.rng.f() < 0.05 {
                    // knights cut the player's way in: bridges near their post are torn down
                    if let Some(b) = self.bridge_to_tear(e) {
                        e.job = Job::TearBridge(b);
                        e.path.clear();
                        e.repath = 0.0;
                        e.timer = 0.0;
                    }
                } else if !matches!(e.job, Job::AttackTower(_) | Job::TearBridge(_)) {
                    // no unit around: towers within reach are attacked
                    let near = self.towers.iter().filter(|t| !t.hero).filter(|t| {
                        let (tx, ty) = t.pos();
                        (tx - e.x).powi(2) + (ty - e.y).powi(2) < radius * radius
                    }).min_by(|a, b| {
                        let da = (a.pos().0 - e.x).powi(2) + (a.pos().1 - e.y).powi(2);
                        let db = (b.pos().0 - e.x).powi(2) + (b.pos().1 - e.y).powi(2);
                        da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
                    }).map(|t| t.id);
                    if let Some(id) = near {
                        e.job = Job::AttackTower(id);
                        e.path.clear();
                        e.repath = 0.0;
                    }
                }
            }
        }
        if let Job::AttackTower(id) = e.job {
            if self.attack_tower(e, id, dt) {
                return;
            }
            e.job = Job::AttackCore;
            e.path.clear();
            e.think = 1.5;
        }
        if let Job::TearBridge(b) = e.job {
            if self.tear_bridge(e, b, dt) {
                return;
            }
            e.job = Job::None;
            e.path.clear();
        }
        if let Job::Attack(id) = e.job {
            // guards and patrols do not follow too far
            let (gx, gy) = match (e.home, e.patrol.get(e.patrol_k % e.patrol.len().max(1))) {
                (Some(h), _) => h,
                (None, Some(&(px, py))) => (px as f32 + 0.5, py as f32 + 0.5),
                _ => self.gate_center(),
            };
            let far = (e.guard || !e.patrol.is_empty()) && (e.x - gx).powi(2) + (e.y - gy).powi(2) > 14.0 * 14.0;
            if !far && self.attack_job(e, id, dt) {
                return;
            }
            e.job = Job::AttackCore;
            e.path.clear();
            e.think = 1.5;
        }
        if !e.patrol.is_empty() {
            // patrols walk their route in a loop
            let k = e.patrol_k % e.patrol.len();
            let (px, py) = e.patrol[k];
            if (e.x - px as f32 - 0.5).powi(2) + (e.y - py as f32 - 0.5).powi(2) < 0.8 {
                e.patrol_k = (k + 1) % e.patrol.len();
                e.path.clear();
            }
            if e.path.is_empty() && e.repath <= 0.0 {
                e.repath = 1.0;
                let (px, py) = e.patrol[e.patrol_k % e.patrol.len()];
                match self.map.path_to(e.tile(), idx(px, py)) {
                    Some(p) => e.path = p,
                    None => e.patrol_k = (e.patrol_k + 1) % e.patrol.len(), // blocked: next point
                }
            }
            self.step_path(e, dt);
            return;
        }
        if e.guard {
            // guards stay at their post (gate or treasure cave)
            let (gx, gy) = e.home.unwrap_or_else(|| self.gate_center());
            let d2 = (e.x - gx).powi(2) + (e.y - gy).powi(2);
            if d2 > 2.5 * 2.5 && e.path.is_empty() && e.repath <= 0.0 {
                e.repath = 1.0;
                let target = idx(gx as i32, gy as i32);
                if let Some(p) = self.map.path_to(e.tile(), target) {
                    e.path = p;
                }
            }
            self.step_path(e, dt);
            return;
        }
        // a wave sent against a rival master
        if e.target.map_or(false, |t| t >= 2) && self.march_on(e, dt) {
            return;
        }
        let cur = e.tile();
        if e.path.is_empty() && self.map.adj_core(cur) {
            e.working = true;
            // the core next to it is the first master's (whoever is being processed in a match)
            let (cx, cy) = self.core_of_side(0);
            e.face = sgn(cx as f32 + 1.5 - e.x);
            if e.cd <= 0.0 {
                e.cd = st(e.kind).interval;
                self.damage_master_core(0, e.atk());
                let fx = (e.x + cx as f32 + 1.5) * 0.5;
                let fy = (e.y + cy as f32 + 1.5) * 0.5;
                self.fx(2, fx, fy, 0.0, 0.0, 0.3, 0xff4040ff);
                self.sfx(Sfx::CoreHit, fx, fy);
                self.hint(6, "hint.core_attacked");
            }
            return;
        }
        if let Some((wx, wy)) = e.waypoint {
            if (e.x - wx as f32 - 0.5).abs() < 2.5 && (e.y - wy as f32 - 0.5).abs() < 2.5 {
                e.waypoint = None; // broke into the realm: now for the core
                e.path.clear();
            }
        }
        if e.path.is_empty() && e.repath <= 0.0 {
            e.repath = 1.0;
            let path = match e.waypoint {
                Some((wx, wy)) => {
                    let goal = idx(wx, wy);
                    let p = self.map.search(cur, self.map.hero_cost(), |i| i == goal, true);
                    if p.is_none() {
                        e.waypoint = None;
                    }
                    p
                }
                None => self.map.hero_path_to_core(cur),
            };
            if let Some(p) = path {
                e.path = p;
            }
        }
        self.step_path(e, dt);
    }

    // Wave AI: choose where the next wave breaks into the realm. Candidates are border tiles of
    // the player's territory on the side facing the hero gate; towers, creatures and reinforced
    // walls nearby make a place less attractive, as does a long way and recent use.
    pub fn plan_entries(&mut self) {
        self.planned_entries.clear();
        let (cx, cy) = (self.map.core.0 + 1, self.map.core.1 + 1);
        let (gx, gy) = (self.map.gate.0 + 1, self.map.gate.1 + 1);
        let dir = norm((gx - cx) as f32, (gy - cy) as f32);
        let mut cands = Vec::new();
        for i in 0..self.map.t.len() {
            let t = &self.map.t[i];
            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 != self.me));
            if !border {
                continue;
            }
            let rel = ((x - cx) as f32, (y - cy) as f32);
            let len = (rel.0 * rel.0 + rel.1 * rel.1).sqrt();
            if len < 2.0 || (rel.0 * dir.0 + rel.1 * dir.1) / len < 0.0 {
                continue;
            }
            cands.push((x, y));
        }
        if cands.is_empty() {
            return;
        }
        let step = (cands.len() / 300).max(1);
        let mut scored: Vec<((i32, i32), f32)> = Vec::new();
        for &(x, y) in cands.iter().step_by(step) {
            let (fx, fy) = (x as f32 + 0.5, y as f32 + 0.5);
            let near = |px: f32, py: f32, r: f32| (px - fx).powi(2) + (py - fy).powi(2) < r * r;
            let towers: u32 = self.towers.iter().filter(|t| near(t.pos().0, t.pos().1, 6.0)).map(|t| t.level).sum();
            let creatures = self.ents.iter().filter(|e| e.alive && e.creature() && near(e.x, e.y, 6.0)).count();
            let mut reinf = 0;
            for dy in -2..=2 {
                for dx in -2..=2 {
                    if self.map.get(x + dx, y + dy).map_or(false, |t| t.reinforced) {
                        reinf += 1;
                    }
                }
            }
            let dist = (((x - gx).pow(2) + (y - gy).pow(2)) as f32).sqrt();
            let recent: f32 = self.entry_history.iter().rev().take(2).filter(|&&(hx, hy)| ((hx - x).pow(2) + (hy - y).pow(2)) < 100).count() as f32 * -60.0;
            let score = -dist * 0.8 - 25.0 * towers as f32 - 12.0 * creatures as f32 - 6.0 * reinf as f32 + recent + self.rng.f() * 25.0;
            scored.push(((x, y), score));
        }
        scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
        let first = scored[0].0;
        self.planned_entries.push(first);
        // second entry point at least 10 tiles away (used by waves of 6+ heroes)
        if let Some(&(second, _)) = scored.iter().find(|((x, y), _)| (x - first.0).pow(2) + (y - first.1).pow(2) >= 100) {
            self.planned_entries.push(second);
        }
    }

    // compass direction of a tile as seen from the core (language key)
    pub fn direction_key(&self, (x, y): (i32, i32)) -> &'static str {
        let (cx, cy) = (self.map.core.0 + 1, self.map.core.1 + 1);
        let a = ((y - cy) as f32).atan2((x - cx) as f32).to_degrees(); // 0 = east, 90 = south (map y grows downwards)
        let k = (((a + 360.0 + 22.5) % 360.0) / 45.0) as usize;
        ["dir.e", "dir.se", "dir.s", "dir.sw", "dir.w", "dir.nw", "dir.n", "dir.ne"][k % 8]
    }

    // ---------------------------------------------------------------- player actions

    pub fn mark_rect(&mut self, x0: i32, y0: i32, x1: i32, y1: i32, on: bool) {
        for y in y0.min(y1)..=y0.max(y1) {
            for x in x0.min(x1)..=x0.max(x1) {
                if inb(x, y) {
                    let t = &mut self.map.t[idx(x, y)];
                    // a master sets and clears only his own marks
                    let side = self.me.side().min(7);
                    if t.diggable() && (!t.marked || t.mark_by == side) {
                        t.marked = on;
                        t.mark_by = side;
                    }
                }
            }
        }
    }

    pub fn build_rect(&mut self, room: usize, x0: i32, y0: i32, x1: i32, y1: i32) {
        let kind = ROOM_KINDS[room];
        let cost = (ROOM_COST[room] as f32 * self.talents.room_cost()).round();
        let mut built = 0;
        let mut broke = false;
        for y in y0.min(y1)..=y0.max(y1) {
            for x in x0.min(x1)..=x0.max(x1) {
                if !inb(x, y) {
                    continue;
                }
                let i = idx(x, y);
                let t = self.map.t[i];
                if t.kind == Kind::Floor && t.owner == self.me {
                    if self.gold < cost {
                        broke = true;
                        continue;
                    }
                    self.gold -= cost;
                    let t = &mut self.map.t[i];
                    t.kind = kind;
                    t.food = 0.0;
                    t.bed = 0;
                    built += 1;
                    self.fx(8, x as f32 + 0.5, y as f32 + 0.5, 0.0, 0.0, 0.5, 0xff40d0ff);
                    if built == 1 {
                        self.sfx(Sfx::Build, x as f32 + 0.5, y as f32 + 0.5);
                    }
                }
            }
        }
        if broke {
            self.msg("msg.no_gold", vec![]);
            self.sfx_ui(Sfx::Error);
        }
        if built == 0 && !broke {
            self.hint(7, "hint.build_where");
        }
        self.count(crate::stats::ROOMS, built as f32);
        self.recount();
    }

    pub fn sell_rect(&mut self, x0: i32, y0: i32, x1: i32, y1: i32) {
        let mut refund = 0.0;
        for y in y0.min(y1)..=y0.max(y1) {
            for x in x0.min(x1)..=x0.max(x1) {
                if !inb(x, y) {
                    continue;
                }
                let i = idx(x, y);
                if self.remove_trap_at(i) {
                    continue;
                }
                if let Some(k) = self.towers.iter().position(|t| t.tile == i && !t.hero) {
                    refund += self.towers[k].invested() as f32 * 0.5;
                    if self.towers[k].kind == TowerKind::Rune && !self.towers[k].rune_final {
                        // the base tower comes back once: in the next mission (free play: at once)
                        if self.mission.is_some() {
                            self.rune_next += 1;
                            self.msg("msg.rune_next", vec![]);
                        } else {
                            self.rune_final += 1;
                            self.msg("msg.rune_back", vec![]);
                        }
                    }
                    self.towers.remove(k);
                    self.map.t[i].kind = Kind::Floor;
                    continue;
                }
                let t = &mut self.map.t[i];
                if t.kind == Kind::Steel {
                    t.kind = Kind::Earth;
                    t.reinforced = true;
                    t.hp = 12.0;
                    refund += STEEL_COST[1] as f32 * 0.5;
                    continue;
                }
                if t.owner == self.me && t.bridge() {
                    let lava = t.river() == Some(Kind::Lava);
                    let cost = if t.kind == Kind::Drawbridge { DRAWBRIDGE_COST[lava as usize] } else { BRIDGE_COST[lava as usize] };
                    t.kind = if lava { Kind::Lava } else { Kind::Water };
                    t.owner = Owner::None;
                    t.reserved = 0;
                    t.res = 0;
                    refund += cost as f32 * 0.5;
                    self.ground_lost(i);
                    continue;
                }
                let t = &mut self.map.t[i];
                if t.owner == self.me {
                    if let Some(r) = room_index(t.kind) {
                        t.kind = Kind::Floor;
                        t.bed = 0;
                        t.food = 0.0;
                        refund += ROOM_COST[r] as f32 * 0.5;
                    }
                }
            }
        }
        self.recount();
        if refund > 0.0 {
            let got = self.add_gold(refund);
            self.sfx_ui(Sfx::Sell);
            self.msg("msg.sold", vec![(got as i32).to_string()]);
        }
    }

    pub fn tower_at(&self, i: usize) -> Option<&Tower> {
        self.towers.iter().find(|t| t.tile == i)
    }

    // Build a tower on own floor, or upgrade an own tower of the same kind
    pub fn build_tower(&mut self, kind: TowerKind, x: i32, y: i32) {
        if !inb(x, y) {
            return;
        }
        let i = idx(x, y);
        let s = tower_stats(kind);
        if let Some(k) = self.towers.iter().position(|t| t.tile == i) {
            let t = &self.towers[k];
            if t.hero {
                self.hint(16, "hint.tower_where");
                self.sfx_ui(Sfx::Error);
                return;
            }
            if t.kind != kind {
                self.hint(14, "hint.tower_other");
                return;
            }
            if t.level >= 3 {
                self.hint(15, "hint.tower_max");
                return;
            }
            let cost = s.cost[t.level as usize] as f32;
            if self.gold < cost {
                self.msg("msg.no_gold", vec![]);
                self.sfx_ui(Sfx::Error);
                return;
            }
            self.gold -= cost;
            let t = &mut self.towers[k];
            let old_max = t.max_hp();
            t.level += 1;
            t.hp += t.max_hp() - old_max;
            let (px, py) = t.pos();
            let lvl = t.level;
            self.fx(7, px, py, 0.0, 0.0, 0.8, 0xff44ddff);
            self.sfx(Sfx::LevelUp, px, py);
            self.msg("msg.tower_upgraded", vec![format!("@{}", tower_name(kind)), lvl.to_string()]);
            return;
        }
        let t = self.map.t[i];
        if t.kind != Kind::Floor || t.owner != self.me {
            self.hint(16, "hint.tower_where");
            self.sfx_ui(Sfx::Error);
            return;
        }
        let cost = s.cost[0] as f32;
        if self.gold < cost {
            self.msg("msg.no_gold", vec![]);
            self.sfx_ui(Sfx::Error);
            return;
        }
        // rune forge towers: one build per opened chest (fresh plans first)
        let mut rune_final = false;
        if kind == TowerKind::Rune {
            if self.rune_free > 0 {
                self.rune_free -= 1;
            } else if self.rune_final > 0 {
                self.rune_final -= 1;
                rune_final = true;
            } else {
                self.hint(24, "hint.rune_none");
                self.sfx_ui(Sfx::Error);
                return;
            }
        }
        self.gold -= cost;
        self.map.t[i].kind = Kind::Tower;
        let id = self.next_id;
        self.next_id += 1;
        let tower = Tower { id, kind, tile: i, level: 1, hp: s.hp, cd: 1.0, aim: 0.0, flash: 0.0, hero: false, rune_final };
        let (px, py) = tower.pos();
        self.towers.push(tower);
        self.count(crate::stats::TOWERS, 1.0);
        // units standing on the tile step aside
        for e in self.ents.iter_mut() {
            if e.alive && e.tile() == i {
                for &(dx, dy) in &DIR8 {
                    if self.map.walk(x + dx, y + dy) {
                        e.x = (x + dx) as f32 + 0.5;
                        e.y = (y + dy) as f32 + 0.5;
                        e.path.clear();
                        break;
                    }
                }
            }
        }
        self.fx(8, px, py, 0.0, 0.0, 0.5, 0xff40d0ff);
        self.sfx(Sfx::Build, px, py);
    }

    fn destroy_tower(&mut self, k: usize) {
        let t = self.towers.remove(k);
        self.map.t[t.tile].kind = Kind::Floor;
        let (px, py) = t.pos();
        self.fx(3, px, py, 0.0, 0.0, 1.0, 0xff505070);
        self.sfx(Sfx::DigDone, px, py);
        if t.hero {
            self.towers_razed += 1;
            self.msg("msg.enemy_tower_destroyed", vec![format!("@{}", tower_name(t.kind))]);
        } else {
            self.msg("msg.tower_destroyed", vec![format!("@{}", tower_name(t.kind))]);
        }
    }

    // a knight tower near the unit (for the player's creatures)
    fn enemy_tower_near(&self, x: f32, y: f32, radius: f32) -> Option<u32> {
        self.towers
            .iter()
            .filter(|t| t.hero)
            .map(|t| (t.id, (t.pos().0 - x).powi(2) + (t.pos().1 - y).powi(2)))
            .filter(|&(_, d)| d < radius * radius)
            .min_by(|a, b| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal))
            .map(|(id, _)| id)
    }

    // damage dealt to a unit by a tower (no attacker unit involved)
    fn tower_damage(&mut self, j: usize, dmg: f32) {
        let e = &mut self.ents[j];
        e.hp -= if e.shield > 0.0 { dmg * 0.5 } else { dmg };
        e.flash = 0.15;
        if e.hp <= 0.0 && e.alive {
            self.kill(j);
        }
    }

    fn tower_target(&self, t: &Tower) -> Option<usize> {
        let (px, py) = t.pos();
        let r = t.range();
        let minr = tower_stats(t.kind).min_range;
        let mut best = None;
        let mut bd = r * r;
        for (j, e) in self.ents.iter().enumerate() {
            // knight towers shoot the player's units, the player's towers shoot heroes
            // knight towers shoot everybody but the humans, the player's towers everybody else
            if !e.alive || e.held || !self.tower_enemy(t, e) || e.invis > 0.0 {
                continue;
            }
            let d = (e.x - px).powi(2) + (e.y - py).powi(2);
            if d < bd && d >= minr * minr && self.los(px, py, e.x, e.y) {
                bd = d;
                best = Some(j);
            }
        }
        best
    }

    // an enemy tower or the gate of the order within reach: (x, y, height, tower id or None = gate)
    fn tower_structure_target(&self, t: &Tower) -> Option<(f32, f32, f32, Option<u32>)> {
        let (px, py) = t.pos();
        let r = t.range();
        let minr = tower_stats(t.kind).min_range;
        let in_reach = |x: f32, y: f32| {
            let d = (x - px).powi(2) + (y - py).powi(2);
            d <= r * r && d >= minr * minr
        };
        let mut best: Option<(f32, (f32, f32, f32, Option<u32>))> = None;
        for o in self.towers.iter().filter(|o| o.hero != t.hero) {
            let (ox, oy) = o.pos();
            if in_reach(ox, oy) && self.los_to_tile(px, py, o.tile) {
                let d = (ox - px).powi(2) + (oy - py).powi(2);
                if best.map_or(true, |b| d < b.0) {
                    best = Some((d, (ox, oy, o.top() * 0.6, Some(o.id))));
                }
            }
        }
        if best.is_none() && !t.hero && self.has_gate() && self.gate_hp > 0.0 {
            // the nearest tile of the gate counts
            let (gx, gy) = self.map.gate;
            let (nx, ny) = ((px - 0.5).clamp(gx as f32, gx as f32 + 2.0) + 0.5, (py - 0.5).clamp(gy as f32, gy as f32 + 2.0) + 0.5);
            if in_reach(nx, ny) && self.los_to_tile(px, py, idx(nx as i32, ny as i32)) {
                best = Some((0.0, (nx, ny, 1.0, None)));
            }
        }
        best.map(|b| b.1)
    }

    // line of sight from a tower to a target tile: walls and other towers block,
    // the tower's own tile and the target tile do not
    fn los_to_tile(&self, x0: f32, y0: f32, target: usize) -> bool {
        let start = idx(x0 as i32, y0 as i32);
        let (tx, ty) = xy(target);
        let (x1, y1) = (tx as f32 + 0.5, ty as f32 + 0.5);
        let n = (((x1 - x0).powi(2) + (y1 - y0).powi(2)).sqrt() * 3.0).ceil().max(1.0) as i32;
        for k in 1..n {
            let f = k as f32 / n as f32;
            let i = idx((x0 + (x1 - x0) * f) as i32, (y0 + (y1 - y0) * f) as i32);
            if i == start || i == target {
                continue;
            }
            let tl = &self.map.t[i];
            if tl.solid() || tl.kind == Kind::Tower {
                return false;
            }
        }
        true
    }

    fn tower_fire_at_structure(&mut self, k: usize, (ex, ey, eh, target): (f32, f32, f32, Option<u32>)) {
        let t = self.towers[k].clone();
        let s = tower_stats(t.kind);
        if s.mana > 0.0 && !t.hero && self.mana < s.mana {
            self.towers[k].cd = 1.0;
            return;
        }
        if !t.hero {
            self.mana -= s.mana;
        }
        let (px, py) = t.pos();
        let aim = (ey - py).atan2(ex - px);
        let tw = &mut self.towers[k];
        tw.cd = s.interval;
        tw.flash = 0.15;
        tw.aim = aim;
        let (mx, my, mh) = match t.kind {
            TowerKind::Arrow => (px, py, t.top() + 0.25),
            TowerKind::Cannon => (px + aim.cos() * 0.55, py + aim.sin() * 0.55, t.top() + 0.2),
            TowerKind::Magic => (px, py, t.top() + 0.45),
            TowerKind::Rune => (px, py, t.top() + 0.55),
        };
        let col = match t.kind {
            TowerKind::Arrow => 0xffd0e0f0,
            TowerKind::Cannon => 0xff303030,
            TowerKind::Magic => 0xffff60d0,
            TowerKind::Rune => 0xff40c0ff,
        };
        self.shot(mx, my, mh, ex, ey, eh, 0.3, col);
        self.style_last_fx(match t.kind {
            TowerKind::Arrow => crate::particles::ST_ARROW,
            TowerKind::Cannon => crate::particles::ST_CANNON,
            TowerKind::Magic => crate::particles::ST_MAGIC,
            TowerKind::Rune => crate::particles::ST_RUNE,
        });
        self.sfx(match t.kind {
            TowerKind::Arrow => Sfx::Shoot,
            TowerKind::Cannon => Sfx::Cannon,
            TowerKind::Magic | TowerKind::Rune => Sfx::Magic,
        }, px, py);
        let dmg = t.dmg();
        match target {
            Some(id) => {
                if let Some(o) = self.towers.iter().position(|o| o.id == id) {
                    self.towers[o].hp -= dmg;
                    if self.towers[o].hp <= 0.0 {
                        self.destroy_tower(o);
                    }
                }
            }
            None => {
                self.gate_hp -= dmg;
                self.gate_hit_t = self.time;
                self.sfx(Sfx::GateHit, ex, ey);
                if self.mission.as_ref().map_or(true, |m| m.gate_defenders) {
                    self.check_gate_stage();
                }
            }
        }
    }

    pub(crate) fn update_towers(&mut self, dt: f32) {
        for k in 0..self.towers.len() {
            if k >= self.towers.len() {
                break;
            }
            let t = &mut self.towers[k];
            t.cd -= dt;
            t.flash = (t.flash - dt).max(0.0);
            if t.cd > 0.0 {
                continue;
            }
            let t = self.towers[k].clone();
            let Some(j) = self.tower_target(&t) else {
                // no unit in reach: enemy towers and the enemy gate are shot at
                if let Some(target) = self.tower_structure_target(&t) {
                    self.tower_fire_at_structure(k, target);
                }
                continue;
            };
            let s = tower_stats(t.kind);
            if s.mana > 0.0 && !t.hero && self.mana < s.mana {
                self.hint(17, "hint.tower_mana");
                self.towers[k].cd = 1.0;
                continue;
            }
            if !t.hero {
                self.mana -= s.mana;
            }
            self.towers[k].cd = s.interval;
            self.towers[k].flash = 0.15;
            let (px, py) = t.pos();
            let (ex, ey) = (self.ents[j].x, self.ents[j].y);
            let aim = (ey - py).atan2(ex - px);
            self.towers[k].aim = aim;
            // where the shot leaves the tower (see the tower models in render3d.rs)
            let (mx, my, mh) = match t.kind {
                TowerKind::Arrow => (px, py, t.top() + 0.25),
                TowerKind::Cannon => (px + aim.cos() * 0.55, py + aim.sin() * 0.55, t.top() + 0.2),
                TowerKind::Magic => (px, py, t.top() + 0.45),
                TowerKind::Rune => (px, py, t.top() + 0.55),
            };
            let dmg = t.dmg();
            match t.kind {
                TowerKind::Arrow => {
                    // the arrow pierces up to two more heroes behind the target
                    let dir = norm(ex - px, ey - py);
                    // what the eye sees: past the target the spent arrow comes down at a random
                    // distance (not all on a circle at the end of the range); the damage below
                    // still reaches along the whole range
                    let to_target = ((ex - px).powi(2) + (ey - py).powi(2)).sqrt();
                    let reach = to_target + 0.8 + self.vrng.f() * (t.range() + 1.5 - to_target - 0.8).max(0.5);
                    let (endx, endy, wall) = self.arrow_end(px, py, dir.0, dir.1, reach);
                    self.shot(mx, my, mh, endx, endy, 0.45, 0.3, 0xffd0e0f0);
                    self.style_last_fx(if wall { crate::particles::ST_ARROW_WALL } else { crate::particles::ST_ARROW_FALL });
                    self.sfx(Sfx::Shoot, px, py);
                    let mut hits = vec![(j, dmg)];
                    for (o, e) in self.ents.iter().enumerate() {
                        if o == j || !e.alive || e.held || !e.active_hero() || hits.len() >= 3 {
                            continue;
                        }
                        let rel = (e.x - px, e.y - py);
                        let along = rel.0 * dir.0 + rel.1 * dir.1;
                        let side = (rel.0 * dir.1 - rel.1 * dir.0).abs();
                        if along > 0.0 && along <= t.range() && side < 0.45 {
                            hits.push((o, dmg * 0.6));
                        }
                    }
                    for (o, d) in hits {
                        if self.ents[o].alive {
                            self.tower_damage(o, d);
                        }
                    }
                }
                TowerKind::Cannon => {
                    // splash damage and knockback around the impact
                    self.shot(mx, my, mh, ex, ey, 0.4, 0.35, 0xff303030);
                    self.style_last_fx(crate::particles::ST_CANNON);
                    self.sfx(Sfx::Cannon, px, py);
                    let mut hits = Vec::new();
                    for (o, e) in self.ents.iter().enumerate() {
                        if !e.alive || e.held || !e.active_hero() {
                            continue;
                        }
                        let d = ((e.x - ex).powi(2) + (e.y - ey).powi(2)).sqrt();
                        if d < 1.6 {
                            hits.push((o, dmg * (1.0 - d / 2.0), d));
                        }
                    }
                    for (o, d, dist) in hits {
                        if !self.ents[o].alive {
                            continue;
                        }
                        // knockback away from the impact, only onto walkable ground
                        let e = &self.ents[o];
                        let away = if dist > 0.05 { norm(e.x - ex, e.y - ey) } else { norm(e.x - px, e.y - py) };
                        self.knock(o, away.0 * 0.7, away.1 * 0.7);
                        if self.ents[o].alive {
                            self.tower_damage(o, d);
                        }
                    }
                }
                TowerKind::Magic => {
                    // sure hit, slows, jumps to a second hero
                    self.shot(mx, my, mh, ex, ey, 0.45, 0.2, 0xffff60d0);
                    self.style_last_fx(crate::particles::ST_MAGIC);
                    self.sfx(Sfx::Magic, px, py);
                    self.ents[j].slow = 2.0;
                    let chain = self
                        .ents
                        .iter()
                        .enumerate()
                        .filter(|(o, e)| *o != j && e.alive && !e.held && e.active_hero() && (e.x - ex).powi(2) + (e.y - ey).powi(2) < 9.0)
                        .min_by(|a, b| {
                            let da = (a.1.x - ex).powi(2) + (a.1.y - ey).powi(2);
                            let db = (b.1.x - ex).powi(2) + (b.1.y - ey).powi(2);
                            da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
                        })
                        .map(|(o, _)| o);
                    self.tower_damage(j, dmg);
                    if let Some(o) = chain {
                        let (ox, oy) = (self.ents[o].x, self.ents[o].y);
                        self.fx(0, ex, ey, ox, oy, 0.2, 0xffff60d0);
                        self.ents[o].slow = 2.0;
                        if self.ents[o].alive {
                            self.tower_damage(o, dmg * 0.6);
                        }
                    }
                }
                TowerKind::Rune => {
                    // a rune bolt that jumps on to up to three more enemies nearby
                    self.shot(mx, my, mh, ex, ey, 0.45, 0.25, 0xff40c0ff);
                    self.style_last_fx(crate::particles::ST_RUNE);
                    self.fx(2, ex, ey, 0.0, 0.0, 0.35, 0xffffc040);
                    self.sfx(Sfx::Magic, px, py);
                    let mut hit = vec![j];
                    let (mut lx, mut ly) = (ex, ey);
                    self.tower_damage(j, dmg);
                    for n in 0..3 {
                        let next = self
                            .ents
                            .iter()
                            .enumerate()
                            .filter(|(o, e)| !hit.contains(o) && e.alive && !e.held && self.tower_enemy(&t, e) && (e.x - lx).powi(2) + (e.y - ly).powi(2) < 3.5 * 3.5)
                            .min_by(|a, b| {
                                let da = (a.1.x - lx).powi(2) + (a.1.y - ly).powi(2);
                                let db = (b.1.x - lx).powi(2) + (b.1.y - ly).powi(2);
                                da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
                            })
                            .map(|(o, _)| o);
                        let Some(o) = next else { break };
                        let (ox, oy) = (self.ents[o].x, self.ents[o].y);
                        self.fx(0, lx, ly, ox, oy, 0.25, 0xff40c0ff);
                        hit.push(o);
                        if self.ents[o].alive {
                            self.tower_damage(o, dmg * (0.75 - 0.1 * n as f32));
                        }
                        lx = ox;
                        ly = oy;
                    }
                }
            }
        }
    }

    // a unit the tower shoots at
    fn tower_enemy(&self, t: &Tower, e: &Ent) -> bool {
        let target = if t.hero {
            e.side() != 1
        } else if self.coop {
            e.side() == 1
        } else if !self.masters.is_empty() {
            // a match: a tower belongs to the master whose ground it stands on and spares his allies
            let owner = self.map.t.get(t.tile).map_or(0, |tl| crate::netplay::side_of_owner(tl.owner));
            !self.allied(owner, e.side())
        } else {
            e.side() != 0
        };
        e.captive == 0 && !e.chained && target
    }

    // a hero attacks a tower; false = tower gone or unreachable
    pub(crate) fn attack_tower(&mut self, e: &mut Ent, id: u32, dt: f32) -> bool {
        let Some(k) = self.towers.iter().position(|t| t.id == id) else { return false };
        let (tx, ty) = self.towers[k].pos();
        let hit_h = self.towers[k].top() * 0.6;
        let s = st(e.kind);
        let d = ((tx - e.x).powi(2) + (ty - e.y).powi(2)).sqrt();
        if d <= s.range + 0.75 && (s.range < 1.5 || self.los(e.x, e.y, tx, ty)) {
            e.path.clear();
            e.face = sgn(tx - e.x);
            e.working = true;
            if e.cd <= 0.0 {
                e.cd = s.interval;
                let dmg = e.atk() * (0.85 + self.rng.f() * 0.3) * crate::siege::tower_breaker(e.kind);
                if s.range > 1.5 {
                    self.shot(e.x, e.y, 0.45, tx, ty, hit_h, 0.25, 0xff70b0d0);
                    self.style_last_fx(if e.kind == EK::Archer { crate::particles::ST_ARROW } else { crate::particles::ST_PLAIN });
                } else {
                    self.fx_at(2, tx, ty, hit_h, 0.25, 0xffffffff);
                }
                self.sfx(Sfx::MeleeHit, tx, ty);
                let t = &mut self.towers[k];
                t.hp -= dmg;
                if t.hp <= 0.0 {
                    self.destroy_tower(k);
                }
            }
            return true;
        }
        if e.path.is_empty() || e.repath <= 0.0 {
            e.repath = 1.0;
            let tile = self.towers[k].tile;
            let (x, y) = xy(tile);
            match self.map.search(e.tile(), self.map.walk_cost(), |i| {
                let (ix, iy) = xy(i);
                (ix - x).abs() <= 1 && (iy - y).abs() <= 1 && i != tile
            }, true) {
                // already next to the tower: step to the middle of the tile (in reach)
                Some(p) if p.is_empty() => e.path = vec![e.tile()],
                Some(p) => e.path = p,
                None => return false,
            }
        }
        self.step_path(e, dt);
        true
    }

    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 == self.me)
    }

    // Left click with the hand: own units anywhere, unconscious heroes only on own ground
    pub fn pickup(&mut self, target: Option<usize>) -> bool {
        if self.hand.len() >= 8 {
            self.hint(8, "hint.hand_full");
            return false;
        }
        let Some(j) = target.filter(|&j| j < self.ents.len() && self.ents[j].alive && !self.ents[j].held) else { return false };
        if self.buy_from_trader(j) {
            return false;
        }
        let e = &self.ents[j];
        if e.rival() || e.dwarf() {
            return false; // the rivals' creatures and the dwarves cannot be picked up
        }
        if e.hero {
            if e.captive != 1 && e.captive != 3 {
                return false;
            }
            if !self.on_own_ground(e.x, e.y) {
                self.hint(18, "hint.pickup_prisoner_where");
                self.sfx_ui(Sfx::Error);
                return false;
            }
        }
        let id = self.ents[j].id;
        let me = id + 1;
        self.unreserve(me);
        if self.ents[j].captive == 3 {
            // taken out of its cell
            for t in self.map.t.iter_mut().filter(|t| t.bed == me && matches!(t.kind, Kind::Torture | Kind::Prison)) {
                t.bed = 0;
            }
        }
        for o in self.ents.iter_mut() {
            if o.carrier == id && o.captive != 0 {
                o.captive = 1;
                o.carrier = 0;
            }
        }
        let e = &mut self.ents[j];
        e.held = true;
        e.carrier = 0;
        e.job = Job::None;
        e.path.clear();
        self.hand.push(id);
        self.sfx_ui(Sfx::Pickup);
        true
    }

    // Right click: drop the last picked unit on own walkable ground. Prisoners dropped on a
    // free torture place are locked up at once.
    pub fn drop(&mut self, wx: f32, wy: f32) -> bool {
        let Some(&id) = self.hand.last() else { return false };
        let (x, y) = (wx as i32, wy as i32);
        if !inb(x, y) {
            return false;
        }
        let i = idx(x, y);
        let t = self.map.t[i];
        if !t.walkable() || t.owner != self.me {
            self.hint(9, "hint.drop_where");
            self.sfx_ui(Sfx::Error);
            return false;
        }
        self.hand.pop();
        let imprison = matches!(t.kind, Kind::Torture | Kind::Prison) && t.bed == 0;
        // the sacrifice altar takes creatures
        if t.kind == Kind::Altar {
            if let Some(k) = self.ents.iter().position(|e| e.id == id && !e.hero) {
                self.ents[k].held = false;
                self.ents[k].x = wx;
                self.ents[k].y = wy;
                self.sacrifice(k);
                return true;
            }
        }
        if let Some(k) = self.ents.iter().position(|e| e.id == id) {
            let e = &mut self.ents[k];
            e.held = false;
            e.x = wx;
            e.y = wy;
            e.job = Job::None;
            e.think = 0.0;
            e.path.clear();
            if e.hero {
                e.carrier = 0;
                e.torture_t = 0.0;
                if imprison {
                    e.captive = 3;
                    e.hp = e.max_hp;
                    e.x = x as f32 + 0.5;
                    e.y = y as f32 + 0.5;
                    self.map.t[i].bed = id + 1;
                    self.sfx(Sfx::Capture, wx, wy);
                } else {
                    e.captive = 1;
                }
            }
        }
        self.fx(3, wx, wy, 0.0, 0.0, 0.4, 0xff707090);
        self.sfx(Sfx::Drop, wx, wy);
        true
    }

    // Shift + left click: backhand for own units (speed-up), fist for heroes on own ground.
    // Returns 1 = backhand, 2 = punch, 0 = nothing.
    pub fn slap(&mut self, target: Option<usize>) -> u8 {
        let Some(j) = target.filter(|&j| j < self.ents.len() && self.ents[j].alive && !self.ents[j].held) else { return 0 };
        let (x, y) = (self.ents[j].x, self.ents[j].y);
        if self.ents[j].dwarf() {
            return 0;
        }
        if !self.ents[j].hero && !self.ents[j].rival() {
            let e = &mut self.ents[j];
            e.boost = 15.0;
            e.hp = (e.hp - e.max_hp * 0.05).max(1.0);
            e.happy -= 0.04;
            e.flash = 0.15;
            if matches!(e.job, Job::Sleep(_)) {
                e.job = Job::None; // woken up
            }
            self.fx(2, x, y, 0.0, 0.0, 0.3, 0xffffffff);
            self.sfx(Sfx::Slap, x, y);
            self.script_event(crate::mscript::ScriptEvent::Slap);
            self.count(crate::stats::SLAPS, 1.0);
            return 1;
        }
        if self.ents[j].captive != 0 {
            return 0;
        }
        if !self.on_own_ground(x, y) {
            self.hint(19, "hint.punch_where");
            self.sfx_ui(Sfx::Error);
            return 0;
        }
        if self.time < self.punch_ready {
            return 0;
        }
        self.punch_ready = self.time + 0.5;
        self.ents[j].stun = 1.0;
        // the punch throws the hero back (into lava = burnt)
        let back = -self.ents[j].face;
        self.knock(j, back * 0.8, 0.0);
        if !self.ents[j].alive {
            self.fx(2, x, y, 0.0, 0.0, 0.35, 0xff40e0ff);
            self.sfx(Sfx::Punch, x, y);
            return 2;
        }
        self.fx(2, x, y, 0.0, 0.0, 0.35, 0xff40e0ff);
        self.fx(7, x, y, 0.0, 0.0, 0.4, 0xff40e0ff);
        self.sfx(Sfx::Punch, x, y);
        self.tower_damage(j, 15.0);
        2
    }

    pub fn lightning(&mut self, wx: f32, wy: f32) {
        let cost = 50.0 * self.talents.spell_cost();
        if self.mana < cost {
            self.msg("msg.no_mana_bolt", vec![]);
            self.sfx_ui(Sfx::Error);
            return;
        }
        self.mana -= cost;
        self.count(crate::stats::SPELLS, 1.0);
        self.sfx(Sfx::Lightning, wx, wy);
        self.fx(1, wx, wy, 0.0, 0.0, 0.5, 0xffffeeaa);
        self.ignite_at(wx, wy);
        let mut kills = Vec::new();
        for (j, e) in self.ents.iter_mut().enumerate() {
            if e.alive && !e.held && e.active_hero() && !crate::rogues::spell_proof(e) && (e.x - wx).powi(2) + (e.y - wy).powi(2) < 2.6 {
                e.hp -= 55.0;
                e.flash = 0.2;
                if e.hp <= 0.0 {
                    kills.push(j);
                }
            }
        }
        for j in kills {
            self.kill(j);
        }
    }

    pub fn heal(&mut self, wx: f32, wy: f32) {
        let cost = 60.0 * self.talents.spell_cost();
        if self.mana < cost {
            self.msg("msg.no_mana_heal", vec![]);
            self.sfx_ui(Sfx::Error);
            return;
        }
        self.mana -= cost;
        self.count(crate::stats::SPELLS, 1.0);
        self.sfx(Sfx::Heal, wx, wy);
        let mut fxs = Vec::new();
        for e in self.ents.iter_mut() {
            if e.alive && !e.held && !e.hero && (e.x - wx).powi(2) + (e.y - wy).powi(2) < 6.5 {
                e.hp = (e.hp + e.max_hp * 0.5).min(e.max_hp);
                fxs.push((e.x, e.y));
            }
        }
        self.fx(7, wx, wy, 0.0, 0.0, 0.6, 0xff60ff80);
        for (x, y) in fxs {
            self.fx(4, x, y, 0.0, 0.0, 0.9, 0xff60ff80);
        }
    }

    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 != self.me {
            self.hint(13, "hint.summon_where");
            return;
        }
        if self.mana < cost {
            self.msg("msg.no_mana_cost", vec![(cost as i32).to_string()]);
            self.sfx_ui(Sfx::Error);
            return;
        }
        self.mana -= cost;
        self.sfx(Sfx::Summon, wx, wy);
        self.spawn(EK::Worker, false, wx, wy, 1);
        self.fx(7, wx, wy, 0.0, 0.0, 0.6, 0xffff66cc);
    }
}

// ------------------------------------------------------------------ defence towers

#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
pub enum TowerKind {
    Arrow,
    Cannon,
    Magic,
    Rune, // dwarven rune forge tower: from a chest of a dwarf cave, built for free
}

pub struct TowerStats {
    pub cost: [i32; 3], // build, upgrade to level 2, upgrade to level 3
    pub hp: f32,
    pub dmg: f32,
    pub range: f32,
    pub min_range: f32,
    pub interval: f32,
    pub mana: f32, // per shot
}

pub fn tower_stats(k: TowerKind) -> TowerStats {
    match k {
        TowerKind::Arrow => TowerStats { cost: [250, 200, 300], hp: 300.0, dmg: 10.0, range: 6.0, min_range: 0.0, interval: 0.8, mana: 0.0 },
        TowerKind::Cannon => TowerStats { cost: [450, 350, 500], hp: 450.0, dmg: 32.0, range: 8.5, min_range: 2.0, interval: 2.6, mana: 0.0 },
        TowerKind::Magic => TowerStats { cost: [350, 300, 450], hp: 300.0, dmg: 24.0, range: 7.0, min_range: 0.0, interval: 1.5, mana: 8.0 },
        TowerKind::Rune => TowerStats { cost: [0, 800, 1200], hp: 1400.0, dmg: 55.0, range: 10.0, min_range: 0.0, interval: 1.3, mana: 0.0 },
    }
}

pub fn tower_name(k: TowerKind) -> &'static str {
    match k {
        TowerKind::Arrow => "tower.arrow",
        TowerKind::Cannon => "tower.cannon",
        TowerKind::Magic => "tower.magic",
        TowerKind::Rune => "tower.rune",
    }
}

#[derive(Clone, Serialize, Deserialize)]
pub struct Tower {
    pub id: u32,
    pub kind: TowerKind,
    pub tile: usize,
    pub level: u32,
    pub hp: f32,
    pub cd: f32,
    pub aim: f32, // direction of the last shot (radians, for drawing)
    pub flash: f32,
    #[serde(default)]
    pub hero: bool, // tower of a knight fortress: shoots the player's units
    #[serde(default)]
    pub rune_final: bool, // rune forge tower built from a refund: selling it gives nothing back
}

impl Tower {
    pub fn max_hp(&self) -> f32 {
        tower_stats(self.kind).hp * [1.0, 1.4, 1.9][(self.level as usize - 1).min(2)]
    }
    pub fn dmg(&self) -> f32 {
        tower_stats(self.kind).dmg * [1.0, 1.5, 2.2][(self.level as usize - 1).min(2)]
    }
    pub fn range(&self) -> f32 {
        tower_stats(self.kind).range + 0.75 * (self.level - 1) as f32
    }
    pub fn pos(&self) -> (f32, f32) {
        let (x, y) = xy(self.tile);
        (x as f32 + 0.5, y as f32 + 0.5)
    }

    // height of the tower body (3D units); grows with the level
    pub fn top(&self) -> f32 {
        match self.kind {
            TowerKind::Arrow => 1.0 + 0.3 * (self.level - 1) as f32,
            TowerKind::Cannon => 0.6 + 0.15 * (self.level - 1) as f32,
            TowerKind::Magic => 1.2 + 0.3 * (self.level - 1) as f32,
            TowerKind::Rune => 1.4 + 0.25 * (self.level - 1) as f32,
        }
    }
    // gold spent on this tower so far
    pub fn invested(&self) -> i32 {
        tower_stats(self.kind).cost[..self.level as usize].iter().sum()
    }
}

// Language key describing what a unit is doing
pub fn job_name(e: &Ent) -> &'static str {
    match e.job {
        Job::None if !e.patrol.is_empty() => "job.patrol",
        Job::None if e.guard => "job.guard",
        Job::None => "job.none",
        Job::Dig(_) => "job.dig",
        Job::Claim(_) => "job.claim",
        Job::Deliver => "job.deliver",
        Job::Wander => "job.wander",
        Job::Sleep(_) => {
            if e.moving {
                "job.sleep_go"
            } else {
                "job.sleep"
            }
        }
        Job::Eat(_) => "job.eat",
        Job::Train(_) => "job.train",
        Job::Forge(_) => "job.forge",
        Job::Brawl(_) => "job.brawl",
        Job::Guard(_) => "job.guard_post",
        Job::Spar(_) => "job.spar",
        Job::Install(_) => "job.install",
        Job::Study(_) => "job.study",
        Job::Attack(_) => "job.fight",
        Job::TearBridge(_) => "job.tear_bridge",
        Job::Rest(_) => "job.rest",
        Job::Torment(_) => "job.torment",
        Job::Register => "job.register",
        Job::MakeBed(_) => "job.make_bed",
        Job::FetchWage(_) => "job.fetch_wage",
        Job::Help(_) => "job.help",
        Job::AttackCore => {
            if e.working {
                "job.core_attack"
            } else {
                "job.core_march"
            }
        }
        Job::Leave => "job.leave",
        Job::Reinforce(_) => "job.reinforce",
        Job::Repair(_) => "job.repair",
        Job::MendBridge(_) => "job.mend_bridge",
        Job::RaiseWall(_) => "job.raise_wall",
        Job::March(_) => "job.march",
        Job::Carry(_) => "job.carry",
        Job::Pray(_) => "job.pray",
        Job::HealCore => "job.heal_core",
        Job::AttackTower(_) => "job.attack_tower",
        Job::Rally => {
            if e.working {
                "job.gate_attack"
            } else {
                "job.rally"
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // Simulates games with a simple bot player and checks that nothing crashes.
    #[test]
    fn simulate_long_game() {
        for seed in [1u32, 7, 12345] {
            let mut g = Game::new(seed, 64, 64);
            let (cx, cy) = g.map.core;
            let (px, py) = g.map.portals[0];
            // dig a way to the portal (through earth/gold, around rock)
            let start = idx(cx - 1, cy + 1);
            let goal = idx(px + 1, py + 1);
            let path = g
                .map
                .search(start, |i| if g.map.t[i].kind == Kind::Rock { None } else { Some(1) }, |i| i == goal, false)
                .expect("Portal erreichbar");
            for i in path {
                if g.map.t[i].diggable() {
                    g.map.t[i].marked = true;
                }
            }
            g.mark_rect(cx - 6, cy - 6, cx + 9, cy + 9, true);
            let (ox, oy) = (cx - 3, cy - 3);
            g.build_rect(1, ox, oy, ox + 2, oy + 1); // lair 3x2
            g.build_rect(2, ox + 5, oy, ox + 7, oy + 1); // farm 3x2
            let dt = 0.05;
            let mut built = false;
            let mut portal_logged = false;
            for step in 0..(40 * 60 * 20) {
                g.update(dt);
                g.events.clear();
                g.msgs.clear();
                if step % 200 == 0 && !built && g.gold > 1900.0 {
                    g.build_rect(0, ox, oy + 6, ox + 1, oy + 8); // treasury
                    g.build_rect(3, ox + 6, oy + 6, ox + 8, oy + 8); // training hall
                    g.build_rect(1, ox, oy + 2, ox + 2, oy + 2); // enlarge the lair
                    built = true;
                }
                // the bot uses lightning against heroes at the core
                if step % 20 == 0 && g.mana >= 50.0 {
                    let target = g.ents.iter().find(|e| e.alive && e.hero && (e.x - cx as f32).abs() < 4.0 && (e.y - cy as f32).abs() < 4.0).map(|e| (e.x, e.y));
                    if let Some((x, y)) = target {
                        g.lightning(x, y);
                    }
                }
                if step == 20 * 60 * 20 {
                    let (gx, gy) = g.map.gate;
                    g.set_flag(gx + 1, gy + 1);
                }
                if step % 2400 == 0 {
                    println!(
                        "seed {} t={:>5.0}s gold={:>5.0} creatures={} workers={} wave={} core={:.0} gate={:.0} heroes={} army={:.0}",
                        seed,
                        g.time,
                        g.gold,
                        g.creature_count(),
                        g.worker_count(),
                        g.wave,
                        g.core_hp,
                        g.gate_hp,
                        g.ents.iter().filter(|e| e.alive && e.hero).count(),
                        g.army_value()
                    );
                }
                if g.portals_owned() > 0 && step % 20 == 0 && !portal_logged {
                    portal_logged = true;
                    println!("seed {} portal claimed after {:.0}s", seed, g.time);
                }
                if g.state != 0 {
                    println!("seed {} game over after {:.0}s, state={}", seed, g.time, g.state);
                    break;
                }
            }
        }
    }

    // a vertical river right next to the start area (east of it)
    fn river_game(lava: bool) -> (Game, i32) {
        let mut g = Game::new(7, 64, 64);
        let (cx, cy) = g.map.core;
        let rx = cx + 6; // the start area reaches to cx + 5
        for y in cy - 6..=cy + 8 {
            for x in rx..rx + 3 {
                let t = &mut g.map.t[idx(x, y)];
                t.kind = if lava { Kind::Lava } else { Kind::Water };
                t.owner = Owner::None;
            }
        }
        (g, rx)
    }

    #[test]
    fn bridges_grow_from_own_ground() {
        let (mut g, rx) = river_game(false);
        let (_, cy) = g.map.core;
        g.gold = 1000.0;
        // not touching own ground: nothing happens
        g.build_bridges(rx + 1, cy, rx + 2, cy);
        assert_eq!(g.map.t[idx(rx + 1, cy)].kind, Kind::Water);
        // from the bank across the river: three tiles at 30 gold
        g.build_bridges(rx - 1, cy, rx + 2, cy);
        for x in rx..rx + 3 {
            let t = g.map.t[idx(x, cy)];
            assert_eq!(t.kind, Kind::Bridge);
            assert_eq!(t.owner, Owner::Player);
            assert!(t.walkable());
        }
        assert_eq!(g.gold, 1000.0 - 3.0 * BRIDGE_COST[0] as f32);
        // the far bank can be reached on foot now
        let (cx, _) = g.map.core;
        assert!(g.map.path_to(idx(cx + 4, cy), idx(rx + 3, cy)).is_some() || !g.map.walk(rx + 3, cy));
        // selling a bridge tile: units on it swim back to a bank, half the cost is refunded
        let id = g.spawn(EK::Kobold, false, rx as f32 + 1.5, cy as f32 + 0.5, 1);
        g.sell_rect(rx + 1, cy, rx + 1, cy);
        assert_eq!(g.map.t[idx(rx + 1, cy)].kind, Kind::Water);
        let e = g.ents.iter().find(|e| e.id == id).unwrap();
        assert!(e.alive && g.map.walk(e.x as i32, e.y as i32));
    }

    #[test]
    fn a_match_gives_every_master_his_core_and_his_ground() {
        let mut g = Game::new(7, 96, 128);
        g.init_fog();
        assert!(g.start_masters(&[0, 2, 3, 4], 2), "four masters, and I am the green one");
        assert_eq!(g.local_side, 2);
        assert_eq!(g.masters.len(), 3);
        for side in Owner::MASTER_SIDES {
            let owner = Owner::of_side(side);
            assert!(g.is_master(side));
            let cores = g.map.t.iter().filter(|t| t.kind == Kind::Core && t.owner == owner).count();
            assert_eq!(cores, 9, "master {side} has his soul core");
            let ground = g.map.t.iter().filter(|t| t.kind == Kind::Floor && t.owner == owner).count();
            assert!(ground >= 40, "master {side} has a starting area of his own");
            g.switch_to(side);
            assert_eq!(g.core_hp, CORE_HP, "every core starts intact");
            assert_eq!(g.gold, 1500.0, "and every master with the same gold");
        }
        g.switch_to(2);
        let green = g.map.core;
        g.switch_to(4);
        assert_ne!(g.map.core, green, "the masters live apart");
        for _ in 0..50 {
            g.update(STEP);
        }
        assert_eq!(g.sim_steps, 50, "every master is simulated");
        assert_eq!(g.me_side, 2, "the saddle goes back to the master who plays here");
    }

    #[test]
    fn lava_burns_and_needs_stone_bridges() {
        let (mut g, rx) = river_game(true);
        let (_, cy) = g.map.core;
        g.gold = 1000.0;
        g.build_bridges(rx - 1, cy, rx, cy);
        assert_eq!(g.map.t[idx(rx, cy)].kind, Kind::LavaBridge);
        assert_eq!(g.gold, 1000.0 - BRIDGE_COST[1] as f32);
        // a hero pushed off the bridge into the lava burns, the bounty is paid
        let id = g.spawn(EK::Knight, true, rx as f32 + 0.5, cy as f32 + 0.5, 1);
        let j = g.ents.iter().position(|e| e.id == id).unwrap();
        let gold = g.gold;
        g.knock(j, 0.0, 1.0);
        assert!(!g.ents[j].alive);
        assert!(g.gold > gold);
        // removing the stone bridge under a unit burns it as well
        let id = g.spawn(EK::Kobold, false, rx as f32 + 0.5, cy as f32 + 0.5, 1);
        g.sell_rect(rx, cy, rx, cy);
        assert!(!g.ents.iter().any(|e| e.id == id && e.alive));
        // heroes cannot path through lava
        assert_eq!(g.map.hero_cost()(idx(rx + 1, cy)), None);
    }

    fn treasury_total(g: &Game) -> f32 {
        g.reserve + g.map.t.iter().filter(|t| t.kind == Kind::Treasury && t.owner == Owner::Player).map(|t| t.gold as f32).sum::<f32>()
    }

    #[test]
    fn treasury_shows_its_treasures() {
        let mut g = Game::new(3, 64, 64);
        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(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(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(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();
        assert!(g.reserve > 0.0 && g.reserve <= CORE_STORE + gem_room + 1.0, "reserve {} gold {} cap {}", g.reserve, g.gold, g.gold_cap());
    }

    #[test]
    fn treasure_lands_in_the_nearest_treasury() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        // a second treasury far from the core ring
        for y in cy - 9..=cy - 7 {
            for x in cx + 10..=cx + 12 {
                let t = &mut g.map.t[idx(x, y)];
                t.kind = Kind::Treasury;
                t.owner = Owner::Player;
                t.gold = 0;
            }
        }
        g.recount();
        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(STEP);
        assert_eq!(far(&g) - before, 900, "the rubies lie where they were delivered");
    }

    #[test]
    fn training_is_billed_on_payday() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        g.spawn(EK::Kobold, false, (cx + 4) as f32 + 0.5, (cy + 4) as f32 + 0.5, 1);
        g.training_bill = 50.0;
        let cost = g.next_payday_cost();
        assert_eq!(cost, 50.0 + st(EK::Kobold).wage as f32);
        let gold = g.gold;
        g.payday = PAYDAY_WARN + 0.05;
        g.update(0.1);
        assert!(g.payday_warned);
        g.payday = 0.01;
        g.update(0.1);
        // the training bill is paid at once, the wage when the kobold fetches it
        assert_eq!(g.training_bill, 0.0);
        assert!((gold - g.gold - 50.0).abs() < 1.0);
        let mut fetched = false;
        for _ in 0..(70 * 20) {
            g.update(0.05);
            fetched |= g.ents.iter().any(|e| matches!(e.job, Job::FetchWage(_)));
        }
        assert!(fetched, "the kobold walks to the treasury");
        assert!((gold - g.gold - cost).abs() < 1.0, "paid {}", gold - g.gold);
        assert!(g.ents.iter().all(|e| e.pay_due == 0.0));
    }

    #[test]
    fn new_creatures_report_and_set_up_their_bed() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        g.gold = 3000.0;
        g.build_rect(1, cx - 3, cy - 3, cx - 2, cy + 1);
        g.build_rect(2, cx + 4, cy - 3, cx + 5, cy + 1);
        // arrives like from a portal (the test map's portal is not connected yet)
        let id = g.spawn(EK::Kobold, false, (cx + 4) as f32 + 0.5, (cy + 4) as f32 + 0.5, 1);
        if let Some(e) = g.ents.iter_mut().find(|e| e.id == id) {
            e.settled = false;
            e.job = Job::Register;
            e.timer = 2.0;
        }
        let mut made_bed = false;
        for _ in 0..(90 * 20) {
            g.update(0.05);
            let e = g.ents.iter().find(|e| e.id == id).unwrap();
            made_bed |= matches!(e.job, Job::MakeBed(_)) && e.path.is_empty();
            if e.settled {
                break;
            }
        }
        let e = g.ents.iter().find(|e| e.id == id).unwrap();
        assert!(made_bed && e.settled);
        assert_eq!(g.map.t[e.bed.unwrap()].kind, Kind::Lair);
    }

    // a fortress east of the start area, joined to it by a claimed corridor
    fn fort_game(spec: impl Fn(i32, i32) -> crate::fortress::FortSpec) -> (Game, crate::fortress::FortSpec) {
        let mut g = Game::new(11, 96, 64);
        let (cx, cy) = g.map.core;
        let f = spec(cx + 14, cy - 6);
        g.build_fortress(&f);
        for x in cx + 5..f.x {
            for y in cy..=cy + 2 {
                let t = &mut g.map.t[idx(x, y)];
                t.kind = Kind::Floor;
                t.owner = Owner::Player;
            }
        }
        (g, f)
    }

    fn spec(x: i32, y: i32) -> crate::fortress::FortSpec {
        crate::fortress::FortSpec { x, y, w: 15, h: 15, doors: vec![3], towers: vec![], tower_level: 1, guards: vec![], patrols: vec![], vaults: 0, vault_value: 0, shard: false, heart: false }
    }

    #[test]
    fn knight_towers_and_creatures_fight() {
        let (mut g, f) = fort_game(|x, y| crate::fortress::FortSpec { towers: vec![TowerKind::Arrow], ..spec(x, y) });
        assert_eq!(g.towers.len(), 1);
        assert!(g.towers[0].hero);
        let (tx, ty) = g.towers[0].pos();
        let id = g.spawn(EK::Ogre, false, tx + 3.0, ty + 2.0, 4);
        let hp0 = g.ents.iter().find(|e| e.id == id).unwrap().hp;
        let thp0 = g.towers[0].hp;
        for _ in 0..200 {
            g.update(0.05);
        }
        let hurt = g.ents.iter().find(|e| e.id == id).map_or(true, |e| e.hp < hp0);
        let tower_hurt = g.towers.first().map_or(true, |t| t.hp < thp0);
        assert!(hurt, "the knight tower shoots the creature");
        assert!(tower_hurt, "the creature attacks the knight tower");
        let _ = f;
    }

    #[test]
    fn towers_fight_towers_and_the_gate() {
        // a tower of the player in the courtyard of a fortress, no units around
        let (mut g, _) = fort_game(|x, y| crate::fortress::FortSpec { towers: vec![TowerKind::Arrow], ..spec(x, y) });
        g.ents.clear();
        let (kx, ky) = xy(g.towers[0].tile);
        let (px, py) = (kx + 3, ky + 2);
        g.map.t[idx(px, py)].owner = Owner::Player;
        g.gold = 5000.0;
        g.build_tower(TowerKind::Arrow, px, py);
        assert_eq!(g.towers.len(), 2);
        let hp: Vec<f32> = g.towers.iter().map(|t| t.hp).collect();
        for _ in 0..100 {
            g.update(0.05);
        }
        assert!(g.towers.iter().zip(&hp).all(|(t, h)| t.hp < *h), "both towers are hit");
        // free game: a tower in reach of the hero gate shoots at the gate
        let mut g = Game::new(5, 64, 64);
        g.ents.clear();
        let (gx, gy) = g.map.gate;
        let (tx, ty) = (gx - 2, gy + 1);
        g.map.t[idx(tx, ty)].kind = Kind::Floor;
        g.map.t[idx(tx, ty)].owner = Owner::Player;
        g.gold = 5000.0;
        g.build_tower(TowerKind::Arrow, tx, ty);
        for _ in 0..60 {
            g.update(0.05);
        }
        assert!(g.gate_hp < GATE_HP, "the gate is shot at");
    }

    #[test]
    fn more_lair_room_brings_creatures_faster() {
        let mut g = Game::new(3, 64, 64);
        g.counts[1] = 4;
        let tight = g.lair_factor();
        g.counts[1] = 12;
        let normal = g.lair_factor();
        g.counts[1] = 30;
        let roomy = g.lair_factor();
        assert!(tight > normal && normal > roomy, "{} {} {}", tight, normal, roomy);
        // creatures fill the lair: arrivals slow down again
        for _ in 0..20 {
            g.spawn(EK::Kobold, false, 10.0, 10.0, 1);
        }
        assert!(g.lair_factor() > roomy);
    }

    #[test]
    fn vaults_are_claimed_and_looted() {
        let (mut g, _) = fort_game(|x, y| crate::fortress::FortSpec { vaults: 2, vault_value: 1800, ..spec(x, y) });
        let gold0 = g.gold;
        for _ in 0..(240 * 20) {
            g.update(0.05);
            if g.loot >= 3000.0 {
                break;
            }
        }
        println!("loot after claiming: {}", g.loot);
        assert!(g.loot > 1000.0);
        assert!(g.gold > gold0);
    }

    #[test]
    fn patrols_walk_and_guards_raise_the_alarm() {
        let (mut g, f) = fort_game(|x, y| crate::fortress::FortSpec {
            guards: vec![(EK::Knight, 1); 4],
            patrols: vec![vec![(EK::Archer, 1)]],
            ..spec(x, y)
        });
        // no imps around (the patrol would shoot them through the door)
        g.ents.retain(|e| e.hero);
        let pj = g.ents.iter().position(|e| !e.patrol.is_empty()).unwrap();
        let pid = g.ents[pj].id;
        let start = (g.ents[pj].x, g.ents[pj].y);
        let mut far = 0.0f32;
        for _ in 0..200 {
            g.update(0.05);
            let p = g.ents.iter().find(|e| e.id == pid).unwrap();
            far = far.max((p.x - start.0).abs() + (p.y - start.1).abs());
        }
        assert!(far > 6.0, "the patrol walks its round");
        // an intruder next to one guard: the others join
        let (hx, hy) = g.ents.iter().find(|e| e.guard).unwrap().home.unwrap();
        g.spawn(EK::Ogre, false, hx + 1.0, hy, 8);
        for _ in 0..20 {
            g.update(0.05);
        }
        let fighting = g.ents.iter().filter(|e| e.guard && matches!(e.job, Job::Attack(_))).count();
        assert!(fighting >= 3, "alarm: {} guards fight", fighting);
        let _ = f;
    }

    #[test]
    fn knights_tear_down_bridges() {
        let (mut g, f) = fort_game(|x, y| crate::fortress::FortSpec { guards: vec![(EK::Knight, 1)], ..spec(x, y) });
        // a bridge of the player in the courtyard, on a small pond
        let (bx, by) = (f.x + f.w / 2 + 2, f.y + f.h / 2 + 2);
        for y in by - 1..=by + 1 {
            g.map.t[idx(bx, y)].kind = Kind::Water;
            g.map.t[idx(bx, y)].owner = Owner::None;
        }
        g.map.t[idx(bx, by)].kind = Kind::Bridge;
        g.map.t[idx(bx, by)].owner = Owner::Player;
        // no imps around to mend it (and to be attacked instead)
        g.ents.retain(|e| e.hero);
        let mut torn = false;
        for _ in 0..(90 * 20) {
            g.update(0.05);
            if g.map.t[idx(bx, by)].kind == Kind::Water {
                torn = true;
                break;
            }
        }
        assert!(torn);
    }

    #[test]
    fn some_imps_always_claim() {
        // lots of digging work: still at least 10% (min. one) of the imps claim the dug-out floor
        let mut g = Game::new(11, 64, 64);
        let (cx, cy) = g.map.core;
        for _ in 0..8 {
            let (x, y) = (g.ents[0].x, g.ents[0].y);
            g.spawn(EK::Worker, false, x, y, 1);
        }
        g.mark_rect(cx - 12, cy - 12, cx + 12, cy + 12, true);
        let (mut samples, mut ok) = (0, 0);
        for step in 0..(150 * 20) {
            g.update(0.05);
            if step % 20 != 0 || step < 200 {
                continue;
            }
            let digging = g.map.t.iter().any(|t| t.marked);
            let claimable = (0..g.map.t.len()).any(|i| g.claimable(i, u32::MAX));
            if digging && claimable {
                let imps = g.worker_count();
                let quota = ((imps as f32 * 0.1).ceil() as usize).max(1);
                let claiming = g.ents.iter().filter(|e| e.alive && e.kind == EK::Worker && matches!(e.job, Job::Claim(_))).count();
                samples += 1;
                if claiming >= quota {
                    ok += 1;
                }
            }
        }
        println!("claim quota met in {}/{} samples", ok, samples);
        assert!(samples > 10);
        assert!(ok * 10 >= samples * 8);
    }

    #[test]
    fn wall_corners_are_reinforced_too() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        // the start area spans cx-3..cx+5 / cy-3..cy+5: its walls are at cx-4 and cy-4
        let (x0, y0) = (cx - 4, cy - 4);
        for k in 1..4 {
            g.map.t[idx(x0 + k, y0)].reinforced = true;
            g.map.t[idx(x0, y0 + k)].reinforced = true;
        }
        assert!(g.map.t[idx(x0, y0)].kind == Kind::Earth && !g.map.t[idx(x0, y0)].reinforced);
        g.reinforce_corners();
        assert!(g.map.t[idx(x0, y0)].reinforced, "the corner is reinforced");
        // nothing spreads into the earth behind the walls
        g.reinforce_corners();
        assert!(!g.map.t[idx(x0 - 1, y0)].reinforced && !g.map.t[idx(x0, y0 - 1)].reinforced && !g.map.t[idx(x0 - 1, y0 - 1)].reinforced);
    }

    #[test]
    fn idle_imps_help_and_speed_up_work() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        for _ in 0..6 {
            g.spawn(EK::Worker, false, cx as f32 + 4.5, cy as f32 + 1.5, 1);
        }
        // a single earth tile to dig, next to the start area: one digs, the others help
        let (dx, dy) = (cx + 6, (cy - 3..=cy + 5).find(|&y| g.map.t[idx(cx + 6, y)].kind == Kind::Earth).expect("earth next to the start area"));
        // no other work: everything around is claimed already, no walls to reinforce
        for t in g.map.t.iter_mut() {
            if t.kind == Kind::Earth {
                t.reinforced = true;
            }
        }
        g.map.t[idx(dx, dy)].reinforced = false;
        g.map.t[idx(dx, dy)].marked = true;
        let mut best = 0.0f32;
        for _ in 0..200 {
            g.update(0.05);
            best = best.max(g.help_speed(idx(dx, dy)));
            if g.map.t[idx(dx, dy)].kind != Kind::Earth {
                break;
            }
        }
        println!("best working speed {}", best);
        assert!(best >= 1.75, "helpers join: {}", best);
        assert!(best <= 2.0);
    }

    #[test]
    fn imps_set_up_torch_stands_in_big_rooms_on_their_own_ground() {
        let mut g = Game::new(5, 96, 96);
        let (cx, cy) = g.map.core;
        // a big hall of own ground east of the core, and as big a neutral cave south of it
        let hall = (cx + 8, cy - 7, cx + 22, cy + 7);
        let cave = (cx - 7, cy + 12, cx + 7, cy + 26);
        for (x0, y0, x1, y1, own) in [(hall.0, hall.1, hall.2, hall.3, true), (cave.0, cave.1, cave.2, cave.3, false)] {
            for y in y0..=y1 {
                for x in x0..=x1 {
                    let t = &mut g.map.t[idx(x, y)];
                    t.kind = Kind::Floor;
                    t.owner = if own { g.me } else { Owner::None };
                }
            }
        }
        g.torches.clear();
        g.place_all_torches();
        let inside = |t: &Torch, r: (i32, i32, i32, i32)| {
            let (x, y) = xy(t.wall);
            x >= r.0 && x <= r.2 && y >= r.1 && y <= r.3
        };
        let stands: Vec<Torch> = g.torches.iter().copied().filter(|t| t.stand).collect();
        assert!(stands.iter().any(|t| inside(t, hall)), "the big hall gets torch stands");
        assert!(!stands.iter().any(|t| inside(t, cave)), "never on neutral ground");
        for t in &stands {
            assert_eq!(g.map.t[t.wall].owner, g.me, "only on own ground");
            let (x, y) = xy(t.wall);
            assert!((-1..=1).all(|dy| (-1..=1).all(|dx| !g.map.t[idx(x + dx, y + dy)].solid())), "not next to a wall");
        }
        // every tile of the hall's middle is within reach of some torch
        for y in hall.1 + 2..=hall.3 - 2 {
            for x in hall.0 + 2..=hall.2 - 2 {
                let lit = g.torches.iter().any(|t| {
                    let (px, pz) = t.pos();
                    (px - x as f32 - 0.5).powi(2) + (pz - y as f32 - 0.5).powi(2) <= (STAND_GAP + 1.0).powi(2)
                });
                assert!(lit, "({}, {}) lies in the dark", x, y);
            }
        }
        // ground lost: the stand goes
        let s0 = stands.iter().find(|t| inside(t, hall)).unwrap().wall;
        g.map.t[s0].owner = Owner::Hero;
        for _ in 0..60 {
            g.update(0.05);
        }
        assert!(!g.torches.iter().any(|t| t.stand && t.wall == s0), "a stand on lost ground is removed");
    }

    #[test]
    fn badly_hurt_creatures_flee_to_the_lair_and_heal() {
        let mut g = Game::new(5, 64, 64);
        let (cx, cy) = g.map.core;
        g.gold = 5000.0;
        g.build_rect(1, cx - 3, cy - 3, cx - 2, cy + 2);
        assert!(g.counts[1] >= 8, "a lair");
        let id = g.spawn(EK::Kobold, false, cx as f32 + 5.5, cy as f32 + 0.5, 2);
        let j = g.ents.iter().position(|e| e.id == id).unwrap();
        g.ents[j].hp = g.ents[j].max_hp * 0.2;
        let mut fled = false;
        for _ in 0..(20 * 6) {
            g.update(0.05);
            fled |= matches!(g.ents[j].job, Job::Rest(_));
        }
        assert!(fled, "it fled to rest");
        for _ in 0..(20 * 20) {
            g.update(0.05);
        }
        assert!(g.ents[j].hp > g.ents[j].max_hp * 0.5, "and healed: {} of {}", g.ents[j].hp, g.ents[j].max_hp);
    }

    #[test]
    fn flyers_take_every_way_across_rivers() {
        let (mut g, rx) = river_game(false);
        let (cx, cy) = g.map.core;
        // open floor on the far bank with one training tile of the player
        for y in cy - 2..=cy + 2 {
            for x in rx + 3..rx + 7 {
                let t = &mut g.map.t[idx(x, y)];
                t.kind = Kind::Floor;
                t.owner = Owner::None;
            }
        }
        let room = idx(rx + 4, cy);
        g.map.t[room].kind = Kind::Training;
        g.map.t[room].owner = g.me;
        let owl = g.spawn(EK::Owl, false, (cx + 4) as f32 + 0.5, cy as f32 + 0.5, 1);
        let kobold = g.spawn(EK::Kobold, false, (cx + 4) as f32 + 0.5, cy as f32 + 0.5, 1);
        let owl = g.ents.iter().find(|e| e.id == owl).unwrap().clone();
        let kobold = g.ents.iter().find(|e| e.id == kobold).unwrap().clone();
        // room searches: the owl flies over the river to the training room, the kobold cannot get there
        let p = g.find_room_tile(&owl, Kind::Training, owl.id + 1, false).expect("the owl finds the room across the river");
        assert_eq!(p.last().copied(), Some(room));
        assert!(g.find_room_tile(&kobold, Kind::Training, kobold.id + 1, false).map_or(true, |p| p.last() != Some(&room)));
        // flyers cut corners over water: a diagonal crossing is as short as on open ground
        let (a, b) = (idx(rx - 1, cy - 1), idx(rx + 3, cy + 1));
        let p = g.map.creature_path(true, a, b).expect("flight path");
        assert!(p.len() <= 5, "diagonal flight over the river: {} steps", p.len());
        assert!(p.iter().any(|&i| g.map.t[i].liquid()));
        // attacking flyers (the fairy spy) also fly over rivers instead of searching for a bridge
        assert!(g.map.hero_cost_as(true)(idx(rx + 1, cy)).is_some());
        assert_eq!(g.map.hero_cost()(idx(rx + 1, cy)), None);
        // a locked door stops flyers too
        g.map.t[idx(rx + 5, cy)].kind = Kind::Door;
        g.map.t[idx(rx + 5, cy)].res = 1;
        assert_eq!(g.map.fly_cost()(idx(rx + 5, cy)), None);
    }

    #[test]
    fn flyers_cross_rivers_flee_and_heal() {
        let (mut g, rx) = river_game(true);
        let (cx, cy) = g.map.core;
        // an aerie in the start area
        g.gold = 5000.0;
        g.build_rect(7, cx - 3, cy - 3, cx - 2, cy + 2);
        assert!(g.counts[7] >= 8);
        // a knight on the far side of the lava: an owl reaches it, a kobold does not
        let far = (rx + 4, cy);
        for x in rx + 3..rx + 7 {
            let t = &mut g.map.t[idx(x, cy)];
            t.kind = Kind::Floor;
            t.owner = Owner::None;
        }
        let k = g.spawn(EK::Knight, true, far.0 as f32 + 0.5, far.1 as f32 + 0.5, 1);
        let owl = g.spawn(EK::Owl, false, (cx + 4) as f32 + 0.5, cy as f32 + 0.5, 3);
        assert!(g.map.fly_path_to(idx(cx + 4, cy), idx(far.0, far.1)).is_some());
        assert!(g.map.path_to(idx(cx + 4, cy), idx(far.0, far.1)).is_none());
        let hp0 = g.ents.iter().find(|e| e.id == k).unwrap().hp;
        for _ in 0..300 {
            g.update(0.05);
        }
        let hit = g.ents.iter().find(|e| e.id == k).map_or(true, |e| e.hp < hp0);
        assert!(hit, "the owl attacks across the lava");
        // a badly hurt flyer flees to the aerie and heals up to 75%
        g.ents.retain(|e| !e.hero);
        let j = g.ents.iter().position(|e| e.id == owl).unwrap();
        g.ents[j].hp = g.ents[j].max_hp * 0.2;
        let mut rested = false;
        for _ in 0..800 {
            g.update(0.05);
            let e = g.ents.iter().find(|e| e.id == owl).unwrap();
            rested |= matches!(e.job, Job::Rest(_));
            if e.hp >= e.max_hp * 0.75 {
                break;
            }
        }
        let e = g.ents.iter().find(|e| e.id == owl).unwrap();
        assert!(rested && e.hp >= e.max_hp * 0.74, "fled and healed: {} / {}", e.hp, e.max_hp);
        // lava does not burn flyers
        let j = g.ents.iter().position(|e| e.id == owl).unwrap();
        g.ents[j].x = (rx - 1) as f32 + 0.5;
        g.ents[j].y = cy as f32 + 0.5;
        g.knock(j, 1.0, 0.0);
        assert!(g.ents[j].alive);
    }

    #[test]
    fn aerie_attracts_flyers() {
        let mut g = Game::new(3, 64, 64);
        g.counts = [16, 0, 9, 0, 6, 4, 0, 16, 0, 0, 0, 0, 0, 0];
        let mut seen = std::collections::HashSet::new();
        for _ in 0..200 {
            g.try_portal_for_test();
            for e in g.ents.iter().filter(|e| e.creature()) {
                seen.insert(e.kind);
            }
            g.ents.retain(|e| !e.creature());
        }
        assert!(seen.contains(&EK::Bat) && seen.contains(&EK::Gargoyle) && seen.contains(&EK::Owl), "{:?}", seen);
        assert!(seen.iter().all(|&k| flies(k)), "no lair: only flyers come ({:?})", seen);
    }

    #[test]
    fn steel_walls_hold_heroes_back() {
        let mut g = Game::new(3, 64, 64);
        let (cx, cy) = g.map.core;
        let (wx, wy) = (cx + 6, (cy - 3..=cy + 5).find(|&y| g.map.t[idx(cx + 6, y)].kind == Kind::Earth).unwrap());
        g.gold = 1000.0;
        g.build_steel(wx, wy, wx, wy);
        assert_eq!(g.map.t[idx(wx, wy)].kind, Kind::Steel);
        assert_eq!(g.gold, 1000.0 - STEEL_COST[0] as f32);
        // far from own ground: nothing happens
        g.build_steel(wx + 5, wy, wx + 5, wy);
        assert_ne!(g.map.t[idx(wx + 5, wy)].kind, Kind::Steel);
        // heroes avoid it and dig 20 times slower than through earth
        assert_eq!(g.map.hero_cost()(idx(wx, wy)), Some(300));
        // selling: a reinforced earth wall again, half of the plating back
        let gold = g.gold;
        g.sell_rect(wx, wy, wx, wy);
        assert_eq!(g.map.t[idx(wx, wy)].kind, Kind::Earth);
        assert!(g.map.t[idx(wx, wy)].reinforced);
        assert!(g.gold > gold);
    }

    #[test]
    fn imps_reinforce_walls() {
        let mut g = Game::new(3, 64, 64);
        for _ in 0..(120 * 20) {
            g.update(0.05);
        }
        let n = g.map.t.iter().filter(|t| t.reinforced).count();
        println!("reinforced walls after 2 minutes: {}", n);
        assert!(n >= 10);
        // heroes avoid them: the hero path cost through reinforced earth is 10x
        let (cx, cy) = g.map.core;
        let w = (cx - 4, cy);
        if g.map.t[idx(w.0, w.1)].reinforced {
            assert_eq!(g.map.hero_cost()(idx(w.0, w.1)), Some(70));
        }
    }

    #[test]
    fn towers_shoot_and_get_attacked() {
        for kind in [TowerKind::Arrow, TowerKind::Cannon, TowerKind::Magic] {
            let mut g = Game::new(5, 64, 64);
            g.gold = 2000.0;
            g.mana = 400.0;
            let (cx, cy) = g.map.core;
            let (tx, ty) = (cx - 2, cy - 2);
            g.build_tower(kind, tx, ty);
            assert_eq!(g.towers.len(), 1);
            g.build_tower(kind, tx, ty); // upgrade
            assert_eq!(g.towers[0].level, 2);
            // a hero inside the start area, 4 tiles away
            let id = g.spawn(EK::Knight, true, (cx + 3) as f32 + 0.5, (cy - 2) as f32 + 0.5, 1);
            let hp0 = g.ents.iter().find(|e| e.id == id).unwrap().hp;
            let mut hurt = false;
            let mut tower_hit = false;
            for _ in 0..400 {
                g.update(0.05);
                if let Some(e) = g.ents.iter().find(|e| e.id == id) {
                    hurt |= e.hp < hp0;
                } else {
                    hurt = true;
                }
                tower_hit |= g.towers.first().map_or(true, |t| t.hp < t.max_hp());
            }
            println!("{:?}: hero hurt {}, tower attacked {}", kind, hurt, tower_hit);
            assert!(hurt, "{:?} did not damage the hero", kind);
        }
    }

    #[test]
    fn heroes_attack_towers() {
        let mut g = Game::new(5, 64, 64);
        g.gold = 2000.0;
        for e in g.ents.iter_mut() {
            e.alive = false; // no imps: the tower is the only target
        }
        let (cx, cy) = g.map.core;
        g.build_tower(TowerKind::Cannon, cx - 2, cy - 2);
        g.spawn(EK::Ogre, true, (cx - 2) as f32 + 0.5, (cy + 4) as f32 + 0.5, 5);
        for _ in 0..600 {
            g.update(0.05);
        }
        let t = g.towers.first();
        println!("tower after attack: {:?}", t.map(|t| t.hp));
        assert!(t.map_or(true, |t| t.hp < t.max_hp()));
    }

    #[test]
    fn prisoners_are_tortured_and_resolved() {
        let mut converted = 0;
        let mut died = 0;
        for seed in 1..=40u32 {
            let mut g = Game::new(seed, 64, 64);
            g.gold = 5000.0;
            let (cx, cy) = g.map.core;
            g.build_rect(5, cx - 3, cy - 3, cx - 2, cy + 1); // torture chamber 2x5 = 5 places... 10 tiles
            assert!(g.prison_space() >= 2, "space {}", g.prison_space());
            let id = g.spawn(EK::Knight, true, (cx + 4) as f32 + 0.5, (cy + 4) as f32 + 0.5, 1);
            let j = g.ents.iter().position(|e| e.id == id).unwrap();
            g.kill(j);
            assert_eq!(g.ents[j].captive, 1);
            let mut reached = false;
            for _ in 0..(200 * 20) {
                g.update(0.05);
                match g.ents.iter().find(|e| e.id == id) {
                    Some(e) if e.captive == 3 => reached = true,
                    Some(e) if !e.hero => {
                        converted += 1;
                        break;
                    }
                    None => {
                        died += 1;
                        break;
                    }
                    _ => {}
                }
            }
            assert!(reached, "seed {}: prisoner never reached the torture chamber", seed);
        }
        println!("40 prisoners: {} defected, {} died", converted, died);
        assert_eq!(converted + died, 40);
        assert!((8..=26).contains(&converted), "defect rate off: {}/40", converted);
    }

    #[test]
    fn jailer_makes_prisoners_defect_more_often() {
        let mut converted = 0;
        let mut worked = 0;
        for seed in 1..=40u32 {
            let mut g = Game::new(seed, 64, 64);
            g.gold = 5000.0;
            let (cx, cy) = g.map.core;
            g.build_rect(5, cx - 3, cy - 3, cx - 2, cy + 1);
            g.build_rect(1, cx + 4, cy - 3, cx + 5, cy - 2); // a lair for the jailer
            let jailer = g.spawn(EK::Jailer, false, (cx - 1) as f32 + 0.5, (cy - 3) as f32 + 0.5, 1);
            let id = g.spawn(EK::Knight, true, (cx + 4) as f32 + 0.5, (cy + 4) as f32 + 0.5, 1);
            let j = g.ents.iter().position(|e| e.id == id).unwrap();
            g.kill(j);
            for _ in 0..(200 * 20) {
                g.update(0.05);
                if let Some(jl) = g.ents.iter_mut().find(|e| e.id == jailer) {
                    // keep the jailer fresh so that it works
                    jl.hunger = 0.0;
                    jl.energy = 1.0;
                    jl.happy = 1.0;
                    if jl.job == Job::Torment(id) {
                        worked += 1;
                    }
                }
                match g.ents.iter().find(|e| e.id == id) {
                    Some(e) if !e.hero => {
                        converted += 1;
                        break;
                    }
                    None => break,
                    _ => {}
                }
            }
        }
        println!("with a jailer: {} of 40 defected (jailer worked {} ticks)", converted, worked);
        assert!(worked > 0, "the jailer works on the prisoners");
        assert!(converted >= 20, "defections with a jailer: {}/40", converted);
    }

    #[test]
    fn temple_prayer_and_priestess_heals_core() {
        let mut g = Game::new(9, 64, 64);
        g.gold = 5000.0;
        let (cx, cy) = g.map.core;
        g.build_rect(6, cx - 3, cy - 3, cx - 2, cy + 1); // temple
        g.build_rect(1, cx + 4, cy - 3, cx + 5, cy - 1); // lair
        g.build_rect(2, cx + 4, cy + 3, cx + 5, cy + 5); // farm
        g.spawn(EK::Priestess, false, (cx + 4) as f32 + 0.5, (cy + 2) as f32 + 0.5, 1);
        for k in 0..3 {
            g.spawn(EK::Kobold, false, (cx - 1) as f32 + 0.5, (cy + k) as f32 + 0.5, 1);
        }
        g.core_hp = 1000.0;
        let mut prayed = false;
        for _ in 0..(120 * 20) {
            g.update(0.05);
            prayed |= g.ents.iter().any(|e| matches!(e.job, Job::Pray(_)) && e.working);
        }
        println!("core after 2 min: {:.0}, prayed: {}", g.core_hp, prayed);
        assert!(prayed);
        assert!(g.core_hp > 1300.0);
    }

    #[test]
    fn waves_vary_their_entry_points() {
        let mut g = Game::new(11, 96, 96);
        let (cx, cy) = g.map.core;
        // a bigger realm so there are several possible entry points
        for y in cy - 8..=cy + 10 {
            for x in cx - 6..=cx + 14 {
                if inb(x, y) && g.map.t[idx(x, y)].kind != Kind::Core && g.map.t[idx(x, y)].kind != Kind::Rock {
                    let t = &mut g.map.t[idx(x, y)];
                    t.kind = Kind::Floor;
                    t.owner = Owner::Player;
                }
            }
        }
        let mut seen = Vec::new();
        for _ in 0..4 {
            g.plan_entries();
            let e = g.planned_entries[0];
            println!("entry {:?} ({})", e, g.direction_key(e));
            seen.push(e);
            g.entry_history.push(e);
        }
        // consecutive waves use different places
        for w in seen.windows(2) {
            assert!((w[0].0 - w[1].0).pow(2) + (w[0].1 - w[1].1).pow(2) >= 16, "same entry twice: {:?}", w);
        }
        // spawning a big wave gives heroes two different waypoints
        g.warned = true;
        g.planned_entries.clear();
        g.plan_entries();
        assert_eq!(g.planned_entries.len(), 2);
    }

    #[test]
    fn core_starts_with_treasury_ring() {
        let g = Game::new(21, 64, 64);
        let (cx, cy) = g.map.core;
        let ring = (cy - 1..=cy + 3).flat_map(|y| (cx - 1..=cx + 3).map(move |x| (x, y))).filter(|&(x, y)| g.map.t[idx(x, y)].kind == Kind::Treasury).count();
        assert_eq!(ring, 16);
        assert_eq!(g.counts[0], 16);
    }

    #[test]
    fn hand_rules() {
        let mut g = Game::new(4, 64, 64);
        g.gold = 5000.0;
        let (cx, cy) = g.map.core;
        // backhand on an own imp: faster for 15 s, costs a little HP
        let imp = g.ents.iter().position(|e| e.kind == EK::Worker).unwrap();
        let hp = g.ents[imp].hp;
        assert_eq!(g.slap(Some(imp)), 1);
        assert_eq!(g.ents[imp].boost, 15.0);
        assert!(g.ents[imp].hp < hp);
        // fist: only on own ground
        let far = g.spawn(EK::Knight, true, 40.5, 40.5, 1);
        let jf = g.ents.iter().position(|e| e.id == far).unwrap();
        if g.map.t[idx(40, 40)].owner != Owner::Player {
            assert_eq!(g.slap(Some(jf)), 0);
        }
        let near = g.spawn(EK::Knight, true, (cx - 2) as f32 + 0.5, (cy - 2) as f32 + 0.5, 1);
        let jn = g.ents.iter().position(|e| e.id == near).unwrap();
        let hp = g.ents[jn].hp;
        assert_eq!(g.slap(Some(jn)), 2);
        assert!(g.ents[jn].hp < hp && g.ents[jn].stun > 0.0);
        assert_eq!(g.slap(Some(jn)), 0, "cooldown");
        // prisoners: pick up on own ground, drop onto a torture place = locked up
        g.build_rect(5, cx - 3, cy - 3, cx - 2, cy + 1);
        let jn = g.ents.iter().position(|e| e.id == near).unwrap();
        g.kill(jn);
        assert_eq!(g.ents[jn].captive, 1);
        assert!(g.pickup(Some(jn)));
        let t = (cx - 3, cy + 1);
        assert!(g.drop(t.0 as f32 + 0.5, t.1 as f32 + 0.5));
        let e = g.ents.iter().find(|e| e.id == near).unwrap();
        assert_eq!(e.captive, 3);
        // own units cannot be dropped outside own ground
        let imp = g.ents.iter().position(|e| e.kind == EK::Worker).unwrap();
        assert!(g.pickup(Some(imp)));
        assert!(!g.drop(40.5, 40.5) || g.map.t[idx(40, 40)].owner == Owner::Player);
    }

    #[test]
    fn chainbreaker_visits_only_great_dungeons() {
        let mut g = Game::new(8, 64, 64);
        g.gold = 9000.0;
        // conditions not met: no Chainbreaker among many portal visits
        let (px, py) = g.map.portals[0];
        for y in 0..3 {
            for x in 0..3 {
                g.map.t[idx(px + x, py + y)].owner = Owner::Player;
            }
        }
        let (cx, cy) = g.map.core;
        g.build_rect(1, cx + 4, cy - 3, cx + 5, cy + 5); // lair 18
        g.build_rect(2, cx - 3, cy - 3, cx - 2, cy + 5); // farm 18
        g.recount();
        for _ in 0..60 {
            g.try_portal();
        }
        assert!(!g.ents.iter().any(|e| e.kind == EK::Chainbreaker));
        // a veteran creature makes it possible (rooms 16 ring + 36 = 52 tiles, gold 9000)
        if let Some(e) = g.ents.iter_mut().find(|e| e.creature()) {
            e.level = 5;
        }
        for e in g.ents.iter_mut().filter(|e| e.creature()) {
            e.alive = false; // free beds
        }
        g.ents.retain(|e| e.alive);
        g.spawn(EK::Kobold, false, cx as f32, cy as f32, 6);
        let mut seen = false;
        for _ in 0..400 {
            g.gold = 9000.0;
            g.try_portal();
            seen |= g.ents.iter().any(|e| e.kind == EK::Chainbreaker);
            g.ents.retain(|e| !e.creature() || e.kind == EK::Chainbreaker || e.level >= 5);
        }
        assert!(seen);
        assert!(g.ents.iter().filter(|e| e.kind == EK::Chainbreaker).count() <= 1);
    }

    #[test]
    fn the_beds_decide_how_many_creatures_come_but_never_more_than_100() {
        let mut g = Game::new(9, 96, 96);
        let (cx, cy) = g.map.core;
        // a lair of 40 beds: room for 40
        let mut n = 0;
        for y in cy + 4..cy + 20 {
            for x in cx - 6..cx + 8 {
                if n < 40 && inb(x, y) {
                    let t = &mut g.map.t[idx(x, y)];
                    t.kind = Kind::Lair;
                    t.owner = Owner::Player;
                    n += 1;
                }
            }
        }
        g.recount();
        assert_eq!(g.creature_cap(), 40);
        assert_eq!(g.free_lair_aerie().0, 40, "more than the old 30");
        // a huge lair: the cap is 100
        for y in cy + 4..cy + 20 {
            for x in cx - 10..cx + 12 {
                if inb(x, y) && g.map.t[idx(x, y)].kind != Kind::Core {
                    let t = &mut g.map.t[idx(x, y)];
                    t.kind = Kind::Lair;
                    t.owner = Owner::Player;
                }
            }
        }
        g.recount();
        assert!(g.counts[1] > 100);
        assert_eq!(g.creature_cap(), MAX_CREATURES);
        for k in 0..100 {
            g.spawn(EK::Kobold, false, cx as f32 + 0.5 + (k % 10) as f32, cy as f32 + 5.5 + (k / 10) as f32, 1);
        }
        assert_eq!(g.free_lair_aerie(), (0, 0), "no room for a 101st");
    }

    #[test]
    fn creatures_never_make_their_bed_in_an_allys_lair() {
        let mut g = Game::new(11, 96, 128);
        g.coop = true;
        assert!(g.start_masters(&[0, 2], 0));
        let (cx, cy) = g.map.core;
        for y in cy + 4..cy + 7 {
            for x in cx - 1..cx + 4 {
                let t = &mut g.map.t[idx(x, y)];
                t.kind = Kind::Lair;
                t.owner = Owner::Player;
            }
        }
        g.recount();
        let id = g.spawn(EK::Kobold, false, cx as f32 + 1.5, cy as f32 + 5.5, 1);
        if let Some(e) = g.ents.iter_mut().find(|e| e.id == id) {
            e.side = 2;
            e.energy = 0.1;
        }
        for _ in 0..(40 * 20) {
            g.update(0.05);
        }
        let e = g.ents.iter().find(|e| e.id == id).expect("still there");
        assert!(e.bed.map_or(true, |b| g.map.t[b].owner != Owner::Player), "no bed in the ally's lair");
        assert!(!g.map.t.iter().any(|t| t.kind == Kind::Lair && t.bed == id + 1));
    }

    #[test]
    fn every_master_of_a_coop_mission_has_an_own_portal() {
        let m = crate::campaign::coop_mission_indexes()[2];
        let mut g = crate::campaign::start_mission(m, None);
        g.coop = true;
        assert!(g.start_masters(&[0, 2, 3], 0));
        for side in [2u8, 3] {
            let owner = Owner::of_side(side);
            let core = g.masters.iter().find(|m| m.side == side).unwrap().core;
            let k = (0..g.map.portals.len()).find(|&k| g.map.portal_owner(k) == owner && g.map.portals[k] == (core.0 + 6, core.1)).expect("a portal of his own");
            let (px, py) = g.map.portals[k];
            let from = idx(core.0 + 1, core.1 + 4);
            assert!(g.map.creature_path(false, from, idx(px, py + 1)).is_some(), "reachable from his dungeon");
        }
        for n in crate::lobby::MATCH_SIZES {
            let seats = crate::lobby::seats_for(n);
            let mut m = Game::new(3, n, n);
            assert!(m.start_masters(seats, 0), "a {}x{} match with {} seats", n, n, seats.len());
        }
    }

    #[test]
    fn a_coop_ai_seat_fights_beside_the_host_not_against_him() {
        let mut g = Game::new(11, 96, 128);
        g.init_fog();
        g.coop = true;
        assert!(g.start_masters(&[0, 2, 3], 2), "a co-op match may keep an empty side as AI");
        g.sync_ai_sides(&[3], 0);
        assert!(g.allied(g.me_side, 3), "side 3 is an allied master seat, not a rival");

        g.ents.clear();
        let (cx, cy) = g.map.core;
        let local = g.spawn(EK::Kobold, false, cx as f32 + 3.5, cy as f32 + 3.5, 1);
        let ally = g.spawn(EK::Kobold, false, cx as f32 + 4.5, cy as f32 + 3.5, 1);
        if let Some(e) = g.ents.iter_mut().find(|e| e.id == ally) {
            e.side = 3;
        }

        let local = g.ents.iter().find(|e| e.id == local).unwrap().clone();
        let ally = g.ents.iter().find(|e| e.id == ally).unwrap().clone();
        assert!(!g.is_hostile(&ally));
        assert_eq!(g.nearest_enemy(&local, 5.0), None, "the allied AI creature is no target for the local master");
    }
}