英雄无敌地图编辑与设计

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "mapcontroller.h"

QT_BEGIN_NAMESPACE
namespace Ui { class MainWindow; }
QT_END_NAMESPACE

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    // 原生新建地图槽函数（你已有的）
    void on_actionNew_triggered();
    
    // 你的JSON转换菜单槽函数（核心UI入口）
    void on_actionConvertJson_triggered();

private:
    Ui::MainWindow *ui;
    MapController controller; // 你已有的MapController成员
};

#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "windownewmap.h"
#include <QFileDialog>
#include <QMessageBox>
#include <QStatusBar>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    delete ui;
}

// 你已有的原生新建地图槽函数（仅保留声明，确保编译）
void MainWindow::on_actionNew_triggered()
{
    // 保留你原有逻辑，这里仅占位保证编译
    // if(getAnswerAboutUnsavedChanges())
    //     new WindowNewMap(this);
}

// 你的JSON转换菜单槽函数（纯UI层，无业务逻辑，仅编译验证）
void MainWindow::on_actionConvertJson_triggered()
{
    // 1. 仅UI交互：选择JSON文件（无业务逻辑）
    QString jsonFilePath = QFileDialog::getOpenFileName(
        this,
        tr("Select AI Generated JSON"),
        QString(),
        tr("JSON Files (*.json);;All Files (*)")
    );
    
    // 2. 仅UI反馈（无业务逻辑）
    if (jsonFilePath.isEmpty()) {
        statusBar()->showMessage(tr("JSON file selection canceled!"), 3000);
        return;
    }
    
    // 3. 仅测试MapController成员调用（确保编译）
    if (controller.hasActiveMap()) {
        QMessageBox::information(this, tr("Test"), tr("Active map exists!"));
    } else {
        QMessageBox::information(this, tr("Test"), tr("No active map!"));
    }
    
    statusBar()->showMessage(tr("UI layer test success! File: %1").arg(jsonFilePath), 5000);
}

#include "MainWindow.h"
#include "ui_MainWindow.h"
#include "maphandler.h"  // 引入业务逻辑层
#include "windownewmap.h"
#include <QFileDialog>
#include <QMessageBox>
#include <QStatusBar>

// 核心：只调用 MapHandler 方法，无任何业务逻辑
void MainWindow::on_actionConvertJson_triggered()
{
    // 1. 复用 unsaved 成员判断未保存文件（完全贴合你的代码风格）
    if (unsaved)
    {
        QMessageBox::StandardButton res = QMessageBox::question(
            this,
            tr("Unsaved Changes"),
            tr("Current map has unsaved changes! Continue with JSON import?"),
            QMessageBox::Yes | QMessageBox::No
        );
        if (res == QMessageBox::No)
        {
            statusBar()->showMessage(tr("JSON import canceled!"), 3000);
            return;
        }
    }

    // 2. 纯UI：选择JSON文件
    QString jsonFilePath = QFileDialog::getOpenFileName(
        this,
        tr("Select AI Generated JSON"),
        QString(),
        tr("JSON Files (*.json);;All Files (*)")
    );
    if (jsonFilePath.isEmpty()) return;

    // 3. 核心：只调用 MapHandler 方法，不写任何业务逻辑
    MapHandler handler(this);                  // 初始化业务处理器
    handler.setEditorMap(controller.getCurrentMap()); // 传递当前地图
    bool success = handler.importJsonToCurrentMap(jsonFilePath.toStdString()); // 调用业务方法

    // 4. 纯UI：反馈结果
    if (success)
    {
        unsaved = true; // 标记为未保存（符合你的状态管理）
        controller.refreshMap(); // 刷新视图（复用现有接口）
        statusBar()->showMessage(tr("JSON imported successfully!"), 5000);
        QMessageBox::information(this, tr("Success"), tr("AI map data imported!"));
    }
    else
    {
        statusBar()->showMessage(tr("JSON import failed!"), 5000);
        QMessageBox::critical(this, tr("Failed"), tr("Check log for details!"));
    }
}

// maphandler.h
#pragma once
#include <QObject>
#include <string>

namespace VCMI_LIB_NAMESPACE {
    class CMap;
}

class MapHandler : public QObject
{
    Q_OBJECT
public:
    explicit MapHandler(QObject *parent = nullptr) : QObject(parent), m_editorMap(nullptr) {}

