mainwindow.cpp

#include "mainwindow.h"

#include <QCoreApplication>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QHash>
#include <QHostAddress>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QKeyEvent>
#include <QAudioOutput>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPainter>
#include <QPixmap>
#include <QPolygonF>
#include <QPushButton>
#include <QQueue>
#include <QRandomGenerator>
#include <QFont>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QTcpServer>
#include <QTcpSocket>
#include <QUrl>

#include <algorithm>
#include <cmath>
#include <limits>

namespace {
constexpr int ShopPanelX = 16;
constexpr int ShopPanelWidth = 355;
constexpr int SidePanelWidth = 320;
constexpr int BoardTop = 64;
constexpr int BoardBenchGap = 48;
constexpr int ShopButtonY = 86;
constexpr int ShopCardOffsetX = 48;
constexpr int ShopCardOffsetY = 0;
constexpr int ShopSlotHeight = 106;
constexpr int ShopSlotGap = 14;
constexpr int ShopPanelLeftPadding = 16;
constexpr int ShopPanelRightPadding = 120;
constexpr int ShopPanelTop = 88;
constexpr int ShopPanelHeight = 750;
constexpr int ShopActionButtonGap = 10;
constexpr int LocalBoardRows = 8;
constexpr int LocalBoardCols = 8;
constexpr int MenuButtonWidth = 510;
constexpr int MenuButtonHeight = 132;
constexpr int MenuButtonGap = 130;
constexpr quint16 LanPort = 45454;
constexpr quint16 RemoteRelayPort = 45455;
const QString RemoteRelayHost = "67.216.192.97";
const QString UiFontFamily = QStringLiteral("Microsoft YaHei UI");

QFont uiFont(int pointSize, int weight = QFont::Normal)
{
    return QFont(UiFontFamily, pointSize, weight);
}

QColor uiTextColor(int alpha = 255)
{
    return QColor(255, 255, 255, alpha);
}

QPolygonF starPolygon(const QPointF& center, qreal radius)
{
    QPolygonF points;
    const qreal innerRadius = radius * 0.48;
    constexpr qreal Pi = 3.14159265358979323846;
    for (int i = 0; i < 10; ++i) {
        const qreal angle = -Pi / 2 + i * Pi / 5;
        const qreal currentRadius = (i % 2 == 0) ? radius : innerRadius;
        points << QPointF(center.x() + std::cos(angle) * currentRadius,
                          center.y() + std::sin(angle) * currentRadius);
    }
    return points;
}

void drawStarLevel(QPainter& painter, const QRect& rect, int star)
{
    const int count = std::clamp(star, 1, 3);
    const qreal radius = std::max<qreal>(4.0, std::min<qreal>(6.0, rect.width() / 15.0));
    const qreal gap = 2.0;
    const qreal totalWidth = count * radius * 2 + (count - 1) * gap;
    const qreal startX = rect.left() + (rect.width() - totalWidth) / 2 + radius;
    const qreal centerY = rect.top() + 7.0;

    painter.setPen(QPen(QColor(115, 86, 24), 1));
    painter.setBrush(QColor(250, 210, 78));
    for (int i = 0; i < count; ++i) {
        painter.drawPolygon(starPolygon(QPointF(startX + i * (radius * 2 + gap), centerY), radius));
    }
}

QString assetPath(const QString& relativePath)
{
    const QStringList roots = {
        QDir::currentPath(),
        QCoreApplication::applicationDirPath()
    };

    for (const QString& root : roots) {
        QDir dir(root);
        for (int i = 0; i < 6; ++i) {
            const QString candidate = dir.filePath(relativePath);
            if (QFileInfo::exists(candidate)) {
                return candidate;
            }
            if (!dir.cdUp()) {
                break;
            }
        }
    }
    return relativePath;
}

QString heroImageFile(const QString& id)
{
    if (id == "sentinel") {
        return QStringLiteral("image/哨卫 Sentinel.png");
    }
    if (id == "arcanist") {
        return QStringLiteral("image/秘术师 Arcanist.png");
    }
    if (id == "druid") {
        return QStringLiteral("image/德鲁伊 Druid.png");
    }
    if (id == "ranger") {
        return QStringLiteral("image/游侠 Ranger.png");
    }
    if (id == "assassin") {
        return QStringLiteral("image/刺客 Assassin.png");
    }
    if (id == "star_knight") {
        return QStringLiteral("image/星铠骑士 Star Knight.png");
    }
    if (id == "dawn_lancer") {
        return QStringLiteral("image/破晓枪卫 Dawn Lancer.png");
    }
    if (id == "spark_gunner") {
        return QStringLiteral("image/星火炮手 Spark Gunner.png");
    }
    if (id == "moonblade") {
        return QStringLiteral("image/月影行者 Moonblade.png");
    }
    if (id == "light_priest") {
        return QStringLiteral("image/光纹祭司 Light Priest.png");
    }
    return QString();
}

const QPixmap* heroImage(const QString& id)
{
    static QHash<QString, QPixmap> cache;

    if (!cache.contains(id)) {
        const QString fileName = heroImageFile(id);
        QPixmap pixmap;
        if (!fileName.isEmpty()) {
            pixmap.load(assetPath(fileName));
        }
        cache.insert(id, pixmap);
    }

    const auto it = cache.constFind(id);
    return it == cache.constEnd() || it.value().isNull() ? nullptr : &it.value();
}

QString equipmentImageFile(EquipmentType type)
{
    switch (type) {
    case EquipmentType::Sword:
        return QStringLiteral("image/铁剑.png");
    case EquipmentType::Armor:
        return QStringLiteral("image/锁子甲.png");
    case EquipmentType::Gloves:
        return QStringLiteral("image/迅捷手套.png");
    case EquipmentType::Crystal:
        return QStringLiteral("image/蓝水晶.png");
    }
    return QString();
}

const QPixmap* equipmentImage(EquipmentType type)
{
    static QHash<int, QPixmap> cache;
    const int key = static_cast<int>(type);

    if (!cache.contains(key)) {
        QPixmap pixmap;
        pixmap.load(assetPath(equipmentImageFile(type)));
        cache.insert(key, pixmap);
    }

    const auto it = cache.constFind(key);
    return it == cache.constEnd() || it.value().isNull() ? nullptr : &it.value();
}

const QPixmap* startPageImage()
{
    static QPixmap pixmap;
    static bool loaded = false;
    if (!loaded) {
        pixmap.load(assetPath(QStringLiteral("image/Start_page.png")));
        loaded = true;
    }
    return pixmap.isNull() ? nullptr : &pixmap;
}

const QPixmap* menuAsset(const QString& fileName)
{
    static QHash<QString, QPixmap> cache;
    if (!cache.contains(fileName)) {
        QPixmap pixmap;
        pixmap.load(assetPath(QStringLiteral("image/") + fileName));
        cache.insert(fileName, pixmap);
    }

    const auto it = cache.constFind(fileName);
    return it == cache.constEnd() || it.value().isNull() ? nullptr : &it.value();
}

QRect alphaBounds(const QPixmap& pixmap)
{
    const QImage image = pixmap.toImage();
    QRect bounds;
    for (int y = 0; y < image.height(); ++y) {
        for (int x = 0; x < image.width(); ++x) {
            if (qAlpha(image.pixel(x, y)) > 8) {
                const QRect pixelRect(x, y, 1, 1);
                bounds = bounds.isNull() ? pixelRect : bounds.united(pixelRect);
            }
        }
    }
    return bounds.isNull() ? pixmap.rect() : bounds.adjusted(-4, -4, 4, 4).intersected(pixmap.rect());
}

QRect pixmapSource(const QString& key, const QPixmap& pixmap)
{
    static QHash<QString, QRect> cache;
    if (!cache.contains(key)) {
        cache.insert(key, alphaBounds(pixmap));
    }
    return cache.value(key);
}

bool isCheckerboardBackgroundPixel(QRgb pixel)
{
    if (qAlpha(pixel) < 8) {
        return true;
    }

    const int red = qRed(pixel);
    const int green = qGreen(pixel);
    const int blue = qBlue(pixel);
    const int brightest = std::max({red, green, blue});
    const int darkest = std::min({red, green, blue});
    return brightest >= 236 && brightest - darkest <= 14;
}

const QPixmap* shopStorePixmap()
{
    static QPixmap pixmap;
    static bool loaded = false;

    if (!loaded) {
        QImage image(assetPath(QStringLiteral("image/back_of_store.png")));
        if (!image.isNull()) {
            image = image.convertToFormat(QImage::Format_ARGB32);
            const int imageWidth = image.width();
            const int imageHeight = image.height();
            std::vector<unsigned char> visited(size_t(imageWidth) * size_t(imageHeight), 0);
            QQueue<QPoint> queue;

            auto enqueue = [&](int x, int y) {
                if (x < 0 || y < 0 || x >= imageWidth || y >= imageHeight) {
                    return;
                }
                const size_t index = size_t(y) * size_t(imageWidth) + size_t(x);
                if (visited[index] || !isCheckerboardBackgroundPixel(image.pixel(x, y))) {
                    return;
                }
                visited[index] = 1;
                queue.enqueue(QPoint(x, y));
            };

            for (int x = 0; x < imageWidth; ++x) {
                enqueue(x, 0);
                enqueue(x, imageHeight - 1);
            }
            for (int y = 0; y < imageHeight; ++y) {
                enqueue(0, y);
                enqueue(imageWidth - 1, y);
            }

            while (!queue.isEmpty()) {
                const QPoint point = queue.dequeue();
                QColor color = image.pixelColor(point);
                color.setAlpha(0);
                image.setPixelColor(point, color);
                enqueue(point.x() + 1, point.y());
                enqueue(point.x() - 1, point.y());
                enqueue(point.x(), point.y() + 1);
                enqueue(point.x(), point.y() - 1);
            }

            pixmap = QPixmap::fromImage(image);
        }
        loaded = true;
    }

    return pixmap.isNull() ? nullptr : &pixmap;
}

QRect heroImageSource(const QString& id, const QPixmap& pixmap)
{
    if (id == "sentinel") {
        return QRect(120, 35, 1175, 940).intersected(pixmap.rect());
    }
    return pixmap.rect();
}

QRect fittedPixmapRect(const QRect& rect, const QSize& sourceSize)
{
    if (sourceSize.isEmpty()) {
        return rect;
    }

    const qreal scale = std::min(rect.width() / qreal(sourceSize.width()),
                                 rect.height() / qreal(sourceSize.height()));
    const int width = std::max(1, int(std::round(sourceSize.width() * scale)));
    const int height = std::max(1, int(std::round(sourceSize.height() * scale)));
    return QRect(rect.left() + (rect.width() - width) / 2,
                 rect.top() + (rect.height() - height) / 2,
                 width,
                 height);
}

void drawHeroImage(QPainter& painter, const QString& id, const QRect& rect, const QColor& fallback)
{
    const QPixmap* pixmap = heroImage(id);
    if (!pixmap) {
        painter.fillRect(rect, fallback);
        return;
    }
    const QRect source = heroImageSource(id, *pixmap);
    const QRect target = fittedPixmapRect(rect, source.size());
    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
    painter.drawPixmap(target, *pixmap, source);
    painter.restore();
}

void drawCoverPixmap(QPainter& painter, const QPixmap& pixmap, const QRect& target)
{
    if (target.isEmpty() || pixmap.isNull()) {
        return;
    }

    const qreal scale = std::max(target.width() / qreal(pixmap.width()),
                                 target.height() / qreal(pixmap.height()));
    const int sourceWidth = std::max(1, int(std::round(target.width() / scale)));
    const int sourceHeight = std::max(1, int(std::round(target.height() / scale)));
    const QRect source((pixmap.width() - sourceWidth) / 2,
                       (pixmap.height() - sourceHeight) / 2,
                       sourceWidth,
                       sourceHeight);
    painter.drawPixmap(target, pixmap, source);
}

bool drawMenuPixmap(QPainter& painter, const QString& fileName, const QRect& target)
{
    const QPixmap* pixmap = menuAsset(fileName);
    if (!pixmap) {
        return false;
    }
    painter.drawPixmap(target, *pixmap, pixmapSource(fileName, *pixmap));
    return true;
}

bool drawShopCardPixmap(QPainter& painter, const QRect& target)
{
    const QPixmap* pixmap = menuAsset(QStringLiteral("back_of_card.png"));
    if (!pixmap || target.isEmpty()) {
        return false;
    }

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, pixmapSource(QStringLiteral("back_of_card.png"), *pixmap));
    painter.restore();
    return true;
}

bool drawShopStorePixmap(QPainter& painter, const QRect& target)
{
    const QPixmap* pixmap = shopStorePixmap();
    if (!pixmap || target.isEmpty()) {
        return false;
    }

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, pixmapSource(QStringLiteral("back_of_store_clean"), *pixmap));
    painter.restore();
    return true;
}

bool drawResultPixmap(QPainter& painter, const QRect& target)
{
    const QPixmap* pixmap = menuAsset(QStringLiteral("back_of_result.png"));
    if (!pixmap || target.isEmpty()) {
        return false;
    }

    const QRectF sourcePanel(38.0, 32.0, 1479.0, 919.0);

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, sourcePanel);
    painter.restore();
    return true;
}

bool drawTexturePixmap(QPainter& painter, const QString& fileName, const QRect& target)
{
    const QPixmap* pixmap = menuAsset(fileName);
    if (!pixmap || target.isEmpty()) {
        return false;
    }

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, pixmap->rect());
    painter.restore();
    return true;
}

bool drawBoardTexturePixmap(QPainter& painter, const QRect& gridTarget)
{
    const QPixmap* pixmap = menuAsset(QStringLiteral("back_of_board.png"));
    if (!pixmap || gridTarget.isEmpty()) {
        return false;
    }

    const QRectF sourceGrid(21.0, 20.0, 1211.0, 1213.0);
    const qreal scaleX = gridTarget.width() / sourceGrid.width();
    const qreal scaleY = gridTarget.height() / sourceGrid.height();
    const QRectF target(gridTarget.left() - sourceGrid.left() * scaleX,
                        gridTarget.top() - sourceGrid.top() * scaleY,
                        pixmap->width() * scaleX,
                        pixmap->height() * scaleY);

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, QRectF(pixmap->rect()));
    painter.restore();
    return true;
}

bool drawPrepareTexturePixmap(QPainter& painter, const QRect& slotsTarget)
{
    const QPixmap* pixmap = menuAsset(QStringLiteral("back_of_prepare.png"));
    if (!pixmap || slotsTarget.isEmpty()) {
        return false;
    }

    const QRectF sourceSlots(43.0, 293.0, 1686.0, 300.0);
    const QRectF sourcePanel(19.0, 265.0, 1735.0, 356.0);
    const qreal scaleX = slotsTarget.width() / sourceSlots.width();
    const qreal scaleY = slotsTarget.height() / sourceSlots.height();
    const QRectF targetPanel(slotsTarget.left() + (sourcePanel.left() - sourceSlots.left()) * scaleX,
                             slotsTarget.top() + (sourcePanel.top() - sourceSlots.top()) * scaleY,
                             sourcePanel.width() * scaleX,
                             sourcePanel.height() * scaleY);

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(targetPanel, *pixmap, sourcePanel);
    painter.restore();
    return true;
}

bool drawEquipmentSitePixmap(QPainter& painter, const QRect& target)
{
    const QPixmap* pixmap = menuAsset(QStringLiteral("back_of_equipment_site.png"));
    if (!pixmap || target.isEmpty()) {
        return false;
    }

    const QRectF sourcePanel(159.0, 0.0, 704.0, 761.0);

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.drawPixmap(target, *pixmap, sourcePanel);
    painter.restore();
    return true;
}

qreal fadeProgress(qint64 elapsedMs, qint64 startMs, qint64 durationMs)
{
    const qreal value = (elapsedMs - startMs) / qreal(durationMs);
    return std::clamp(value, 0.0, 1.0);
}

