VCMI地图编辑器JSON功能开发Debug总结

// 修正 GBK 编码名称（Ubuntu 上兼容写法）
else if (fromEncoding == "gbk")
{
    try
    {
        // 尝试 Ubuntu 上的 GBK locale 名称（小写）
        std::wstring_convert<std::codecvt_byname<wchar_t, char, std::mbstate_t>> converter(
            new std::codecvt_byname<wchar_t, char, std::mbstate_t>("zh_CN.gbk")
        );
        std::wstring wideStr = converter.from_bytes(str);
        return converter.to_bytes(wideStr);
    }
    catch (...)
    {
        // 若小写失败，尝试大写
        std::wstring_convert<std::codecvt_byname<wchar_t, char, std::mbstate_t>> converter(
            new std::codecvt_byname<wchar_t, char, std::mbstate_t>("zh_CN.GBK")
        );
        std::wstring wideStr = converter.from_bytes(str);
        return converter.to_bytes(wideStr);
    }
}

#include <iostream>
#include <string>
#include <cstring>
#include <locale>
#include <codecvt>
#include <vector>

// 复制之前的 isUtf8、convertToUtf8、fixMapStringEncoding 三个函数到这里

int main()
{
    // 测试用例：模拟不同编码的地图名/描述
    std::vector<std::pair<std::string, std::string>> testCases = {
        // 测试 1：UTF-8 编码（"测试地图"）
        {u8"测试地图", "UTF-8 测试"},
        // 测试 2：Windows-1252 编码（"Elven Forest" 带特殊字符 é）
        {std::string({0x45, 0x6C, 0x76, 0x65, 0x6E, 0x20, 0x46, 0x6F, 0x72, 0x65, 0x73, 0x74, 0xE9}), "Windows-1252 测试"},
        // 测试 3：ISO-8859-1 编码（"Desert Map"）
        {std::string({0x44, 0x65, 0x73, 0x65, 0x72, 0x74, 0x20, 0x4D, 0x61, 0x70}), "ISO-8859-1 测试"},
        // 测试 4：GBK 编码（"中文地图"，GBK 十六进制：0xD6 0xD0 0xCE 0xC4 0xB5 0xD8 0xCD 0xBC）
        {std::string({0xD6, 0xD0, 0xCE, 0xC4, 0xB5, 0xD8, 0xCD, 0xBC}), "GBK 测试"}
    };

    std::cout << "=== 编码识别与转换测试 ===\n";
    for (auto &test : testCases)
    {
        std::string original = test.first;
        std::string desc = test.second;
        std::string fixed = fixMapStringEncoding(original);

        std::cout << "\n" << desc << ":\n";
        std::cout << "原字符串（十六进制）: ";
        for (unsigned char c : original)
            printf("%02X ", c);
        std::cout << "\n转换后（UTF-8）: " << fixed << "\n";
        std::cout << "是否为合法 UTF-8: " << (isUtf8(fixed) ? "是" : "否") << "\n";
    }

    return 0;
}

#include <string>
#include <cstdio>
#include <iostream>

// 辅助函数：用 iconv 执行编码转换（Ubuntu 上最可靠）
std::string convertWithIconv(const std::string &input, const std::string &from, const std::string &to)
{
    // 构造 iconv 命令
    std::string cmd = "echo -n \"" + input + "\" | iconv -f " + from + " -t " + to + " 2>/dev/null";
    FILE *pipe = popen(cmd.c_str(), "r");
    if (!pipe) return input;

    char buffer[1024];
    std::string result;
    while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
    {
        result += buffer;
    }
    pclose(pipe);
    return result;
}