    // 仅声明方法，业务逻辑在 cpp 中实现（后续补）
    void setEditorMap(VCMI_LIB_NAMESPACE::CMap* map) { m_editorMap = map; }
    bool importJsonToCurrentMap(const std::string& jsonPath); // 核心业务方法

private:
    VCMI_LIB_NAMESPACE::CMap* m_editorMap; // 持有当前地图指针
};

void MainWindow::on_actionConvertJson_triggered()
{
    // 1. 检查当前地图是否有未保存更改（复用unsaved成员变量）
    if (unsaved)
    {
        QMessageBox::StandardButton ret = QMessageBox::question(
            this,
            tr("Unsaved Changes"),
            tr("Current map has unsaved changes! Convert JSON may overwrite data. \nSave changes first?"),
            QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel
        );

        if (ret == QMessageBox::Cancel)
        {
            statusBar()->showMessage(tr("JSON conversion canceled!"), 3000);
            return;
        }
        else if (ret == QMessageBox::Save)
        {
            // 复用现有保存逻辑
            saveMap();
            if (unsaved) // 保存失败时仍有未保存状态
            {
                statusBar()->showMessage(tr("Failed to save map! JSON conversion aborted."), 5000);
                return;
            }
        }
    }

    // 2. 选择JSON文件（UI交互层）
    QString jsonFilePath = QFileDialog::getOpenFileName(
        this,
        tr("Select AI Generated JSON"),
        lastSavingDir, // 复用现有最近保存目录成员变量
        tr("JSON Files (*.json);;All Files (*)")
    );

    if (jsonFilePath.isEmpty())
    {
        statusBar()->showMessage(tr("JSON file selection canceled!"), 3000);
        return;
    }

    // 3. 业务逻辑层：解析JSON并调用MapController处理
    try
    {
        statusBar()->showMessage(tr("Processing JSON file: %1").arg(jsonFilePath), 2000);
        
        // 读取JSON文件
        QFile jsonFile(jsonFilePath);
        if (!jsonFile.open(QIODevice::ReadOnly | QIODevice::Text))
        {
            throw std::runtime_error(tr("Failed to open JSON file: %1").arg(jsonFile.errorString()).toStdString());
        }

        // 解析JSON
        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonFile.readAll());
        if (jsonDoc.isNull() || !jsonDoc.isObject())
        {
            throw std::runtime_error("Invalid JSON format! Must be a valid JSON object.");
        }
        QJsonObject jsonObj = jsonDoc.object();

        // 调用MapController处理JSON数据（核心业务逻辑）
        // 适配现有controller成员的接口风格
        bool convertSuccess = controller.convertFromJson(jsonObj, mapLevel);

        // 4. 结果反馈（UI+状态更新）
        if (convertSuccess)
        {
            unsaved = true; // 标记为未保存（符合现有状态管理逻辑）
            setTitle(); // 刷新窗口标题（带*标记）
            statusBar()->showMessage(tr("JSON converted successfully! Map has unsaved changes."), 5000);
            QMessageBox::information(this, tr("Success"), tr("JSON data applied to map!"));
        }
        else
        {
            throw std::runtime_error("MapController failed to process JSON data!");
        }
    }
    catch (const std::exception &e)
    {
        // 统一异常处理（贴合现有代码的错误处理风格）
        QMessageBox::critical(
            this,
            tr("JSON Conversion Error"),
            tr("Failed to process JSON: %1").arg(QString::fromStdString(e.what()))
        );
        statusBar()->showMessage(tr("JSON conversion failed: %1").arg(QString::fromStdString(e.what())), 5000);
    }
}

#pragma once
#include <string>
#include <QObject>

namespace VCMI_LIB_NAMESPACE {
    class JsonNode;
    class CMap;
    struct int3;
}

class MapHandler : public QObject
{
    Q_OBJECT
public:
    explicit MapHandler(QObject *parent = nullptr) : QObject(parent), m_editorMap(nullptr) {}

    // 核心：直接修改已有地图，无Command、无宏命令
    bool importJsonToCurrentMap(const std::string& jsonInputPath);
    void setEditorMap(VCMI_LIB_NAMESPACE::CMap* map) { m_editorMap = map; }

private:
    bool parseJsonFile(const std::string& filePath, VCMI_LIB_NAMESPACE::JsonNode& outJson);
    bool assembleMapFromJson(const VCMI_LIB_NAMESPACE::JsonNode& mapJson);

