idlerpg.sh 0.1.0

package/dist/tui/GameUIAdapter.js

@@ -0,0 +1,1342 @@
+/**
+ * Game UI Adapter - Unified UI interface using section-based architecture
+ * This replaces the monolithic GameUI.ts with a clean adapter pattern
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="49e26bda-c9cc-543b-8e45-e2d60795329c")}catch(e){}}();
+import { getScreen, ANSI } from './Screen.js';
+import { getInput } from './Input.js';
+import { getStrings } from '../i18n/index.js';
+// Section-based architecture
+import { SectionManager, createGridLayout } from './core/SectionManager.js';
+import { MapSection } from './sections/MapSection.js';
+import { StatusSection } from './sections/StatusSection.js';
+import { ActionsSection } from './sections/ActionsSection.js';
+import { EventsSection } from './sections/EventsSection.js';
+import { TravelingSection } from './sections/TravelingSection.js';
+import { DungeonSection } from './sections/DungeonSection.js';
+/**
+ * Game UI Adapter - Clean interface using section-based architecture
+ */
+export class GameUI {
+    PADDING = 2;
+    screen;
+    input;
+    mode = 'explore';
+    refreshInterval = null;
+    // Section management
+    sectionManager;
+    mapSection;
+    statusSection;
+    actionsSection;
+    eventsSection;
+    travelingSection;
+    dungeonSection;
+    // Mode state
+    isTravelMode = false;
+    isDungeonMode = false;
+    // Cached state
+    cachedState = null;
+    cachedNPCs = [];
+    cachedQuests = [];
+    // Dialog state
+    dialogNPC = null;
+    dialogHistory = [];
+    dialogOptions = [];
+    isWaitingForAI = false;
+    // Callbacks
+    onCommand = null;
+    onDialogInput = null;
+    onCharacterEdit = null;
+    // Modal state
+    activeModal = null;
+    modalSelectedIndex = 0;
+    modalScrollOffset = 0;
+    // Inventory modal state
+    inventoryTab = 0;
+    INVENTORY_TABS = ['All', 'Weapons', 'Armor', 'Consumables', 'Materials'];
+    // Character modal state
+    characterEditMode = false;
+    characterEditField = '';
+    characterEditBuffer = '';
+    characterExternalEditMode = false; // 是否在等待外部编辑器确认
+    characterExternalEditTempFile = ''; // 临时文件路径
+    // Size warning
+    showingSizeWarning = false;
+    constructor() {
+        this.screen = getScreen();
+        this.input = getInput();
+        // Initialize section-based architecture
+        this.sectionManager = new SectionManager();
+        this.mapSection = new MapSection();
+        this.statusSection = new StatusSection();
+        this.actionsSection = new ActionsSection();
+        this.eventsSection = new EventsSection();
+        this.travelingSection = new TravelingSection();
+        this.dungeonSection = new DungeonSection();
+        // Register sections
+        this.sectionManager.register(this.mapSection);
+        this.sectionManager.register(this.statusSection);
+        this.sectionManager.register(this.actionsSection);
+        this.sectionManager.register(this.eventsSection);
+        // Set up layout - Map on left (full height), Actions/Status on right
+        const layout = createGridLayout([
+            ['map', 'actions'],
+            ['map', 'status'],
+            ['events', 'events'],
+        ]);
+        this.sectionManager.setLayout(layout);
+        this.sectionManager.setDefaultFocus('map');
+        // Set up section callbacks
+        this.setupSectionCallbacks();
+    }
+    setupSectionCallbacks() {
+        this.mapSection.setOnTravel((roomIndex) => {
+            this.onCommand?.(String(roomIndex + 1));
+        });
+        this.actionsSection.setOnNpcSelect((npcIndex) => {
+            this.onCommand?.('npc');
+            setTimeout(() => this.onCommand?.(String(npcIndex + 1)), 50);
+        });
+        this.actionsSection.setOnOpenModal((modal) => {
+            this.openModal(modal);
+        });
+    }
+    /**
+     * Initialize UI
+     *
+     * Pushes the main key handler onto the input focus stack.
+     * This handler will be at the bottom of the stack and will receive
+     * input when no full-screen overlays are active.
+     */
+    async initialize() {
+        this.screen.hideCursor();
+        this.input.start();
+        // Push main UI handler onto focus stack (base handler)
+        this.input.pushFocus((key) => this.handleKeypress(key));
+        this.input.onLine((line) => this.handleLine(line));
+        this.screen.onResize((w, h) => this.handleResize(w, h));
+        this.sectionManager.focusDefault();
+        this.setMode('explore');
+    }
+    /**
+     * Cleanup
+     */
+    cleanup() {
+        this.stopRefresh();
+        this.input.stop();
+        this.screen.cleanup();
+    }
+    /**
+     * Set UI mode
+     */
+    setMode(mode) {
+        this.mode = mode;
+        if (mode === 'travel' || mode === 'combat') {
+            this.startRefresh(100);
+        }
+        else if (mode === 'explore' || mode === 'dialog') {
+            this.startRefresh(200);
+        }
+        else {
+            this.stopRefresh();
+        }
+        if (mode === 'dialog') {
+            this.input.setMode('line');
+        }
+        else {
+            this.input.setMode('raw');
+        }
+    }
+    /**
+     * Add event to log
+     */
+    addEventLog(message) {
+        this.eventsSection.addEvent(message);
+    }
+    /**
+     * Enter travel mode - replaces ActionsSection with TravelingSection
+     */
+    enterTravelMode() {
+        if (this.isTravelMode)
+            return;
+        this.sectionManager.unregister('actions');
+        this.sectionManager.register(this.travelingSection);
+        // Update layout to use 'traveling' instead of 'actions'
+        const travelLayout = createGridLayout([
+            ['map', 'traveling'],
+            ['map', 'status'],
+            ['events', 'events'],
+        ]);
+        this.sectionManager.setLayout(travelLayout);
+        this.isTravelMode = true;
+    }
+    /**
+     * Exit travel mode - restores ActionsSection
+     */
+    exitTravelMode() {
+        if (!this.isTravelMode)
+            return;
+        this.sectionManager.unregister('traveling');
+        this.sectionManager.register(this.actionsSection);
+        // Restore original layout with 'actions'
+        const normalLayout = createGridLayout([
+            ['map', 'actions'],
+            ['map', 'status'],
+            ['events', 'events'],
+        ]);
+        this.sectionManager.setLayout(normalLayout);
+        this.isTravelMode = false;
+    }
+    /**
+     * Update travel state for both TravelingSection and MapSection
+     */
+    updateTravelState(data) {
+        // Update TravelingSection
+        this.travelingSection.update({
+            fromName: data.fromName,
+            toName: data.toName,
+            progress: data.progress,
+            duration: data.duration,
+            events: data.events,
+            phase: data.phase,
+        });
+        // Update MapSection travel state (for showing moving icon)
+        this.mapSection.setTravelState({
+            fromRoomId: data.fromRoomId,
+            toRoomId: data.toRoomId,
+            progress: data.progress,
+        });
+    }
+    /**
+     * Clear travel state from MapSection
+     */
+    clearTravelState() {
+        this.mapSection.setTravelState(null);
+    }
+    /**
+     * Set cancel travel callback
+     */
+    setOnCancelTravel(callback) {
+        this.travelingSection.setOnCancelTravel(callback);
+    }
+    /**
+     * Enter dungeon mode - replaces ActionsSection with DungeonSection
+     * Layout changes to horizontal: Map | Dungeon | Status
+     */
+    enterDungeonMode() {
+        if (this.isDungeonMode)
+            return;
+        // Exit travel mode first if active
+        if (this.isTravelMode) {
+            this.exitTravelMode();
+        }
+        this.sectionManager.unregister('actions');
+        this.sectionManager.register(this.dungeonSection);
+        // Update layout for dungeon mode - horizontal arrangement
+        // Map takes left side, Dungeon and Status share right side horizontally
+        const dungeonLayout = createGridLayout([
+            ['map', 'dungeon', 'status'],
+            ['events', 'events', 'events'],
+        ]);
+        this.sectionManager.setLayout(dungeonLayout);
+        this.isDungeonMode = true;
+    }
+    /**
+     * Exit dungeon mode - restores ActionsSection
+     */
+    exitDungeonMode() {
+        if (!this.isDungeonMode)
+            return;
+        this.sectionManager.unregister('dungeon');
+        this.sectionManager.register(this.actionsSection);
+        // Restore normal layout
+        const normalLayout = createGridLayout([
+            ['map', 'actions'],
+            ['map', 'status'],
+            ['events', 'events'],
+        ]);
+        this.sectionManager.setLayout(normalLayout);
+        this.isDungeonMode = false;
+    }
+    /**
+     * Update dungeon progress data
+     */
+    updateDungeonData(data) {
+        this.dungeonSection.update(data);
+    }
+    /**
+     * Set abort dungeon callback
+     */
+    setOnAbortDungeon(callback) {
+        this.dungeonSection.setOnAbort(callback);
+    }
+    /**
+     * Register command handler
+     */
+    onCommandInput(handler) {
+        this.onCommand = handler;
+    }
+    /**
+     * Register dialog input handler
+     */
+    onDialogInputHandler(handler) {
+        this.onDialogInput = handler;
+    }
+    /**
+     * Register character edit handler
+     */
+    onCharacterEditHandler(handler) {
+        this.onCharacterEdit = handler;
+    }
+    // =========================================================================
+    // RENDERING
+    // =========================================================================
+    /**
+     * Render main exploration screen
+     */
+    renderMainScreen(state, npcsInRoom = [], activeQuests = []) {
+        this.cachedState = state;
+        this.cachedNPCs = npcsInRoom;
+        this.cachedQuests = activeQuests;
+        if (this.activeModal)
+            return;
+        const { width: screenWidth, height: screenHeight } = this.screen.getSize();
+        this.screen.clear();
+        const px = this.PADDING;
+        const py = this.PADDING;
+        const width = screenWidth - this.PADDING * 2;
+        const height = screenHeight - this.PADDING * 2;
+        // Layout
+        const headerHeight = 3;
+        const eventsHeight = Math.min(8, Math.floor(height * 0.25));
+        const mainAreaHeight = height - headerHeight - eventsHeight - 2;
+        // Render header
+        this.renderHeader(state.player, width, px, py);
+        // Update sections
+        this.mapSection.update(state);
+        this.statusSection.update({ state, npcs: npcsInRoom, quests: activeQuests });
+        this.actionsSection.update({ npcs: npcsInRoom, quests: activeQuests });
+        // Calculate bounds based on current mode
+        const boundsMap = new Map();
+        if (this.isDungeonMode) {
+            // Dungeon mode: horizontal layout - Map | Dungeon | Status
+            const mapWidth = Math.floor(width * 0.5);
+            const dungeonWidth = Math.floor(width * 0.25);
+            const statusWidth = width - mapWidth - dungeonWidth;
+            boundsMap.set('map', { x: px, y: py + headerHeight, width: mapWidth, height: mainAreaHeight });
+            boundsMap.set('dungeon', { x: px + mapWidth, y: py + headerHeight, width: dungeonWidth, height: mainAreaHeight });
+            boundsMap.set('status', { x: px + mapWidth + dungeonWidth, y: py + headerHeight, width: statusWidth, height: mainAreaHeight });
+        }
+        else {
+            // Normal mode: Map on left, Actions/Status on right (vertical)
+            const menuWidth = Math.min(28, Math.floor(width * 0.28));
+            const leftWidth = width - menuWidth - 1;
+            const actionsHeight = Math.floor(mainAreaHeight * 0.6);
+            const statusHeight = mainAreaHeight - actionsHeight;
+            boundsMap.set('map', { x: px, y: py + headerHeight, width: leftWidth, height: mainAreaHeight });
+            // Use traveling section bounds when in travel mode, otherwise actions
+            if (this.isTravelMode) {
+                boundsMap.set('traveling', { x: px + leftWidth, y: py + headerHeight, width: menuWidth + 1, height: actionsHeight });
+            }
+            else {
+                boundsMap.set('actions', { x: px + leftWidth, y: py + headerHeight, width: menuWidth + 1, height: actionsHeight });
+            }
+            boundsMap.set('status', { x: px + leftWidth, y: py + headerHeight + actionsHeight, width: menuWidth + 1, height: statusHeight });
+        }
+        boundsMap.set('events', { x: px, y: py + headerHeight + mainAreaHeight, width, height: eventsHeight });
+        // Render sections
+        for (const section of this.sectionManager.getAll()) {
+            const bounds = boundsMap.get(section.id);
+            if (bounds) {
+                section.bounds = bounds;
+                section.render({ screen: this.screen, bounds });
+            }
+        }
+        // Hint bar
+        this.renderHintBar(px + 1, py + height - 1, width - 2);
+        this.screen.render();
+    }
+    /**
+     * Render travel screen
+     */
+    renderTravelScreen(state, fromRoom, toRoom, progress, duration, events) {
+        const { width: screenWidth, height: screenHeight } = this.screen.getSize();
+        this.screen.clear();
+        const px = this.PADDING;
+        const py = this.PADDING;
+        const width = screenWidth - this.PADDING * 2;
+        const height = screenHeight - this.PADDING * 2;
+        // Header
+        this.renderHeader(state.player, width, px, py);
+        // Travel info
+        const contentY = py + 4;
+        const dots = '.'.repeat(Math.floor(Date.now() / 300) % 4);
+        this.screen.drawBox(px, contentY, width, height - 5, `Traveling${dots}`);
+        const centerX = px + Math.floor(width / 2);
+        const centerY = contentY + Math.floor((height - 7) / 2);
+        // From/To
+        const fromName = fromRoom?.name || 'Unknown';
+        const toName = toRoom?.name || 'Unknown';
+        this.screen.write(centerX - 15, centerY - 2, `From: ${fromName}`, ANSI.fg.gray);
+        this.screen.write(centerX - 15, centerY, `To:   ${toName}`, ANSI.fg.yellow);
+        // Progress bar
+        const barWidth = 30;
+        const barX = centerX - Math.floor(barWidth / 2);
+        this.screen.drawProgressBar(barX, centerY + 2, barWidth, progress, 1);
+        const pct = Math.floor(progress * 100);
+        this.screen.write(centerX - 5, centerY + 3, `${pct}% complete`, ANSI.fg.cyan);
+        // Time remaining
+        const remaining = Math.ceil(duration * (1 - progress));
+        this.screen.write(centerX - 8, centerY + 5, `${remaining}s remaining`, ANSI.fg.gray);
+        // Events
+        if (events.length > 0) {
+            const eventY = contentY + height - 8;
+            this.screen.write(px + 2, eventY, '- Events -', ANSI.fg.cyan);
+            events.slice(-3).forEach((ev, i) => {
+                this.screen.write(px + 2, eventY + 1 + i, `* ${ev}`.slice(0, width - 4), ANSI.fg.white);
+            });
+        }
+        // Hint
+        this.screen.write(px + 2, py + height - 1, '[ESC] Cancel Travel', ANSI.fg.yellow);
+        this.screen.render();
+    }
+    /**
+     * Render combat screen
+     */
+    renderCombatScreen(combat, player) {
+        const { width: screenWidth, height: screenHeight } = this.screen.getSize();
+        this.screen.clear();
+        const px = this.PADDING;
+        const py = this.PADDING;
+        const width = screenWidth - this.PADDING * 2;
+        const height = screenHeight - this.PADDING * 2;
+        // Header
+        this.renderHeader(player, width, px, py);
+        // Combat box
+        this.screen.drawBox(px, py + 3, width, height - 4, '⚔ COMBAT ⚔');
+        const contentY = py + 5;
+        const centerX = px + Math.floor(width / 2);
+        // Turn info
+        this.screen.write(centerX - 5, contentY, `Turn: ${combat.turn}`, ANSI.fg.yellow);
+        // Enemy info
+        const enemyY = contentY + 2;
+        this.screen.write(px + 4, enemyY, '-- Enemies --', ANSI.fg.red, undefined, ANSI.bold);
+        combat.enemies.forEach((enemy, i) => {
+            const hp = enemy.hp;
+            const maxHp = enemy.maxHp;
+            const hpPct = hp / maxHp;
+            const status = hp <= 0 ? ' [DEAD]' : '';
+            const color = hp <= 0 ? ANSI.fg.gray : ANSI.fg.white;
+            this.screen.write(px + 4, enemyY + 1 + i, `${enemy.name}${status}`, color);
+            if (hp > 0) {
+                this.screen.drawProgressBar(px + 20, enemyY + 1 + i, 15, hp, maxHp, ANSI.fg.red);
+                this.screen.write(px + 36, enemyY + 1 + i, `${hp}/${maxHp}`, ANSI.fg.white);
+            }
+        });
+        // Player stats
+        const playerY = enemyY + combat.enemies.length + 3;
+        this.screen.write(px + 4, playerY, '-- Your Stats --', ANSI.fg.green, undefined, ANSI.bold);
+        this.screen.write(px + 4, playerY + 1, `HP: ${player.stats.hp}/${player.stats.maxHp}`, ANSI.fg.white);
+        this.screen.write(px + 4, playerY + 2, `ATK: ${player.stats.attack}  DEF: ${player.stats.defense}`, ANSI.fg.white);
+        // Combat log
+        const logY = playerY + 5;
+        this.screen.write(px + 4, logY, '-- Combat Log --', ANSI.fg.cyan, undefined, ANSI.bold);
+        // Hint
+        this.screen.write(px + 2, py + height - 1, 'Combat is automatic... | 1:Aggressive 2:Defensive 3:Balanced', ANSI.fg.gray);
+        this.screen.render();
+    }
+    /**
+     * Render dialog screen
+     */
+    renderDialogScreen(npc, history, options, waiting) {
+        this.dialogNPC = npc;
+        this.dialogHistory = history;
+        this.dialogOptions = options;
+        this.isWaitingForAI = waiting;
+        const { width: screenWidth, height: screenHeight } = this.screen.getSize();
+        this.screen.clear();
+        const px = this.PADDING;
+        const py = this.PADDING;
+        const width = screenWidth - this.PADDING * 2;
+        const height = screenHeight - this.PADDING * 2;
+        // Dialog box
+        this.screen.drawBox(px, py, width, height, `Dialog: ${npc.name}`);
+        // NPC info
+        const infoY = py + 2;
+        this.screen.write(px + 2, infoY, `${npc.name} (${npc.role})`, ANSI.fg.yellow, undefined, ANSI.bold);
+        const rel = npc.playerRelationship;
+        const relText = rel > 50 ? 'Friendly' : rel > 0 ? 'Neutral+' : rel > -50 ? 'Neutral' : 'Unfriendly';
+        this.screen.write(px + 2, infoY + 1, `Relationship: ${relText}`, ANSI.fg.gray);
+        // Dialog history
+        const historyY = infoY + 3;
+        const maxHistoryLines = height - 12;
+        const recentHistory = history.slice(-maxHistoryLines);
+        recentHistory.forEach((entry, i) => {
+            const prefix = entry.role === 'player' ? 'You: ' : `${npc.name}: `;
+            const color = entry.role === 'player' ? ANSI.fg.cyan : ANSI.fg.white;
+            const text = `${prefix}${entry.text}`.slice(0, width - 4);
+            this.screen.write(px + 2, historyY + i, text, color);
+        });
+        // Waiting indicator
+        if (waiting) {
+            const dots = '.'.repeat(Math.floor(Date.now() / 300) % 4);
+            this.screen.write(px + 2, historyY + recentHistory.length + 1, `${npc.name} is thinking${dots}`, ANSI.fg.yellow);
+        }
+        // Quick options
+        const optionsY = py + height - 5;
+        this.screen.write(px + 2, optionsY, '-- Quick Options --', ANSI.fg.gray);
+        options.forEach((opt, i) => {
+            this.screen.write(px + 2, optionsY + 1 + i, `[${opt.key}] ${opt.text}`, ANSI.fg.white);
+        });
+        // Input hint
+        const inputY = py + height - 1;
+        const inputBuffer = this.input.getInputBuffer();
+        this.screen.write(px + 2, inputY, `> ${inputBuffer}▌`, ANSI.fg.white);
+        this.screen.render();
+    }
+    // =========================================================================
+    // PRIVATE HELPERS
+    // =========================================================================
+    renderHeader(player, width, x, y) {
+        const s = getStrings();
+        this.screen.drawBox(x, y, width, 3, '', true);
+        this.screen.write(x + 2, y + 1, 'IDLERPG.TERMINAL', ANSI.fg.cyan, undefined, ANSI.bold);
+        const playerInfo = `${s.status.level}.${player.stats.level} ${player.name}`;
+        this.screen.write(x + 25, y + 1, playerInfo, ANSI.fg.yellow);
+        this.screen.write(x + 45, y + 1, `${s.status.hp}:`, ANSI.fg.white);
+        this.screen.drawProgressBar(x + 49, y + 1, 10, player.stats.hp, player.stats.maxHp, ANSI.fg.red);
+        this.screen.write(x + 60, y + 1, `${player.stats.hp}/${player.stats.maxHp}`, ANSI.fg.white);
+        const time = new Date().toLocaleTimeString('en-US', { hour12: false });
+        this.screen.write(x + width - time.length - 2, y + 1, time, ANSI.fg.gray);
+    }
+    renderHintBar(x, y, width) {
+        const isAnyEntered = this.sectionManager.isAnyEntered();
+        let hints;
+        if (isAnyEntered) {
+            hints = this.sectionManager.getCurrentHint() || 'Up/Down: navigate  Enter: select  Esc: exit';
+        }
+        else {
+            hints = 'Arrows: focus  Enter: enter  |  1-9: Travel  I C Q W [M]enu';
+        }
+        this.screen.write(x, y, hints.slice(0, width), ANSI.fg.gray);
+    }
+    startRefresh(intervalMs) {
+        this.stopRefresh();
+        this.refreshInterval = setInterval(() => {
+            if (this.showingSizeWarning || this.screen.isCurrentlyResizing())
+                return;
+            if (this.activeModal) {
+                this.renderModal();
+                return;
+            }
+            if (this.mode === 'explore' && this.cachedState) {
+                this.renderMainScreen(this.cachedState, this.cachedNPCs, this.cachedQuests);
+            }
+            else if (this.mode === 'dialog' && this.dialogNPC) {
+                this.renderDialogScreen(this.dialogNPC, this.dialogHistory, this.dialogOptions, this.isWaitingForAI);
+            }
+            else {
+                this.screen.render();
+            }
+        }, intervalMs);
+    }
+    stopRefresh() {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+            this.refreshInterval = null;
+        }
+    }
+    /**
+     * Pause automatic rendering (for full-screen overlays like Prologue, CharacterCreation)
+     * This stops the refresh interval to prevent it from overwriting overlay screens.
+     *
+     * Note: Key handling is now managed by the InputManager's focus stack.
+     * When a full-screen overlay pushes its handler onto the stack, it receives
+     * exclusive input. This method only controls the render loop.
+     */
+    pauseRendering() {
+        this.stopRefresh();
+    }
+    /**
+     * Resume automatic rendering after full-screen overlay exits.
+     * Restores the refresh interval based on current mode.
+     *
+     * Note: Key handling is restored automatically when the overlay pops its
+     * handler from the InputManager's focus stack.
+     */
+    resumeRendering() {
+        if (this.mode === 'travel' || this.mode === 'combat') {
+            this.startRefresh(100);
+        }
+        else if (this.mode === 'explore' || this.mode === 'dialog') {
+            this.startRefresh(200);
+        }
+    }
+    handleResize(width, height) {
+        const sizeCheck = this.screen.checkMinimumSize();
+        if (!sizeCheck.valid) {
+            this.showingSizeWarning = true;
+            this.screen.renderSizeWarning();
+        }
+        else {
+            this.showingSizeWarning = false;
+            this.screen.clear();
+            if (this.mode === 'explore' && this.cachedState) {
+                this.renderMainScreen(this.cachedState, this.cachedNPCs, this.cachedQuests);
+            }
+            this.screen.forceRedraw();
+        }
+    }
+    handleKeypress(key) {
+        if (key.ctrl && key.name === 'c') {
+            this.cleanup();
+            process.exit(0);
+        }
+        // Note: Full-screen overlays (prologue, character creation) now push their
+        // own handlers onto the InputManager's focus stack, so they automatically
+        // receive exclusive input. No need for isFullScreenActive check here.
+        if (this.activeModal) {
+            this.handleModalKey(key);
+            return;
+        }
+        switch (this.mode) {
+            case 'travel':
+                // Delegate to section manager - TravelingSection handles 'q' to cancel
+                this.sectionManager.handleKey(key);
+                break;
+            case 'explore':
+                this.handleExploreKey(key);
+                break;
+            case 'dialog':
+                break;
+        }
+    }
+    handleExploreKey(key) {
+        // When a section is entered OR focused, let it handle keys first
+        // This allows sections like Map to capture WASD/+- for panning/zooming
+        const focused = this.sectionManager.getFocused();
+        if (focused) {
+            // Try to let the focused section handle the key
+            if (focused.handleKey(key)) {
+                if (this.cachedState) {
+                    this.renderMainScreen(this.cachedState, this.cachedNPCs, this.cachedQuests);
+                }
+                return;
+            }
+        }
+        // Modal shortcuts (only when section didn't handle the key)
+        // Note: Don't intercept WASD when map is focused (map uses these for panning)
+        const isMapFocused = focused?.id === 'map';
+        const modalKeys = {
+            'i': 'inventory',
+            'c': 'character',
+            'q': 'quests',
+            'm': 'menu',
+        };
+        // Only add workshop shortcut if map is not focused
+        if (!isMapFocused) {
+            modalKeys['w'] = 'workshop';
+        }
+        if (key.raw && modalKeys[key.raw.toLowerCase()]) {
+            this.openModal(modalKeys[key.raw.toLowerCase()]);
+            return;
+        }
+        // Number shortcuts for travel
+        if (key.raw && /^[1-9]$/.test(key.raw) && this.onCommand) {
+            this.onCommand(key.raw);
+            return;
+        }
+        // Global shortcuts
+        // Note: Don't intercept 's' when map is focused (map uses S for panning)
+        const globalShortcuts = {
+            'n': 'npc',
+            'h': 'help',
+            'l': 'load',
+        };
+        // Only add save shortcut if map is not focused
+        if (!isMapFocused) {
+            globalShortcuts['s'] = 'save';
+        }
+        if (key.raw) {
+            const cmd = globalShortcuts[key.raw.toLowerCase()];
+            if (cmd && this.onCommand) {
+                this.onCommand(cmd);
+                return;
+            }
+        }
+        // Delegate to section manager for navigation (arrows, enter, etc.)
+        if (this.sectionManager.handleKey(key)) {
+            if (this.cachedState) {
+                this.renderMainScreen(this.cachedState, this.cachedNPCs, this.cachedQuests);
+            }
+        }
+    }
+    handleLine(line) {
+        if (this.mode === 'explore' && this.onCommand) {
+            this.onCommand(line.trim().toLowerCase());
+        }
+        else if (this.mode === 'dialog' && this.onDialogInput) {
+            this.onDialogInput(line);
+        }
+    }
+    // =========================================================================
+    // MODAL HANDLING
+    // =========================================================================
+    openModal(modal) {
+        this.activeModal = modal;
+        this.modalSelectedIndex = 0;
+        this.modalScrollOffset = 0;
+    }
+    closeModal() {
+        this.activeModal = null;
+        if (this.cachedState) {
+            this.renderMainScreen(this.cachedState, this.cachedNPCs, this.cachedQuests);
+        }
+    }
+    handleModalKey(key) {
+        // Handle based on active modal
+        switch (this.activeModal) {
+            case 'inventory':
+                this.handleInventoryKey(key);
+                break;
+            case 'character':
+                this.handleCharacterKey(key);
+                break;
+            case 'quests':
+                this.handleQuestsKey(key);
+                break;
+            case 'menu':
+                this.handleMenuKey(key);
+                break;
+            default:
+                if (key.name === 'escape') {
+                    this.closeModal();
+                }
+        }
+    }
+    handleInventoryKey(key) {
+        const items = this.getFilteredInventory();
+        // Escape to close
+        if (key.name === 'escape' || key.raw === 'i') {
+            this.closeModal();
+            return;
+        }
+        // Tab switching with 1-5
+        if (key.raw && /^[1-5]$/.test(key.raw)) {
+            this.inventoryTab = parseInt(key.raw) - 1;
+            this.modalSelectedIndex = 0;
+            this.modalScrollOffset = 0;
+            this.renderModal();
+            return;
+        }
+        // Left/Right for tabs
+        if (key.name === 'left' || key.raw === 'h') {
+            if (this.inventoryTab > 0) {
+                this.inventoryTab--;
+                this.modalSelectedIndex = 0;
+                this.modalScrollOffset = 0;
+            }
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'right' || key.raw === 'l') {
+            if (this.inventoryTab < this.INVENTORY_TABS.length - 1) {
+                this.inventoryTab++;
+                this.modalSelectedIndex = 0;
+                this.modalScrollOffset = 0;
+            }
+            this.renderModal();
+            return;
+        }
+        // Up/Down for item selection
+        if (key.name === 'up' || key.raw === 'k') {
+            if (this.modalSelectedIndex > 0) {
+                this.modalSelectedIndex--;
+                if (this.modalSelectedIndex < this.modalScrollOffset) {
+                    this.modalScrollOffset = this.modalSelectedIndex;
+                }
+            }
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'down' || key.raw === 'j') {
+            if (this.modalSelectedIndex < items.length - 1) {
+                this.modalSelectedIndex++;
+                const maxVisible = 10;
+                if (this.modalSelectedIndex >= this.modalScrollOffset + maxVisible) {
+                    this.modalScrollOffset = this.modalSelectedIndex - maxVisible + 1;
+                }
+            }
+            this.renderModal();
+            return;
+        }
+        // E to equip
+        if (key.raw === 'e' || key.raw === 'E') {
+            this.equipSelectedItem();
+            return;
+        }
+        // U to unequip or use
+        if (key.raw === 'u' || key.raw === 'U') {
+            this.useOrUnequipSelectedItem();
+            return;
+        }
+        // D to drop
+        if (key.raw === 'd' || key.raw === 'D') {
+            this.dropSelectedItem();
+            return;
+        }
+    }
+    handleCharacterKey(key) {
+        const editableFields = ['name', 'backstory', 'appearance', 'personality'];
+        if (key.name === 'escape' || key.raw === 'c') {
+            if (this.characterEditMode) {
+                this.characterEditMode = false;
+                this.characterEditBuffer = '';
+            }
+            else if (this.characterExternalEditMode) {
+                // Cancel external edit
+                this.characterExternalEditMode = false;
+                this.characterExternalEditTempFile = '';
+            }
+            else {
+                this.closeModal();
+            }
+            this.renderModal();
+            return;
+        }
+        // In external edit mode, wait for Enter to confirm
+        if (this.characterExternalEditMode) {
+            if (key.name === 'return') {
+                // Read the temp file and apply
+                this.confirmExternalEdit();
+                return;
+            }
+            // Ignore other keys while waiting for confirmation
+            return;
+        }
+        // In edit mode, handle text input
+        if (this.characterEditMode) {
+            if (key.name === 'return') {
+                // Submit edit
+                if (this.characterEditBuffer.trim()) {
+                    this.onCharacterEdit?.(this.characterEditField, this.characterEditBuffer.trim());
+                }
+                this.characterEditMode = false;
+                this.characterEditBuffer = '';
+                this.renderModal();
+                return;
+            }
+            if (key.name === 'backspace') {
+                this.characterEditBuffer = this.characterEditBuffer.slice(0, -1);
+                this.renderModal();
+                return;
+            }
+            if (key.raw && key.raw.length === 1 && key.raw.charCodeAt(0) >= 32) {
+                this.characterEditBuffer += key.raw;
+                this.renderModal();
+                return;
+            }
+            return;
+        }
+        // Navigate editable fields
+        if (key.name === 'up' || key.raw === 'k') {
+            this.modalSelectedIndex = Math.max(0, this.modalSelectedIndex - 1);
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'down' || key.raw === 'j') {
+            this.modalSelectedIndex = Math.min(editableFields.length - 1, this.modalSelectedIndex + 1);
+            this.renderModal();
+            return;
+        }
+        // Ctrl+E to open external editor
+        if (key.ctrl && key.name === 'e') {
+            this.openExternalEditor(editableFields[this.modalSelectedIndex]);
+            return;
+        }
+        // Enter to edit
+        if (key.name === 'return') {
+            this.characterEditMode = true;
+            this.characterEditField = editableFields[this.modalSelectedIndex];
+            this.characterEditBuffer = '';
+            this.renderModal();
+            return;
+        }
+    }
+    async openExternalEditor(fieldKey) {
+        const player = this.cachedState?.player;
+        if (!player)
+            return;
+        const fs = await import('fs');
+        const path = await import('path');
+        const os = await import('os');
+        const { spawn } = await import('child_process');
+        // Get current value
+        let currentValue = '';
+        if (fieldKey === 'name') {
+            currentValue = player.name;
+        }
+        else if (player.character) {
+            currentValue = player.character[fieldKey] || '';
+        }
+        // Create temp file
+        const tempDir = os.tmpdir();
+        const tempFile = path.join(tempDir, `rougelike_edit_${fieldKey}.txt`);
+        fs.writeFileSync(tempFile, currentValue, 'utf-8');
+        // Save state
+        this.characterExternalEditMode = true;
+        this.characterEditField = fieldKey;
+        this.characterExternalEditTempFile = tempFile;
+        // Open editor (Windows uses notepad)
+        const editor = process.platform === 'win32' ? 'notepad' : (process.env.EDITOR || 'vi');
+        const child = spawn(editor, [tempFile], {
+            stdio: 'inherit',
+            detached: false,
+        });
+        child.on('close', () => {
+            // Re-render the modal after editor closes
+            this.renderModal();
+        });
+    }
+    async confirmExternalEdit() {
+        if (!this.characterExternalEditTempFile)
+            return;
+        try {
+            const fs = await import('fs');
+            const content = fs.readFileSync(this.characterExternalEditTempFile, 'utf-8').trim();
+            if (content) {
+                this.onCharacterEdit?.(this.characterEditField, content);
+            }
+            // Clean up temp file
+            try {
+                fs.unlinkSync(this.characterExternalEditTempFile);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        catch {
+            // Failed to read temp file
+        }
+        // Reset external edit state
+        this.characterExternalEditMode = false;
+        this.characterExternalEditTempFile = '';
+        this.renderModal();
+    }
+    handleQuestsKey(key) {
+        if (key.name === 'escape' || key.raw === 'q') {
+            this.closeModal();
+            return;
+        }
+        const quests = this.cachedQuests;
+        if (key.name === 'up' || key.raw === 'k') {
+            this.modalSelectedIndex = Math.max(0, this.modalSelectedIndex - 1);
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'down' || key.raw === 'j') {
+            this.modalSelectedIndex = Math.min(quests.length - 1, this.modalSelectedIndex + 1);
+            this.renderModal();
+            return;
+        }
+    }
+    handleMenuKey(key) {
+        if (key.name === 'escape' || key.raw === 'm') {
+            this.closeModal();
+            return;
+        }
+        const menuItems = ['New Game', 'Save Game', 'Load Game', 'Help', 'Settings', 'Exit'];
+        if (key.name === 'up' || key.raw === 'k') {
+            this.modalSelectedIndex = Math.max(0, this.modalSelectedIndex - 1);
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'down' || key.raw === 'j') {
+            this.modalSelectedIndex = Math.min(menuItems.length - 1, this.modalSelectedIndex + 1);
+            this.renderModal();
+            return;
+        }
+        if (key.name === 'return') {
+            const action = ['newgame', 'save', 'load', 'help', 'settings', 'exit'][this.modalSelectedIndex];
+            this.closeModal();
+            this.onCommand?.(action);
+            return;
+        }
+    }
+    getFilteredInventory() {
+        if (!this.cachedState?.player)
+            return [];
+        const items = this.cachedState.player.inventory;
+        const tabTypes = ['all', 'weapon', 'armor', 'consumable', 'material'];
+        const filterType = tabTypes[this.inventoryTab];
+        if (filterType === 'all')
+            return items;
+        return items.filter(i => i.type === filterType);
+    }
+    equipSelectedItem() {
+        const items = this.getFilteredInventory();
+        const item = items[this.modalSelectedIndex];
+        if (!item || !this.cachedState?.player)
+            return;
+        if (item.type === 'weapon' || item.type === 'armor') {
+            this.onCommand?.(`equip:${item.id}`);
+            this.addEventLog(`Equipped ${item.name}`);
+        }
+        this.renderModal();
+    }
+    useOrUnequipSelectedItem() {
+        const items = this.getFilteredInventory();
+        const item = items[this.modalSelectedIndex];
+        if (!item || !this.cachedState?.player)
+            return;
+        const eq = this.cachedState.player.equipment;
+        const isEquipped = eq.weapon?.id === item.id || eq.armor?.id === item.id || eq.accessory?.id === item.id;
+        if (isEquipped) {
+            this.onCommand?.(`unequip:${item.type}`);
+            this.addEventLog(`Unequipped ${item.name}`);
+        }
+        else if (item.type === 'consumable') {
+            this.onCommand?.(`use:${item.id}`);
+            this.addEventLog(`Used ${item.name}`);
+        }
+        this.renderModal();
+    }
+    dropSelectedItem() {
+        const items = this.getFilteredInventory();
+        const item = items[this.modalSelectedIndex];
+        if (!item)
+            return;
+        this.onCommand?.(`drop:${item.id}`);
+        this.addEventLog(`Dropped ${item.name}`);
+        if (this.modalSelectedIndex >= items.length - 1) {
+            this.modalSelectedIndex = Math.max(0, items.length - 2);
+        }
+        this.renderModal();
+    }
+    renderModal() {
+        if (!this.activeModal || !this.cachedState)
+            return;
+        const { width: screenWidth, height: screenHeight } = this.screen.getSize();
+        const modalWidth = Math.min(70, screenWidth - 6);
+        const modalHeight = Math.min(24, screenHeight - 4);
+        const mx = Math.floor((screenWidth - modalWidth) / 2);
+        const my = Math.floor((screenHeight - modalHeight) / 2);
+        // Fill modal background to cover the main screen
+        for (let row = my; row < my + modalHeight; row++) {
+            this.screen.write(mx, row, ' '.repeat(modalWidth), ANSI.fg.white, ANSI.bg.black);
+        }
+        // Draw modal box with title
+        this.screen.drawBox(mx, my, modalWidth, modalHeight, this.activeModal.toUpperCase());
+        // Content based on modal type
+        switch (this.activeModal) {
+            case 'inventory':
+                this.renderInventoryModal(mx, my, modalWidth, modalHeight);
+                break;
+            case 'character':
+                this.renderCharacterModal(mx, my, modalWidth, modalHeight);
+                break;
+            case 'quests':
+                this.renderQuestsModal(mx, my, modalWidth, modalHeight);
+                break;
+            case 'workshop':
+                this.renderWorkshopModal(mx, my, modalWidth, modalHeight);
+                break;
+            case 'menu':
+                this.renderMenuModal(mx, my, modalWidth, modalHeight);
+                break;
+        }
+        // Hint
+        this.screen.write(mx + 2, my + modalHeight - 1, '[ESC] Close', ANSI.fg.gray);
+        this.screen.render();
+    }
+    renderInventoryModal(x, y, width, height) {
+        const player = this.cachedState?.player;
+        if (!player)
+            return;
+        // Tabs
+        let tabX = x + 2;
+        for (let i = 0; i < this.INVENTORY_TABS.length; i++) {
+            const isActive = i === this.inventoryTab;
+            const fg = isActive ? ANSI.fg.black : ANSI.fg.white;
+            const bg = isActive ? ANSI.bg.cyan : undefined;
+            const label = `[${i + 1}]${this.INVENTORY_TABS[i]}`;
+            this.screen.write(tabX, y + 2, label, fg, bg);
+            tabX += label.length + 1;
+        }
+        // Gold
+        this.screen.write(x + width - 15, y + 2, `Gold: ${player.stats.gold}`, ANSI.fg.yellow);
+        // Split view: items list (left) + details (right)
+        const listWidth = Math.floor((width - 4) * 0.5);
+        const detailX = x + listWidth + 3;
+        const detailWidth = width - listWidth - 5;
+        const listY = y + 4;
+        const listHeight = height - 7;
+        // Items list
+        this.screen.write(x + 2, listY - 1, '─'.repeat(listWidth), ANSI.fg.gray);
+        const items = this.getFilteredInventory();
+        if (items.length === 0) {
+            this.screen.write(x + 2, listY + 1, '(No items)', ANSI.fg.gray);
+        }
+        else {
+            const maxVisible = Math.min(listHeight, 10);
+            for (let i = 0; i < maxVisible; i++) {
+                const itemIdx = this.modalScrollOffset + i;
+                if (itemIdx >= items.length)
+                    break;
+                const item = items[itemIdx];
+                const isSelected = itemIdx === this.modalSelectedIndex;
+                const eq = player.equipment;
+                const isEquipped = eq.weapon?.id === item.id || eq.armor?.id === item.id || eq.accessory?.id === item.id;
+                const equipMark = isEquipped ? '[E]' : '   ';
+                const fg = isSelected ? ANSI.fg.black : ANSI.fg.white;
+                const bg = isSelected ? ANSI.bg.cyan : undefined;
+                const icon = this.getItemIcon(item.type);
+                const label = `${icon} ${item.name} ${equipMark}`.slice(0, listWidth - 2);
+                this.screen.write(x + 2, listY + i, isSelected ? '▸' : ' ', ANSI.fg.yellow);
+                this.screen.write(x + 4, listY + i, label.padEnd(listWidth - 4), fg, bg);
+            }
+            // Scroll indicator
+            if (items.length > maxVisible) {
+                const pct = this.modalScrollOffset / Math.max(1, items.length - maxVisible);
+                const barY = Math.floor(pct * (maxVisible - 1));
+                for (let i = 0; i < maxVisible; i++) {
+                    this.screen.write(x + listWidth, listY + i, i === barY ? '█' : '░', ANSI.fg.gray);
+                }
+            }
+        }
+        // Item details (right panel)
+        this.screen.write(detailX, listY - 1, '─ Details ─', ANSI.fg.gray);
+        const selectedItem = items[this.modalSelectedIndex];
+        if (selectedItem) {
+            let lineY = listY;
+            this.screen.write(detailX, lineY++, selectedItem.name, ANSI.fg.yellow, undefined, ANSI.bold);
+            this.screen.write(detailX, lineY++, `Type: ${selectedItem.type}`, ANSI.fg.gray);
+            lineY++;
+            if (selectedItem.type === 'weapon') {
+                const w = selectedItem;
+                this.screen.write(detailX, lineY++, `Rarity: ${w.rarity}`, this.getRarityColor(w.rarity));
+                this.screen.write(detailX, lineY++, `Attack: ${w.baseAttack}`, ANSI.fg.red);
+                if (w.durability !== undefined) {
+                    this.screen.write(detailX, lineY++, `Durability: ${w.durability}/${w.maxDurability}`, ANSI.fg.white);
+                }
+            }
+            if (selectedItem.type === 'armor') {
+                const a = selectedItem;
+                this.screen.write(detailX, lineY++, `Rarity: ${a.rarity}`, this.getRarityColor(a.rarity));
+                this.screen.write(detailX, lineY++, `Defense: ${a.baseDefense}`, ANSI.fg.blue);
+            }
+            if (selectedItem.description) {
+                lineY++;
+                const desc = selectedItem.description.slice(0, detailWidth * 2);
+                this.screen.write(detailX, lineY++, desc.slice(0, detailWidth), ANSI.fg.gray);
+                if (desc.length > detailWidth) {
+                    this.screen.write(detailX, lineY++, desc.slice(detailWidth), ANSI.fg.gray);
+                }
+            }
+            // Actions
+            lineY = y + height - 4;
+            const eq = player.equipment;
+            const isEquipped = eq.weapon?.id === selectedItem.id || eq.armor?.id === selectedItem.id;
+            if (isEquipped) {
+                this.screen.write(detailX, lineY++, '[U] Unequip', ANSI.fg.white);
+            }
+            else if (selectedItem.type === 'weapon' || selectedItem.type === 'armor') {
+                this.screen.write(detailX, lineY++, '[E] Equip', ANSI.fg.white);
+            }
+            else if (selectedItem.type === 'consumable') {
+                this.screen.write(detailX, lineY++, '[U] Use', ANSI.fg.white);
+            }
+            this.screen.write(detailX, lineY, '[D] Drop', ANSI.fg.red);
+        }
+        // Equipment summary
+        const eqY = y + height - 2;
+        const eqWeapon = player.equipment.weapon?.name || '(none)';
+        const eqArmor = player.equipment.armor?.name || '(none)';
+        this.screen.write(x + 2, eqY, `⚔${eqWeapon}  🛡${eqArmor}`, ANSI.fg.gray);
+    }
+    renderCharacterModal(x, y, width, height) {
+        const player = this.cachedState?.player;
+        if (!player)
+            return;
+        const s = player.stats;
+        let lineY = y + 2;
+        // Header
+        this.screen.write(x + 2, lineY++, player.name, ANSI.fg.yellow, undefined, ANSI.bold);
+        this.screen.write(x + 2, lineY++, `Level ${s.level} Adventurer`, ANSI.fg.gray);
+        lineY++;
+        // Stats section
+        this.screen.write(x + 2, lineY++, '─── Stats ───', ANSI.fg.cyan);
+        this.screen.write(x + 2, lineY, `HP: `, ANSI.fg.white);
+        this.screen.drawProgressBar(x + 6, lineY, 12, s.hp, s.maxHp, ANSI.fg.red);
+        this.screen.write(x + 19, lineY++, `${s.hp}/${s.maxHp}`, ANSI.fg.white);
+        this.screen.write(x + 2, lineY, `MP: `, ANSI.fg.white);
+        this.screen.drawProgressBar(x + 6, lineY, 12, s.mp, s.maxMp, ANSI.fg.blue);
+        this.screen.write(x + 19, lineY++, `${s.mp}/${s.maxMp}`, ANSI.fg.white);
+        this.screen.write(x + 2, lineY, `EXP:`, ANSI.fg.white);
+        this.screen.drawProgressBar(x + 6, lineY, 12, s.exp, s.expToNextLevel, ANSI.fg.green);
+        this.screen.write(x + 19, lineY++, `${s.exp}/${s.expToNextLevel}`, ANSI.fg.white);
+        lineY++;
+        this.screen.write(x + 2, lineY++, `ATK: ${s.attack}   DEF: ${s.defense}   SPD: ${s.speed}`, ANSI.fg.white);
+        lineY++;
+        // Editable fields section
+        this.screen.write(x + 2, lineY++, '─── Profile ───', ANSI.fg.cyan);
+        const editableFields = [
+            { key: 'name', label: 'Name', value: player.name },
+            { key: 'backstory', label: 'Backstory', value: player.character?.backstory || '(not set)' },
+            { key: 'appearance', label: 'Appearance', value: player.character?.appearance || '(not set)' },
+            { key: 'personality', label: 'Personality', value: player.character?.personality || '(not set)' },
+        ];
+        for (let i = 0; i < editableFields.length; i++) {
+            const field = editableFields[i];
+            const isSelected = i === this.modalSelectedIndex && !this.characterEditMode && !this.characterExternalEditMode;
+            const isEditing = this.characterEditMode && this.characterEditField === field.key;
+            const isExternalEditing = this.characterExternalEditMode && this.characterEditField === field.key;
+            const fg = isSelected ? ANSI.fg.black : ANSI.fg.white;
+            const bg = isSelected ? ANSI.bg.cyan : undefined;
+            const indicator = isSelected ? '▸' : ' ';
+            this.screen.write(x + 2, lineY, indicator, ANSI.fg.yellow);
+            this.screen.write(x + 4, lineY, `${field.label}: `, fg, bg);
+            if (isEditing) {
+                this.screen.write(x + 4 + field.label.length + 2, lineY, this.characterEditBuffer + '▌', ANSI.fg.cyan);
+            }
+            else if (isExternalEditing) {
+                this.screen.write(x + 4 + field.label.length + 2, lineY, 'Press Enter To Confirm', ANSI.fg.cyan);
+            }
+            else {
+                const displayValue = field.value.slice(0, width - field.label.length - 10);
+                this.screen.write(x + 4 + field.label.length + 2, lineY, displayValue, ANSI.fg.gray);
+            }
+            lineY++;
+        }
+        // Hint
+        if (this.characterExternalEditMode) {
+            this.screen.write(x + 2, y + height - 2, 'Enter: confirm  Esc: cancel', ANSI.fg.gray);
+        }
+        else if (this.characterEditMode) {
+            this.screen.write(x + 2, y + height - 2, 'Enter: save  Esc: cancel', ANSI.fg.gray);
+        }
+        else {
+            this.screen.write(x + 2, y + height - 2, '↑↓: select  Enter: edit  Ctrl+E: external editor  Esc: close', ANSI.fg.gray);
+        }
+    }
+    renderQuestsModal(x, y, width, height) {
+        const quests = this.cachedQuests;
+        if (quests.length === 0) {
+            this.screen.write(x + 2, y + 2, '(No active quests)', ANSI.fg.gray);
+            this.screen.write(x + 2, y + 4, 'Talk to NPCs to get quests!', ANSI.fg.white);
+            return;
+        }
+        // Quest list (left) + details (right)
+        const listWidth = Math.floor((width - 4) * 0.4);
+        const detailX = x + listWidth + 3;
+        // Quest list
+        this.screen.write(x + 2, y + 2, '─── Quests ───', ANSI.fg.cyan);
+        quests.slice(0, height - 6).forEach((quest, i) => {
+            const completed = quest.objectives.filter(o => o.isComplete).length;
+            const total = quest.objectives.length;
+            const isSelected = i === this.modalSelectedIndex;
+            const fg = isSelected ? ANSI.fg.black : ANSI.fg.white;
+            const bg = isSelected ? ANSI.bg.cyan : undefined;
+            const status = completed === total ? '✓' : `${completed}/${total}`;
+            const label = `${quest.name} [${status}]`.slice(0, listWidth - 2);
+            this.screen.write(x + 2, y + 3 + i, isSelected ? '▸' : ' ', ANSI.fg.yellow);
+            this.screen.write(x + 4, y + 3 + i, label.padEnd(listWidth - 4), fg, bg);
+        });
+        // Quest details
+        const selectedQuest = quests[this.modalSelectedIndex];
+        if (selectedQuest) {
+            let lineY = y + 2;
+            this.screen.write(detailX, lineY++, selectedQuest.name, ANSI.fg.yellow, undefined, ANSI.bold);
+            this.screen.write(detailX, lineY++, `Type: ${selectedQuest.type}`, ANSI.fg.gray);
+            lineY++;
+            if (selectedQuest.description) {
+                const desc = selectedQuest.description.slice(0, (width - listWidth - 6) * 2);
+                this.screen.write(detailX, lineY++, desc.slice(0, width - listWidth - 6), ANSI.fg.white);
+            }
+            lineY++;
+            this.screen.write(detailX, lineY++, '─── Objectives ───', ANSI.fg.cyan);
+            for (const obj of selectedQuest.objectives.slice(0, 5)) {
+                const check = obj.isComplete ? '✓' : '○';
+                const color = obj.isComplete ? ANSI.fg.green : ANSI.fg.white;
+                const progress = obj.required > 1 ? ` (${obj.current}/${obj.required})` : '';
+                this.screen.write(detailX, lineY++, `${check} ${obj.description}${progress}`, color);
+            }
+            // Rewards
+            if (selectedQuest.rewards && selectedQuest.rewards.length > 0) {
+                lineY++;
+                this.screen.write(detailX, lineY++, '─── Rewards ───', ANSI.fg.cyan);
+                for (const reward of selectedQuest.rewards) {
+                    const qty = reward.quantity ? ` x${reward.quantity}` : '';
+                    if (reward.type === 'gold') {
+                        this.screen.write(detailX, lineY++, `Gold: ${reward.value}${qty}`, ANSI.fg.yellow);
+                    }
+                    else if (reward.type === 'exp') {
+                        this.screen.write(detailX, lineY++, `EXP: ${reward.value}${qty}`, ANSI.fg.green);
+                    }
+                    else if (reward.type === 'item') {
+                        this.screen.write(detailX, lineY++, `Item: ${reward.value}${qty}`, ANSI.fg.cyan);
+                    }
+                }
+            }
+        }
+    }
+    renderWorkshopModal(x, y, width, height) {
+        this.screen.write(x + 2, y + 2, 'Affix Workshop', ANSI.fg.cyan, undefined, ANSI.bold);
+        this.screen.write(x + 2, y + 4, 'Modify and enhance your equipment with affixes.', ANSI.fg.white);
+        this.screen.write(x + 2, y + 6, '─── Options ───', ANSI.fg.cyan);
+        const options = [
+            'Add Affix - Add a new modifier to equipment',
+            'Remove Affix - Remove an existing modifier',
+            'Reroll Affix - Reroll modifier values',
+            'Craft Item - Create new equipment',
+        ];
+        options.forEach((opt, i) => {
+            const isSelected = i === this.modalSelectedIndex;
+            const fg = isSelected ? ANSI.fg.black : ANSI.fg.white;
+            const bg = isSelected ? ANSI.bg.cyan : undefined;
+            this.screen.write(x + 2, y + 7 + i, isSelected ? '▸' : ' ', ANSI.fg.yellow);
+            this.screen.write(x + 4, y + 7 + i, opt.slice(0, width - 6), fg, bg);
+        });
+        this.screen.write(x + 2, y + height - 3, 'Workshop requires materials and gold.', ANSI.fg.gray);
+        this.screen.write(x + 2, y + height - 2, 'Feature coming soon!', ANSI.fg.yellow);
+    }
+    getItemIcon(type) {
+        switch (type) {
+            case 'weapon': return '⚔';
+            case 'armor': return '🛡';
+            case 'consumable': return '🧪';
+            case 'material': return '📦';
+            default: return '•';
+        }
+    }
+    getRarityColor(rarity) {
+        switch (rarity?.toLowerCase()) {
+            case 'common': return ANSI.fg.white;
+            case 'uncommon': return ANSI.fg.green;
+            case 'rare': return ANSI.fg.blue;
+            case 'epic': return ANSI.fg.magenta;
+            case 'legendary': return ANSI.fg.yellow;
+            default: return ANSI.fg.gray;
+        }
+    }
+    renderMenuModal(x, y, width, height) {
+        const menuItems = ['New Game', 'Save Game', 'Load Game', 'Help', 'Settings', 'Exit'];
+        menuItems.forEach((item, i) => {
+            const isSelected = i === this.modalSelectedIndex;
+            const fg = isSelected ? ANSI.fg.black : ANSI.fg.white;
+            const bg = isSelected ? ANSI.bg.cyan : undefined;
+            this.screen.write(x + 2, y + 2 + i, item.padEnd(width - 4), fg, bg);
+        });
+    }
+}
+// Singleton instance
+let gameUIInstance = null;
+export function getGameUI() {
+    if (!gameUIInstance) {
+        gameUIInstance = new GameUI();
+    }
+    return gameUIInstance;
+}
+//# sourceMappingURL=GameUIAdapter.js.map
+//# debugId=49e26bda-c9cc-543b-8e45-e2d60795329c