sindicate 0.4.0 → 0.6.0

package/src/systems/enemy.js

@@ -0,0 +1,442 @@
+// Enemies: the outlaws of Dustwater — simple but lively AI:
+// wander -> aggro -> chase -> attack/shoot -> stagger/death.
+// Brawlers box with the punch set; gunmen hang back in a ranged band and fire
+// real bullets through combat.fireBullet (tracer + muzzle flash + gunshot).
+import { Character } from './entity.js';
+// fighter clip list + subset helper are game data: setEnemyContent({ clipSubset, fighterClips })
+let EC = { clipSubset: (c) => c, fighterClips: [] };
+export function setEnemyContent(c) { EC = { ...EC, ...c }; }
+import { steerCarrot } from './pathFollow.js';
+import { dist2D, tmpV1 } from '../core/utils.js';
+import { collectFistJoints, applyFist } from './fistCurl.js';
+
+const _echase = { x: 0, z: 0 };   // scratch: the point steerCarrot hands a chasing enemy to aim at
+
+// Faction enmity: 'hostile' outlaws fight the player (and any 'ally', if one ever exists);
+// allies NEVER target the player. An undefined team is a non-combatant — no foe of anyone.
+const TEAM = { hostile: 'evil', player: 'good', ally: 'good' };
+export function foes(a, b) { const ta = TEAM[a], tb = TEAM[b]; return !!ta && !!tb && ta !== tb; }
+
+// ── HOW WELL THEY SHOOT, AND HOW THAT CHANGES ────────────────────────────────────────────────
+// Every round an outlaw ever fired used to LAND: _landSwing drew a straight line from his chest to
+// yours and let go. The only thing keeping you alive was his rate of fire, which is a countdown,
+// not a gunfight.
+//
+// So he rolls. A shot is decided HIT or MISS first, and then AIMED to match — which is the only way
+// to say "one in five" and mean it. Fake it with a cone of spread instead and the hit rate becomes a
+// function of range and of how wide the man is, i.e. of nothing you can tune.
+//
+// The county learns. The first men who come at you are drunks with a pistol who have never been shot
+// at; the ones who come later have heard what you did to the others. combat.playerKills is the count,
+// because a death by your hand is the one thing every other system only sees half of.
+export const AIM = {
+  green: 0.20,       // one shot in five, at the start. He is nervous and you are moving.
+  master: 0.90,      // ...and by the end he does not miss much. 1.0 would be a cheat, not a duel.
+  seasonedAt: 45,    // kills. The ramp is smoothstepped, so it steepens in the middle of the game.
+  // A MISS MUST BE A MISS YOU CAN SEE. Deflect enough to whistle past — 0.5m to 1.4m off at the
+  // player's range — and no further: a shot that lands ten metres wide reads as a bug, not a near
+  // thing. (The player's capsule is 0.42m; anything past ~0.6m of offset is clean air.)
+  missNear: 0.55,
+  missFar: 1.40,
+  // and the good ones do not all shoot alike
+  skill: { rifle: 1.15, boss: 1.35, brawler: 0.75 },     // multipliers on the hit chance
+  // Distance still matters. At the far end of his band he is worse, whatever he has learnt.
+  falloffFrom: 12,   // metres — inside this, his practised chance stands
+  falloffTo: 40,     // ...and by here it is halved
+};
+
+const smooth = (t) => t * t * (3 - 2 * t);
+
+// THE LAW SHOOTS BY THE STARS, NOT BY YOUR KILL COUNT. An outlaw gets better because he has heard
+// what you did to the last one; a deputy is not a better shot for that reason — a BETTER MAN is
+// sent. At one and two stars it is whoever the sheriff could find: a shopkeeper with a badge, and he
+// shoots like one. Past that they send men who do this for a living, and at five they have sent the
+// best they have. Indexed BY STAR (0..5), so index 0 is the peacetime deputy nobody called for.
+const LAW_AIM = [0.20, 0.20, 0.25, 0.45, 0.70, 0.92];
+
+// The chance THIS man lands THIS shot, right now.
+export function hitChance(e, dist, game) {
+  const d = e.def ?? {};
+  let c;
+  if (d.law || /^law_/.test(e.type ?? '')) {
+    const stars = Math.max(0, Math.min(5, game?.crime?.level ?? 0));
+    c = LAW_AIM[stars];
+  } else {
+    const kills = game?.combat?.playerKills ?? 0;
+    const learn = smooth(Math.min(1, kills / AIM.seasonedAt));
+    c = AIM.green + (AIM.master - AIM.green) * learn;
+  }
+  if (d.boss) c *= AIM.skill.boss;
+  else if (d.aimClip === 'rifleAim') c *= AIM.skill.rifle;
+  else if (d.brawler) c *= AIM.skill.brawler;
+  const far = smooth(Math.min(1, Math.max(0, (dist - AIM.falloffFrom) / (AIM.falloffTo - AIM.falloffFrom))));
+  c *= 1 - 0.5 * far;
+  return Math.max(0.02, Math.min(0.97, c));
+}
+
+// Roll the shot, and bend the barrel to match the answer. `dir` is a unit vector, modified in place.
+export function aimError(dir, e, dist, game) {
+  if (Math.random() < hitChance(e, dist, game)) return false;   // he has you: the line stands
+  // A miss goes WIDE, or high, or into the dirt at your feet — but it goes somewhere you can read.
+  const off = AIM.missNear + Math.random() * (AIM.missFar - AIM.missNear);
+  const ang = Math.random() * Math.PI * 2;
+  // build a basis square to the shot: right = dir x up, and up' = right x dir
+  const rx = dir.z, rz = -dir.x;                  // dir cross (0,1,0), un-normalised is fine at |dir|=1
+  const rl = Math.hypot(rx, rz) || 1;
+  const t = off / Math.max(dist, 1);              // the angle that puts him `off` metres wide AT the player
+  dir.x += (rx / rl) * Math.cos(ang) * t;
+  dir.z += (rz / rl) * Math.cos(ang) * t;
+  dir.y += Math.sin(ang) * t * 0.7;               // less vertical: a shot over his hat reads better than one at his boots
+  dir.normalize();
+  return true;
+}
+
+// POLYGON Western characters: one multi-char FBX on the standard Synty ANIM rig →
+// keep-filter one body each + the western char atlas; they retarget on the shared
+// FIGHTER_CLIPS like every other Synty character. FBX is cm → default 0.01 scale.
+// The enemy roster is GAME data — register at boot: registerEnemyTypes(defs).
+// `??=` merge semantics: a hot-reload re-registration must not stamp a second def
+// over live enemies holding the first one by reference.
+export const ENEMY_TYPES = {};
+export function registerEnemyTypes(defs) { for (const k in defs) ENEMY_TYPES[k] ??= defs[k]; }
+
+export class Enemy extends Character {
+  constructor(game, type, clips, { x, z, y = null, leashR = 26, passive = false } = {}) {
+    const def = ENEMY_TYPES[type];
+    const cs = EC.clipSubset(clips, EC.fighterClips, { strip: true });
+    super(game, {
+      model: def.model,
+      texture: def.texture,
+      clips: cs,
+      scale: def.scale, // undefined → Character picks by URL (.glb metres=1, .fbx cm=0.01)
+      speed: def.speed,
+      health: def.health,
+      faction: def.faction ?? 'hostile',
+      name: def.name,
+      keep: def.keep,      // multi-body western FBX → base load() keep-filters + atlases
+      attach: def.attach,
+      texFlipY: def.texFlipY,
+    });
+    this.type = type;
+    this.def = def;
+    this.home = { x, z };
+    this.leashR = leashR;
+    this.passive = passive;        // won't aggro until provoked
+    this.state = 'wander';
+    this.wanderTarget = null;
+    this.thinkT = Math.random();
+    this.attackT = 0;
+    this.civilian = !!def.civilian;   // a NEUTRAL outfit's gun: an Enemy by mechanism, a civilian by law
+    this.setPosition(x, y ?? game.world.groundAt(x, z), z);   // y override: seat on a building floor
+  }
+
+  async load() {
+    await super.load();
+    // Brawlers box bare-fisted (ENEMY_TYPES … brawler:true). Collect the finger joints at REST here — the
+    // mixer hasn't posed the fingers yet — so update() can close them into fists on the punch clips, the
+    // same procedural curl the player uses (fistCurl.js). Gunmen skip this: their fingers hold the gun.
+    if (this.def.brawler) this._fistBones = collectFistJoints(this.model);
+    return this;
+  }
+
+  provoke() { this.passive = false; this.state = 'chase'; }
+
+  // A NEUTRAL MAN WHO IS SHOT AT. He is an Enemy only so that he can shoot back — by law he is a
+  // civilian, so hurting him is an assault and killing him is a murder, weighted by whoever saw it
+  // (his outfit are real NPCs standing right there, and crime.js counts them). And it brings his
+  // whole outfit down on you, which is the point: they take it badly.
+  //
+  // Plain hostiles fall straight through to Character.takeDamage, unchanged — a bandit who drew
+  // on you still costs nothing, and that must never change.
+  takeDamage(amount, fromPos = null, opts = {}) {
+    if (!this.alive || !this.civilian) return super.takeDamage(amount, fromPos, opts);
+    const g = this.game;
+    this._killer = opts.attacker ?? null;   // die() runs INSIDE super.takeDamage — stash it first
+    const byPlayer = this._killer == null || this._killer === g.player;
+    super.takeDamage(amount, fromPos, opts);
+    if (byPlayer) {
+      // AND HE DRAWS HIS OWN GUN. encounters.provokeGroup wakes his OUTFIT and deliberately skips
+      // the man who was hit (it is iterating the group's guns and he is one of them) — so without
+      // this line the only body in the outfit who can shoot back was the only one who didn't, and
+      // putting the first round into the drover's gun-hand was a free kill with no answer.
+      // 40 m of leash: he will follow you off the trail for it, but not across the county.
+      if (this.alive) { this.provoke(); this.leashR = Math.max(this.leashR, 40); }
+      g.encounters?.provokeGroup(this);
+      // ...but only if he's someone it's a CRIME to hit — a civilian (the drover fights back but is
+      // still a townsman) or a badge. Landing a round on a HOSTILE OUTLAW is self-defence, not
+      // assault — the same factional rule die() uses for murder. Without this, clearing the deputy's
+      // four outlaws earned a wanted star (Nick). (dead? die() handles the murder/no-crime call.)
+      if (this.alive && (this.civilian || this.lawman)) g.crime?.report('assault', this.position.clone());
+    }
+  }
+
+  die() {
+    // A neutral man killed by the player is a MURDER, and it is scored by his outfit as witnesses.
+    // A hostile is not: killing an Enemy reports nothing, which is the self-defence rule.
+    const murder = this.civilian && (this._killer == null || this._killer === this.game.player);
+    super.die();
+    if (murder) this.game.crime?.report('murder', this.position.clone());
+    if (this.faction === 'ally') return;
+    // outlaws bleed where they fall
+    const gy = this.game.world.groundAt(this.position.x, this.position.z);
+    this.game.vfx?.bloodDecal({ x: this.position.x, y: gy, z: this.position.z });
+    // tell the mission engine — a kill stage tallies hostiles by the mission tag stamped on them
+    // when they spawned (game/missions.js), so it advances only on the RIGHT deaths.
+    this.game.missions?.enemyKilled?.(this);
+    // ...and the bounty board (main.js): a poster's men are tagged 'bounty'
+    this.game._bountyKill?.(this);
+  }
+
+  // Pick the nearest FOE: outlaws weigh the player + any allies; allies can NEVER return the
+  // player. No range limit — the FSM's aggroR gates whether it actually engages, so a lone
+  // enemy with a far foe just stays in wander (unchanged behaviour).
+  acquireTarget() {
+    let best = null, bestD = Infinity;
+    const player = this.game.player;
+    if (player?.alive && foes(this.faction, 'player')) { best = player; bestD = dist2D(this.position.x, this.position.z, player.position.x, player.position.z); }
+    for (const e of this.game.combat.enemies) {
+      if (e === this || !e.alive || !foes(this.faction, e.faction)) continue;
+      const d = dist2D(this.position.x, this.position.z, e.position.x, e.position.z);
+      if (d < bestD) { bestD = d; best = e; }
+    }
+    return best;
+  }
+
+  // the deferred blow, ticked from update() on game time (menu/map-paused, Load-evicted).
+  // alive checks: the tick only runs while this enemy lives; the victim is re-checked here.
+  _landSwing(sw) {
+    const player = sw.target ?? this.game.player;   // the FSM's victim — NOT necessarily the human
+    if (!player?.alive) return;
+    if (sw.kind === 'ranged') {
+      const rg = sw.rg;
+      const from = this.position.clone().setY(this.position.y + 1.3);
+      const to = player.position.clone().setY(player.position.y + 1.0);
+      const dir = to.sub(from).normalize();
+      // ...AND HE MIGHT MISS. He never did: this line drew a straight line from his chest to yours
+      // and every round he ever fired landed. The only thing between you and death was how slowly he
+      // pulled the trigger, which is not a gunfight, it is a countdown.
+      if (player === this.game.player) aimError(dir, this, from.distanceTo(to), this.game);
+      this.game.combat.fireBullet({
+        from, dir, damage: Math.round(this.def.damage * (this._dmgMul ?? 1)),
+        speed: rg.projSpeed, range: rg.max + 12, friendly: false, shooter: this,
+      });
+      this.game.vfx?.muzzleFlash?.(from.addScaledVector(dir, 0.35), dir);
+      this.game.audio?.play('gunshot');
+      return;
+    }
+    const dd = dist2D(this.position.x, this.position.z, player.position.x, player.position.z);
+    if (dd < 2.3 && !this.game.world.losBlocked(this.position, player.position)) { // not through a wall
+      player.takeDamage(Math.round(this.def.damage * (this._dmgMul ?? 1)), this.position, { attacker: this });
+      if (player === this.game.player) this.game.audio?.play('hurt');   // YOU took it — the full body thud
+      else {                                                            // a brawl you're only near — impact, distance-faded
+        const dL = dist2D(this.position.x, this.position.z, this.game.player.position.x, this.game.player.position.z);
+        if (dL < 20) this.game.audio?.play('hit', 1 - dL / 20);
+      }
+    }
+  }
+
+  update(dt) {
+    super.update(dt);
+    if (!this.alive) return;
+    // Bare-knuckle brawlers: curl the fingers into fists on the punch clips, open otherwise. AFTER the
+    // mixer (super.update ran it), and only while on-screen (super.update hides off-screen bodies).
+    if (this._fistBones && this.model.visible) applyFist(this._fistBones, (this.animator?.currentName || '').startsWith('punch'));
+    // pending swing lands on GAME time (was setTimeout): pausing (menu) freezes it with
+    // the world instead of silently voiding the blow, hit-stop slows it in sync with the
+    // animation, and a Load evicts it with the enemy — the finisher-timer bug class (audit C12)
+    if (this._swing) {
+      this._swing.t -= dt;
+      if (this._swing.t <= 0) { const sw = this._swing; this._swing = null; this._landSwing(sw); }
+    }
+    // Far-enemy AI stride: beyond 1.5× the entity cull the whole FSM ticks every 4th frame with
+    // accumulated dt (a leashed wander doesn't need 60Hz; combat always happens well inside
+    // this radius). dt accumulation keeps every FSM timer exact — moves just step 4× as far.
+    if (this.game.player && this.game.quality) {
+      const dp = dist2D(this.position.x, this.position.z, this.game.player.position.x, this.game.player.position.z);
+      if (dp > (this.cullDist ?? this.game.quality.entityCull) * 1.5) {
+        this._aiPhase = ((this._aiPhase ?? 0) + 1) % 4;
+        if (this._aiPhase) { this._aiDt = (this._aiDt ?? 0) + dt; return; }
+        dt += this._aiDt ?? 0; this._aiDt = 0;
+      } else if (this._aiDt) { dt += this._aiDt; this._aiDt = 0; }
+    }
+    // Resolve the current foe (throttled + re-acquired on target death). Keeping the local named
+    // `player` lets the whole FSM below drive at `this.target` unchanged.
+    this._acqT = (this._acqT ?? 0) - dt;
+    if (!this.target || !this.target.alive || this._acqT <= 0) { this.target = this.acquireTarget(); this._acqT = 0.4; }
+    const player = this.target;
+    if (!player?.alive) { this.idleBehaviour(dt); return; }
+
+    // boss phase two: below half health the leaders ENRAGE — faster, harder, announced
+    if (this.def.phase2 && !this._enraged && this.health <= this.maxHealth * 0.5) {
+      this._enraged = true;
+      this.speed *= 1.3;
+      this._dmgMul = 1.3;
+      this.game.ui?.toast(`${this.name} is enraged!`);
+      this.game.shake?.(0.25);
+      this.game.audio?.play('aggro');
+      this.game.vfx?.spawn?.({ pos: this.position.clone().setY(this.position.y + 1.2), count: 16, size: 0.5, life: 0.7, color: 0xff3020, spread: 2.0 });
+    }
+
+    const d = dist2D(this.position.x, this.position.z, player.position.x, player.position.z);
+    const homeD = dist2D(this.position.x, this.position.z, this.home.x, this.home.z);
+
+    if (this.state === 'wander') {
+      if (!this.passive && d < this.def.aggroR) {
+        this.state = 'chase';
+        if (player === this.game.player) {   // don't announce a scrap the player isn't in
+          this.game.audio?.play('aggro');
+          this.game.hint?.('combat', 'Tab locks on. Ctrl dodge-rolls — time it as the blow lands.');
+        }
+      } else {
+        this.idleBehaviour(dt);
+        return;
+      }
+    }
+
+    if (this.state === 'chase') {
+      if (homeD > this.leashR * 1.6 || d > this.def.aggroR * 2.5) {
+        this.state = 'wander';
+        this.wanderTarget = { x: this.home.x, z: this.home.z };
+        return;
+      }
+      // gunmen stop and fire once the player is inside their band (LOS permitting)
+      const rg = this.def.ranged;
+      if (rg && d > rg.min && d < rg.max && !this.game.world.losBlocked(this.position, player.position)) {
+        this.state = 'shoot';
+      } else if (d < 1.7 && this._token !== false) {
+        this.state = 'attack';
+      } else if (this._token === false && d < 6 && !this.busy && this.staggerT <= 0) {
+        // no attack token (AC ring, phase 2): prowl the circle around the player instead
+        // of piling in — the director (combat.js) hands tokens to the closest two only
+        this._circle(player, d, dt);
+        return;
+      } else if (!this.busy && this.staggerT <= 0) {
+        // When the line to the player is blocked by static geometry (a building corner, a fence), route
+        // AROUND it via the camp's grid instead of grinding the wall; when it's clear (the common case)
+        // this is free and charges straight. Whiskers below still dodge crates/troughs/each other.
+        let ax = player.position.x, az = player.position.z;
+        if (steerCarrot(this, this.game, this.home, this.position.x, this.position.z, player.position.x, player.position.z, _echase, { dt, arrive: 1.2 })) { ax = _echase.x; az = _echase.z; }
+        const dir = tmpV1.set(ax - this.position.x, 0, az - this.position.z).normalize();
+        const sd = this.walkDir(dir, dt);   // whiskers: chase AROUND crates/troughs/each other, not into them
+        this.move(sd, this.speed, dt);
+        this.faceToward(this.position.x + sd.x, this.position.z + sd.z, dt);
+        this.animator.play('run');
+        return;
+      }
+    }
+
+    if (this.state === 'shoot') {
+      const rg = this.def.ranged;
+      if (!rg || d <= rg.min || d >= rg.max || this.game.world.losBlocked(this.position, player.position)) { this.state = 'chase'; return; }
+      this.faceToward(player.position.x, player.position.z, dt);
+      this.attackT -= dt;
+      if (!this.busy && this.attackT <= 0 && this.staggerT <= 0) {
+        this.attackT = rg.cooldown + Math.random() * 0.6;
+        this.busy = true;
+        // gun clip when the retarget has landed; punch cross keeps a readable telegraph until then
+        const shot = this.animator.actions.gunFire ? 'gunFire' : 'punchCross';
+        this.animator.play(shot, { once: true, fade: 0.08, timeScale: 1.2, onDone: () => { this.busy = false; } });
+        this._telegraph();
+        this._swing = { t: 0.38, kind: 'ranged', rg, target: player };   // lands via _landSwing (game-time)
+      } else if (!this.busy) {
+        const aim = this.def.aimClip && this.animator.actions[this.def.aimClip] ? this.def.aimClip : 'idle';
+        this.animator.play(aim);
+      }
+      return;
+    }
+
+    if (this.state === 'attack') {
+      if (d > 2.2) { this.state = 'chase'; return; }
+      if (this._token === false && !this.busy && this.staggerT <= 0) {
+        // token lost mid-melee: back out to the ring instead of swinging
+        this._circle(player, d, dt);
+        return;
+      }
+      this.faceToward(player.position.x, player.position.z, dt);
+      this.attackT -= dt;
+      if (!this.busy && this.attackT <= 0 && this.staggerT <= 0) {
+        this.attackT = 1.2 + Math.random() * 0.8;
+        this.busy = true;
+        const swing = Math.random() < 0.25 ? 'punchUpper' : (Math.random() < 0.5 ? 'punchJab' : 'punchCross');
+        this.animator.play(swing, {
+          once: true, fade: 0.08, timeScale: 1.3,
+          onDone: () => { this.busy = false; },
+        });
+        this._telegraph(); // readable wind-up: a glint at the fist before the blow lands
+        // the WHIFF of the blow — attenuated by the listener's (player's) distance so a brawl across
+        // the street is faint, not full-blast. The uppercut gets the beefier swing.
+        const dL = dist2D(this.position.x, this.position.z, this.game.player.position.x, this.game.player.position.z);
+        if (dL < 20) this.game.audio?.play(swing === 'punchUpper' ? 'swingHeavy' : 'swing', 1 - dL / 20);
+        // damage lands mid-swing — stored so a hit on this enemy can cancel it (interrupt)
+        this._swing = { t: 0.42, kind: 'melee', target: player };        // lands via _landSwing (game-time)
+      } else if (!this.busy) {
+        this.animator.play('punchIdle'); // bob in a boxing guard between swings
+      }
+    }
+  }
+
+  // AC ring: prowl a circle around the player while another enemy holds the attack
+  // token — sideways drift onto a ~3.4m radius, facing the player the whole time
+  _circle(player, d, dt) {
+    this._orbitDir ??= Math.random() < 0.5 ? 1 : -1;   // each enemy picks a lifelong orbit direction
+    const rx = (this.position.x - player.position.x) / (d || 1);
+    const rz = (this.position.z - player.position.z) / (d || 1);
+    const inward = (3.4 - d) * 0.6;                     // radial drift toward the ring radius
+    const dir = tmpV1.set(rx * inward - rz * this._orbitDir, 0, rz * inward + rx * this._orbitDir).normalize();
+    const sd = this.walkDir(dir, dt);                   // whiskers still steer around props/each other
+    this.move(sd, this.speed * 0.45, dt);
+    this.faceToward(player.position.x, player.position.z, dt); // guard stays ON the player
+    this.animator.play('walk');
+  }
+
+  // the attack TELEGRAPH: a bright glint at the raised hand as the wind-up starts,
+  // giving the dodge window a readable cue (diegetic — no floating UI)
+  _telegraph() {
+    const p = this.position.clone().setY(this.position.y + 1.5);
+    this.game.vfx?.spark?.(p, 0.55);
+  }
+
+  // Nav home (Character._navRegion): camp wanderers grid around their leash home.
+  _navHome() { return this.home ?? null; }
+
+  idleBehaviour(dt) {
+    this.thinkT -= dt;
+    if (this.thinkT <= 0) {
+      this.thinkT = 2 + Math.random() * 4;
+      if (Math.random() < 0.6) {
+        const a = Math.random() * Math.PI * 2;
+        const r = Math.random() * this.leashR * 0.5;
+        const cand = { x: this.home.x + Math.sin(a) * r, z: this.home.z + Math.cos(a) * r };
+        // route on the navgrid — but ONLY when the player is near enough to see it: every
+        // spawner in the world requesting its grid at boot ran dozens of concurrent bakes
+        // over the load. Far camps wander blind like they always did — invisible.
+        const pp = this.game.player?.position;
+        const near = pp && dist2D(this.position.x, this.position.z, pp.x, pp.z) < 90;
+        const grd = near ? this._navGrid() : null;
+        if (grd && grd.walkable(cand.x, cand.z) !== true) { this.wanderTarget = null; }
+        else {
+          this.wanderTarget = cand;
+          this._navPath = grd ? this._requestPath(cand) : null; this._navI = 0;
+          if (!this._navPath && grd) this.wanderTarget = null;
+        }
+      } else {
+        this.wanderTarget = null;
+      }
+    }
+    if (this.wanderTarget && !this.busy) {
+      const d = dist2D(this.position.x, this.position.z, this.wanderTarget.x, this.wanderTarget.z);
+      if (d > 1) {
+        const wp = this._pathWaypoint(this.wanderTarget);
+        const dir = tmpV1.set(wp.x - this.position.x, 0, wp.z - this.position.z).normalize();
+        const sd = this.walkDir(dir, dt);   // whiskers: dynamic avoidance on top of the path
+        this.move(sd, this.speed * 0.45 * (this._steerSlow ? 0.6 : 1), dt);
+        this.faceToward(this.position.x + sd.x, this.position.z + sd.z, dt);
+        this.animator.play('walk');
+        return;
+      }
+      this.wanderTarget = null;
+    }
+    if (!this.busy) this.animator.play('idle');
+  }
+
+}