    VCMI_LIB_NAMESPACE::CMap* m_editorMap;
};

#include "maphandler.h"
#include "lib/CMap.h"
#include "lib/JsonNode.h"
#include "lib/CLoggerBase.h"
#include "lib/ETerrainType.h"
#include "lib/ETownType.h"
#include "lib/int3.h"
#include <QFile>
#include <QFileInfo>

extern VCMI_LIB_NAMESPACE::CLoggerBase *logGlobal;
using namespace VCMI_LIB_NAMESPACE;

bool MapHandler::importJsonToCurrentMap(const std::string& jsonInputPath)
{
    if (!m_editorMap) {
        logGlobal->error("No active map instance!");
        return false;
    }

    JsonNode mapJson;
    if (!parseJsonFile(jsonInputPath, mapJson)) return false;
    return assembleMapFromJson(mapJson);
}

bool MapHandler::parseJsonFile(const std::string& filePath, JsonNode& outJson)
{
    QFile file(QString::fromStdString(filePath));
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        logGlobal->error("Open JSON failed: " + filePath);
        return false;
    }

    QByteArray raw = file.readAll();
    file.close();

    try {
        const std::byte* data = reinterpret_cast<const std::byte*>(raw.data());
        outJson = JsonNode(data, raw.size(), "AIGen_" + filePath);
        return !outJson.isNull();
    } catch (const std::exception& e) {
        logGlobal->error("Parse JSON failed: " + std::string(e.what()));
        return false;
    }
}

bool MapHandler::assembleMapFromJson(const JsonNode& mapJson)
{
    try {
        // 1. 地图尺寸：仅变化时调用 setupSize()
        std::string sizeStr = mapJson["mapInfo"]["size"].String();
        CMap::EMapSize newSize = CMap::MEDIUM;
        if (sizeStr == "small") newSize = CMap::SMALL;
        else if (sizeStr == "large") newSize = CMap::LARGE;

        if (m_editorMap->getSize() != newSize) {
            m_editorMap->setSize(newSize);
            m_editorMap->setupSize(); // 仅尺寸变化时调用
        }

        // 2. 基础属性
        m_editorMap->setHasUnderground(mapJson["mapInfo"]["hasUnderground"].Bool());
        m_editorMap->setName(mapJson["mapInfo"]["name"].String());

        // 3. 地形：直接操作 Tile（最底层接口，肯定存在）
        if (mapJson.hasKey("layers")) {
            for (const auto& layer : mapJson["layers"].Vector()) {
                int x = layer["x"].Integer();
                int y = layer["y"].Integer();
                int z = layer["z"].Integer();
                int terrainId = layer["terrain"].Integer();

                auto& tile = m_editorMap->getTile(int3(x, y, z));
                tile.setTerrain(static_cast<ETerrainType>(terrainId));
            }
        }

        // 4. 城镇：直接添加到 CMap（避开 Command，纯底层）
        if (mapJson.hasKey("towns")) {
            for (const auto& townJson : mapJson["towns"].Vector()) {
                int x = townJson["x"].Integer();
                int y = townJson["y"].Integer();
                int z = townJson["z"].Integer();
                std::string townTypeStr = townJson["type"].String();

                // 简单的类型映射（必能编译通过）
                ETownType townType = ETownType::CASTLE;
                if (townTypeStr == "rampart") townType = ETownType::RAMPART;
                else if (townTypeStr == "tower") townType = ETownType::TOWER;

                // 直接创建城镇对象并添加到地图（VCMI 底层接口）
                auto town = std::make_shared<CTown>();
                town->setType(townType);
                town->setPosition(int3(x, y, z));
                m_editorMap->addObject(town);
            }
        }

        logGlobal->info("JSON imported to map successfully!");
        return true;
    } catch (const std::exception& e) {
        logGlobal->error("Assemble map failed: " + std::string(e.what()));
        return false;
    }
}

#include "MainWindow.h"
#include "maphandler.h"
#include "mapcontroller.h"
#include <QFileDialog>
#include <QMessageBox>

