import {
    Container,
    Graphics,
    IsoDepthLayer,
    ParticleEmitter,
    PixelText,
    Sprite,
    SpriteAnimator,
    SpriteMotion,
    Texture,
    IsometricTileMap,
    worldToScreen,
    worldNorm,
    tileToWorld,
    DebugOverlay,
    SpriteDebugView,
    VirtualJoystick,
    type Camera,
    type Entity,
    type Invariant,
    type JsonValue,
    type Scene,
    type SnapshotLayer,
    type Vec2
} from '@rpg/engine';
import { Game } from '../Game';
import { MenuScene, SAVE_VERSION, type SaveData } from './MenuScene';
import { InventoryScene } from './InventoryScene';
import { TILES, DECOR } from '../data/map';
import {
    areaOf,
    type AmbienceLayerDef,
    type AreaDef,
    type AreaId,
    type HazardDef,
    type TransitionDef
} from '../data/locations';
import { AudioSystem, type AudioLayerDef } from '../systems/AudioSystem';
import { InteractionRouter } from '../systems/ClickRouting';
import { SceneAgentView } from '../agent/SceneAgentView';
import type { NpcDef } from '../data/npcs';
import { DIALOGUES } from '../data/dialogues';
import { QUEST_FLOWERS, questDialogueFor, questEffectFor } from '../data/quests';
import { VARS } from '../data/ids';
import type { EnemyKindId } from '../data/enemies';
import { PlayerController, type HeroTextures } from '../systems/PlayerController';
import { FaunaSystem } from '../systems/fauna/FaunaSystem';
import { CutsceneRunner } from '@rpg/engine';
import { DialogueSystem } from '../systems/DialogueSystem';
import { CombatWorld } from '../systems/combat/CombatWorld';
import { CombatViews } from '../systems/combat/CombatViews';
import { PlayerCombat } from '../systems/combat/PlayerCombat';
import { HealthBar } from '../systems/combat/HealthBar';
import { PLAYER_COMBAT } from '../systems/combat/stats';
import { Interactables } from '../systems/Interactables';
import { SceneObjects } from '../systems/SceneObjects';
import type { InteractableDef } from '../data/interactables';

/**
 * Локация «Выжженные луга»: карта, герой, NPC, диалоги, бой со сгустками, автосейв по Esc.
 */
export class LocationScene implements Scene {
    private world = new Container();
    private map: IsometricTileMap;
    private player: PlayerController;
    private dialogue: DialogueSystem;
    private npcs: { def: NpcDef; view: Container }[] = [];
    private actors = new IsoDepthLayer();
    private hint: Container;
    /** Атмосферные частицы (в интерьерах их нет). */
    private ash: ParticleEmitter | null;
    /** Тёплые мотыльки над лугами (светящиеся, дрейф по синусу). */
    private moths: ParticleEmitter | null;
    /** Мигание при неуязвимости — процедурный blink (duty живой). */
    private heroMotion: SpriteMotion;
    private locationLabel: PixelText;
    private camera: Camera;

    // --- бой ---
    private combat: CombatWorld;
    private combatViews: CombatViews;
    private playerCombat: PlayerCombat;
    private healthBar: HealthBar;
    /** Индикатор заряда резонанса (под героем). */
    private chargeRing: Graphics;
    /** Маршрутизация клика/переходов/отложенных взаимодействий. */
    private router: InteractionRouter;
    /** Интерактивные объекты области (сундуки, очаги, прилавки). */
    private interactables: Interactables;
    /** Объекты сцены на движковом реестре (кто на тайле — для кликов/коллизий). */
    private objects: SceneObjects;
    private interactViews: { def: InteractableDef; label: PixelText }[] = [];
    /** Оверлей дымки (зоны наката). Виден только в низинах. */
    private fog: Graphics;
    /** Пейзажная фауна (безгласные олени). */
    private fauna: FaunaSystem;
    /** Позиционный звук мира + события боя (звук — подпиской). */
    private worldAudio: AudioSystem;
    /** off() подписок worldAudio (снять в exit). */
    private audioOff: () => void;
    /** Кат-сцены (раннер шагов; на время сцены геймплей на паузе). */
    private cutscene = new CutsceneRunner();
    /** Зона наката, в которой герой был в прошлом кадре (для тоста при входе). */
    private inHazard: HazardDef | null = null;
    /** Тач-джойстик (активен только для касаний). */
    private joystick: VirtualJoystick;
    private debug: DebugOverlay;
    private charDebug: SpriteDebugView;
    /** Последний тост (текст + тик) — канал текста для агентного моста. */
    private lastToast: { text: string; tick: number } | null = null;
    /** Агентный мост сцены (снапшот/инварианты/команды). */
    private agentView: SceneAgentView;
    /** Позиции тайлов-источников амбиент-слоёв, по id (собираются один раз). */
    private layerTilePos = new Map<number, Vec2[]>();