void drawImageMenuButton(QPainter& painter,
                         const QString& fileName,
                         const QRect& rect,
                         const QString& text,
                         bool enabled,
                         qreal opacity,
                         bool hovered)
{
    const QRect imageRect = hovered && enabled ? rect.adjusted(-5, -3, 5, 3) : rect;

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.setRenderHint(QPainter::TextAntialiasing, true);
    painter.setOpacity(opacity * (enabled ? 1.0 : 0.45));
    drawMenuPixmap(painter, fileName, imageRect);

    QFont font(UiFontFamily, 22, QFont::Black);
    painter.setFont(font);
    const QRect textRect = imageRect.adjusted(22, 4, -22, -6);
    painter.setPen(uiTextColor(130));
    painter.drawText(textRect.translated(0, 3), Qt::AlignCenter, text);
    painter.setPen(uiTextColor(150));
    painter.drawText(textRect.translated(0, -1), Qt::AlignCenter, text);
    painter.setPen(enabled ? uiTextColor() : uiTextColor(150));
    painter.drawText(textRect, Qt::AlignCenter, text);
    painter.restore();
}

void drawEquipmentImage(QPainter& painter, const Equipment& equipment, const QRect& rect)
{
    const QPixmap* pixmap = equipmentImage(equipment.type);
    if (!pixmap) {
        painter.setFont(uiFont(8, QFont::Bold));
        painter.setPen(uiTextColor());
        painter.drawText(rect, Qt::AlignCenter | Qt::TextWordWrap, equipment.name);
        return;
    }

    const QRect target = fittedPixmapRect(rect, pixmap->size());
    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, false);
    painter.drawPixmap(target, *pixmap, pixmap->rect());
    painter.restore();
}

QString traitDisplayName(const QString& trait)
{
    if (trait == "Warrior") {
        return QStringLiteral("战士");
    }
    if (trait == "Guardian") {
        return QStringLiteral("守护者");
    }
    if (trait == "Mage") {
        return QStringLiteral("法师");
    }
    if (trait == "Mystic") {
        return QStringLiteral("秘术");
    }
    if (trait == "Ranger") {
        return QStringLiteral("游侠");
    }
    return trait;
}

QString traitDisplayList(const QStringList& traits)
{
    QStringList localized;
    for (const QString& trait : traits) {
        localized << traitDisplayName(trait);
    }
    return localized.join(QStringLiteral("、"));
}

int indexOf(int row, int col)
{
    return row * LocalBoardCols + col;
}

bool inBounds(int row, int col)
{
    return row >= 0 && row < LocalBoardRows && col >= 0 && col < LocalBoardCols;
}

double gridDistance(const Unit* a, const Unit* b)
{
    const int dr = a->row() - b->row();
    const int dc = a->col() - b->col();
    return std::sqrt(static_cast<double>(dr * dr + dc * dc));
}

QString equipmentName(const Unit* unit)
{
    return unit->hasEquipment() ? unit->equipment().name : QStringLiteral("无");
}

QString cleanRemoteToken(QString value, int maxLength)
{
    value = value.trimmed();
    value.replace(QRegularExpression(QStringLiteral("[\\r\\n\\t]")), QStringLiteral(" "));
    while (value.contains(QStringLiteral("  "))) {
        value.replace(QStringLiteral("  "), QStringLiteral(" "));
    }
    if (value.size() > maxLength) {
        value = value.left(maxLength);
    }
    return value;
}
}

MainWindow::MainWindow(QWidget* parent)
    : QWidget(parent)
{
    setWindowTitle(QStringLiteral("星尘骑士团"));
    setMinimumSize(1440, 900);
    setMouseTracking(true);

    for (int row = 0; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            m_tiles[row][col] = Tile(row, col);
        }
    }
    for (auto& row : m_board) {
        row.fill(nullptr);
    }
    m_bench.fill(nullptr);

    m_menuAudioOutput = new QAudioOutput(this);
    m_menuAudioOutput->setVolume(float(m_menuVolume));
    m_menuMusicPlayer.setAudioOutput(m_menuAudioOutput);
    m_menuMusicPlayer.setSource(QUrl::fromLocalFile(assetPath(QStringLiteral("music/Beneath_the_Iron_Crown.mp3"))));
    m_menuMusicPlayer.setLoops(QMediaPlayer::Infinite);

    connect(&m_timer, &QTimer::timeout, this, &MainWindow::tickGame);
    m_timer.start(250);
    m_menuAnimationClock.start();
    connect(&m_menuAnimationTimer, &QTimer::timeout, this, [this]() {
        if (m_screen != Screen::Playing && m_menuAnimationClock.elapsed() < 1900) {
            update();
        } else {
            m_menuAnimationTimer.stop();
        }
    });
    m_menuAnimationTimer.start(16);
    updateMenuMusic();
}

void MainWindow::initializeGame()
{
    setScreen(Screen::Playing);
    m_phase = Phase::Prep;
    m_round = 1;
    const QString nickname = m_localNickname;
    const QString roomId = m_remoteRoomId;
    m_player.setState(100, 30, 1, 3, 0, 0);
    m_units.clear();
    for (auto& row : m_board) {
        row.fill(nullptr);
    }
    m_bench.fill(nullptr);
    m_equipmentPool.clear();
    m_activeTraits.clear();
    m_log.clear();
    m_finalMessage.clear();
    m_menuMessage.clear();
    m_localCombatReady = false;
    m_remoteCombatReady = false;
    m_hasServerBattleResult = false;
    m_serverPlayerWon = false;
    m_remoteOpponentHealth = 100;
    m_localNickname = nickname;
    m_remoteOpponentName.clear();
    m_remoteRoomId = roomId;
    m_remoteBoardSnapshot = QJsonArray();

    Unit* first = addUnit(createHero("sentinel", Owner::PlayerCtrl));
    Unit* second = addUnit(createHero("ranger", Owner::PlayerCtrl));
    placeOnBench(first, 0);
    placeOnBench(second, 1);
    refreshShop(false);
    updateActiveTraits();
    pushLog(QStringLiteral("购买单位，拖到棋盘下半区，然后开始战斗。"));
    update();
}

void MainWindow::tickGame()
{
    if (m_screen != Screen::Playing) {
        update();
        return;
    }

    if (m_phase == Phase::Combat) {
        QVector<Unit*> all = combatUnits();
        for (Unit* unit : all) {
            updateUnit(unit, all);
            clearDeadOccupants();
        }

        const bool enemyAlive = hasAlive(Owner::EnemyCtrl);
        const bool playerAlive = hasAlive(Owner::PlayerCtrl);
        if (!enemyAlive || !playerAlive) {
            bool playerWon = !enemyAlive;
            if (m_networkRole == NetworkRole::Remote && m_hasServerBattleResult) {
                if (playerWon != m_serverPlayerWon) {
                    pushLog(QStringLiteral("服务器结果覆盖本地战斗演出。"));
                }
                playerWon = m_serverPlayerWon;
            }
            finishCombat(playerWon);
        }
        update();
        return;
    }

    if (m_phase == Phase::Resolve) {
        --m_resolveTicks;
        if (m_resolveTicks <= 0) {
            enterPrepAfterResolve();
        }
        update();
    }
}

void MainWindow::startCombat()
{
    if (m_phase != Phase::Prep) {
        return;
    }
    if (boardPlayerCount() == 0) {
        pushLog(QStringLiteral("请至少放置一个单位到棋盘上。"));
        update();
        return;
    }
    if (m_networkRole != NetworkRole::Offline) {
        sendLocalCombatReady();
        return;
    }

    m_combatStart.clear();
    for (Unit* unit : playerBoardUnits()) {
        m_combatStart.push_back({unit, unit->row(), unit->col()});
    }

    spawnEnemies();
    for (Unit* unit : combatUnits()) {
        unit->resetForCombat();
    }
    const int enemyPower = std::max(0, m_round - 1);
    for (Unit* unit : combatUnits()) {
        if (unit->owner() == Owner::EnemyCtrl) {
            unit->addMaxHp(enemyPower * 45);
            unit->addAttack(enemyPower * 6);
        }
    }
    applyTraitBonuses();

    m_phase = Phase::Combat;
    pushLog(QStringLiteral("第 %1 回合战斗开始。").arg(m_round));
    update();
}

void MainWindow::finishCombat(bool playerWon)
{
    if (m_phase != Phase::Combat) {
        return;
    }
    if (m_networkRole == NetworkRole::Remote) {
        m_remoteOpponentHealth = std::max(0, m_remoteOpponentHealth - (playerWon ? 12 + m_round * 3 : 0));
    }
    m_hasServerBattleResult = false;
    m_serverPlayerWon = false;
    m_lastRoundWon = playerWon;
    resolveRewards(playerWon);
    restorePlayerPositions();
    clearEnemies();

    if (!playerWon) {
        if (m_player.health() <= 0) {
            m_phase = Phase::Finished;
            m_finalMessage = QStringLiteral("失败：第 %1 回合 HP 归零。").arg(m_round);
            pushLog(QStringLiteral("失败：玩家 HP 已经归零。"));
            update();
            return;
        }

        const int finishedRound = m_round;
        if (m_networkRole != NetworkRole::Offline) {
            ++m_round;
        }
        m_phase = Phase::Resolve;
        m_resolveTicks = 8;
        pushLog(m_networkRole == NetworkRole::Offline
                    ? QStringLiteral("第 %1 回合失败，整备后再挑战本回合。").arg(finishedRound)
                    : QStringLiteral("第 %1 回合失败，进入下一回合。").arg(finishedRound));
        update();
        return;
    }

    if (m_networkRole == NetworkRole::Offline && m_round >= MaxRounds) {
        m_phase = Phase::Finished;
        m_finalMessage = QStringLiteral("胜利：已通关全部五个回合。");
        pushLog(QStringLiteral("胜利：已通关全部五个回合。"));
        update();
        return;
    }
    if (m_networkRole == NetworkRole::Remote && m_remoteOpponentHealth <= 0) {
        m_phase = Phase::Finished;
        m_finalMessage = QStringLiteral("胜利：%1 HP 已归零。").arg(m_remoteOpponentName.isEmpty() ? QStringLiteral("对手") : m_remoteOpponentName);
        pushLog(m_finalMessage);
        update();
        return;
    }

    ++m_round;
    m_phase = Phase::Resolve;
    m_resolveTicks = 8;
    update();
}

void MainWindow::enterPrepAfterResolve()
{
    m_phase = Phase::Prep;
    refreshShop(false);
    updateActiveTraits();
    pushLog(QStringLiteral("准备阶段。"));
}

void MainWindow::spawnEnemies()
{
    clearEnemies();

    QVector<QString> lineups;
    if (m_round == 1) {
        lineups = {"sentinel", "ranger"};
    } else if (m_round == 2) {
        lineups = {"sentinel", "druid", "spark_gunner"};
    } else if (m_round == 3) {
        lineups = {"star_knight", "ranger", "assassin", "arcanist"};
    } else if (m_round == 4) {
        lineups = {"sentinel", "light_priest", "spark_gunner", "moonblade", "arcanist"};
    } else {
        lineups = {"star_knight", "dawn_lancer", "light_priest", "ranger", "moonblade", "arcanist"};
    }

    const QVector<QPoint> spots = {
        {1, 2}, {1, 5}, {0, 3}, {0, 4}, {2, 2}, {2, 5}
    };
    for (int i = 0; i < lineups.size(); ++i) {
        Unit* enemy = addUnit(createHero(lineups[i], Owner::EnemyCtrl));
        if (m_round >= 4 && (i % 2 == 0)) {
            enemy->setStar(2);
        }
        placeOnBoard(enemy, spots[i].x(), spots[i].y());
    }
}

void MainWindow::updateActiveTraits()
{
    refreshActiveTraits(false);
}

void MainWindow::applyTraitBonuses()
{
    refreshActiveTraits(true);
}

void MainWindow::refreshActiveTraits(bool applyBonuses)
{
    m_activeTraits.clear();
    QVector<Unit*> units = playerBoardUnits();
    auto countTrait = [&units](const QString& trait) {
        int count = 0;
        for (Unit* unit : units) {
            if (unit->hasTrait(trait)) {
                ++count;
            }
        }
        return count;
    };

    const int warriors = countTrait("Warrior");
    if (warriors > 0) {
        const int bonus = warriors >= 4 ? 160 : 80;
        if (warriors >= 2 && applyBonuses) {
            for (Unit* unit : units) {
                if (unit->hasTrait("Warrior")) {
                    unit->addMaxHp(bonus);
                }
            }
        }
        if (warriors >= 2) {
            m_activeTraits << QStringLiteral("战士 %1：战士单位 +%2 HP").arg(warriors).arg(bonus);
        } else {
            m_activeTraits << QStringLiteral("战士 %1/2（未激活）：战士单位 +80 HP").arg(warriors);
        }
    }

    const int guardians = countTrait("Guardian");
    if (guardians > 0) {
        if (guardians >= 2 && applyBonuses) {
            for (Unit* unit : units) {
                unit->addMaxHp(60);
            }
        }
        if (guardians >= 2) {
            m_activeTraits << QStringLiteral("守护者 2：我方全体 +60 HP");
        } else {
            m_activeTraits << QStringLiteral("守护者 %1/2（未激活）：我方全体 +60 HP").arg(guardians);
        }
    }

    const int mages = countTrait("Mage");
    if (mages > 0) {
        const int bonus = mages >= 3 ? 100 : 50;
        if (mages >= 2 && applyBonuses) {
            for (Unit* unit : units) {
                unit->addSkillDamagePercent(bonus);
            }
        }
        if (mages >= 2) {
            m_activeTraits << QStringLiteral("法师 %1：技能伤害 +%2%").arg(mages).arg(bonus);
        } else {
            m_activeTraits << QStringLiteral("法师 %1/2（未激活）：技能伤害 +50%").arg(mages);
        }
    }

    const int rangers = countTrait("Ranger");
    if (rangers > 0) {
        if (rangers >= 2 && applyBonuses) {
            for (Unit* unit : units) {
                if (unit->hasTrait("Ranger")) {
                    unit->setDoubleAttackChance(35);
                }
            }
        }
        if (rangers >= 2) {
            m_activeTraits << QStringLiteral("游侠 2：游侠有概率连击");
        } else {
            m_activeTraits << QStringLiteral("游侠 %1/2（未激活）：游侠有概率连击").arg(rangers);
        }
    }

    const int mystics = countTrait("Mystic");
    if (mystics > 0) {
        if (mystics >= 2 && applyBonuses) {
            for (Unit* unit : units) {
                unit->addManaGain(5);
            }
        }
        if (mystics >= 2) {
            m_activeTraits << QStringLiteral("秘术 2：我方全体法力获取 +5");
        } else {
            m_activeTraits << QStringLiteral("秘术 %1/2（未激活）：我方全体法力获取 +5").arg(mystics);
        }
    }
}

void MainWindow::resolveRewards(bool playerWon)
{
    m_player.recordResult(playerWon);
    if (!playerWon) {
        m_player.takeDamage(12 + m_round * 3);
    }

    const int baseGold = playerWon ? 6 : 3;
    m_lastInterest = std::min(5, m_player.gold() / 10);
    const int streak = playerWon ? m_player.winStreak() : m_player.lossStreak();
    m_lastStreakBonus = streak >= 2 ? std::min(3, streak - 1) : 0;
    const int rewardMultiplier = m_networkRole == NetworkRole::Offline ? 1 : 2;
    const int totalGold = (baseGold + m_lastInterest + m_lastStreakBonus) * rewardMultiplier;
    m_player.addGold(totalGold);

    if (playerWon && QRandomGenerator::global()->bounded(100) < 65) {
        const QVector<Equipment> catalog = Equipment::catalog();
        m_equipmentPool << catalog[QRandomGenerator::global()->bounded(catalog.size())];
        pushLog(QStringLiteral("获得一件装备。"));
    }

    pushLog(QStringLiteral("%1：+%2 金币（基础 %3，利息 +%4，连胜/连败 +%5%6）。")
                .arg(playerWon ? QStringLiteral("胜利") : QStringLiteral("失败"))
                .arg(totalGold)
                .arg(baseGold)
                .arg(m_lastInterest)
                .arg(m_lastStreakBonus)
                .arg(rewardMultiplier > 1 ? QStringLiteral("，联机 x2") : QString()));
}

void MainWindow::clearEnemies()
{
    for (auto& row : m_board) {
        for (Unit*& unit : row) {
            if (unit && unit->owner() == Owner::EnemyCtrl) {
                unit = nullptr;
            }
        }
    }

    m_units.erase(std::remove_if(m_units.begin(), m_units.end(), [](const std::unique_ptr<Unit>& unit) {
        return unit->owner() == Owner::EnemyCtrl;
    }), m_units.end());
}