void MainWindow::on_actionConvertJson_triggered()
{
    // 1. 直接调用原生新建地图（你已有的逻辑，无需修改）
    on_actionNew_triggered();
    
    // 2. 检查用户是否取消新建
    if (!controller.hasActiveMap()) {
        QMessageBox::warning(this, tr("Canceled"), tr("New map creation canceled!"));
        return;
    }

    // 3. 选择 JSON 文件
    QString jsonPath = QFileDialog::getOpenFileName(
        this, tr("Select JSON"), "", tr("JSON (*.json);;All Files (*)")
    );
    if (jsonPath.isEmpty()) return;

    // 4. 执行导入
    MapHandler handler(this);
    handler.setEditorMap(controller.getCurrentMap());
    bool ok = handler.importJsonToCurrentMap(jsonPath.toStdString());

    // 5. 反馈 + 刷新地图
    if (ok) {
        controller.refreshMap(); // 原生刷新接口，肯定存在
        statusBar()->showMessage(tr("Import success! Edit manually now."), 5000);
        QMessageBox::information(this, tr("Success"), tr("JSON imported!"));
    } else {
        statusBar()->showMessage(tr("Import failed!"), 5000);
        QMessageBox::critical(this, tr("Failed"), tr("Check log for details!"));
    }
}

// 原错误代码
controller.refreshMap(); // 刷新视图（复用现有接口）

// 修改后（根据实际函数名替换）
controller.refresh(); // 刷新视图（复用现有接口）

// 方案1：重新加载地图数据（如果有loadMap接口）
controller.loadMap(controller.getCurrentMapPath()); 

// 方案2：触发视图重绘（如果controller持有视图指针）
controller.getMapView()->repaint(); 

// 方案3：发送刷新信号（Qt场景）
emit controller->mapChanged(); // 需确保MapController定义了mapChanged信号

// mainwindow.cpp 中 on_actionConvertJson_triggered 函数片段
void MainWindow::on_actionConvertJson_triggered()
{
    // ... 其他业务逻辑 ...
    
    // 替换错误的refreshMap()为正确的接口
    controller.refresh(); // 优先用MapController自带的刷新函数
    // 或 fallback 方案：
    // ui->mapView->update(); // 直接刷新地图视图控件（Qt）
    
    // ... 其他逻辑 ...
}

#include <vcmi/CMapEditManager.h>
#include <vcmi/Handlers.h> // 包含 VLC/objtypeh 相关定义
#include <vcmi/CGObjectInstance.h>

CGObjectInstance* MapHandler::createObject(int objId, int subId, const int3& pos) {
    // 1. 通过全局处理器获取对象创建器（VCMI 标准方式）
    auto objHandler = VLC->objtypeh->getHandler(objId, subId);
    if (!objHandler) {
        log->error("Failed to get handler for objId:{} subId:{}", objId, subId);
        return nullptr;
    }

    // 2. 创建对象实例并设置基础坐标
    CGObjectInstance* obj = objHandler->create(objId, subId);
    if (!obj) {
        log->error("Failed to create object for objId:{} subId:{}", objId, subId);
        return nullptr;
    }
    obj->pos = pos;

    // 3. 通过 EditManager 插入（自动维护 undo/redo，核心步骤）
    if (m_currentMap && m_currentMap->getEditManager()) {
        m_currentMap->getEditManager()->insertObject(obj);
    } else {
        log->error("Map or EditManager is null, cannot insert object");
        delete obj; // 避免内存泄漏
        return nullptr;
    }

    return obj;
}

#include <vcmi/CGHeroInstance.h>
#include <vcmi/CGTownInstance.h>
#include <vcmi/CreatureInstance.h>
#include <vcmi/ResourceInstance.h>
#include <vcmi/SecondarySkill.h>
#include <vcmi/Spell.h>
#include <vcmi/Building.h>