    constructor(
        private game: Game,
        save: SaveData | null,
        private area: AreaDef,
        /** Точка входа при переходе из другой области (приоритетнее save). */
        entry?: { x: number; y: number },
        /** Откуда вошли (для target kind 'return'): область + тайл триггера. */
        private returnTo?: { area: AreaId; entry: { x: number; y: number } }
    ) {
        this.camera = game.engine.camera;
        const data = this.game.mapFiles.get(area.id)!;
        this.map = new IsometricTileMap(data, this.tileTextures());
        // Живая вода: один общий таймлайн на все клетки с id WATER (2 кадра).
        this.map.setTileAnimation(
            TILES.WATER,
            [this.game.assets.texture('tiles/water_1'), this.game.assets.texture('tiles/water_2')],
            2
        );
        this.world.addChild(this.map.view, this.actors);
        // Источники амбиент-слоёв: позиции тайлов по id — один проход по карте.
        for (let y = 0; y < data.height; y++) {
            for (let x = 0; x < data.width; x++) {
                const id = data.tiles[y * data.width + x]!;
                const list = this.layerTilePos.get(id) ?? [];
                list.push({ x, y });
                this.layerTilePos.set(id, list);
            }
        }
        // Крупные объекты карты (дома) — в общий depth-слой по footprint'у.
        for (const p of this.map.propViews) this.actors.addRect(p.view, p.prop.x, p.prop.y, p.prop.w, p.prop.h);
        this.game.renderer.worldRoot.addChild(this.world);
        // Единый реестр объектов сцены: NPC, интерактивы, пропы (враги/фауна
        // добавляются позже своими системами).
        this.objects = new SceneObjects(area, this.map);

        const startTile = entry ?? save?.pos ?? area.spawn;
        // Тайл входа: step-переходы на нём глушатся, пока герой с него не ушёл
        // (иначе вошёл в дверь — и немедленно вылетел обратно).
        const disarmTile = entry ? { ...startTile } : null;
        if (save?.state) this.game.state.load(save.state);
        // Позиционный звук: слушатель — герой.
        this.worldAudio = new AudioSystem({
            audio: this.game.audio,
            events: this.game.engine.events,
            getListener: () => this.player.position
        });
        this.audioOff = this.worldAudio.attach();
        this.player = new PlayerController(this.map, this.heroTextures(), startTile, () => {
            this.worldAudio.playStep(this.stepKey(this.player.currentTile()), this.player.position, 0.35);
            // Шаги — тихий шум (0.35): бодрых сгустков настораживает, спящих не будит.
            this.combat.noise(this.player.position, 0.35);
        });
        // Тела: герой не проходит сквозь NPC (расталкивание через реестр),
        // пути строятся по grid с занятыми NPC-тайлами — A* не ведёт сквозь тело.
        this.player.setBodies(this.objects.registry);
        this.player.setWalkGrid(this.objects.walkGrid());

        // Мигание героя при неуязвимости — процедурный blink (duty меняется на лету).
        this.heroMotion = new SpriteMotion(this.player.view, { blink: { period: 0.25, duty: 1 } });
        this.game.engine.fx.add(this.heroMotion);

        // Герой и NPC — в один depth-слой: глубина = tx + ty (кто юго-восточнее, тот ближе).
        this.actors.add(this.player.view, startTile.x, startTile.y);
        for (const def of area.npcs) {
            const view = this.makeNpcView(def);
            this.actors.add(view, def.tile.x, def.tile.y);
            this.npcs.push({ def, view });
        }

        // Интерактивные объекты: те же вьюхи в actors-слое, реакции — через Interactables.
        this.interactables = new Interactables(area.interactables ?? [], this.game.state, {
            hasItem: (id) => this.game.inventory.has(id),
            give: (id, n) => this.game.inventory.add(id, n),
            playSound: (k) => this.worldAudio.playAt(k, this.player.position, 0.6),
            showToast: (t) => this.showToast(t)
        });
        for (const def of area.interactables ?? []) {
            const made = this.makeInteractableView(def);
            this.actors.add(made.view, def.tile.x, def.tile.y);
            this.interactViews.push({ def, label: made.label });
        }

        // --- боевая система: враги на ECS, звуки/события/урон героя — через колбэки ---
        this.combat = new CombatWorld(
            {
                map: this.map,
                events: this.game.engine.events,
                getPlayerPos: () => this.player.position,
                damagePlayer: (dmg, from) => this.onPlayerDamaged(dmg, from),
                registry: this.objects.registry
            },
            (kind) => {
                // счётчики прогресса — в vars GameState
                this.game.state.setVar(VARS.kills, this.game.state.getNumber(VARS.kills) + 1);
                this.game.state.setVar(VARS.motes, this.game.state.getNumber(VARS.motes) + kind.motes);
            }
        );
        for (const s of area.enemies) {
            this.combat.spawnEnemy(s.kind, tileToWorld(s.tile.x, s.tile.y), s.patrol ? { patrol: s.patrol } : undefined);
        }
        this.combatViews = new CombatViews(
            this.combat,
            this.actors,
            this.enemyTextures(),
            this.world,
            this.game.engine.fx
        );

        // Вспышка урона и брызги пепла — реакция вьюх на события ECS-мира.
        this.game.engine.events.on<{ entity: Entity }>('combat:hurt', ({ entity }) => {
            const en = this.combat.enemies.get(entity);
            if (!en) return;
            this.combatViews.flashEnemy(entity);
            const s = worldToScreen(en.pos.x, en.pos.y);
            if (en.brain.dead) this.combatViews.deathBurst(s);
            else this.combatViews.hitBurst(s);
        });

        // Пейзажная фауна: безгласные олени у берегов (сама по себе, вне боя).
        this.fauna = new FaunaSystem(
            this.actors,
            this.game.engine.events,
            data,
            (area.fauna ?? []).map((t) => tileToWorld(t.x, t.y)),
            this.objects.registry
        );
        this.fauna.setFrames(
            this.game.assets.animation('chars/fauna_sheet.json', 'fauna_deer_walk') as [Texture, Texture]
        );
        // Мотыли над потревоженным пеплом: серые, дрейф вверх от точки звона.
        this.game.engine.events.on<{ origin: Vec2 }>('combat:attack', ({ origin }) => {
            const s = worldToScreen(origin.x, origin.y);
            const fx = ParticleEmitter.oneShot(6, {
                color: 0x8a8a96,
                rate: 0,
                lifetime: [1.2, 2.2],
                velocity: { x: [-6, 6], y: [-14, -8] },
                size: 1,
                seed: ((origin.x * 13 + origin.y) | 0) || 1
            });
            fx.position.set(s.x, s.y - 8);
            this.world.addChild(fx);
        });

        const savedHp = this.game.state.getNumber(VARS.hp) || PLAYER_COMBAT.maxHp;
        this.playerCombat = new PlayerCombat(savedHp);
        this.healthBar = new HealthBar();
        this.healthBar.setHp(this.playerCombat.hp);
        this.game.renderer.uiRoot.addChild(this.healthBar);

        this.chargeRing = new Graphics();
        this.game.renderer.worldRoot.addChild(this.chargeRing);

        this.dialogue = new DialogueSystem(this.game.renderer.uiRoot, this.game.state, {
            width: Game.VIRTUAL_W,
            height: Game.VIRTUAL_H,
            margin: 8
        });
        this.dialogue.onDialogueFinished = (id) => this.onDialogueFinished(id);
        this.dialogue.onLineShown = () => void this.game.audio.play('sfx/chime', 0.5);

        // Маршрутизация клика/переходов/отложенных взаимодействий.
        this.router = new InteractionRouter({
            game: this.game,
            map: this.map,
            area,
            player: this.player,
            combat: this.combat,
            interactables: this.interactables,
            objects: this.objects,
            disarmTile,
            worldRootOffset: () => this.game.renderer.worldRoot.position,
            callbacks: {
                showToast: (t) => this.showToast(t),
                playUiClick: () => void this.game.audio.play('sfx/ui_click', 0.4),
                talkTo: (d) => this.talkTo(d),
                collectFlower: (x, y) => this.collectFlower(x, y),
                useTransition: (d) => this.useTransition(d),
                attackTarget: (from, dir) => this.attackTarget(from, dir)
            }
        });

        // Агентный мост сцены (снапшот/инварианты/команды).
        this.agentView = new SceneAgentView({
            game: this.game,
            map: this.map,
            area,
            player: this.player,
            playerCombat: this.playerCombat,
            combat: this.combat,
            npcs: this.npcs.map((n) => n.def),
            interactables: this.interactables,
            registry: this.objects.registry,
            walkGrid: () => this.objects.walkGrid(),
            dialogue: this.dialogue,
            cutscene: this.cutscene,
            lastToast: () => this.lastToast,
            inHazard: () => this.inHazard,
            followCamera: (snap) => this.updateCameraFollow(snap)
        });

        // Атмосфера локации: пепел на лугах, туман над прудами, в интерьере — ничего.
        this.ash =
            area.atmosphere === 'none'
                ? null
                : area.atmosphere === 'fog'
                ? new ParticleEmitter({
                      color: 0x7a7a88,
                      rate: 6,
                      lifetime: [5, 10],
                      velocity: { x: [-3, 3], y: [-1, 1] },
                      size: 2,
                      spawnArea: { width: 560, height: 340 },
                      seed: 20260906
                  })
                : new ParticleEmitter({
                      color: 0x666677,
                      rate: 5,
                      lifetime: [4, 9],
                      velocity: { x: [-9, -3], y: [-2, 2] },
                      size: 1,
                      spawnArea: { width: 520, height: 300 },
                      seed: 20260905
                  });
        if (this.ash) {
            this.ash.position.set(240, 120);
            this.game.renderer.worldRoot.addChild(this.ash);
            // Пепел тикается реестром эффектов (engine.fx) — без ручного update.
            this.game.engine.fx.add(this.ash);
        }

        // Тёплые мотыльки над лугами: светятся (add), дышат по синусу, в интерьере их нет.
        this.moths =
            area.atmosphere === 'ash'
                ? new ParticleEmitter({
                      colors: [0xf0d878, 0xd8b050],
                      blend: 'add',
                      rate: 2,
                      lifetime: [3, 6],
                      velocity: { x: [-4, 4], y: [-2, 2] },
                      size: 1,
                      wobble: 8,
                      fadeIn: 0.6,
                      spawnArea: { width: 520, height: 300 },
                      seed: 20260907
                  })
                : null;
        if (this.moths) {
            this.moths.position.set(240, 120);
            this.game.renderer.worldRoot.addChild(this.moths);
            this.game.engine.fx.add(this.moths);
        }

        // Дымка наката: полупрозрачная пелена на весь экран (в низинах без маски — гуще).
        this.fog = new Graphics().rect(0, 0, Game.VIRTUAL_W, Game.VIRTUAL_H).fill(0x5a6a78);
        this.fog.alpha = 0;
        this.game.renderer.uiRoot.addChildAt(this.fog, 0);

        // Название локации в правом верхнем углу.
        const name = new PixelText({ text: area.name, size: 11, color: 0x999988 });
        name.anchor.set(1, 0);
        name.position.set(474, 4);
        this.game.renderer.uiRoot.addChild(name);
        this.locationLabel = name;

        // Камера: следим за героем; границы — мировой прямоугольник карты (юниты).
        this.camera.bounds = this.map.worldBounds;
        // Камера-«окно»: герой ходит в центральной зоне свободно, у виртуальной
        // границы экрана толкает камеру (движение остаётся плавным).
        this.camera.deadZonePx = { width: 180, height: 120 };
        this.updateCameraFollow(true);

        this.hint = new Container();
        const text = new PixelText({
            text: 'клик — идти/атаковать · Space — удар (удержать — резонанс) · I — сумка · Esc — меню',
            size: 10,
            color: 0x999988
        });
        // Под сердечками (HealthBar занимает y≈13..18).
        text.position.set(6, 23);
        this.hint.addChild(text);
        this.game.renderer.uiRoot.addChild(this.hint);

        // Тач-джойстик: перехватывает касания (мышь проходит насквозь).
        this.joystick = new VirtualJoystick({ screen: { width: Game.VIRTUAL_W, height: Game.VIRTUAL_H } });
        this.joystick.eventMode = 'none'; // включается при первом касании
        this.game.renderer.uiRoot.addChild(this.joystick);

        // Дебаг-оверлей (F3).
        this.debug = new DebugOverlay(false);
        this.game.renderer.uiRoot.addChild(this.debug.view);

        // Дебаг спрайта героя (P): текущий кадр, увеличенный с пиксельной сеткой.
        this.charDebug = new SpriteDebugView({ zoom: 8 });
        this.charDebug.view.position.set(390, 120);
        this.game.renderer.uiRoot.addChild(this.charDebug.view);
    }