// 核心修复函数：处理 Heroes 3 乱码（假 UTF-8 → 原始 Windows-1252 → 真 UTF-8）
std::string fixHeroes3Encoding(const std::string &corruptedStr)
{
    // 第一步：把「假 UTF-8」转回原始 Windows-1252 字节
    std::string win1252Str = convertWithIconv(corruptedStr, "utf-8", "windows-1252");
    if (win1252Str.empty()) return corruptedStr;

    // 第二步：把原始 Windows-1252 转成真正 UTF-8
    std::string utf8Str = convertWithIconv(win1252Str, "windows-1252", "utf-8");
    return utf8Str.empty() ? corruptedStr : utf8Str;
}

std::string fixMapStringEncoding(const std::string &originalStr)
{
    if (isUtf8(originalStr))
        return originalStr;

    // 优先尝试 Windows-1252（Heroes 3 原生编码，你的乱码就是这个）
    std::string utf8Str = convertToUtf8(originalStr, "windows-1252");
    if (isUtf8(utf8Str))
        return utf8Str;

    // 再尝试 ISO-8859-1
    utf8Str = convertToUtf8(originalStr, "iso-8859-1");
    if (isUtf8(utf8Str))
        return utf8Str;

    // 最后尝试 GBK（中文地图）
    utf8Str = convertToUtf8(originalStr, "gbk");
    if (isUtf8(utf8Str))
        return utf8Str;

    return originalStr;
}

// MapController.cpp
#include "MapController.h"
#include "CMap.h"
#include "FileOperations.h" // VCMI 原生文件操作头文件
#include "JsonSerializeFormat.h"

// 导出 JSON：先通过原生接口加载 .h3m 地图，再导出
void MapController::exportH3mToJson(const std::string &h3mFilePath, const std::string &jsonFilePath)
{
    // 1. 调用 VCMI 原生 openInternal 加载 .h3m 地图（获取 CMap 指针）
    // openInternal 是 VCMI 内部加载地图的核心接口，自动处理 .h3m 解析、内存初始化
    if (!openInternal(h3mFilePath))
    {
        logGlobal->error("Failed to load H3M map: %s", h3mFilePath.c_str());
        return;
    }

    // 2. 加载成功，获取 CMap 指针（_map 是 MapController 的成员变量，openInternal 已初始化）
    if (!_map)
    {
        logGlobal->error("CMap pointer is null after loading H3M");
        return;
    }

    // 3. 处理地图名和描述的编码识别与转换
    std::string mapName = fixMapStringEncoding(_map->name.toString());
    std::string mapDesc = fixMapStringEncoding(_map->description.toString());

    // 4. 后续 JSON 导出逻辑（复用之前的框架，替换为正确编码的 name/desc）
    JsonNode root;
    auto &rootStruct = root.Struct();

    // 写入正确编码的地图名和描述
    rootStruct["name"] = JsonNode(mapName);
    rootStruct["description"] = JsonNode(mapDesc);
    rootStruct["width"] = JsonNode(static_cast<double>(_map->width));
    rootStruct["height"] = JsonNode(static_cast<double>(_map->height));
    rootStruct["twoLevel"] = JsonNode(_map->twoLevel);

    // （后续地形、对象导出逻辑不变，直接复用之前的代码）
    // ... 地形独立文件导出、objects 序列化 ...

    // 写入 JSON 文件
    std::ofstream os(jsonFilePath);
    if (os.is_open())
    {
        os << root.toString(true);
        os.close();
        logGlobal->info("Successfully exported H3M to JSON: %s", jsonFilePath.c_str());
    }
    else
    {
        logGlobal->error("Failed to open JSON file for writing: %s", jsonFilePath.c_str());
    }
}

#include <string>
#include <cstring>
#include <locale>
#include <codecvt>