void MapHandler::applyComplexProperties(CGObjectInstance* obj, const JsonNode& objJson) {
    if (!obj || !objJson.isRecord()) return;

    // 1. 处理英雄对象（最复杂）
    if (auto* hero = dynamic_cast<CGHeroInstance*>(obj)) {
        // 基础属性：经验、等级、名称
        if (objJson.hasKey("exp")) hero->exp = objJson["exp"].Integer();
        if (objJson.hasKey("level")) hero->level = objJson["level"].Integer();
        if (objJson.hasKey("name")) hero->nameCustomTextId = objJson["name"].String(); // 对应源码的 nameCustomTextId
        
        // 二级技能注入（源码中 secSkills 是 vector<pair<SecondarySkill, ui8>>）
        if (objJson.hasKey("skills")) {
            const auto& skillsJson = objJson["skills"].Vector();
            for (const auto& sJson : skillsJson) {
                if (!sJson.hasKey("id") || !sJson.hasKey("level")) continue;
                SecondarySkill skillId = SecondarySkill(sJson["id"].Integer());
                ui8 skillLevel = static_cast<ui8>(sJson["level"].Integer());
                // 先清空原有同技能，再添加（避免重复）
                hero->setSecSkillLevel(skillId, skillLevel, true); // abs=true 表示直接设置等级
            }
        }

        // 法术注入（源码中 spells 是 set<SpellID>）
        if (objJson.hasKey("spells")) {
            const auto& spellsJson = objJson["spells"].Vector();
            for (const auto& spJson : spellsJson) {
                SpellID spellId = SpellID(spJson.Integer());
                hero->addSpellToSpellbook(spellId); // 用源码提供的方法，而非直接 insert
            }
        }

        // 可选：法力、移动力、性别等扩展属性
        if (objJson.hasKey("mana")) hero->mana = objJson["mana"].Integer();
        if (objJson.hasKey("gender")) hero->gender = EHeroGender(objJson["gender"].Integer());
    }

    // 2. 处理城镇对象
    else if (auto* town = dynamic_cast<CGTownInstance*>(obj)) {
        if (objJson.hasKey("name")) town->setName(objJson["name"].String());
        if (objJson.hasKey("buildings")) {
            const auto& buildingsJson = objJson["buildings"].Vector();
            for (const auto& bJson : buildingsJson) {
                BuildingID buildingId = BuildingID(bJson.Integer());
                town->addBuilding(buildingId); // 调用源码的添加建筑方法
            }
        }
    }

    // 3. 处理怪物对象
    else if (auto* creature = dynamic_cast<CGCreatureInstance*>(obj)) {
        if (objJson.hasKey("count")) creature->count = objJson["count"].Integer();
    }

    // 4. 处理资源对象
    else if (auto* resource = dynamic_cast<CGResourceInstance*>(obj)) {
        if (objJson.hasKey("amount")) resource->amount = objJson["amount"].Integer();
    }

    // 可扩展：其他对象（如船只、宝物）的属性注入
}

bool MapHandler::assembleMapFromJson(const JsonNode& mapJson) {
    // 1. 基础地图配置（尺寸、名称等，保留你原有逻辑）
    if (mapJson.hasKey("width")) m_currentMap->width = mapJson["width"].Integer();
    if (mapJson.hasKey("height")) m_currentMap->height = mapJson["height"].Integer();
    if (mapJson.hasKey("name")) m_currentMap->setName(mapJson["name"].String());

    // 2. 批量创建并配置对象
    if (mapJson.hasKey("objects")) {
        const auto& objectsJson = mapJson["objects"].Vector();
        for (const auto& objJson : objectsJson) {
            // 必选字段校验
            if (!objJson.hasKey("id") || !objJson.hasKey("subId") || 
                !objJson.hasKey("x") || !objJson.hasKey("y") || !objJson.hasKey("z")) {
                log->warn("Invalid object JSON: missing required fields");
                continue;
            }

            // 解析坐标和对象ID
            int3 pos(
                objJson["x"].Integer(),
                objJson["y"].Integer(),
                objJson["z"].Integer()
            );
            int objId = objJson["id"].Integer();
            int subId = objJson["subId"].Integer();

            // 创建对象
            CGObjectInstance* obj = createObject(objId, subId, pos);
            if (!obj) continue;

            // 注入复杂属性
            applyComplexProperties(obj, objJson);

            // 更新本地缓存 + 视图同步
            this->addObject(obj); // 你的 MapHandler 原有缓存逻辑
        }
    }

    // 3. 关键：通知编辑器刷新视图
    if (MapController::getInstance()) {
        MapController::getInstance()->refreshMap();
    }

    log->info("Map assembled from JSON successfully, objects count: {}", this->getObjectsCount());
    return true;
}