    enter(): void {
        console.log('[location]', this.area.id); // маяк для смоук-тестов
        // Амбиент локации (кроссфейд; тот же ключ не перезапускается, '' — тишина).
        this.game.playAmbience(this.area.ambience ?? '');
    }

    exit(): void {
        this.audioOff();
        this.worldAudio.setLayers([]);
        this.fauna.exit();
        this.combatViews.exit();
        this.ash?.clear();
        this.world.destroy({ children: true });
        this.ash?.destroy();
        this.moths?.destroy();
        this.fog.destroy();
        this.healthBar.destroy({ children: true });
        this.hint.destroy({ children: true });
        this.locationLabel.destroy({ children: true });
        this.joystick.destroy({ children: true });
        this.debug.view.destroy({ children: true });
        this.charDebug.view.destroy({ children: true });
    }

    update(dt: number): void {
        this.map.update(dt); // анимированные тайлы (вода) — no-op без анимаций
        this.worldAudio.update(dt);
        this.updateAudioLayers();
        this.fauna.update(dt);
        // Кат-сцена: мир на паузе, камера под контролем раннера.
        if (this.cutscene.active) {
            this.cutscene.update(dt);
            return;
        }
        const input = this.game.engine.input;
        if (this.dialogue.active) {
            // Во время диалога клик/пробел только листают реплики.
            if (input.getPointer().justPressed || input.isActionJustPressed('advance')) {
                this.dialogue.advance();
            }
            return;
        }
        if (this.game.engine.scenes.transitioning) return;

        if (input.isActionJustPressed('menu')) {
            this.saveAndExit();
            return;
        }

        if (input.isActionJustPressed('inventory')) {
            void this.game.audio.play('sfx/ui_click');
            void this.game.scenes.push(
                new InventoryScene(this.game, () => void this.game.scenes.pop()),
                { duration: 0.2 }
            );
            return;
        }

        if (input.isActionJustPressed('debug')) {
            this.debug.view.visible = !this.debug.view.visible;
        }
        if (input.isActionJustPressed('debugChar')) {
            this.charDebug.view.visible = !this.charDebug.view.visible;
        }

        // --- ввод боя: тап = короткий удар, удержание = заряд резонанса ---
        if (input.isActionJustPressed('attack')) {
            this.playerCombat.startCharge();
        }
        if (input.isActionJustReleased('attack') && this.playerCombat.isCharging()) {
            this.doPlayerRelease();
        }

        const pointer = input.getPointer();
        if (pointer.justPressed) {
            if (pointer.isTouch) {
                // Касание отдаём джойстику (мышь идёт в мир обычным порядком).
                this.joystick.eventMode = 'static';
            } else {
                this.router.handleWorldClick(pointer.x, pointer.y);
            }
        }

        // --- боевой мир ---
        this.combat.update(dt);
        this.combatViews.sync(dt);
        this.playerCombat.update(dt);
        this.router.updateTarget(dt);
        this.updateChargeRing();
        this.healthBar.setHp(this.playerCombat.hp);

        // Мигание героя при неуязвимости: duty blink-оживителя живой.
        this.heroMotion.params.blink!.duty = this.playerCombat.invuln ? 0.5 : 1;

        if (this.joystick.active) {
            this.player.moveFree(this.joystick.getVector(), dt);
        } else {
            this.player.update(dt);
        }
        this.router.resolvePending();
        const tile = this.player.currentTile();
        this.updateHazard(tile);
        this.actors.setDepth(this.player.view, tile.x, tile.y);
        this.updateCameraFollow();
        this.router.checkTransitions(tile);
        // Подписи объектов: видны вблизи, пока объект не использован (once).
        for (const iv of this.interactViews) {
            iv.label.visible =
                this.router.inInteractRange(iv.def.tile.x, iv.def.tile.y) &&
                !(iv.def.once && this.interactables.isUsed(iv.def.id));
        }

        this.debug.setLines([
            `tile ${tile.x},${tile.y}`,
            `pos ${Math.round(this.player.position.x)},${Math.round(this.player.position.y)}`,
            `hp ${this.playerCombat.hp} kills ${this.game.state.getNumber(VARS.kills)}`
        ]);
        this.debug.update(dt);
        if (this.charDebug.view.visible) this.charDebug.setTexture(this.player.currentTexture);
    }