void MainWindow::restorePlayerPositions()
{
    for (auto& row : m_board) {
        for (Unit*& unit : row) {
            if (unit && unit->owner() == Owner::PlayerCtrl) {
                unit = nullptr;
            }
        }
    }
    for (const UnitSnapshot& snapshot : m_combatStart) {
        if (snapshot.unit) {
            snapshot.unit->resetForCombat();
            placeOnBoard(snapshot.unit, snapshot.row, snapshot.col);
        }
    }
    updateActiveTraits();
}

int MainWindow::shopPanelWidth() const
{
    const int centeredBoardX = (width() - BoardCols * CellSize) / 2;
    const int maxWidthBeforeBoard = centeredBoardX - ShopPanelX - 20;
    return std::clamp(maxWidthBeforeBoard, 296, ShopPanelWidth);
}

QRect MainWindow::shopPanelRect() const
{
    return QRect(ShopPanelX - ShopPanelLeftPadding,
                 ShopPanelTop,
                 shopPanelWidth() + ShopPanelLeftPadding + ShopPanelRightPadding,
                 ShopPanelHeight);
}

int MainWindow::shopCardsTop() const
{
    const int cardsHeight = ShopSlots * ShopSlotHeight + (ShopSlots - 1) * ShopSlotGap;
    const QRect panel = shopPanelRect();
    return panel.top() + (panel.height() - cardsHeight) / 2 + ShopCardOffsetY;
}

int MainWindow::boardX() const
{
    return std::max(ShopPanelX + shopPanelWidth() + 20,
                    (width() - BoardCols * CellSize) / 2);
}

int MainWindow::sidePanelX() const
{
    return width() - SidePanelWidth - 16;
}

QRect MainWindow::boardRect() const
{
    return QRect(boardX(), BoardTop, BoardCols * CellSize, BoardRows * CellSize);
}

QRect MainWindow::cellRect(int row, int col) const
{
    return QRect(boardX() + col * CellSize, BoardTop + row * CellSize, CellSize, CellSize);
}

QRect MainWindow::benchRect(int index) const
{
    return QRect(boardX() + index * CellSize,
                 boardRect().bottom() + 1 + BoardBenchGap,
                 CellSize,
                 CellSize);
}

QRect MainWindow::shopRect(int index) const
{
    return QRect(ShopPanelX + ShopCardOffsetX,
                 shopCardsTop() + index * (ShopSlotHeight + ShopSlotGap),
                 shopPanelWidth(),
                 ShopSlotHeight);
}

QRect MainWindow::equipmentPanelRect() const
{
    constexpr int PanelWidth = 250;
    constexpr int PanelHeight = 270;
    return QRect(sidePanelX() + (SidePanelWidth - PanelWidth) / 2 - 24,
                 height() - PanelHeight - 36,
                 PanelWidth,
                 PanelHeight);
}

QRect MainWindow::equipmentRect(int index) const
{
    const QRect panel = equipmentPanelRect();
    constexpr int SlotSize = 64;
    constexpr int SlotGapX = 9;
    constexpr int SlotGapY = 10;
    constexpr int Columns = 3;
    const int slotsWidth = Columns * SlotSize + (Columns - 1) * SlotGapX;
    return QRect(panel.left() + (panel.width() - slotsWidth) / 2 + (index % Columns) * (SlotSize + SlotGapX),
                 panel.top() + 112 + (index / Columns) * (SlotSize + SlotGapY),
                 SlotSize,
                 SlotSize);
}

QRect MainWindow::startButtonRect() const
{
    return QRect(sidePanelX(), ShopButtonY, SidePanelWidth / 2, 44);
}

QRect MainWindow::refreshButtonRect() const
{
    const int y = shopPanelRect().bottom() + 1 + ShopActionButtonGap;
    return QRect(ShopPanelX, y, shopPanelWidth() / 2 - 4, 44);
}

QRect MainWindow::upgradeButtonRect() const
{
    const int y = shopPanelRect().bottom() + 1 + ShopActionButtonGap;
    return QRect(ShopPanelX + shopPanelWidth() / 2 + 4, y, shopPanelWidth() / 2 - 4, 44);
}

QRect MainWindow::saveButtonRect() const
{
    return QRect(sidePanelX() + SidePanelWidth / 2, ShopButtonY, SidePanelWidth / 2, 44);
}

QRect MainWindow::finalExitButtonRect() const
{
    const QRect area = boardRect().adjusted(42, 150, -42, -150);
    return QRect(area.center().x() - 105, area.bottom() - 66, 210, 48);
}

QRect MainWindow::menuNewGameButtonRect() const
{
    constexpr int ButtonGroupBottomMargin = 52;
    const int groupHeight = MenuButtonHeight + MenuButtonGap * 3;
    const int firstButtonY = std::max(360, height() - ButtonGroupBottomMargin - groupHeight);
    return QRect((width() - MenuButtonWidth) / 2, firstButtonY, MenuButtonWidth, MenuButtonHeight);
}

QRect MainWindow::menuLoadButtonRect() const
{
    const QRect newGame = menuNewGameButtonRect();
    return newGame.translated(0, MenuButtonGap);
}

QRect MainWindow::menuLanButtonRect() const
{
    const QRect newGame = menuNewGameButtonRect();
    return newGame.translated(0, MenuButtonGap * 2);
}

QRect MainWindow::menuExitButtonRect() const
{
    const QRect newGame = menuNewGameButtonRect();
    return newGame.translated(0, MenuButtonGap * 3);
}

QRect MainWindow::menuBackButtonRect() const
{
    const QRect newGame = menuNewGameButtonRect();
    return newGame.translated(0, MenuButtonGap * 3);
}

QRect MainWindow::menuSlotButtonRect(int index) const
{
    const QRect newGame = menuNewGameButtonRect();
    return newGame.translated(0, MenuButtonGap * index);
}

QRect MainWindow::menuLanHostButtonRect() const
{
    return menuNewGameButtonRect();
}

QRect MainWindow::menuLanJoinButtonRect() const
{
    return menuLanHostButtonRect().translated(0, MenuButtonGap);
}

QRect MainWindow::menuLanRemoteButtonRect() const
{
    return menuLanHostButtonRect().translated(0, MenuButtonGap * 2);
}

QRect MainWindow::remotePanelRect() const
{
    constexpr int PanelWidth = 760;
    constexpr int PanelHeight = 501;
    return QRect((width() - PanelWidth) / 2, 230, PanelWidth, PanelHeight);
}

QRect MainWindow::lanHostInputRect() const
{
    const QRect panel = remotePanelRect();
    return QRect(panel.left() + 118, panel.top() + 154, panel.width() - 236, 104);
}

QRect MainWindow::remoteNicknameInputRect() const
{
    const QRect panel = remotePanelRect();
    return QRect(panel.left() + 118, panel.top() + 124, panel.width() - 236, 104);
}

QRect MainWindow::remoteRoomInputRect() const
{
    return remoteNicknameInputRect().translated(0, 124);
}

QRect MainWindow::remoteConnectButtonRect() const
{
    const QRect panel = remotePanelRect();
    const QRect roomInput = remoteRoomInputRect();
    return QRect(panel.left() + 132, roomInput.bottom() + 28, 244, 82);
}

QRect MainWindow::remoteCancelButtonRect() const
{
    const QRect panel = remotePanelRect();
    const QRect roomInput = remoteRoomInputRect();
    return QRect(panel.right() - 132 - 244, roomInput.bottom() + 28, 244, 82);
}

QRect MainWindow::settingsButtonRect() const
{
    const int buttonWidth = std::clamp(width() / 10, 144, 168);
    const int buttonHeight = int(std::round(buttonWidth / 1.576));
    constexpr int Margin = 28;
    return QRect(width() - Margin - buttonWidth,
                 height() - Margin - buttonHeight,
                 buttonWidth,
                 buttonHeight);
}

QRect MainWindow::settingsPanelRect() const
{
    const int panelWidth = std::clamp(width() - 520, 640, 760);
    const int panelHeight = int(std::round(panelWidth / 1.55));
    return QRect((width() - panelWidth) / 2,
                 std::max(110, (height() - panelHeight) / 2),
                 panelWidth,
                 panelHeight);
}

QRect MainWindow::settingsVolumeSliderRect() const
{
    const QRect panel = settingsPanelRect();
    const int sliderWidth = std::min(panel.width() - 210, 500);
    const int sliderHeight = int(std::round(sliderWidth / 6.745));
    return QRect(panel.center().x() - sliderWidth / 2,
                 panel.top() + 238,
                 sliderWidth,
                 sliderHeight);
}

QRect MainWindow::settingsVolumeKnobRect() const
{
    const QRect slider = settingsVolumeSliderRect();
    const int knobSize = std::max(60, slider.height() + 4);
    const int centerX = slider.left() + int(std::round((slider.width() - 1) * m_menuVolume));
    return QRect(centerX - knobSize / 2,
                 slider.center().y() - knobSize / 2,
                 knobSize,
                 knobSize);
}

QRect MainWindow::settingsReturnButtonRect() const
{
    const QRect panel = settingsPanelRect();
    constexpr int ButtonWidth = 284;
    constexpr int ButtonHeight = 98;
    return QRect(panel.center().x() - ButtonWidth / 2,
                 panel.bottom() - 118,
                 ButtonWidth,
                 ButtonHeight);
}

void MainWindow::paintEvent(QPaintEvent*)
{
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing, false);
    painter.fillRect(rect(), QColor(244, 244, 238));

    if (m_screen != Screen::Playing) {
        drawStartMenu(painter);
        return;
    }

    if (const QPixmap* background = menuAsset(QStringLiteral("in_game_background,png.png"))) {
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
        drawCoverPixmap(painter, *background, rect());
    }

    const QString roundText = m_networkRole == NetworkRole::Offline
        ? QStringLiteral("%1/%2").arg(m_round).arg(MaxRounds)
        : QString::number(m_round);
    QString statusText = QStringLiteral("HP %1 | 金币 %2 | 等级 %3 | 人口 %4/%5 | 回合 %6 | 阶段 %7")
                         .arg(m_player.health())
                         .arg(m_player.gold())
                         .arg(m_player.level())
                         .arg(boardPlayerCount())
                         .arg(m_player.populationCap())
                         .arg(roundText)
                         .arg(phaseName());
    if (m_networkRole == NetworkRole::Remote && !m_remoteOpponentName.isEmpty()) {
        statusText += QStringLiteral(" | 对手 %1 HP %2")
                          .arg(m_remoteOpponentName)
                          .arg(m_remoteOpponentHealth);
    }
    painter.setPen(uiTextColor());
    painter.setFont(uiFont(12, QFont::DemiBold));
    painter.drawText(QRect(boardX(), 24, BoardCols * CellSize, 32),
                     Qt::AlignCenter | Qt::AlignVCenter,
                     statusText);

    drawBoard(painter);
    drawBench(painter);
    drawShop(painter);
    drawSidePanel(painter);
    drawHoverPanel(painter);
    drawShopHoverPanel(painter);
    drawEquipmentHoverPanel(painter);
    drawFinalOverlay(painter);

    if (m_dragKind == DragKind::Unit && m_dragUnit) {
        const int dragSize = CellSize - 10;
        drawUnit(painter,
                 m_dragUnit,
                 QRect(m_mousePos.x() - dragSize / 2, m_mousePos.y() - dragSize / 2, dragSize, dragSize),
                 true);
    } else if (m_dragKind == DragKind::Equipment && m_dragEquipmentIndex >= 0 && m_dragEquipmentIndex < m_equipmentPool.size()) {
        const QRect dragRect(m_mousePos.x() - 25, m_mousePos.y() - 25, 50, 50);
        painter.fillRect(dragRect, QColor(255, 248, 190));
        painter.setPen(QPen(QColor(70, 70, 70), 2));
        painter.drawRect(dragRect);
        drawEquipmentImage(painter, m_equipmentPool[m_dragEquipmentIndex], dragRect.adjusted(4, 4, -4, -4));
    }
}

void MainWindow::drawStartMenu(QPainter& painter)
{
    painter.save();
    painter.setRenderHint(QPainter::Antialiasing, true);

    if (const QPixmap* background = startPageImage()) {
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
        drawCoverPixmap(painter, *background, rect());
        painter.fillRect(rect(), QColor(0, 0, 0, 72));
    } else {
        painter.fillRect(rect(), QColor(28, 32, 38));
    }

    if (m_screen == Screen::StartMenu) {
        const qint64 elapsed = m_menuAnimationClock.elapsed();
        const qreal titleOpacity = fadeProgress(elapsed, 120, 720);
        const QRect titleRect((width() - 720) / 2 + 2, 26, 720, 425);

        painter.save();
        painter.setOpacity(titleOpacity);
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
        drawMenuPixmap(painter, QStringLiteral("title.png"), titleRect);
        painter.restore();

        const QStringList buttonImages = {
            QStringLiteral("back_of_start_new_game.png"),
            QStringLiteral("back_of_load.png"),
            QStringLiteral("back_of_battal.png"),
            QStringLiteral("back_of_quit.png")
        };
        const QStringList buttonTexts = {
            QStringLiteral("开始新游戏"),
            QStringLiteral("读取存档"),
            QStringLiteral("联机对战"),
            QStringLiteral("退出")
        };
        const QRect buttonRects[4] = {
            menuNewGameButtonRect(),
            menuLoadButtonRect(),
            menuLanButtonRect(),
            menuExitButtonRect()
        };
        for (int i = 0; i < 4; ++i) {
            drawImageMenuButton(painter,
                                buttonImages[i],
                                buttonRects[i],
                                buttonTexts[i],
                                true,
                                fadeProgress(elapsed, 640 + i * 150, 560),
                                buttonRects[i].contains(m_mousePos));
        }
    } else if (m_screen == Screen::LoadMenu) {
        const QRect subtitleRect((width() - 600) / 2, 174, 600, 147);
        drawMenuPixmap(painter, QStringLiteral("sub_title_choose.png"), subtitleRect);
        for (int slot = 1; slot <= 3; ++slot) {
            const bool exists = QFileInfo::exists(savePath(slot));
            const QRect buttonRect = menuSlotButtonRect(slot - 1);
            drawImageMenuButton(painter,
                                QStringLiteral("back_of_three_save_site.png"),
                                buttonRect,
                                saveSlotLabel(slot),
                                exists,
                                1.0,
                                buttonRect.contains(m_mousePos));
        }
        const QRect backRect = menuBackButtonRect();
        drawImageMenuButton(painter,
                            QStringLiteral("back_of_return.png"),
                            backRect,
                            QStringLiteral("返回"),
                            true,
                            1.0,
                            backRect.contains(m_mousePos));
    } else if (m_screen == Screen::LanMenu) {
        const QRect subtitleRect((width() - 600) / 2, 190, 600, 112);
        drawMenuPixmap(painter, QStringLiteral("sub_title_battal.png"), subtitleRect);

        drawImageMenuButton(painter,
                            QStringLiteral("back_of_create_LAN.png"),
                            menuLanHostButtonRect(),
                            QStringLiteral("创建局域网"),
                            true,
                            1.0,
                            menuLanHostButtonRect().contains(m_mousePos));
        drawImageMenuButton(painter,
                            QStringLiteral("back_of_join_LAN.png"),
                            menuLanJoinButtonRect(),
                            QStringLiteral("加入局域网"),
                            true,
                            1.0,
                            menuLanJoinButtonRect().contains(m_mousePos));
        drawImageMenuButton(painter,
                            QStringLiteral("back_of_remote_server.png"),
                            menuLanRemoteButtonRect(),
                            QStringLiteral("远程服务器"),
                            true,
                            1.0,
                            menuLanRemoteButtonRect().contains(m_mousePos));
        const QRect cancelRect = menuBackButtonRect();
        drawImageMenuButton(painter,
                            QStringLiteral("back_of_cancel.png"),
                            cancelRect,
                            QStringLiteral("取消"),
                            true,
                            1.0,
                            cancelRect.contains(m_mousePos));
    } else if (m_screen == Screen::RemoteMenu) {
        drawRemoteMenu(painter);
    } else if (m_screen == Screen::LanJoinMenu) {
        drawLanJoinMenu(painter);
    } else if (m_screen == Screen::SettingsMenu) {
        drawSettingsMenu(painter);
    }

    if (m_screen != Screen::SettingsMenu) {
        drawSettingsButton(painter);
    }

    if (!m_menuMessage.isEmpty()) {
        painter.setPen(uiTextColor());
        painter.setFont(uiFont(14, QFont::Bold));
        const int messageY = (m_screen == Screen::LanJoinMenu || m_screen == Screen::RemoteMenu)
            ? remotePanelRect().bottom() + 12
            : 656;
        painter.drawText(QRect(0, messageY, width(), 34), Qt::AlignCenter, m_menuMessage);
    }

    painter.restore();
}