// 辅助函数：判断字符串是否为合法 UTF-8
bool isUtf8(const std::string &str)
{
    const char *ptr = str.c_str();
    const char *end = ptr + str.size();
    while (ptr < end)
    {
        if (*ptr >= 0) // 单字节（0xxxxxxx）
        {
            ptr++;
        }
        else if ((ptr[0] & 0xE0) == 0xC0 && ptr+1 < end) // 双字节（110xxxxx 10xxxxxx）
        {
            if ((ptr[1] & 0xC0) != 0x80) return false;
            ptr += 2;
        }
        else if ((ptr[0] & 0xF0) == 0xE0 && ptr+2 < end) // 三字节（1110xxxx 10xxxxxx 10xxxxxx）
        {
            if ((ptr[1] & 0xC0) != 0x80 || (ptr[2] & 0xC0) != 0x80) return false;
            ptr += 3;
        }
        else if ((ptr[0] & 0xF8) == 0xF0 && ptr+3 < end) // 四字节（11110xxx 10xxxxxx 10xxxxxx 10xxxxxx）
        {
            if ((ptr[1] & 0xC0) != 0x80 || (ptr[2] & 0xC0) != 0x80 || (ptr[3] & 0xC0) != 0x80) return false;
            ptr += 4;
        }
        else
        {
            return false; // 非法 UTF-8 序列
        }
    }
    return true;
}

// 辅助函数：编码转换（Windows-1252/ISO-8859-1/GBK → UTF-8）
std::string convertToUtf8(const std::string &str, const std::string &fromEncoding)
{
    try
    {
        // Windows-1252 编码（.h3m 最常见）
        if (fromEncoding == "windows-1252")
        {
            std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
            std::wstring wideStr;
            for (char c : str)
            {
                wideStr.push_back(static_cast<wchar_t>(static_cast<unsigned char>(c)));
            }
            return converter.to_bytes(wideStr);
        }
        // ISO-8859-1（Latin-1），与 Windows-1252 前 128 字符兼容
        else if (fromEncoding == "iso-8859-1")
        {
            return convertToUtf8(str, "windows-1252"); // 直接复用 Windows-1252 转换
        }
        // GBK（中文地图）
        else if (fromEncoding == "gbk")
        {
            std::wstring_convert<std::codecvt_byname<wchar_t, char, std::mbstate_t>> converter(
                new std::codecvt_byname<wchar_t, char, std::mbstate_t>("zh_CN.GBK")
            );
            std::wstring wideStr = converter.from_bytes(str);
            return converter.to_bytes(wideStr);
        }
    }
    catch (...)
    {
        logGlobal->warn("Failed to convert string from encoding: %s", fromEncoding.c_str());
    }
    return str; // 转换失败则返回原字符串
}

// 核心函数：自动识别编码并修复为 UTF-8
std::string fixMapStringEncoding(const std::string &originalStr)
{
    // 1. 先判断是否已为合法 UTF-8（直接返回）
    if (isUtf8(originalStr))
    {
        logGlobal->debug("String is already valid UTF-8");
        return originalStr;
    }

    // 2. 尝试 Windows-1252（.h3m 主流编码）
    std::string utf8Str = convertToUtf8(originalStr, "windows-1252");
    if (isUtf8(utf8Str) && !utf8Str.empty())
    {
        logGlobal->debug("String encoding identified as Windows-1252, converted to UTF-8");
        return utf8Str;
    }

    // 3. 尝试 ISO-8859-1
    utf8Str = convertToUtf8(originalStr, "iso-8859-1");
    if (isUtf8(utf8Str) && !utf8Str.empty())
    {
        logGlobal->debug("String encoding identified as ISO-8859-1, converted to UTF-8");
        return utf8Str;
    }

    // 4. 最后尝试 GBK（中文地图）
    utf8Str = convertToUtf8(originalStr, "gbk");
    if (isUtf8(utf8Str) && !utf8Str.empty())
    {
        logGlobal->debug("String encoding identified as GBK, converted to UTF-8");
        return utf8Str;
    }

    // 5. 所有编码都不匹配，返回原字符串（加警告）
    logGlobal->warn("Failed to identify string encoding, returning original");
    return originalStr;
}

// 调用示例：将 test.h3m 导出为 test.json（自动处理编码）
mapController.exportH3mToJson("/path/to/test.h3m", "/path/to/test.json");