    /**
     * Зона наката под ногами: без маски герой еле идёт и рискует голосом,
     * звон здесь «проверяет воздух» — пепел на секунду видно волной.
     */
    private updateHazard(tile: { x: number; y: number }): void {
        const hazard =
            (this.area.hazards ?? []).find((h) =>
                h.tiles.some((t) => t.x === tile.x && t.y === tile.y)
            ) ?? null;
        const masked = hazard !== null && this.game.inventory.has(hazard.requiresItem ?? 'cloth');
        this.player.speedMul = hazard !== null && !masked ? 0.5 : 1;

        // Вход в низину: предупреждение один раз за вход.
        if (hazard !== null && this.inHazard === null) {
            this.showToast(
                masked ? `${hazard.name}: полотно держит — но пепел у самых губ.` : `${hazard.name}! Дышать поверх — потерять голос.`
            );
            void this.game.audio.play('sfx/ash_hiss', 0.5);
        }
        this.inHazard = hazard;

        // Дымка: плотная без маски, лёгкая с ней, вне низин её нет.
        this.fog.alpha = hazard === null ? 0 : masked ? 0.12 : 0.28;
    }

    /** Куда ведёт переход: область + точка входа ('return' — откуда вошли). */
    private targetEntry(def: TransitionDef): { area: AreaDef; entry: { x: number; y: number } } {
        const t = def.target;
        if (t.kind === 'area') return { area: areaOf(t.area), entry: t.entry };
        return {
            area: areaOf(this.returnTo?.area),
            entry: this.returnTo?.entry ?? this.area.spawn
        };
    }