void MainWindow::drawMenuButton(QPainter& painter, const QRect& rect, const QString& text, const QColor& color, bool enabled)
{
    const QColor fill = enabled ? color : QColor(92, 98, 104);
    painter.setBrush(fill);
    painter.setPen(QPen(enabled ? color.lighter(142) : QColor(125, 131, 136), 2));
    painter.drawRoundedRect(rect, 8, 8);
    painter.setPen(enabled ? uiTextColor() : uiTextColor(150));
    painter.setFont(uiFont(17, QFont::Bold));
    painter.drawText(rect.adjusted(12, 0, -12, 0), Qt::AlignCenter, text);
}

void MainWindow::drawSettingsButton(QPainter& painter)
{
    const QRect button = settingsButtonRect();
    const bool hovered = button.contains(m_mousePos);
    const QRect imageRect = hovered ? button.adjusted(-4, -3, 4, 3) : button;

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.setRenderHint(QPainter::TextAntialiasing, true);
    drawMenuPixmap(painter, QStringLiteral("back_of_settings.png"), imageRect);
    painter.restore();
}

void MainWindow::drawSettingsMenu(QPainter& painter)
{
    const QRect panel = settingsPanelRect();
    const QRect slider = settingsVolumeSliderRect();
    const QRect knob = settingsVolumeKnobRect();
    const QRect backButton = settingsReturnButtonRect();

    painter.save();
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.setRenderHint(QPainter::TextAntialiasing, true);
    drawMenuPixmap(painter, QStringLiteral("back_of_settings_panel.png"), panel);

    painter.setFont(uiFont(32, QFont::Black));
    const QRect titleRect(panel.left() + 80, panel.top() + 72, panel.width() - 160, 54);
    painter.setPen(uiTextColor(120));
    painter.drawText(titleRect.translated(0, 4), Qt::AlignCenter, QStringLiteral("设置"));
    painter.setPen(uiTextColor(150));
    painter.drawText(titleRect.translated(0, -1), Qt::AlignCenter, QStringLiteral("设置"));
    painter.setPen(uiTextColor());
    painter.drawText(titleRect, Qt::AlignCenter, QStringLiteral("设置"));

    painter.setFont(uiFont(18, QFont::Bold));
    const QRect labelRect(slider.left(), slider.top() - 52, slider.width(), 36);
    painter.setPen(uiTextColor(120));
    painter.drawText(labelRect.translated(0, 2), Qt::AlignCenter, QStringLiteral("音乐音量"));
    painter.setPen(uiTextColor());
    painter.drawText(labelRect, Qt::AlignCenter, QStringLiteral("音乐音量"));

    drawMenuPixmap(painter, QStringLiteral("back_of_volume_slider.png"), slider);
    drawMenuPixmap(painter, QStringLiteral("back_of_volume_knob.png"), knob);

    const QString volumeText = QStringLiteral("%1%").arg(int(std::round(m_menuVolume * 100.0)));
    const QRect percentRect(slider.right() + 18, slider.top() - 4, panel.right() - slider.right() - 42, slider.height() + 8);
    painter.setFont(uiFont(16, QFont::Black));
    painter.setPen(uiTextColor(120));
    painter.drawText(percentRect.translated(0, 2), Qt::AlignVCenter | Qt::AlignLeft, volumeText);
    painter.setPen(uiTextColor());
    painter.drawText(percentRect, Qt::AlignVCenter | Qt::AlignLeft, volumeText);

    painter.restore();

    drawImageMenuButton(painter,
                        QStringLiteral("back_of_return_of_setting.png"),
                        backButton,
                        QStringLiteral("返回"),
                        true,
                        1.0,
                        backButton.contains(m_mousePos));
}

void MainWindow::drawLanJoinMenu(QPainter& painter)
{
    const QRect panel = remotePanelRect();
    painter.save();
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    drawMenuPixmap(painter, QStringLiteral("back_of_third_page_panel.png"), panel);

    painter.setPen(uiTextColor(120));
    painter.setFont(uiFont(24, QFont::Black));
    const QRect titleRect(panel.left() + 60, panel.top() + 42, panel.width() - 120, 46);
    painter.drawText(titleRect.translated(0, 3), Qt::AlignCenter, QStringLiteral("加入局域网"));
    painter.setPen(uiTextColor());
    painter.drawText(titleRect, Qt::AlignCenter, QStringLiteral("加入局域网"));

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(11, QFont::Bold));
    painter.drawText(QRect(panel.left() + 78, panel.top() + 98, panel.width() - 156, 28),
                     Qt::AlignCenter,
                     QStringLiteral("输入主机 IPv4 地址"));

    drawRemoteInput(painter,
                    lanHostInputRect(),
                    QStringLiteral("主机 IPv4 地址"),
                    m_lanHostDraft,
                    true);

    const QRect connectRect = remoteConnectButtonRect().translated(0, -6);
    const QRect cancelRect = remoteCancelButtonRect().translated(0, -6);
    drawImageMenuButton(painter,
                        QStringLiteral("back_of_join_LAN.png"),
                        connectRect,
                        QStringLiteral("连接"),
                        true,
                        1.0,
                        connectRect.contains(m_mousePos));
    drawImageMenuButton(painter,
                        QStringLiteral("back_of_cancel.png"),
                        cancelRect,
                        QStringLiteral("返回"),
                        true,
                        1.0,
                        cancelRect.contains(m_mousePos));

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(10, QFont::Bold));
    painter.drawText(QRect(panel.left() + 78, connectRect.bottom() + 12, panel.width() - 156, 24),
                     Qt::AlignCenter,
                     QStringLiteral("Enter 连接，Esc 返回"));
    painter.restore();
}

void MainWindow::drawRemoteMenu(QPainter& painter)
{
    const QRect panel = remotePanelRect();
    painter.save();
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    drawMenuPixmap(painter, QStringLiteral("back_of_third_page_panel.png"), panel);

    painter.setPen(uiTextColor(120));
    painter.setFont(uiFont(24, QFont::Black));
    const QRect titleRect(panel.left() + 60, panel.top() + 34, panel.width() - 120, 46);
    painter.drawText(titleRect.translated(0, 3), Qt::AlignCenter, QStringLiteral("加入远程房间"));
    painter.setPen(uiTextColor());
    painter.drawText(titleRect,
                     Qt::AlignCenter,
                     QStringLiteral("加入远程房间"));

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(11, QFont::Bold));
    painter.drawText(QRect(panel.left() + 78, panel.top() + 88, panel.width() - 156, 28),
                     Qt::AlignCenter,
                     QStringLiteral("输入昵称和房间号"));

    drawRemoteInput(painter,
                    remoteNicknameInputRect(),
                    QStringLiteral("昵称"),
                    m_remoteNicknameDraft,
                    m_remoteInputField == RemoteInputField::Nickname);
    drawRemoteInput(painter,
                    remoteRoomInputRect(),
                    QStringLiteral("房间号"),
                    m_remoteRoomDraft,
                    m_remoteInputField == RemoteInputField::Room);

    const QRect connectRect = remoteConnectButtonRect();
    const QRect cancelRect = remoteCancelButtonRect();
    drawImageMenuButton(painter,
                        QStringLiteral("back_of_remote_server.png"),
                        connectRect,
                        QStringLiteral("连接"),
                        true,
                        1.0,
                        connectRect.contains(m_mousePos));
    drawImageMenuButton(painter,
                        QStringLiteral("back_of_cancel.png"),
                        cancelRect,
                        QStringLiteral("返回"),
                        true,
                        1.0,
                        cancelRect.contains(m_mousePos));

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(10, QFont::Bold));
    const QRect helpRect(panel.left() + 78,
                         connectRect.bottom() + 8,
                         panel.width() - 156,
                         24);
    painter.drawText(helpRect,
                     Qt::AlignCenter,
                     QStringLiteral("Tab 切换输入框，Enter 连接，Esc 返回"));
    painter.restore();
}

void MainWindow::drawRemoteInput(QPainter& painter, const QRect& rect, const QString& label, const QString& value, bool focused)
{
    painter.save();
    painter.setRenderHint(QPainter::Antialiasing, true);
    painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
    painter.setOpacity(focused ? 1.0 : 0.72);
    drawMenuPixmap(painter, QStringLiteral("back_of_input_box.png"), rect);
    painter.setOpacity(1.0);
    if (focused) {
        painter.setPen(QPen(QColor(255, 226, 126, 185), 2));
        painter.setBrush(Qt::NoBrush);
        painter.drawRoundedRect(rect.adjusted(12, 12, -12, -12), 8, 8);
    }

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(10, QFont::Bold));
    painter.drawText(QRect(rect.left() + 34, rect.top() + 22, rect.width() - 68, 22),
                     Qt::AlignLeft | Qt::AlignVCenter,
                     label);

    QString display = value;
    if (focused) {
        display += QStringLiteral("|");
    }
    painter.setPen(uiTextColor());
    painter.setFont(uiFont(18, QFont::Black));
    painter.drawText(QRect(rect.left() + 34, rect.top() + 48, rect.width() - 68, 34),
                     Qt::AlignLeft | Qt::AlignVCenter,
                     display);
    painter.restore();
}

void MainWindow::drawBoard(QPainter& painter)
{
    const bool textured = drawBoardTexturePixmap(painter, boardRect());

    for (int row = 0; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            QRect rect = cellRect(row, col);
            const QColor fill = row < 4 ? QColor(239, 211, 211) : QColor(211, 228, 248);
            painter.fillRect(rect.adjusted(1, 1, -1, -1),
                             textured ? QColor(fill.red(), fill.green(), fill.blue(), 80) : fill);
            painter.setPen(QPen(QColor(70, 70, 70), 2));
            painter.drawRect(rect);
            if (m_board[row][col] && m_board[row][col] != m_dragUnit) {
                drawUnit(painter, m_board[row][col], rect.adjusted(5, 5, -5, -5));
            }
        }
    }
}

void MainWindow::drawBench(QPainter& painter)
{
    const QRect prepareArea(boardX(), benchRect(0).top(), BoardCols * CellSize, CellSize);
    const bool textured = drawPrepareTexturePixmap(painter, prepareArea);

    for (int i = 0; i < BenchSlots; ++i) {
        QRect rect = benchRect(i);
        painter.fillRect(rect.adjusted(1, 1, -1, -1),
                         textured ? QColor(232, 232, 232, 70) : QColor(232, 232, 232));
        painter.setPen(QPen(QColor(70, 70, 70), 2));
        painter.drawRect(rect);
        if (m_bench[i] && m_bench[i] != m_dragUnit) {
            drawUnit(painter, m_bench[i], rect.adjusted(5, 5, -5, -5));
        }
    }
}

void MainWindow::drawShop(QPainter& painter)
{
    drawShopStorePixmap(painter, shopPanelRect());

    auto drawButton = [&painter](const QRect& rect, const QString& text, bool enabled) {
        painter.fillRect(rect, enabled ? QColor(18, 32, 46, 220) : QColor(56, 62, 68, 190));
        painter.setPen(QPen(QColor(45, 45, 45), 2));
        painter.drawRect(rect);
        painter.setPen(enabled ? uiTextColor() : uiTextColor(150));
        painter.setFont(uiFont(11, QFont::Bold));
        painter.drawText(rect, Qt::AlignCenter, text);
    };

    drawButton(startButtonRect(), QStringLiteral("开战"), m_phase == Phase::Prep);
    drawButton(refreshButtonRect(), QStringLiteral("刷新 2"), m_phase == Phase::Prep);
    drawButton(upgradeButtonRect(), QStringLiteral("人口 +1 %1").arg(m_player.upgradeCost()), m_phase == Phase::Prep);
    drawButton(saveButtonRect(), QStringLiteral("保存"), m_phase != Phase::Combat);

    painter.setFont(uiFont(11));
    for (int i = 0; i < m_shop.size(); ++i) {
        const ShopSlot& slot = m_shop[i];
        QRect rect = shopRect(i);
        if (!drawShopCardPixmap(painter, rect)) {
            painter.fillRect(rect, QColor(255, 255, 250));
        }
        painter.setPen(uiTextColor());
        drawHeroImage(painter,
                      slot.heroId,
                      QRect(rect.left() + 14, rect.top() + 12, 74, 74),
                      heroColor(slot.heroId, Owner::PlayerCtrl));
        painter.setPen(QColor(15, 15, 15));
        painter.setFont(uiFont(13, QFont::Bold));
        painter.drawText(rect.adjusted(100, 14, -12, -64), Qt::AlignLeft | Qt::AlignVCenter, heroName(slot.heroId));
        painter.setFont(uiFont(11));
        painter.drawText(rect.adjusted(100, 46, -12, -38), Qt::AlignLeft | Qt::AlignVCenter, QStringLiteral("价格 %1").arg(slot.cost));
        for (const HeroDefinition& hero : heroCatalog()) {
            if (hero.id == slot.heroId) {
                painter.drawText(rect.adjusted(14, 82, -12, -6), Qt::AlignLeft | Qt::AlignVCenter, traitDisplayList(hero.traits));
                break;
            }
        }
    }
}

void MainWindow::drawSidePanel(QPainter& painter)
{
    const int panelX = sidePanelX();

    painter.setFont(uiFont(11));
    QRect traitBox(panelX, 164, SidePanelWidth, 220);
    const bool traitTextured = drawTexturePixmap(painter, QStringLiteral("back_of_traits.png"), traitBox);
    painter.fillRect(traitBox, traitTextured ? QColor(0, 0, 0, 70) : QColor(0, 0, 0, 170));
    painter.setPen(QPen(QColor(70, 70, 70), 2));
    painter.drawRect(traitBox);
    painter.setPen(uiTextColor());
    if (m_activeTraits.isEmpty()) {
        painter.drawText(traitBox.adjusted(12, 10, -12, -10), Qt::TextWordWrap, QStringLiteral("作战区暂无羁绊预览。"));
    } else {
        painter.drawText(traitBox.adjusted(12, 10, -12, -10), Qt::TextWordWrap, m_activeTraits.join("\n"));
    }

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(13, QFont::Bold));
    painter.drawText(panelX, 424, QStringLiteral("回合结果"));
    painter.setFont(uiFont(11));
    QRect resultBox(panelX, 438, SidePanelWidth, 150);
    const bool resultTextured = drawResultPixmap(painter, resultBox);
    painter.fillRect(resultBox, resultTextured ? QColor(0, 0, 0, 70) : QColor(0, 0, 0, 170));
    painter.setPen(uiTextColor());
    QString resultText = QStringLiteral("上回合：%1\n利息 +%2 | 连胜/连败 +%3")
                             .arg(m_lastRoundWon ? QStringLiteral("胜利") : QStringLiteral("失败/无"))
                             .arg(m_lastInterest)
                             .arg(m_lastStreakBonus);
    if (m_networkRole == NetworkRole::Remote && !m_remoteOpponentName.isEmpty()) {
        resultText += QStringLiteral("\n对手：%1 | HP %2").arg(m_remoteOpponentName).arg(m_remoteOpponentHealth);
    }
    painter.drawText(resultBox.adjusted(12, 10, -12, -10), Qt::TextWordWrap, resultText);

    const QRect equipmentArea = equipmentPanelRect();
    const bool equipmentTextured = drawEquipmentSitePixmap(painter, equipmentArea);

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(13, QFont::Bold));
    painter.drawText(equipmentArea.adjusted(0, 26, 0, -equipmentArea.height() + 56),
                     Qt::AlignCenter,
                     QStringLiteral("装备"));
    painter.setFont(uiFont(9, QFont::Bold));
    for (int i = 0; i < m_equipmentPool.size(); ++i) {
        QRect rect = equipmentRect(i);
        painter.fillRect(rect, equipmentTextured ? QColor(255, 248, 190, 80) : QColor(255, 248, 190));
        painter.setPen(QPen(QColor(70, 70, 70), 2));
        painter.drawRect(rect);
        drawEquipmentImage(painter, m_equipmentPool[i], rect.adjusted(5, 4, -5, -4));
    }

}