    /** Выполнить переход: новая сцена с fade (длительность — из определения). */
    private useTransition(def: TransitionDef): void {
        const next = this.targetEntry(def);
        void this.game.audio.play('sfx/whoosh', 0.5);
        void this.game.scenes.replace(
            new LocationScene(this.game, null, next.area, next.entry, {
                area: this.area.id,
                entry: this.player.currentTile()
            }),
            { duration: def.duration ?? 0.4 }
        );
    }

    render(): void {}

    // ---------- бой ----------

    /** Отпускание атаки: резонанс (долгое) или короткий удар. */
    private doPlayerRelease(): void {
        const action = this.playerCombat.release();
        const from = this.player.position;
        if (action === 'resonance') {
            const slept = this.combat.resonancePulse(from);
            const s = worldToScreen(from.x, from.y);
            this.combatViews.resonanceRing(s);
            this.game.camera.addShake(1.5, 0.25);
            this.game.state.setVar(VARS.resonances, this.game.state.getNumber(VARS.resonances) + (slept > 0 ? 1 : 0));
            // Звон как «проверка воздуха»: в накате волна на миг подсвечивает пепел.
            if (this.inHazard !== null) {
                this.combatViews.hitBurst({ x: s.x - 14, y: s.y + 6 });
                this.combatViews.hitBurst({ x: s.x + 14, y: s.y + 6 });
                void this.game.audio.play('sfx/ash_hiss', 0.7);
            }
        } else if (action === 'attack') {
            this.combat.playerConeAttack(from, this.player.dirVector);
        }
    }

    /** Удар из зоны авто-атаки (кулдаун внутри PlayerCombat). */
    private attackTarget(from: Vec2, dir: Vec2): boolean {
        if (this.playerCombat.attackCd.trigger()) {
            this.combat.playerConeAttack(from, dir);
            return true;
        }
        return false;
    }

    /** Индикатор заряда резонанса под героем. */
    private updateChargeRing(): void {
        this.chargeRing.clear();
        if (!this.playerCombat.isCharging()) return;
        const u = this.player.position;
        const p = worldToScreen(u.x, u.y);
        const k = Math.min(1, this.playerCombat.chargeTime / PLAYER_COMBAT.resonanceCharge);
        const color = k >= 1 ? 0xd99a32 : 0x888899;
        this.chargeRing
            .circle(p.x, p.y - 2, 6 + 4 * k)
            .stroke({ color, width: 1, alpha: 0.9 });
    }

    /** Урон герою: неуязвимость внутри PlayerCombat; здесь отброс, шейк, звук, смерть. */
    private onPlayerDamaged(damage: number, from: Vec2): void {
        const applied = this.playerCombat.takeDamage(damage);
        if (applied <= 0) return;
        this.game.engine.events.emit('combat:playerHit', { hp: this.playerCombat.hp });
        this.game.camera.addShake(2.5, 0.3);
        // Отброс от источника урона (направление — по метрике проекции)
        const dx = this.player.position.x - from.x;
        const dy = this.player.position.y - from.y;
        this.player.applyKnockback(worldNorm(dx, dy), PLAYER_COMBAT.knockback);

        if (this.playerCombat.dead) {
            this.game.state.setVar(VARS.deaths, this.game.state.getNumber(VARS.deaths) + 1);
            this.playerCombat.revive();
            // Респаун на стартовом тайле локации
            this.player.teleportTo(this.area.spawn);
            this.updateCameraFollow(true);
            this.healthBar.setHp(this.playerCombat.hp);
        }
    }

    // ---------- агентный мост (SceneAgent → SceneAgentView) ----------

    /** Контентный слой снапшота — см. apps/game/src/agent/snapshot.ts. */
    agentSnapshot(): SnapshotLayer {
        return this.agentView.agentSnapshot();
    }

    /** Инварианты сцены: валидность контента + целостность героя/врагов. */
    agentInvariants(): Invariant[] {
        return this.agentView.agentInvariants();
    }

    /** Whitelist-команды для проверок (перемотки/читы). Неизвестная — null. */
    agentCommand(name: string, args?: JsonValue): JsonValue {
        return this.agentView.agentCommand(name, args);
    }

    // ---------- остальное ----------

    private updateCameraFollow(snap = false): void {
        // Непрерывное следование за ногами героя; snap — телепорты/спавн.
        const p = this.player.position;
        if (snap) this.camera.snap(p.x, p.y);
        else this.camera.follow(p.x, p.y);
    }

    /** Текстуры тайлов из загруженных ассетов (id -> Texture). */
    private tileTextures(): Map<number, Texture> {
        const a = this.game.assets;
        return new Map([
            [TILES.GRASS, a.texture('tiles/grass')],
            [TILES.GRASS_V1, a.texture('tiles/grass_2')],
            [TILES.GRASS_V2, a.texture('tiles/grass_3')],
            [TILES.PATH, a.texture('tiles/path')],
            [TILES.PATH_V1, a.texture('tiles/path_2')],
            [TILES.WATER, a.texture('tiles/water_1')],
            [TILES.ASH, a.texture('tiles/ash')],
            [TILES.ASH_V1, a.texture('tiles/ash_2')],
            [DECOR.TUFT, a.texture('tiles/decor_tuft')],
            [DECOR.STONE, a.texture('tiles/decor_stone')],
            [DECOR.BALD, a.texture('tiles/decor_bald')],
            [TILES.BELLFLOWER, a.texture('tiles/bellflower')],
            [TILES.TREE, a.texture('tiles/tree')],
            [TILES.TOWER, a.texture('tiles/tower')],
            [TILES.HOUSE, a.texture('tiles/house')],
            [TILES.FLOOR, a.texture('tiles/floor')],
            [TILES.WALL, a.texture('tiles/wall')],
            [TILES.WELL, a.texture('tiles/well')]
        ]);
    }

    /** Кадры сгустков из атласа chars/clumps_sheet. */
    private enemyTextures(): Map<EnemyKindId, [Texture, Texture]> {
        const frames = (prefix: string) =>
            this.game.assets.frames('chars/clumps_sheet.json', prefix) as [Texture, Texture];
        return new Map([
            ['crawler', frames('clump_crawler')],
            ['spitter', frames('clump_spitter')],
            ['heavy', frames('clump_heavy')]
        ]);
    }

    /** Кадры героя из атласа chars/hero_sheet (именованные анимации генератора). */
    private heroTextures(): HeroTextures {
        const a = this.game.assets;
        return {
            down: a.animation('chars/hero_sheet.json', 'hero_walk_down') as [Texture, Texture],
            up: a.animation('chars/hero_sheet.json', 'hero_walk_up') as [Texture, Texture],
            side: a.animation('chars/hero_sheet.json', 'hero_walk_side') as [Texture, Texture]
        };
    }

    /** Экранные координаты центра ромба тайла (с Origin карты). */
    private tileCenter(tx: number, ty: number): { x: number; y: number } {
        const u = tileToWorld(tx, ty);
        return worldToScreen(u.x, u.y);
    }

    /** id тайла карты (для кликов по сборным объектам). */
    private tileId(x: number, y: number): number {
        return this.map.data.tiles[y * this.map.data.width + x];
    }

    /** Ключ шага по поверхности под ногами (трава/пепел/вода/пол). */
    private stepKey(tile: Vec2): string {
        const id = this.tileId(tile.x, tile.y);
        if (id === TILES.WATER) return 'sfx/step_water';
        if (id === TILES.ASH || id === TILES.HOUSE || id === TILES.TOWER) return 'sfx/step_ash';
        if (id === TILES.FLOOR || id === TILES.PATH) return 'sfx/step_floor';
        return 'sfx/step_grass';
    }