void MainWindow::drawHoverPanel(QPainter& painter)
{
    Unit* unit = hoveredUnit();
    if (!unit) {
        return;
    }

    QStringList lines;
    lines << QStringLiteral("%1  %2星").arg(unit->name()).arg(unit->star());
    lines << QStringLiteral("HP %1/%2 | ATK %3").arg(unit->hp()).arg(unit->maxHp()).arg(unit->atk());
    lines << QStringLiteral("射程 %1 | 法力 %2/%3").arg(unit->range()).arg(unit->mana()).arg(unit->maxMana());
    lines << QStringLiteral("状态：%1 | 阵营：%2")
                 .arg(stateName(unit->state()))
                 .arg(unit->owner() == Owner::PlayerCtrl ? QStringLiteral("我方") : QStringLiteral("敌方"));
    lines << QStringLiteral("羁绊：") + traitDisplayList(unit->traits());

    if (unit->hasEquipment()) {
        const Equipment item = unit->equipment();
        lines << QStringLiteral("装备：") + item.name;
        lines << QStringLiteral("效果：") + item.description();
        if (m_phase == Phase::Prep && unit->owner() == Owner::PlayerCtrl) {
            lines << QStringLiteral("Ctrl+右键或 U 卸下装备");
        }
    } else {
        lines << QStringLiteral("装备：无");
    }
    if (m_phase == Phase::Prep && unit->owner() == Owner::PlayerCtrl) {
        lines << QStringLiteral("右键出售：+%1 金币").arg(sellValue(unit));
    }

    const int detailRows = static_cast<int>(lines.size()) - 1;
    const int panelHeight = std::max(202, 58 + detailRows * 24 + 14);
    QRect panel(m_mousePos.x() + 18, m_mousePos.y() + 18, 360, panelHeight);
    if (panel.right() > width() - 10) {
        panel.moveRight(m_mousePos.x() - 18);
    }
    if (panel.bottom() > height() - 10) {
        panel.moveBottom(m_mousePos.y() - 18);
    }

    painter.save();
    painter.setPen(QPen(QColor(230, 238, 255), 2));
    painter.setBrush(QColor(8, 14, 24, 235));
    painter.drawRect(panel);
    painter.setPen(uiTextColor());
    painter.setFont(uiFont(12, QFont::Bold));
    painter.drawText(QRect(panel.left() + 12, panel.top() + 10, panel.width() - 24, 26),
                     Qt::AlignLeft | Qt::AlignVCenter,
                     lines[0]);

    painter.setFont(uiFont(11));
    int y = panel.top() + 46;
    for (int i = 1; i < lines.size(); ++i) {
        painter.drawText(QRect(panel.left() + 12, y, panel.width() - 24, 22),
                         Qt::AlignLeft | Qt::AlignVCenter,
                         lines[i]);
        y += 24;
    }
    painter.restore();
}

void MainWindow::drawShopHoverPanel(QPainter& painter)
{
    if (hoveredUnit() || hoveredEquipmentIndex() >= 0 || m_dragKind != DragKind::None) {
        return;
    }

    const int index = hoveredShopIndex();
    if (index < 0 || index >= m_shop.size()) {
        return;
    }

    const ShopSlot& slot = m_shop[index];
    QStringList lines;
    std::unique_ptr<Unit> preview = createHero(slot.heroId, Owner::PlayerCtrl);
    lines << heroName(slot.heroId);
    lines << QStringLiteral("价格 %1 | HP %2 | ATK %3")
                 .arg(slot.cost)
                 .arg(preview->maxHp())
                 .arg(preview->atk());
    lines << QStringLiteral("射程 %1 | 法力 %2")
                 .arg(preview->range())
                 .arg(preview->maxMana());
    for (const HeroDefinition& hero : heroCatalog()) {
        if (hero.id == slot.heroId) {
            lines << QStringLiteral("羁绊：") + traitDisplayList(hero.traits);
            break;
        }
    }
    lines << QStringLiteral("2星属性为 1星的 1.7 倍");
    lines << QStringLiteral("3星属性为 2星的 2 倍");

    QRect panel(m_mousePos.x() + 18, m_mousePos.y() + 18, 410, 196);
    if (panel.right() > width() - 10) {
        panel.moveRight(m_mousePos.x() - 18);
    }
    if (panel.bottom() > height() - 10) {
        panel.moveBottom(m_mousePos.y() - 18);
    }

    painter.save();
    painter.setPen(QPen(QColor(230, 238, 255), 2));
    painter.setBrush(QColor(8, 14, 24, 235));
    painter.drawRect(panel);
    drawHeroImage(painter,
                  slot.heroId,
                  QRect(panel.left() + 12, panel.top() + 14, 48, 48),
                  heroColor(slot.heroId, Owner::PlayerCtrl));
    painter.setPen(uiTextColor());
    painter.setFont(uiFont(13, QFont::Bold));
    painter.drawText(QRect(panel.left() + 72, panel.top() + 12, panel.width() - 84, 28),
                     Qt::AlignLeft | Qt::AlignVCenter,
                     lines[0]);

    painter.setFont(uiFont(11));
    int y = panel.top() + 48;
    for (int i = 1; i < lines.size(); ++i) {
        painter.drawText(QRect(panel.left() + 72, y, panel.width() - 84, 24),
                         Qt::AlignLeft | Qt::AlignVCenter,
                         lines[i]);
        y += 25;
    }
    painter.restore();
}

void MainWindow::drawEquipmentHoverPanel(QPainter& painter)
{
    if (hoveredUnit() || m_dragKind != DragKind::None) {
        return;
    }

    const int index = hoveredEquipmentIndex();
    if (index < 0 || index >= m_equipmentPool.size()) {
        return;
    }

    const Equipment& item = m_equipmentPool[index];
    QStringList lines;
    lines << item.name;
    lines << QStringLiteral("效果：") + item.description();
    lines << QStringLiteral("拖动到我方单位身上装备");

    QRect panel(m_mousePos.x() + 18, m_mousePos.y() + 18, 320, 116);
    if (panel.right() > width() - 10) {
        panel.moveRight(m_mousePos.x() - 18);
    }
    if (panel.bottom() > height() - 10) {
        panel.moveBottom(m_mousePos.y() - 18);
    }

    painter.save();
    painter.setPen(QPen(QColor(230, 238, 255), 2));
    painter.setBrush(QColor(8, 14, 24, 235));
    painter.drawRect(panel);
    drawEquipmentImage(painter, item, QRect(panel.left() + 12, panel.top() + 14, 48, 48));

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(13, QFont::Bold));
    painter.drawText(QRect(panel.left() + 72, panel.top() + 12, panel.width() - 84, 28),
                     Qt::AlignLeft | Qt::AlignVCenter,
                     lines[0]);

    painter.setFont(uiFont(11));
    int y = panel.top() + 48;
    for (int i = 1; i < lines.size(); ++i) {
        painter.drawText(QRect(panel.left() + 72, y, panel.width() - 84, 24),
                         Qt::AlignLeft | Qt::AlignVCenter,
                         lines[i]);
        y += 25;
    }
    painter.restore();
}

void MainWindow::drawFinalOverlay(QPainter& painter)
{
    if (m_phase != Phase::Finished || m_finalMessage.isEmpty()) {
        return;
    }

    const QRect area = boardRect().adjusted(42, 150, -42, -150);
    const bool victory = m_finalMessage.startsWith(QStringLiteral("胜利")) || m_finalMessage.startsWith("VICTORY");

    painter.save();
    painter.setBrush(QColor(8, 14, 24, 235));
    painter.setPen(QPen(QColor(35, 35, 35), 2));
    painter.drawRect(area);

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(27, QFont::Bold));
    painter.drawText(area.adjusted(16, 24, -16, -72),
                     Qt::AlignCenter | Qt::TextWordWrap,
                     m_finalMessage);

    painter.setPen(uiTextColor());
    painter.setFont(uiFont(13));
    painter.drawText(area.adjusted(20, 108, -20, -18),
                     Qt::AlignCenter | Qt::TextWordWrap,
                     QStringLiteral("游戏已结束。可回到标题界面重新开始或读取存档。"));

    const QRect exitRect = finalExitButtonRect();
    painter.fillRect(exitRect.adjusted(3, 3, 3, 3), QColor(190, 190, 180, 190));
    painter.fillRect(exitRect, QColor(218, 235, 221));
    painter.setPen(QPen(QColor(35, 35, 35), 3));
    painter.drawRect(exitRect);
    painter.setPen(uiTextColor());
    painter.setFont(uiFont(14, QFont::Bold));
    painter.drawText(exitRect, Qt::AlignCenter, QStringLiteral("返回标题"));
    painter.restore();
}

void MainWindow::drawUnit(QPainter& painter, const Unit* unit, const QRect& rect, bool dragged)
{
    if (!unit) {
        return;
    }
    painter.save();
    if (dragged) {
        painter.setOpacity(0.75);
    } else if (!unit->isAlive()) {
        painter.setOpacity(0.45);
    }
    const QRect hpRect(rect.left() + 2, rect.bottom() - 12, rect.width() - 25, 4);
    const QRect manaRect(rect.left() + 2, rect.bottom() - 7, rect.width() - 25, 4);
    const QRect starRect(rect.right() - 20, rect.bottom() - 14, 18, 12);
    const QRect imageArea(rect.left(),
                          rect.top(),
                          rect.width(),
                          hpRect.top() - rect.top() - 1);

    drawHeroImage(painter, unit->id(), imageArea, heroColor(unit->id(), unit->owner()));
    drawStarLevel(painter, starRect, unit->star());

    painter.fillRect(hpRect, QColor(80, 80, 80));
    painter.fillRect(manaRect, QColor(80, 80, 80));
    if (unit->maxHp() > 0) {
        QRect fill = hpRect;
        fill.setWidth(hpRect.width() * unit->hp() / unit->maxHp());
        painter.fillRect(fill, QColor(80, 190, 90));
    }
    if (unit->maxMana() > 0) {
        QRect fill = manaRect;
        fill.setWidth(manaRect.width() * unit->mana() / unit->maxMana());
        painter.fillRect(fill, QColor(75, 135, 210));
    }
    painter.restore();
}

QRect MainWindow::unitRect(const Unit* unit) const
{
    if (!unit) {
        return QRect();
    }
    if (unit->place() == UnitPlace::Board) {
        return cellRect(unit->row(), unit->col()).adjusted(5, 5, -5, -5);
    }
    if (unit->place() == UnitPlace::Bench) {
        return benchRect(unit->benchIndex()).adjusted(5, 5, -5, -5);
    }
    return QRect();
}

QColor MainWindow::heroColor(const QString& id, Owner owner) const
{
    if (owner == Owner::EnemyCtrl) {
        return QColor(194, 104, 104);
    }
    if (id == "sentinel") {
        return QColor(130, 170, 210);
    }
    if (id == "arcanist") {
        return QColor(155, 135, 205);
    }
    if (id == "druid") {
        return QColor(130, 190, 135);
    }
    if (id == "ranger") {
        return QColor(215, 170, 90);
    }
    if (id == "assassin") {
        return QColor(205, 130, 170);
    }
    if (id == "star_knight") {
        return QColor(96, 155, 210);
    }
    if (id == "dawn_lancer") {
        return QColor(222, 186, 96);
    }
    if (id == "spark_gunner") {
        return QColor(230, 125, 88);
    }
    if (id == "moonblade") {
        return QColor(142, 118, 202);
    }
    if (id == "light_priest") {
        return QColor(222, 210, 128);
    }
    return QColor(180, 180, 180);
}

Unit* MainWindow::hoveredUnit() const
{
    if (m_dragKind != DragKind::None) {
        return nullptr;
    }

    for (int row = 0; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            Unit* unit = m_board[row][col];
            if (unit && unitRect(unit).contains(m_mousePos)) {
                return unit;
            }
        }
    }

    for (Unit* unit : m_bench) {
        if (unit && unitRect(unit).contains(m_mousePos)) {
            return unit;
        }
    }
    return nullptr;
}

int MainWindow::hoveredShopIndex() const
{
    if (m_dragKind != DragKind::None) {
        return -1;
    }

    for (int i = 0; i < m_shop.size(); ++i) {
        if (shopRect(i).contains(m_mousePos)) {
            return i;
        }
    }
    return -1;
}

int MainWindow::hoveredEquipmentIndex() const
{
    if (m_dragKind != DragKind::None) {
        return -1;
    }

    for (int i = 0; i < m_equipmentPool.size(); ++i) {
        if (equipmentRect(i).contains(m_mousePos)) {
            return i;
        }
    }
    return -1;
}

QString MainWindow::heroStatsText(const QString& id) const
{
    std::unique_ptr<Unit> unit = createHero(id, Owner::PlayerCtrl);
    return QStringLiteral("HP %1 | ATK %2 | 射程 %3 | 法力 %4")
        .arg(unit->maxHp())
        .arg(unit->atk())
        .arg(unit->range())
        .arg(unit->maxMana());
}