    /**
     * Тик амбиент-слоёв: громкость каждого — от дистанции героя до ближайшего
     * источника (тайлы или точка). Пустой набор — setLayers сам снимет лишние.
     */
    private updateAudioLayers(): void {
        const p = this.player.position;
        const defs: AudioLayerDef[] = [];
        for (const layer of this.area.ambienceLayers ?? []) {
            const d = this.layerDistance(layer, p);
            const volume = (layer.volume ?? 0.5) * Math.max(0, 1 - d / layer.radius);
            if (volume > 0.01) defs.push({ key: layer.key, volume, fade: 0.5 });
        }
        this.worldAudio.setLayers(defs);
    }

    /** Дистанция до ближайшего источника слоя (юниты; тайл — центр ромба). */
    private layerDistance(layer: AmbienceLayerDef, p: Vec2): number {
        if (layer.at) return Math.hypot(p.x - (layer.at.x + 0.5), p.y - (layer.at.y + 0.5));
        let best = Infinity;
        for (const id of layer.tiles ?? []) {
            for (const tile of this.layerTilePos.get(id) ?? []) {
                const d = Math.hypot(p.x - (tile.x + 0.5), p.y - (tile.y + 0.5));
                if (d < best) best = d;
            }
        }
        return best;
    }

    /** Сбор лунного колокольчика: тайл зеленеет, цветок — в сумку, прогресс — в vars. */
    private collectFlower(x: number, y: number): void {
        this.map.setTile(x, y, TILES.GRASS);
        this.game.inventory.add('bellflower');
        const n = this.game.state.getNumber(VARS.flowers) + 1;
        this.game.state.setVar(VARS.flowers, n);
        this.game.engine.events.emit('quest:flower', { n });
        void this.game.audio.play('sfx/bell_hit', 0.6);
        const c = this.tileCenter(x, y);
        this.combatViews.hitBurst(c);
        this.showToast(`Лунный колокольчик (${Math.min(n, QUEST_FLOWERS)}/${QUEST_FLOWERS})`);
    }

    private talkTo(def: NpcDef): void {
        const met = this.game.state.hasFlag(def.flagKey);
        if (!met) this.game.state.setFlag(def.flagKey);
        // Сюжетная ветка — из квест-стадии; иначе обычный диалог.
        const id = !met
            ? def.dialogueFirst
            : (questDialogueFor(this.game.state, def.id) ?? def.dialogueRepeat);
        this.dialogue.start(DIALOGUES[id], id);
    }

    private onDialogueFinished(id: string): void {
        // Побочные эффекты — из квест-стадий реестра.
        const effect = questEffectFor(id);
        if (effect === 'plant_flowers') this.startHandInCutscene();
        if (effect === 'give_cloth') this.game.inventory.add('cloth');
    }

    /** Посадка цветов у тропы: поляна гудит колокольчиками и разрастается. */
    private plantFlowers(): void {
        const left = this.game.state.getNumber(VARS.flowers) - QUEST_FLOWERS;
        this.game.state.setVar(VARS.flowers, Math.max(0, left));
        const planted: [number, number][] = [
            [15, 13],
            [16, 14],
            [15, 15]
        ];
        for (const [tx, ty] of planted) {
            this.map.setTile(tx, ty, TILES.BELLFLOWER);
            this.combatViews.hitBurst(this.tileCenter(tx, ty));
        }
        // Пересев: поляна расползается на соседние тайлы (якорь «надежда растёт»).
        for (const [tx, ty] of planted) {
            for (const [dx, dy] of [
                [1, 0],
                [-1, 0],
                [0, 1],
                [0, -1]
            ]) {
                const id = this.tileId(tx + dx, ty + dy);
                if (id === TILES.GRASS || id === TILES.ASH) this.map.setTile(tx + dx, ty + dy, TILES.BELLFLOWER);
            }
        }
        void this.game.audio.play('sfx/bell_low', 0.8);
        this.showToast('Цветы в земле. Поляна гудит.');
    }

    /** Кат-сцена сдачи: посадка, камера к башне, удар колокола, зелень — финал акта 1. */
    private startHandInCutscene(): void {
        const tower = tileToWorld(14, 7); // башня Звенца (юниты)
        const s = worldToScreen(tower.x, tower.y);
        this.cutscene.play([
            // Пересев: поляна гудит, герой стоит.
            { kind: 'call', fn: () => this.plantFlowers(), seconds: 0.8 },
            // Камера уходит к башне.
            { kind: 'cameraMove', x: tower.x, y: tower.y, seconds: 1.2, camera: this.game.camera },
            // Удар колокола: низкий звон, тряска, кольцо резонанса.
            {
                kind: 'burst',
                fn: () => {
                    void this.game.audio.play('sfx/bell_low', 1);
                    this.game.camera.addShake(2.5, 0.4);
                    this.combatViews.resonanceRing(s);
                },
                seconds: 1
            },
            // Зелень поднимается у подножия башни (визуальный финал акта).
            {
                kind: 'burst',
                fn: () => {
                    for (const [tx, ty] of [
                        [13, 8],
                        [15, 8],
                        [14, 9]
                    ]) {
                        if (this.tileId(tx, ty) === TILES.GRASS || this.tileId(tx, ty) === TILES.ASH) {
                            this.map.setTile(tx, ty, TILES.BELLFLOWER);
                            this.combatViews.hitBurst(this.tileCenter(tx, ty));
                        }
                    }
                },
                seconds: 1.2
            },
            // Тост-финал акта 1.
            { kind: 'call', fn: () => this.showToast('Пепел отступил у тропы. Машина дышит тише... но дышит.') }
        ]);
    }

    /** Всплывающая подсказка: появляется и растворяется над UI. */
    private showToast(text: string): void {
        this.lastToast = { text, tick: this.game.engine.tickCount };
        const toast = new PixelText({ text, size: 11, color: 0xd8c79a });
        toast.anchor.set(0.5);
        toast.position.set(240, 40);
        toast.alpha = 0;
        this.game.renderer.uiRoot.addChild(toast);
        const tweens = this.game.engine.tweens;
        tweens.to(toast, { alpha: 1 }, { duration: 0.25 });
        tweens.delay(1.6, () => {
            tweens.to(toast, { alpha: 0, y: 32 }, { duration: 0.5, onDone: () => toast.destroy() });
        });
    }

    /** Вьюха интерактивного объекта: спрайт из def.view или плейсхолдер + подпись. */
    private makeInteractableView(def: InteractableDef): { view: Container; label: PixelText } {
        const view = new Container();
        const p = this.tileCenter(def.tile.x, def.tile.y);
        view.position.set(p.x, p.y);
        let g: Graphics | Sprite;
        if (def.view?.tex) {
            // Настоящий арт из def.view: якорь низом в центр ромба (или задан).
            const sprite = new Sprite(this.game.assets.texture(def.view.tex));
            sprite.anchor.set(0.5, def.view.anchorY ?? 1);
            g = sprite;
        } else {
            // Плейсхолдер-ящик по роду (пока нет арта конкретного объекта).
            g = new Graphics();
            switch (def.kind) {
                case 'signpost': // столбик с доской
                    g.rect(-1, -10, 2, 10).fill(0x4a3b2a);
                    g.rect(-6, -14, 12, 5).fill(0x5c4a33);
                    g.rect(-6, -14, 12, 1).fill(0x8a6d3a);
                    break;
                case 'lever': // рычаг: основание и наклонная рукоять
                    g.rect(-3, -2, 6, 2).fill(0x4a3b2a);
                    g.rect(0, -8, 2, 7).fill(0x8a6d3a);
                    g.rect(-2, -10, 4, 2).fill(0x8a6d3a);
                    break;
                case 'pickup': // кучка пепла с тёплой искрой
                    g.rect(-4, -3, 8, 3).fill(0x3a3a3a);
                    g.rect(-2, -4, 4, 2).fill(0x4a4a4a);
                    g.rect(0, -4, 1, 1).fill(0xf0d878);
                    break;
                default: // контейнер/предмет осмотра: ящик с бронзовой кромкой
                    g.rect(-5, -12, 10, 12).fill(0x4a3b2a);
                    g.rect(-5, -12, 10, 2).fill(0x8a6d3a); // бронзовая кромка: «звонное» железо
            }
        }
        view.addChild(g);
        // Искра в кучке пепла пульсирует (alpha+scale, детерминированная фаза).
        if (def.kind === 'pickup') {
            this.game.engine.fx.add(
                new SpriteMotion(g, { pulse: { min: 0.4, max: 1, period: 1.6 } }, {
                    seed: def.tile.x * 31 + def.tile.y
                })
            );
        }
        const label = new PixelText({ text: def.label ?? def.id, size: 9, color: 0xd8c79a });
        label.anchor.set(0.5, 1);
        label.position.set(0, -16);
        label.visible = false;
        view.addChild(label);
        return { view, label };
    }

    private makeNpcView(def: NpcDef): Container {
        const view = new Container();
        const p = this.tileCenter(def.tile.x, def.tile.y);
        view.position.set(p.x, p.y);

        const sprite = new Sprite();
        sprite.anchor.set(0.5, 1); // ноги в центре ромба
        // idle-дыхание кадрами из атласа (по умолчанию — общий лист NPC).
        const idle = this.game.assets.animation(
            def.atlas ?? 'chars/npcs_sheet.json',
            `${def.sprite}_idle`
        );
        sprite.texture = idle[0]!;
        const animator = new SpriteAnimator(
            sprite,
            { idle: { frames: idle, fps: 1.2 } },
            'idle',
            { randomPhase: def.tile.y * 64 + def.tile.x }
        );
        this.game.engine.fx.add(animator);
        view.addChild(sprite);

        // Маркер «с ним можно говорить»: восклицательный штрих над головой
        // (высота — от реального кадра атласа, не от захардкоженной).
        const frameH = idle[0]!.height;
        const marker = new Graphics();
        marker.rect(-1, -(frameH + 3), 2, 4).fill(0xf0d878);
        marker.rect(-1, -(frameH - 3), 2, 2).fill(0xf0d878);
        view.addChild(marker);
        return view;
    }

    private saveAndExit(): void {
        const pos = this.player.currentTile();
        this.game.state.setVar(VARS.hp, this.playerCombat.hp);
        this.game.saves.save('autosave', {
            version: SAVE_VERSION,
            area: this.area.id,
            pos,
            state: this.game.state.serialize(),
            items: this.game.inventory.serialize().items,
            returnTo: this.returnTo ?? null,
            savedAt: Date.now()
        } satisfies SaveData);
        void this.game.scenes.replace(new MenuScene(this.game), { duration: 0.3 });
    }
}