void MainWindow::mousePressEvent(QMouseEvent* event)
{
    m_mousePos = event->pos();

    if (m_screen != Screen::Playing && m_screen != Screen::SettingsMenu
        && event->button() == Qt::LeftButton && settingsButtonRect().contains(event->pos())) {
        openSettingsMenu();
        return;
    }

    if (m_screen == Screen::SettingsMenu) {
        if (event->button() != Qt::LeftButton) {
            return;
        }
        if (settingsReturnButtonRect().contains(event->pos())) {
            returnFromSettingsMenu();
            return;
        }
        const QRect sliderHit = settingsVolumeSliderRect().adjusted(-24, -24, 24, 24);
        if (sliderHit.contains(event->pos()) || settingsVolumeKnobRect().contains(event->pos())) {
            m_draggingVolumeSlider = true;
            updateVolumeFromPoint(event->pos());
            return;
        }
        return;
    }

    if (m_screen == Screen::StartMenu) {
        if (menuNewGameButtonRect().contains(event->pos())) {
            resetNetwork();
            initializeGame();
            return;
        }
        if (menuLoadButtonRect().contains(event->pos())) {
            setScreen(Screen::LoadMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        if (menuLanButtonRect().contains(event->pos())) {
            setScreen(Screen::LanMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        if (menuExitButtonRect().contains(event->pos())) {
            close();
            return;
        }
        return;
    }

    if (m_screen == Screen::LanMenu) {
        if (menuLanHostButtonRect().contains(event->pos())) {
            hostLanBattle();
            return;
        }
        if (menuLanJoinButtonRect().contains(event->pos())) {
            openLanJoinMenu();
            return;
        }
        if (menuLanRemoteButtonRect().contains(event->pos())) {
            openRemoteBattleMenu();
            return;
        }
        if (menuBackButtonRect().contains(event->pos())) {
            setScreen(Screen::StartMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        return;
    }

    if (m_screen == Screen::LanJoinMenu) {
        const QRect connectRect = remoteConnectButtonRect().translated(0, -6);
        const QRect cancelRect = remoteCancelButtonRect().translated(0, -6);
        if (lanHostInputRect().contains(event->pos())) {
            update();
            return;
        }
        if (connectRect.contains(event->pos())) {
            joinLanBattle();
            return;
        }
        if (cancelRect.contains(event->pos()) || menuBackButtonRect().contains(event->pos())) {
            setScreen(Screen::LanMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        return;
    }

    if (m_screen == Screen::RemoteMenu) {
        if (remoteNicknameInputRect().contains(event->pos())) {
            m_remoteInputField = RemoteInputField::Nickname;
            update();
            return;
        }
        if (remoteRoomInputRect().contains(event->pos())) {
            m_remoteInputField = RemoteInputField::Room;
            update();
            return;
        }
        if (remoteConnectButtonRect().contains(event->pos())) {
            joinRemoteBattle();
            return;
        }
        if (remoteCancelButtonRect().contains(event->pos()) || menuBackButtonRect().contains(event->pos())) {
            setScreen(Screen::LanMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        return;
    }

    if (m_screen == Screen::LoadMenu) {
        for (int slot = 1; slot <= 3; ++slot) {
            if (menuSlotButtonRect(slot - 1).contains(event->pos())) {
                if (loadGame(slot)) {
                    resetNetwork();
                    setScreen(Screen::Playing);
                    m_menuMessage.clear();
                }
                update();
                return;
            }
        }
        if (menuBackButtonRect().contains(event->pos())) {
            setScreen(Screen::StartMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        return;
    }

    if (event->button() == Qt::RightButton) {
        if (m_phase == Phase::Prep) {
            Unit* unitToSell = nullptr;
            for (const std::unique_ptr<Unit>& unit : m_units) {
                if (unit->owner() == Owner::PlayerCtrl && unitRect(unit.get()).contains(event->pos())) {
                    unitToSell = unit.get();
                    break;
                }
            }
            if (unitToSell) {
                if (event->modifiers() & Qt::ControlModifier) {
                    unequipUnit(unitToSell);
                    update();
                    return;
                }
                sellUnit(unitToSell);
                update();
                return;
            }
        }
        return;
    }

    if (event->button() != Qt::LeftButton) {
        return;
    }

    if (m_phase == Phase::Finished) {
        if (finalExitButtonRect().contains(event->pos())) {
            resetNetwork();
            setScreen(Screen::StartMenu);
            m_menuMessage.clear();
            update();
        }
        return;
    }

    if (saveButtonRect().contains(event->pos())) {
        saveGame();
        return;
    }

    if (m_phase == Phase::Prep) {
        if (startButtonRect().contains(event->pos())) {
            startCombat();
            return;
        }
        if (refreshButtonRect().contains(event->pos())) {
            refreshShop(true);
            update();
            return;
        }
        if (upgradeButtonRect().contains(event->pos())) {
            if (!m_player.upgradePopulation()) {
                pushLog(QStringLiteral("金币不足，无法提升人口。"));
            }
            update();
            return;
        }

        for (int i = 0; i < m_shop.size(); ++i) {
            if (shopRect(i).contains(event->pos())) {
                buyShopUnit(i);
                update();
                return;
            }
        }

        for (int i = 0; i < m_equipmentPool.size(); ++i) {
            if (equipmentRect(i).contains(event->pos())) {
                m_dragKind = DragKind::Equipment;
                m_dragEquipmentIndex = i;
                update();
                return;
            }
        }

        for (int i = 0; i < BenchSlots; ++i) {
            if (m_bench[i] && unitRect(m_bench[i]).contains(event->pos())) {
                m_dragKind = DragKind::Unit;
                m_dragUnit = m_bench[i];
                m_dragSourcePlace = UnitPlace::Bench;
                m_dragSourceBench = i;
                update();
                return;
            }
        }
        for (int row = 4; row < BoardRows; ++row) {
            for (int col = 0; col < BoardCols; ++col) {
                Unit* unit = m_board[row][col];
                if (unit && unit->owner() == Owner::PlayerCtrl && unitRect(unit).contains(event->pos())) {
                    m_dragKind = DragKind::Unit;
                    m_dragUnit = unit;
                    m_dragSourcePlace = UnitPlace::Board;
                    m_dragSourceRow = row;
                    m_dragSourceCol = col;
                    update();
                    return;
                }
            }
        }
    }
}

void MainWindow::mouseMoveEvent(QMouseEvent* event)
{
    m_mousePos = event->pos();
    if (m_draggingVolumeSlider) {
        updateVolumeFromPoint(event->pos());
        return;
    }
    update();
}

void MainWindow::mouseReleaseEvent(QMouseEvent* event)
{
    m_mousePos = event->pos();
    if (m_draggingVolumeSlider) {
        updateVolumeFromPoint(event->pos());
        m_draggingVolumeSlider = false;
        update();
        return;
    }
    if (m_screen != Screen::Playing) {
        return;
    }

    bool handled = false;

    if (m_dragKind == DragKind::Unit && m_dragUnit) {
        QRect board = boardRect();
        if (board.contains(event->pos())) {
            const int row = (event->pos().y() - board.top()) / CellSize;
            const int col = (event->pos().x() - board.left()) / CellSize;
            handled = moveDraggedUnitToBoard(row, col);
        } else {
            for (int i = 0; i < BenchSlots; ++i) {
                if (benchRect(i).contains(event->pos())) {
                    handled = moveDraggedUnitToBench(i);
                    break;
                }
            }
        }
        if (!handled) {
            pushLog(QStringLiteral("不能放在这里。"));
        }
    } else if (m_dragKind == DragKind::Equipment && m_dragEquipmentIndex >= 0) {
        for (const std::unique_ptr<Unit>& unit : m_units) {
            if (unit->owner() == Owner::PlayerCtrl && unitRect(unit.get()).contains(event->pos())) {
                handled = equipDraggedItem(unit.get());
                break;
            }
        }
        if (!handled) {
            pushLog(QStringLiteral("请把装备拖到单位身上。"));
        }
    }

    m_dragKind = DragKind::None;
    m_dragUnit = nullptr;
    m_dragEquipmentIndex = -1;
    m_dragSourcePlace = UnitPlace::None;
    m_dragSourceRow = -1;
    m_dragSourceCol = -1;
    m_dragSourceBench = -1;
    update();
}

void MainWindow::keyPressEvent(QKeyEvent* event)
{
    if (m_screen != Screen::Playing) {
        if (m_screen == Screen::SettingsMenu) {
            if (event->key() == Qt::Key_Escape) {
                returnFromSettingsMenu();
                return;
            }
            if (event->key() == Qt::Key_Left) {
                setMenuVolume(m_menuVolume - 0.05);
                return;
            }
            if (event->key() == Qt::Key_Right) {
                setMenuVolume(m_menuVolume + 0.05);
                return;
            }
            QWidget::keyPressEvent(event);
            return;
        }
        if (m_screen == Screen::LanJoinMenu) {
            handleLanJoinMenuKey(event);
            return;
        }
        if (m_screen == Screen::RemoteMenu) {
            handleRemoteMenuKey(event);
            return;
        }
        if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
            if (m_screen == Screen::StartMenu) {
                resetNetwork();
                initializeGame();
                return;
            }
        } else if (event->key() == Qt::Key_Escape) {
            if (m_screen == Screen::LoadMenu || m_screen == Screen::LanMenu) {
                setScreen(Screen::StartMenu);
                m_menuMessage.clear();
                update();
                return;
            }
            close();
            return;
        }
        QWidget::keyPressEvent(event);
        return;
    }

    if (m_phase == Phase::Finished) {
        if (event->key() == Qt::Key_Escape) {
            resetNetwork();
            setScreen(Screen::StartMenu);
            m_menuMessage.clear();
            update();
            return;
        }
        QWidget::keyPressEvent(event);
        return;
    }

    if (event->key() == Qt::Key_S) {
        saveGame();
    } else if (event->key() == Qt::Key_Space) {
        startCombat();
    } else if (event->key() == Qt::Key_U && m_phase == Phase::Prep) {
        Unit* unit = hoveredUnit();
        if (unit && unit->owner() == Owner::PlayerCtrl) {
            unequipUnit(unit);
            update();
            return;
        }
        QWidget::keyPressEvent(event);
    } else {
        QWidget::keyPressEvent(event);
    }
}

Unit* MainWindow::addUnit(std::unique_ptr<Unit> unit)
{
    Unit* raw = unit.get();
    m_units.push_back(std::move(unit));
    return raw;
}

void MainWindow::placeOnBoard(Unit* unit, int row, int col)
{
    if (!unit || !inBounds(row, col)) {
        return;
    }
    m_board[row][col] = unit;
    unit->setBoardPos(row, col);
    updateActiveTraits();
}

void MainWindow::placeOnBench(Unit* unit, int index)
{
    if (!unit || index < 0 || index >= BenchSlots) {
        return;
    }
    m_bench[index] = unit;
    unit->setBenchPos(index);
    updateActiveTraits();
}

void MainWindow::clearUnitPlace(Unit* unit)
{
    if (!unit) {
        return;
    }
    if (unit->place() == UnitPlace::Board && inBounds(unit->row(), unit->col()) && m_board[unit->row()][unit->col()] == unit) {
        m_board[unit->row()][unit->col()] = nullptr;
    } else if (unit->place() == UnitPlace::Bench && unit->benchIndex() >= 0 && unit->benchIndex() < BenchSlots && m_bench[unit->benchIndex()] == unit) {
        m_bench[unit->benchIndex()] = nullptr;
    }
    unit->clearPlace();
    updateActiveTraits();
}

void MainWindow::removeUnit(Unit* unit)
{
    clearUnitPlace(unit);
    m_units.erase(std::remove_if(m_units.begin(), m_units.end(), [unit](const std::unique_ptr<Unit>& owned) {
        return owned.get() == unit;
    }), m_units.end());
}

bool MainWindow::moveDraggedUnitToBoard(int row, int col)
{
    if (!m_dragUnit || !inBounds(row, col) || row < 4) {
        return false;
    }
    Unit* target = m_board[row][col];
    if (target == m_dragUnit) {
        return true;
    }
    if (target && target->owner() != Owner::PlayerCtrl) {
        return false;
    }

    const bool enteringEmptyBoard = m_dragSourcePlace == UnitPlace::Bench && target == nullptr;
    if (enteringEmptyBoard && boardPlayerCount(m_dragUnit) >= m_player.populationCap()) {
        pushLog(QStringLiteral("已达到人口上限。"));
        return false;
    }

    const UnitPlace sourcePlace = m_dragSourcePlace;
    const int sourceRow = m_dragSourceRow;
    const int sourceCol = m_dragSourceCol;
    const int sourceBench = m_dragSourceBench;

    clearUnitPlace(m_dragUnit);
    if (target) {
        clearUnitPlace(target);
    }
    placeOnBoard(m_dragUnit, row, col);
    if (target) {
        if (sourcePlace == UnitPlace::Board) {
            placeOnBoard(target, sourceRow, sourceCol);
        } else if (sourcePlace == UnitPlace::Bench) {
            placeOnBench(target, sourceBench);
        }
    }
    return true;
}

bool MainWindow::moveDraggedUnitToBench(int index)
{
    if (!m_dragUnit || index < 0 || index >= BenchSlots) {
        return false;
    }
    Unit* target = m_bench[index];
    if (target == m_dragUnit) {
        return true;
    }

    const UnitPlace sourcePlace = m_dragSourcePlace;
    const int sourceRow = m_dragSourceRow;
    const int sourceCol = m_dragSourceCol;
    const int sourceBench = m_dragSourceBench;

    clearUnitPlace(m_dragUnit);
    if (target) {
        clearUnitPlace(target);
    }
    placeOnBench(m_dragUnit, index);
    if (target) {
        if (sourcePlace == UnitPlace::Board) {
            placeOnBoard(target, sourceRow, sourceCol);
        } else if (sourcePlace == UnitPlace::Bench) {
            placeOnBench(target, sourceBench);
        }
    }
    return true;
}

bool MainWindow::equipDraggedItem(Unit* unit)
{
    if (!unit || m_dragEquipmentIndex < 0 || m_dragEquipmentIndex >= m_equipmentPool.size()) {
        return false;
    }
    if (!unit->equip(m_equipmentPool[m_dragEquipmentIndex])) {
        pushLog(QStringLiteral("这个单位已经有装备了。"));
        return false;
    }
    pushLog(unit->name() + QStringLiteral(" 装备了 ") + m_equipmentPool[m_dragEquipmentIndex].name + QStringLiteral("。"));
    m_equipmentPool.removeAt(m_dragEquipmentIndex);
    return true;
}

bool MainWindow::unequipUnit(Unit* unit, bool logAction)
{
    if (!unit || unit->owner() != Owner::PlayerCtrl) {
        return false;
    }
    if (!unit->hasEquipment()) {
        if (logAction) {
            pushLog(QStringLiteral("这个单位没有装备。"));
        }
        return false;
    }

    const QString unitName = unit->name();
    const Equipment equipment = unit->unequip();
    if (equipment.name.isEmpty()) {
        return false;
    }

    m_equipmentPool << equipment;
    if (logAction) {
        pushLog(QStringLiteral("%1 卸下了 %2。").arg(unitName, equipment.name));
    }
    return true;
}

int MainWindow::firstEmptyBench() const
{
    for (int i = 0; i < BenchSlots; ++i) {
        if (!m_bench[i]) {
            return i;
        }
    }
    return -1;
}

int MainWindow::boardPlayerCount(const Unit* ignore) const
{
    int count = 0;
    for (int row = 4; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            Unit* unit = m_board[row][col];
            if (unit && unit != ignore && unit->owner() == Owner::PlayerCtrl) {
                ++count;
            }
        }
    }
    return count;
}

QVector<Unit*> MainWindow::combatUnits() const
{
    QVector<Unit*> result;
    for (int row = 0; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            Unit* unit = m_board[row][col];
            if (unit && unit->isAlive()) {
                result << unit;
            }
        }
    }
    return result;
}

QVector<Unit*> MainWindow::playerBoardUnits() const
{
    QVector<Unit*> result;
    for (int row = 4; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            Unit* unit = m_board[row][col];
            if (unit && unit->owner() == Owner::PlayerCtrl) {
                result << unit;
            }
        }
    }
    return result;
}

bool MainWindow::hasAlive(Owner owner) const
{
    for (Unit* unit : combatUnits()) {
        if (unit->owner() == owner && unit->isAlive()) {
            return true;
        }
    }
    return false;
}

void MainWindow::clearDeadOccupants()
{
    for (auto& row : m_board) {
        for (Unit*& unit : row) {
            if (unit && !unit->isAlive()) {
                unit = nullptr;
            }
        }
    }
}

void MainWindow::buyShopUnit(int index)
{
    if (index < 0 || index >= m_shop.size()) {
        return;
    }
    const int benchIndex = firstEmptyBench();
    if (benchIndex < 0) {
        pushLog(QStringLiteral("备战席已满。"));
        return;
    }
    const ShopSlot slot = m_shop[index];
    if (!m_player.spendGold(slot.cost)) {
        pushLog(QStringLiteral("金币不足。"));
        return;
    }
    Unit* unit = addUnit(createHero(slot.heroId, Owner::PlayerCtrl));
    placeOnBench(unit, benchIndex);
    pushLog(QStringLiteral("购买了 ") + unit->name() + QStringLiteral("。"));
    tryMerge(unit);
    const QString newId = randomHeroId();
    m_shop[index] = {newId, heroCost(newId)};
}

void MainWindow::sellUnit(Unit* unit)
{
    if (!unit || unit->owner() != Owner::PlayerCtrl || m_phase != Phase::Prep) {
        return;
    }

    const int refund = sellValue(unit);
    const QString name = unit->name();
    const int star = unit->star();
    const bool returnedEquipment = unequipUnit(unit, false);
    removeUnit(unit);
    m_player.addGold(refund);
    pushLog(QStringLiteral("出售了 %1（%2 星），获得 %3 金币%4。")
                .arg(name)
                .arg(star)
                .arg(refund)
                .arg(returnedEquipment ? QStringLiteral("，装备已卸下") : QString()));
    updateActiveTraits();
}

int MainWindow::sellValue(const Unit* unit) const
{
    if (!unit) {
        return 0;
    }

    const int baseRefund = heroCost(unit->id()) <= 2 ? 1 : 2;
    int copies = 1;
    for (int star = 1; star < unit->star(); ++star) {
        copies *= 3;
    }
    return baseRefund * copies;
}

void MainWindow::refreshShop(bool payCost)
{
    if (payCost && !m_player.spendGold(2)) {
        pushLog(QStringLiteral("金币不足，无法刷新商店。"));
        return;
    }
    m_shop.clear();
    for (int i = 0; i < ShopSlots; ++i) {
        const QString id = randomHeroId();
        m_shop << ShopSlot{id, heroCost(id)};
    }
    if (payCost) {
        pushLog(QStringLiteral("商店已刷新。"));
    }
}

void MainWindow::tryMerge(Unit* preferred)
{
    if (!preferred || preferred->star() >= 3 || preferred->owner() != Owner::PlayerCtrl) {
        return;
    }

    bool merged = true;
    while (merged && preferred->star() < 3) {
        merged = false;
        QVector<Unit*> matches;
        for (const std::unique_ptr<Unit>& unit : m_units) {
            if (unit->owner() == Owner::PlayerCtrl
                && unit->id() == preferred->id()
                && unit->star() == preferred->star()) {
                matches << unit.get();
            }
        }
        if (matches.size() < 3) {
            break;
        }

        bool returnedEquipment = unequipUnit(preferred, false);
        const int nextStar = preferred->star() + 1;
        preferred->setStar(nextStar);
        int removed = 0;
        for (Unit* unit : matches) {
            if (unit == preferred) {
                continue;
            }
            returnedEquipment = unequipUnit(unit, false) || returnedEquipment;
            removeUnit(unit);
            ++removed;
            if (removed == 2) {
                break;
            }
        }
        pushLog(preferred->name()
                + QStringLiteral(" 合成为 %1 星%2。")
                      .arg(nextStar)
                      .arg(returnedEquipment ? QStringLiteral("，装备已自动卸下") : QString()));
        merged = true;
    }
}

QString MainWindow::randomHeroId() const
{
    const QVector<HeroDefinition> heroes = heroCatalog();
    return heroes[QRandomGenerator::global()->bounded(heroes.size())].id;
}

QString MainWindow::heroName(const QString& id) const
{
    for (const HeroDefinition& hero : heroCatalog()) {
        if (hero.id == id) {
            return hero.name;
        }
    }
    return QStringLiteral("未知");
}

int MainWindow::heroCost(const QString& id) const
{
    for (const HeroDefinition& hero : heroCatalog()) {
        if (hero.id == id) {
            return hero.cost;
        }
    }
    return 3;
}

Unit* MainWindow::targetFor(Unit* unit) const
{
    Unit* best = nullptr;
    double bestDistance = std::numeric_limits<double>::max();
    for (Unit* candidate : combatUnits()) {
        if (!candidate || candidate == unit || !candidate->isAlive() || candidate->owner() == unit->owner()) {
            continue;
        }
        const double distance = gridDistance(unit, candidate);
        bool better = distance < bestDistance - 1e-6;
        if (!better && std::abs(distance - bestDistance) <= 1e-6 && best) {
            if (candidate->hp() != best->hp()) {
                better = candidate->hp() > best->hp();
            } else if (candidate->col() != best->col()) {
                better = candidate->col() < best->col();
            } else {
                better = candidate->row() > best->row();
            }
        }
        if (!best || better) {
            best = candidate;
            bestDistance = distance;
        }
    }
    return best;
}

bool MainWindow::inRange(const Unit* unit, const Unit* target) const
{
    return unit && target && gridDistance(unit, target) <= unit->range() + 1e-6;
}

QPoint MainWindow::nextStepToward(const Unit* unit, const Unit* target) const
{
    if (!unit || !target) {
        return {-1, -1};
    }

    QVector<int> dist(BoardRows * BoardCols, -1);
    QVector<int> parent(BoardRows * BoardCols, -1);
    QQueue<QPoint> queue;
    const int start = indexOf(unit->row(), unit->col());
    dist[start] = 0;
    queue.enqueue({unit->row(), unit->col()});

    const int dr[4] = {-1, 1, 0, 0};
    const int dc[4] = {0, 0, -1, 1};
    while (!queue.isEmpty()) {
        const QPoint cur = queue.dequeue();
        for (int dir = 0; dir < 4; ++dir) {
            const int nr = cur.x() + dr[dir];
            const int nc = cur.y() + dc[dir];
            if (!inBounds(nr, nc)) {
                continue;
            }
            const int next = indexOf(nr, nc);
            if (dist[next] >= 0) {
                continue;
            }
            if (m_board[nr][nc] && m_board[nr][nc] != unit) {
                continue;
            }
            const int curIndex = indexOf(cur.x(), cur.y());
            dist[next] = dist[curIndex] + 1;
            parent[next] = curIndex;
            queue.enqueue({nr, nc});
        }
    }

    int best = -1;
    int bestDist = std::numeric_limits<int>::max();
    double bestTargetDistance = std::numeric_limits<double>::max();
    for (int row = 0; row < BoardRows; ++row) {
        for (int col = 0; col < BoardCols; ++col) {
            const int idx = indexOf(row, col);
            if (dist[idx] <= 0 || m_board[row][col]) {
                continue;
            }
            const int tr = row - target->row();
            const int tc = col - target->col();
            const double targetDistance = std::sqrt(static_cast<double>(tr * tr + tc * tc));
            if (targetDistance > unit->range() + 1e-6) {
                continue;
            }
            if (dist[idx] < bestDist || (dist[idx] == bestDist && targetDistance < bestTargetDistance)) {
                best = idx;
                bestDist = dist[idx];
                bestTargetDistance = targetDistance;
            }
        }
    }
    if (best < 0) {
        return {-1, -1};
    }

    int step = best;
    while (parent[step] >= 0 && parent[step] != start) {
        step = parent[step];
    }
    return {step / BoardCols, step % BoardCols};
}

void MainWindow::updateUnit(Unit* unit, const QVector<Unit*>& allUnits)
{
    if (!unit || !unit->isAlive() || unit->place() != UnitPlace::Board) {
        return;
    }

    unit->tickCooldowns();
    Unit* target = targetFor(unit);
    if (!target) {
        unit->setState(UnitState::Idle);
        return;
    }

    if (unit->mana() >= unit->maxMana()) {
        unit->setState(UnitState::Casting);
        unit->castSkill(target, allUnits, m_log);
        unit->gainMana(-unit->maxMana());
        unit->takeDamage(0);
        unit->startAttackCooldown();
        clearDeadOccupants();
        return;
    }

    if (inRange(unit, target)) {
        if (unit->canAttack()) {
            basicAttack(unit, target);
            unit->startAttackCooldown();
            unit->setState(UnitState::Attacking);
        } else {
            unit->setState(UnitState::Idle);
        }
        return;
    }

    if (unit->canMove()) {
        const QPoint step = nextStepToward(unit, target);
        if (inBounds(step.x(), step.y()) && !m_board[step.x()][step.y()]) {
            m_board[unit->row()][unit->col()] = nullptr;
            placeOnBoard(unit, step.x(), step.y());
            unit->startMoveCooldown();
            unit->setState(UnitState::Moving);
        } else {
            unit->setState(UnitState::Idle);
        }
    } else {
        unit->setState(UnitState::Idle);
    }
}

void MainWindow::basicAttack(Unit* unit, Unit* target)
{
    if (!unit || !target || !target->isAlive()) {
        return;
    }
    int hits = 1;
    if (unit->doubleAttackChance() > 0 && QRandomGenerator::global()->bounded(100) < unit->doubleAttackChance()) {
        hits = 2;
    }
    for (int i = 0; i < hits && target->isAlive(); ++i) {
        target->takeDamage(unit->atk());
        unit->gainMana(unit->manaGain());
    }
    clearDeadOccupants();
}

void MainWindow::startLanBattle()
{
    setScreen(Screen::LanMenu);
    m_menuMessage.clear();
    update();
}

void MainWindow::setScreen(Screen screen)
{
    if (m_screen == screen) {
        updateMenuMusic();
        return;
    }

    if (screen != Screen::SettingsMenu) {
        m_draggingVolumeSlider = false;
    }
    m_screen = screen;
    updateMenuMusic();
}

void MainWindow::updateMenuMusic()
{
    const bool shouldPlay = m_screen != Screen::Playing;
    if (shouldPlay) {
        if (m_menuMusicPlayer.playbackState() != QMediaPlayer::PlayingState) {
            m_menuMusicPlayer.play();
        }
    } else if (m_menuMusicPlayer.playbackState() != QMediaPlayer::StoppedState) {
        m_menuMusicPlayer.stop();
    }
}

void MainWindow::openSettingsMenu()
{
    m_settingsReturnScreen = m_screen == Screen::SettingsMenu ? Screen::StartMenu : m_screen;
    m_menuMessage.clear();
    setScreen(Screen::SettingsMenu);
    update();
}

void MainWindow::returnFromSettingsMenu()
{
    Screen target = m_settingsReturnScreen;
    if (target == Screen::SettingsMenu || target == Screen::Playing) {
        target = Screen::StartMenu;
    }
    m_draggingVolumeSlider = false;
    setScreen(target);
    update();
}

void MainWindow::setMenuVolume(qreal volume)
{
    m_menuVolume = std::clamp(volume, 0.0, 1.0);
    if (m_menuAudioOutput) {
        m_menuAudioOutput->setVolume(float(m_menuVolume));
    }
    update();
}

void MainWindow::updateVolumeFromPoint(const QPoint& pos)
{
    const QRect slider = settingsVolumeSliderRect();
    if (slider.width() <= 1) {
        return;
    }
    const qreal volume = (pos.x() - slider.left()) / qreal(slider.width() - 1);
    setMenuVolume(volume);
}

void MainWindow::hostLanBattle()
{
    resetNetwork();
    initializeGame();
    m_networkRole = NetworkRole::Host;
    m_lanServer = new QTcpServer(this);

    connect(m_lanServer, &QTcpServer::newConnection, this, [this]() {
        QTcpSocket* socket = m_lanServer->nextPendingConnection();
        if (m_lanSocket) {
            socket->write("{\"type\":\"full\"}\n");
            socket->disconnectFromHost();
            socket->deleteLater();
            return;
        }
        setLanSocket(socket);
        pushLog(QStringLiteral("局域网对手已连接。"));
        sendNetworkMessage({{"type", "hello"}});
        update();
    });

    if (!m_lanServer->listen(QHostAddress::AnyIPv4, LanPort)) {
        pushLog(QStringLiteral("无法创建局域网对战。"));
        m_networkRole = NetworkRole::Offline;
        update();
        return;
    }

    pushLog(QStringLiteral("正在端口 %1 创建局域网对战。").arg(LanPort));
    pushLog(QStringLiteral("对手可使用你的 IPv4 地址加入。"));
    update();
}

void MainWindow::joinLanBattle()
{
    const QString host = m_lanHostDraft.trimmed();
    if (host.isEmpty()) {
        m_menuMessage = QStringLiteral("请输入主机 IPv4 地址。");
        update();
        return;
    }

    resetNetwork();
    initializeGame();
    m_networkRole = NetworkRole::Client;
    QTcpSocket* socket = new QTcpSocket(this);
    setLanSocket(socket);
    socket->connectToHost(host, LanPort);
    pushLog(QStringLiteral("正在连接 %1:%2……").arg(host).arg(LanPort));
    update();
}

void MainWindow::openLanJoinMenu()
{
    if (m_lanHostDraft.isEmpty()) {
        m_lanHostDraft = QStringLiteral("192.168.1.");
    }
    m_menuMessage.clear();
    setScreen(Screen::LanJoinMenu);
    update();
}

void MainWindow::openRemoteBattleMenu()
{
    m_remoteNicknameDraft = m_localNickname.isEmpty() ? QStringLiteral("玩家") : m_localNickname;
    m_remoteRoomDraft = m_remoteRoomId.isEmpty() ? QStringLiteral("1001") : m_remoteRoomId;
    m_remoteInputField = RemoteInputField::Nickname;
    m_menuMessage.clear();
    setScreen(Screen::RemoteMenu);
    update();
}

void MainWindow::joinRemoteBattle()
{
    QString nickname = cleanRemoteToken(m_remoteNicknameDraft, 16);
    if (nickname.isEmpty()) {
        m_menuMessage = QStringLiteral("昵称不能为空。");
        update();
        return;
    }

    QString roomId = cleanRemoteToken(m_remoteRoomDraft, 24);
    roomId.replace(QRegularExpression(QStringLiteral("[^A-Za-z0-9_-]")), QString());
    if (roomId.isEmpty()) {
        m_menuMessage = QStringLiteral("房间号只能包含字母、数字、下划线或短横线。");
        update();
        return;
    }

    m_localNickname = nickname;
    m_remoteRoomId = roomId;
    resetNetwork();
    m_localNickname = nickname;
    m_remoteRoomId = roomId;
    initializeGame();
    m_localNickname = nickname;
    m_remoteRoomId = roomId;
    m_networkRole = NetworkRole::Remote;
    QTcpSocket* socket = new QTcpSocket(this);
    setLanSocket(socket);
    socket->connectToHost(RemoteRelayHost, RemoteRelayPort);
    pushLog(QStringLiteral("正在连接远程中继 %1:%2……")
                .arg(RemoteRelayHost)
                .arg(RemoteRelayPort));
    pushLog(QStringLiteral("远程房间：%1，昵称：%2。").arg(m_remoteRoomId, m_localNickname));
    update();
}

void MainWindow::handleLanJoinMenuKey(QKeyEvent* event)
{
    if (event->key() == Qt::Key_Escape) {
        setScreen(Screen::LanMenu);
        m_menuMessage.clear();
        update();
        return;
    }
    if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
        joinLanBattle();
        return;
    }
    if (event->key() == Qt::Key_Backspace) {
        if (!m_lanHostDraft.isEmpty()) {
            m_lanHostDraft.chop(1);
            update();
        }
        return;
    }
    if (event->key() == Qt::Key_Delete) {
        m_lanHostDraft.clear();
        update();
        return;
    }

    appendLanHostInputText(event->text());
}

void MainWindow::handleRemoteMenuKey(QKeyEvent* event)
{
    if (event->key() == Qt::Key_Escape) {
        setScreen(Screen::LanMenu);
        m_menuMessage.clear();
        update();
        return;
    }
    if (event->key() == Qt::Key_Tab || event->key() == Qt::Key_Backtab) {
        m_remoteInputField = m_remoteInputField == RemoteInputField::Nickname
            ? RemoteInputField::Room
            : RemoteInputField::Nickname;
        update();
        return;
    }
    if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
        joinRemoteBattle();
        return;
    }

    QString* target = m_remoteInputField == RemoteInputField::Nickname ? &m_remoteNicknameDraft : &m_remoteRoomDraft;
    if (event->key() == Qt::Key_Backspace) {
        if (!target->isEmpty()) {
            target->chop(1);
            update();
        }
        return;
    }
    if (event->key() == Qt::Key_Delete) {
        target->clear();
        update();
        return;
    }

    appendRemoteInputText(event->text());
}

void MainWindow::appendLanHostInputText(const QString& text)
{
    if (text.isEmpty()) {
        return;
    }

    for (const QChar ch : text) {
        if (!(ch.isDigit() || ch == QLatin1Char('.'))) {
            continue;
        }
        if (m_lanHostDraft.size() >= 15) {
            break;
        }
        m_lanHostDraft.append(ch);
    }
    update();
}

void MainWindow::appendRemoteInputText(const QString& text)
{
    if (text.isEmpty()) {
        return;
    }

    QString* target = m_remoteInputField == RemoteInputField::Nickname ? &m_remoteNicknameDraft : &m_remoteRoomDraft;
    const int maxLength = m_remoteInputField == RemoteInputField::Nickname ? 16 : 24;
    for (const QChar ch : text) {
        if (ch.unicode() < 0x20 || ch.unicode() == 0x7f) {
            continue;
        }
        if (m_remoteInputField == RemoteInputField::Room
            && !(ch.isLetterOrNumber() || ch == QLatin1Char('_') || ch == QLatin1Char('-'))) {
            continue;
        }
        if (target->size() >= maxLength) {
            break;
        }
        target->append(ch);
    }
    update();
}

void MainWindow::resetNetwork()
{
    if (m_lanSocket) {
        disconnect(m_lanSocket, nullptr, this, nullptr);
        m_lanSocket->disconnectFromHost();
        m_lanSocket->deleteLater();
        m_lanSocket = nullptr;
    }
    if (m_lanServer) {
        m_lanServer->close();
        m_lanServer->deleteLater();
        m_lanServer = nullptr;
    }
    m_networkRole = NetworkRole::Offline;
    m_localCombatReady = false;
    m_remoteCombatReady = false;
    m_remoteRelayPaired = false;
    m_hasServerBattleResult = false;
    m_serverPlayerWon = false;
    m_remoteOpponentHealth = 100;
    m_remoteOpponentName.clear();
    m_remoteBoardSnapshot = QJsonArray();
    m_networkBuffer.clear();
}

void MainWindow::setLanSocket(QTcpSocket* socket)
{
    m_lanSocket = socket;
    m_lanSocket->setParent(this);
    m_networkBuffer.clear();

    connect(m_lanSocket, &QTcpSocket::connected, this, [this]() {
        pushLog(m_networkRole == NetworkRole::Remote ? QStringLiteral("已连接远程中继。") : QStringLiteral("已连接局域网主机。"));
        if (m_networkRole == NetworkRole::Remote) {
            sendNetworkMessage({
                {"type", "join"},
                {"nickname", m_localNickname},
                {"room", m_remoteRoomId}
            });
        } else {
            sendNetworkMessage({{"type", "hello"}});
        }
        update();
    });
    connect(m_lanSocket, &QTcpSocket::readyRead, this, &MainWindow::readNetworkMessages);
    connect(m_lanSocket, &QTcpSocket::disconnected, this, [this, socket]() {
        if (m_lanSocket == socket) {
            m_lanSocket = nullptr;
            m_networkBuffer.clear();
            m_localCombatReady = false;
            m_remoteCombatReady = false;
            m_remoteRelayPaired = false;
            m_hasServerBattleResult = false;
            m_serverPlayerWon = false;
            if (m_networkRole == NetworkRole::Client || m_networkRole == NetworkRole::Remote) {
                m_networkRole = NetworkRole::Offline;
            }
        }
        pushLog(QStringLiteral("联机对手已断开。"));
        socket->deleteLater();
        update();
    });
    connect(m_lanSocket, &QTcpSocket::errorOccurred, this, [this, socket](QAbstractSocket::SocketError) {
        pushLog(QStringLiteral("网络连接错误：") + socket->errorString());
        update();
    });
}

void MainWindow::readNetworkMessages()
{
    if (!m_lanSocket) {
        return;
    }

    m_networkBuffer += m_lanSocket->readAll();
    int lineEnd = m_networkBuffer.indexOf('\n');
    while (lineEnd >= 0) {
        const QByteArray line = m_networkBuffer.left(lineEnd).trimmed();
        m_networkBuffer.remove(0, lineEnd + 1);
        if (!line.isEmpty()) {
            const QJsonDocument document = QJsonDocument::fromJson(line);
            if (document.isObject()) {
                handleNetworkMessage(document.object());
            }
        }
        lineEnd = m_networkBuffer.indexOf('\n');
    }
}

void MainWindow::sendNetworkMessage(const QJsonObject& message)
{
    if (!m_lanSocket || m_lanSocket->state() != QAbstractSocket::ConnectedState) {
        return;
    }

    QByteArray payload = QJsonDocument(message).toJson(QJsonDocument::Compact);
    payload.append('\n');
    m_lanSocket->write(payload);
}

void MainWindow::handleNetworkMessage(const QJsonObject& message)
{
    const QString type = message["type"].toString();
    if (type == "hello") {
        pushLog(QStringLiteral("网络握手完成。"));
    } else if (type == "full") {
        pushLog(QStringLiteral("主机已有对手。"));
    } else if (type == "waiting") {
        m_remoteRoomId = message["room"].toString(m_remoteRoomId);
        m_remoteRelayPaired = false;
        pushLog(QStringLiteral("房间 %1 已就绪，等待另一名玩家。").arg(m_remoteRoomId));
    } else if (type == "paired") {
        m_remoteRelayPaired = true;
        m_remoteRoomId = message["room"].toString(m_remoteRoomId);
        m_remoteOpponentName = message["opponentName"].toString(QStringLiteral("对手"));
        m_remoteOpponentHealth = message["opponentHealth"].toInt(100);
        pushLog(QStringLiteral("已匹配 %1（HP %2），房间 %3。")
                    .arg(m_remoteOpponentName)
                    .arg(m_remoteOpponentHealth)
                    .arg(m_remoteRoomId));
    } else if (type == "peer_left") {
        m_remoteRelayPaired = false;
        m_remoteOpponentName.clear();
        pushLog(QStringLiteral("远程对手已离开房间。"));
    } else if (type == "ready_wait") {
        pushLog(QStringLiteral("服务器已收到你的阵容，等待对手。"));
    } else if (type == "battle_start") {
        m_remoteBoardSnapshot = message["units"].toArray();
        m_remoteCombatReady = true;
        m_hasServerBattleResult = true;
        m_serverPlayerWon = message["result"].toString() == "win";
        m_remoteOpponentName = message["opponentName"].toString(m_remoteOpponentName.isEmpty() ? QStringLiteral("对手") : m_remoteOpponentName);
        m_remoteOpponentHealth = message["opponentHealth"].toInt(m_remoteOpponentHealth);
        pushLog(QStringLiteral("服务器锁定结果：%1（%2 对 %3），对手 %4 HP %5。")
                    .arg(m_serverPlayerWon ? QStringLiteral("胜利") : QStringLiteral("失败"))
                    .arg(message["score"].toInt())
                    .arg(message["opponentScore"].toInt())
                    .arg(m_remoteOpponentName)
                    .arg(m_remoteOpponentHealth));
        startLanCombatIfReady();
    } else if (type == "ready") {
        m_remoteBoardSnapshot = message["units"].toArray();
        m_remoteCombatReady = true;
        m_remoteOpponentName = message["nickname"].toString(m_remoteOpponentName.isEmpty() ? QStringLiteral("对手") : m_remoteOpponentName);
        m_remoteOpponentHealth = message["health"].toInt(m_remoteOpponentHealth);
        pushLog(QStringLiteral("%1 阵容已就绪：%2 个单位，HP %3。")
                    .arg(m_remoteOpponentName)
                    .arg(m_remoteBoardSnapshot.size())
                    .arg(m_remoteOpponentHealth));
        startLanCombatIfReady();
    }
    update();
}

void MainWindow::sendLocalCombatReady()
{
    if (!m_lanSocket || m_lanSocket->state() != QAbstractSocket::ConnectedState) {
        pushLog(QStringLiteral("联机对手尚未连接。"));
        update();
        return;
    }
    if (m_networkRole == NetworkRole::Remote && !m_remoteRelayPaired) {
        pushLog(QStringLiteral("远程中继仍在等待另一名玩家。"));
        update();
        return;
    }

    m_localCombatReady = true;
    sendNetworkMessage({
        {"type", "ready"},
        {"round", m_round},
        {"nickname", m_localNickname},
        {"health", m_player.health()},
        {"units", localBoardSnapshot()}
    });
    pushLog(QStringLiteral("你的阵容已就绪，等待对手。"));
    startLanCombatIfReady();
    update();
}

void MainWindow::startLanCombatIfReady()
{
    if (m_phase != Phase::Prep || !m_localCombatReady || !m_remoteCombatReady) {
        return;
    }

    m_combatStart.clear();
    for (Unit* unit : playerBoardUnits()) {
        m_combatStart.push_back({unit, unit->row(), unit->col()});
    }

    spawnRemoteEnemies(m_remoteBoardSnapshot);
    for (Unit* unit : combatUnits()) {
        unit->resetForCombat();
    }
    applyTraitBonuses();

    m_phase = Phase::Combat;
    m_localCombatReady = false;
    m_remoteCombatReady = false;
    m_remoteBoardSnapshot = QJsonArray();
    pushLog(QStringLiteral("联机第 %1 回合战斗开始。").arg(m_round));
    update();
}

void MainWindow::spawnRemoteEnemies(const QJsonArray& units)
{
    clearEnemies();

    auto firstEnemySlot = [this]() {
        for (int row = 0; row < 4; ++row) {
            for (int col = 0; col < BoardCols; ++col) {
                if (!m_board[row][col]) {
                    return QPoint(row, col);
                }
            }
        }
        return QPoint(-1, -1);
    };

    for (const QJsonValue& value : units) {
        const QJsonObject item = value.toObject();
        Unit* enemy = addUnit(createHero(item["id"].toString("sentinel"), Owner::EnemyCtrl));
        enemy->setStar(item["star"].toInt(1));
        const QString equipment = item["equipment"].toString();
        if (!equipment.isEmpty()) {
            enemy->equip(Equipment::fromName(equipment));
        }

        int row = BoardRows - 1 - item["row"].toInt(4);
        int col = BoardCols - 1 - item["col"].toInt(0);
        if (row < 0 || row >= 4 || col < 0 || col >= BoardCols || m_board[row][col]) {
            const QPoint fallback = firstEnemySlot();
            row = fallback.x();
            col = fallback.y();
        }
        if (inBounds(row, col)) {
            placeOnBoard(enemy, row, col);
        }
    }
}

QJsonArray MainWindow::localBoardSnapshot() const
{
    QJsonArray units;
    for (Unit* unit : playerBoardUnits()) {
        QJsonObject item;
        item["id"] = unit->id();
        item["star"] = unit->star();
        item["row"] = unit->row();
        item["col"] = unit->col();
        item["hp"] = unit->maxHp();
        item["atk"] = unit->atk();
        item["range"] = unit->range();
        item["traits"] = QJsonArray::fromStringList(unit->traits());
        item["equipment"] = unit->hasEquipment() ? unit->equipment().name : "";
        units.append(item);
    }
    return units;
}

void MainWindow::saveGame()
{
    if (m_phase == Phase::Combat) {
        pushLog(QStringLiteral("战斗中不能保存。"));
        update();
        return;
    }

    const int slot = chooseSaveSlot();
    if (slot == 0) {
        return;
    }
    saveGame(slot);
}

bool MainWindow::saveGame(int slot)
{
    if (slot < 1 || slot > 3) {
        return false;
    }
    if (m_phase == Phase::Combat) {
        pushLog(QStringLiteral("战斗中不能保存。"));
        update();
        return false;
    }

    QJsonObject root;
    root["round"] = m_round;
    root["phase"] = phaseName();
    root["health"] = m_player.health();
    root["gold"] = m_player.gold();
    root["level"] = m_player.level();
    root["cap"] = m_player.populationCap();
    root["wins"] = m_player.winStreak();
    root["losses"] = m_player.lossStreak();
    root["finalMessage"] = m_finalMessage;

    QJsonArray shop;
    for (const ShopSlot& slot : m_shop) {
        QJsonObject item;
        item["id"] = slot.heroId;
        item["cost"] = slot.cost;
        shop.append(item);
    }
    root["shop"] = shop;

    QJsonArray equipment;
    for (const Equipment& item : m_equipmentPool) {
        equipment.append(item.name);
    }
    root["equipment"] = equipment;

    QJsonArray units;
    for (const std::unique_ptr<Unit>& unit : m_units) {
        if (unit->owner() != Owner::PlayerCtrl) {
            continue;
        }
        QJsonObject item;
        item["id"] = unit->id();
        item["star"] = unit->star();
        item["place"] = unit->place() == UnitPlace::Board ? "board" : "bench";
        item["row"] = unit->row();
        item["col"] = unit->col();
        item["bench"] = unit->benchIndex();
        item["equipment"] = unit->hasEquipment() ? unit->equipment().name : "";
        units.append(item);
    }
    root["units"] = units;

    QFile file(savePath(slot));
    if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
        pushLog(QStringLiteral("无法写入存档文件。"));
        update();
        return false;
    }
    file.write(QJsonDocument(root).toJson(QJsonDocument::Indented));
    pushLog(QStringLiteral("游戏已保存到存档 %1。").arg(slot));
    update();
    return true;
}

bool MainWindow::loadGame(int slot)
{
    if (slot < 1 || slot > 3) {
        return false;
    }

    QFile file(savePath(slot));
    if (!file.open(QIODevice::ReadOnly)) {
        m_menuMessage = QStringLiteral("存档 %1 为空。").arg(slot);
        update();
        return false;
    }
    QJsonParseError error;
    const QJsonDocument document = QJsonDocument::fromJson(file.readAll(), &error);
    if (error.error != QJsonParseError::NoError || !document.isObject()) {
        m_menuMessage = QStringLiteral("存档 %1 无效。").arg(slot);
        update();
        return false;
    }

    const QJsonObject root = document.object();
    m_units.clear();
    for (auto& row : m_board) {
        row.fill(nullptr);
    }
    m_bench.fill(nullptr);
    m_equipmentPool.clear();
    m_activeTraits.clear();
    m_combatStart.clear();
    m_finalMessage = root["finalMessage"].toString();
    const QString savedPhase = root["phase"].toString("Prep");
    if (savedPhase == "Finished" || savedPhase == QStringLiteral("结束")) {
        m_phase = Phase::Finished;
        if (m_finalMessage.isEmpty()) {
            m_finalMessage = QStringLiteral("游戏已结束。");
        }
    } else if (savedPhase == "Resolve" || savedPhase == QStringLiteral("结算")) {
        m_phase = Phase::Resolve;
        m_resolveTicks = 8;
    } else {
        m_phase = Phase::Prep;
    }
    m_round = std::max(1, root["round"].toInt(1));
    m_player.setState(root["health"].toInt(100),
                      root["gold"].toInt(10),
                      root["level"].toInt(1),
                      root["cap"].toInt(3),
                      root["wins"].toInt(0),
                      root["losses"].toInt(0));

    m_shop.clear();
    for (const QJsonValue& value : root["shop"].toArray()) {
        const QJsonObject item = value.toObject();
        m_shop << ShopSlot{item["id"].toString("sentinel"), item["cost"].toInt(3)};
    }
    while (m_shop.size() < ShopSlots) {
        const QString id = randomHeroId();
        m_shop << ShopSlot{id, heroCost(id)};
    }

    for (const QJsonValue& value : root["equipment"].toArray()) {
        m_equipmentPool << Equipment::fromName(value.toString());
    }

    for (const QJsonValue& value : root["units"].toArray()) {
        const QJsonObject item = value.toObject();
        Unit* unit = addUnit(createHero(item["id"].toString("sentinel"), Owner::PlayerCtrl));
        unit->setStar(item["star"].toInt(1));
        const QString equipment = item["equipment"].toString();
        if (!equipment.isEmpty()) {
            unit->equip(Equipment::fromName(equipment));
        }
        if (item["place"].toString() == "board") {
            placeOnBoard(unit, item["row"].toInt(4), item["col"].toInt(0));
        } else {
            placeOnBench(unit, item["bench"].toInt(firstEmptyBench()));
        }
    }

    m_menuMessage.clear();
    updateActiveTraits();
    pushLog(QStringLiteral("已读取存档 %1。").arg(slot));
    update();
    return true;
}

int MainWindow::chooseSaveSlot()
{
    QMessageBox dialog(this);
    dialog.setWindowTitle(QStringLiteral("保存游戏"));
    dialog.setText(QStringLiteral("选择存档位。"));
    dialog.setInformativeText(QStringLiteral("保存到已有存档会覆盖原内容。"));

    QPushButton* buttons[3] = {nullptr, nullptr, nullptr};
    for (int slot = 1; slot <= 3; ++slot) {
        buttons[slot - 1] = dialog.addButton(saveSlotLabel(slot), QMessageBox::AcceptRole);
    }
    dialog.addButton(QStringLiteral("取消"), QMessageBox::RejectRole);
    dialog.setDefaultButton(buttons[0]);
    dialog.exec();

    for (int slot = 1; slot <= 3; ++slot) {
        if (dialog.clickedButton() == buttons[slot - 1]) {
            return slot;
        }
    }
    return 0;
}

QString MainWindow::savePath(int slot) const
{
    return QCoreApplication::applicationDirPath() + QString("/save_slot_%1.json").arg(slot);
}

QString MainWindow::saveSlotLabel(int slot) const
{
    const QFileInfo info(savePath(slot));
    return QStringLiteral("存档 %1 - %2").arg(slot).arg(info.exists() ? QStringLiteral("已保存") : QStringLiteral("空"));
}

void MainWindow::pushLog(const QString& line)
{
    m_log.prepend(line);
    while (m_log.size() > 8) {
        m_log.removeLast();
    }
}

QString MainWindow::phaseName() const
{
    switch (m_phase) {
    case Phase::Prep: return QStringLiteral("准备");
    case Phase::Combat: return QStringLiteral("战斗");
    case Phase::Resolve: return QStringLiteral("结算");
    case Phase::Finished: return QStringLiteral("结束");
    }
    return QStringLiteral("准备");
}