@yangrunchi/a_6 1.0.0

package/AutoNetMsg/A5_generate-funcdata.js

@@ -0,0 +1,1021 @@
+// -- 作者: 杨润池
+// -- 日期: 2025年10月23日
+// -- 版本: 2.6
+// -- 描述: 从 NetMsgCfg.lua 生成 funcData 类（区分请求和响应，只添加新方法），并生成管理器，自动提交SVN
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const os = require('os');
+
+// ==================== 配置 ====================
+
+const bPath = path.join(__dirname, '../../../dev/GUILayout/ssrgame/net', 'NetMsgCfg.lua');
+const ssrgameRoot = path.join(__dirname, '../../../dev/GUILayout/ssrgame');
+const funcDataDir = path.join(ssrgameRoot, 'funcData');
+const mgrDir = path.join(ssrgameRoot, 'mgr');
+
+// 标记定义（统一管理，避免硬编码）
+const MARKERS = {
+    requestStart: '--------------------------------自动生成 ↓↓↓ 请求方法 ↓↓↓ start---------------------------------------',
+    requestEnd: '--------------------------------自动生成 ↓↓↓ 请求方法 ↓↓↓ end---------------------------------------',
+    responseStart: '--------------------------------自动生成 ↓↓↓ 响应方法 ↓↓↓ start---------------------------------------',
+    responseEnd: '--------------------------------自动生成 ↓↓↓ 响应方法 ↓↓↓ end---------------------------------------'
+};
+
+// 读取排除模块配置
+const excludeModulesPath = path.join(__dirname, 'A4_exclude_modules.json');
+let excludeModules = new Set(['Global', 'sync', 'ssrNetMsgCfg', 'test']);
+
+try {
+    if (fs.existsSync(excludeModulesPath)) {
+        const excludeConfig = JSON.parse(fs.readFileSync(excludeModulesPath, 'utf-8'));
+        excludeModules = new Set(excludeConfig.excludeModules || []);
+        console.log('✅ 已加载排除模块配置:', Array.from(excludeModules));
+    } else {
+        console.log('⚠️ 未找到排除模块配置文件，使用默认排除列表');
+    }
+} catch (err) {
+    console.log('⚠️ 读取排除模块配置失败，使用默认排除列表');
+}
+
+// 读取数据类模板
+const dataTemplatePath = path.join(__dirname, 'A4_template_3.txt');
+let dataTemplate = '';
+
+try {
+    dataTemplate = fs.readFileSync(dataTemplatePath, 'utf-8');
+    console.log('✅ 已加载数据类模板: A4_template_3.txt');
+} catch (err) {
+    console.error(`❌ 数据类模板不存在: ${dataTemplatePath}`);
+    process.exit(1);
+}
+
+// 读取管理器模板
+const managerTemplatePath = path.join(__dirname, 'A4_template_4.txt');
+let managerTemplate = '';
+
+try {
+    managerTemplate = fs.readFileSync(managerTemplatePath, 'utf-8');
+    console.log('✅ 已加载管理器模板: A4_template_4.txt');
+} catch (err) {
+    console.error(`❌ 管理器模板不存在: ${managerTemplatePath}`);
+    process.exit(1);
+}
+
+// 读取配置
+let config = { author: "杨润池" };
+try {
+    const configPath = path.join(__dirname, '../AutoCode/A1_996_config.json');
+    if (fs.existsSync(configPath)) {
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        config = JSON.parse(configContent);
+        console.log('✅ 已加载配置, 作者:', config.author);
+    }
+} catch (err) {
+    console.log('⚠️ 未找到配置文件，使用默认配置');
+}
+
+console.log('🚀 开始生成 funcData 类...');
+console.log('📁 协议文件:', bPath);
+console.log('📁 数据类输出目录:', funcDataDir);
+console.log('📁 管理器输出目录:', mgrDir);
+
+// ==================== 辅助函数 ====================
+function getDateTime() {
+    const d = new Date();
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    const hours = String(d.getHours()).padStart(2, '0');
+    const minutes = String(d.getMinutes()).padStart(2, '0');
+    const seconds = String(d.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+function getShortIP() {
+    try {
+        const interfaces = os.networkInterfaces();
+        for (const name of Object.keys(interfaces)) {
+            for (const iface of interfaces[name]) {
+                if (iface.family === 'IPv4' && !iface.internal) {
+                    const parts = iface.address.split('.');
+                    if (parts.length === 4) {
+                        return `${parts[2]}.${parts[3]}`;
+                    }
+                    return iface.address;
+                }
+            }
+        }
+    } catch (err) { }
+    return 'local';
+}
+
+function getCommitMessage(action, fileName, responseCount, requestCount) {
+    const ip = getShortIP();
+    const author = config.author;
+    const respInfo = responseCount ? `响应+${responseCount}` : '';
+    const reqInfo = requestCount ? `请求+${requestCount}` : '';
+    const methodInfo = [respInfo, reqInfo].filter(s => s).join(',');
+    return `[Auto] ${action} ${fileName}${methodInfo ? ` (${methodInfo})` : ''} ${author}@${ip}`;
+}
+
+function commitToSvn(filePath, action, responseCount = 0, requestCount = 0) {
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+
+    try {
+        const fileName = path.basename(filePath);
+
+        let isVersioned = false;
+        try {
+            execSync(`svn info "${filePath}"`, { stdio: 'ignore' });
+            isVersioned = true;
+        } catch (err) {
+            isVersioned = false;
+        }
+
+        if (!isVersioned) {
+            console.log(`   📝 添加新文件: ${fileName}`);
+            execSync(`svn add "${filePath}"`, { stdio: 'ignore' });
+        }
+
+        const statusOutput = execSync(`svn status "${filePath}"`, { encoding: 'utf8' });
+        const needCommit = statusOutput.trim().length > 0 &&
+            (statusOutput.trim().startsWith('M') || statusOutput.trim().startsWith('A'));
+
+        if (needCommit) {
+            const commitMsg = getCommitMessage(action, fileName, responseCount, requestCount);
+            console.log(`   📤 提交: ${fileName} - ${commitMsg}`);
+            execSync(`svn commit "${filePath}" -m "${commitMsg}"`, { stdio: 'ignore' });
+            return true;
+        }
+        return false;
+    } catch (error) {
+        console.log(`   ⚠️ 提交失败: ${error.message}`);
+        return false;
+    }
+}
+
+// 判断方法类型
+function isResponseMethod(methodName) {
+    if (methodName.includes('Request')) return false;
+    if (methodName.includes('Response')) return true;
+    if (methodName.startsWith('Sync')) return true;
+    if (methodName.startsWith('On')) return true;
+    return false;
+}
+
+function isRequestMethod(methodName) {
+    if (methodName.includes('Request')) return true;
+    if (methodName.startsWith('Send')) return true;
+    if (methodName.startsWith('Req')) return true;
+    return false;
+}
+
+// 解析协议，提取模块的响应和请求方法
+function parseModulesWithProtocols(content) {
+    const modules = new Map();
+    const processedKeys = new Set(); // 去重
+
+    const modulePattern = /ssrNetMsgCfg\.(\w+)\s*=\s*"(\w+)"/g;
+    let match;
+
+    while ((match = modulePattern.exec(content)) !== null) {
+        const moduleName = match[1];
+        if (!excludeModules.has(moduleName)) {
+            if (!modules.has(moduleName)) {
+                modules.set(moduleName, { responseMethods: [], requestMethods: [] });
+            }
+        }
+    }
+
+    const methodPattern = /ssrNetMsgCfg\.(\w+)_(\w+)\s*=\s*(\d+)(?:\s*--\s*(.+))?/g;
+    while ((match = methodPattern.exec(content)) !== null) {
+        const moduleName = match[1];
+        const methodName = match[2];
+        const protocolId = match[3];
+        const comment = match[4] || '';
+        const fullKey = `${moduleName}_${methodName}`;
+
+        // 去重检查
+        if (processedKeys.has(fullKey)) {
+            console.log(`   ⚠️ 重复协议定义: ${fullKey}，跳过`);
+            continue;
+        }
+        processedKeys.add(fullKey);
+
+        if (!excludeModules.has(moduleName)) {
+            if (!modules.has(moduleName)) {
+                modules.set(moduleName, { responseMethods: [], requestMethods: [] });
+            }
+
+            const module = modules.get(moduleName);
+            const methodInfo = {
+                name: methodName,
+                protocolId: parseInt(protocolId),
+                fullKey: fullKey,
+                comment: comment.trim()
+            };
+
+            if (isResponseMethod(methodName)) {
+                module.responseMethods.push(methodInfo);
+            } else if (isRequestMethod(methodName)) {
+                module.requestMethods.push(methodInfo);
+            } else {
+                console.log(`   ⚠️ 无法识别方法类型: ${moduleName}_${methodName}`);
+            }
+        }
+    }
+
+    // 排序
+    for (const [_, module] of modules) {
+        module.responseMethods.sort((a, b) => a.protocolId - b.protocolId);
+        module.requestMethods.sort((a, b) => a.protocolId - b.protocolId);
+    }
+
+    return modules;
+}
+
+// 生成响应方法代码
+function generateResponseMethods(methods, moduleName) {
+    if (!methods || methods.length === 0) return '';
+
+    const methodLines = [];
+    for (const method of methods) {
+        const methodName = method.name;
+        const comment = method.comment || `${methodName} 协议响应处理`;
+
+        methodLines.push(`--- ${comment}
+function ${moduleName}Data:${methodName}(arg1, arg2, arg3, data)
+    -- TODO: 处理 ${methodName} 协议
+    -- ssrPrintNet("${moduleName}Data_${methodName}", arg1, arg2, arg3,data)
+end`);
+    }
+    return methodLines.join('\n\n');
+}
+
+// 生成请求方法代码
+function generateRequestMethods(methods, moduleName) {
+    if (!methods || methods.length === 0) return '';
+
+    const methodLines = [];
+    for (const method of methods) {
+        const methodName = method.name;
+        const comment = method.comment || `${methodName} 协议请求发送`;
+
+        methodLines.push(`--- ${comment}
+function ${moduleName}Data:${methodName}(arg1, arg2, arg3, data)
+    ssrMessage:sendmsg(ssrNetMsgCfg.${moduleName}_${methodName}, arg1, arg2, arg3, data)
+end`);
+    }
+    return methodLines.join('\n\n');
+}
+
+// 生成模块类（新文件用）
+function generateModuleClass(moduleName, moduleData, author, template) {
+    const responseMethods = generateResponseMethods(moduleData.responseMethods, moduleName);
+    const requestMethods = generateRequestMethods(moduleData.requestMethods, moduleName);
+
+    return template
+        .replace(/\{AUTHOR\}/g, author)
+        .replace(/\{DATETIME\}/g, getDateTime())
+        .replace(/\{CLASSNAME\}/g, moduleName + "Data")
+        .replace(/\{MODULE_NAME\}/g, moduleName)
+        .replace(/\{RESPONSE_METHODS\}/g, responseMethods || '    -- 暂无响应方法')
+        .replace(/\{REQUEST_METHODS\}/g, requestMethods || '    -- 暂无请求方法');
+}
+
+// ==================== 修复后的合并函数 ====================
+
+// 验证文件结构是否有效
+function isFileStructureValid(content) {
+    // 检查所有标记是否都存在
+    for (const [key, marker] of Object.entries(MARKERS)) {
+        if (content.indexOf(marker) === -1) {
+            return { valid: false, reason: `缺少标记: ${key}` };
+        }
+    }
+
+    // 检查标记顺序是否正确
+    const requestStartIdx = content.indexOf(MARKERS.requestStart);
+    const requestEndIdx = content.indexOf(MARKERS.requestEnd);
+    const responseStartIdx = content.indexOf(MARKERS.responseStart);
+    const responseEndIdx = content.indexOf(MARKERS.responseEnd);
+
+    if (requestStartIdx > requestEndIdx) {
+        return { valid: false, reason: '请求开始标记在结束标记之后' };
+    }
+    if (responseStartIdx > responseEndIdx) {
+        return { valid: false, reason: '响应开始标记在结束标记之后' };
+    }
+    if (requestEndIdx > responseStartIdx) {
+        return { valid: false, reason: '请求区域应在响应区域之前' };
+    }
+
+    return { valid: true };
+}
+
+// 精确提取指定区域的方法（推荐使用）
+function extractMethodsFromSection(section, className) {
+    const methods = new Map();
+    if (!section || section.trim().length === 0) return methods;
+
+    // 匹配从可选注释行到 end 的完整方法块
+    const methodPattern = new RegExp(
+        `(?:---[^\\n]*\\n)?` +                    // 可选的注释行
+        `function\\s+${className}:(\\w+)\\s*\\([^)]*\\)[\\n\\r]+` +
+        `([\\s\\S]*?)` +
+        `[\\n\\r]+end(?=[\\n\\r]+|$)`,
+        'gm'
+    );
+
+    let match;
+    while ((match = methodPattern.exec(section)) !== null) {
+        const methodName = match[1];
+        const fullMethod = match[0].trim();
+
+        if (!methods.has(methodName)) {
+            methods.set(methodName, fullMethod);
+        }
+    }
+
+    console.log(`   📋 提取到 ${methods.size} 个方法: ${Array.from(methods.keys()).join(', ') || '无'}`);
+    return methods;
+}
+
+// 获取标记区域的边界（修复版）
+function getMarkerBoundaries(content) {
+    const boundaries = {};
+
+    boundaries.requestStartIdx = content.indexOf(MARKERS.requestStart);
+    boundaries.requestEndIdx = content.indexOf(MARKERS.requestEnd);
+    boundaries.responseStartIdx = content.indexOf(MARKERS.responseStart);
+    boundaries.responseEndIdx = content.indexOf(MARKERS.responseEnd);
+
+    // 验证所有标记都存在
+    for (const [key, idx] of Object.entries(boundaries)) {
+        if (idx === -1) {
+            console.log(`   ⚠️ 未找到标记: ${key}`);
+            return null;
+        }
+    }
+
+    boundaries.requestStartLength = MARKERS.requestStart.length;
+    boundaries.requestEndLength = MARKERS.requestEnd.length;
+    boundaries.responseStartLength = MARKERS.responseStart.length;
+    boundaries.responseEndLength = MARKERS.responseEnd.length;
+
+    // 调试：打印边界位置
+    console.log(`   📍 标记边界: 请求区域(${boundaries.requestStartIdx}-${boundaries.requestEndIdx}), 响应区域(${boundaries.responseStartIdx}-${boundaries.responseEndIdx})`);
+
+    return boundaries;
+}
+
+// 智能合并：添加新方法、删除已移除的方法、自动移除占位符
+function mergeWithExisting(existingContent, newResponseContent, newRequestContent, moduleName) {
+    if (!existingContent) return null;
+
+    // 检查文件结构
+    const structureCheck = isFileStructureValid(existingContent);
+    if (!structureCheck.valid) {
+        console.log(`   ⚠️ 文件结构无效: ${structureCheck.reason}，将重新生成`);
+        return null;
+    }
+
+    const className = moduleName + 'Data';
+    const boundaries = getMarkerBoundaries(existingContent);
+
+    if (!boundaries) {
+        console.log(`   ⚠️ 未找到完整的标记区域，将重新生成`);
+        return null;
+    }
+
+    // 提取现有内容
+    let existingRequestSection = '';
+    let existingResponseSection = '';
+    let middleSection = '';
+
+    try {
+        existingRequestSection = existingContent.substring(
+            boundaries.requestStartIdx + boundaries.requestStartLength,
+            boundaries.requestEndIdx
+        );
+
+        middleSection = existingContent.substring(
+            boundaries.requestEndIdx + boundaries.requestEndLength,
+            boundaries.responseStartIdx
+        );
+
+        existingResponseSection = existingContent.substring(
+            boundaries.responseStartIdx + boundaries.responseStartLength,
+            boundaries.responseEndIdx
+        );
+
+        console.log(`   📏 请求区域长度: ${existingRequestSection.length}, 响应区域长度: ${existingResponseSection.length}`);
+
+    } catch (err) {
+        console.log(`   ⚠️ 提取区域失败: ${err.message}`);
+        return null;
+    }
+
+    // 提取现有方法
+    console.log(`   🔍 解析现有响应方法...`);
+    const existingResponses = extractMethodsFromSection(existingResponseSection, className);
+    console.log(`   🔍 解析现有请求方法...`);
+    const existingRequests = extractMethodsFromSection(existingRequestSection, className);
+
+    // 解析新方法（从生成的代码中提取）
+    console.log(`   🔍 解析新响应方法...`);
+    const newResponses = extractMethodsFromSection(newResponseContent, className);
+    console.log(`   🔍 解析新请求方法...`);
+    const newRequests = extractMethodsFromSection(newRequestContent, className);
+
+    console.log(`   📋 协议中的响应方法: ${Array.from(newResponses.keys()).join(', ') || '无'}`);
+    console.log(`   📋 协议中的请求方法: ${Array.from(newRequests.keys()).join(', ') || '无'}`);
+
+    // 找出需要添加和删除的方法
+    const toAddResponses = [];
+    const toAddRequests = [];
+    const toRemoveResponses = [];
+    const toRemoveRequests = [];
+
+    // 检查需要删除的响应方法（存在于文件但不在协议中）
+    for (const [name] of existingResponses) {
+        if (!newResponses.has(name)) {
+            toRemoveResponses.push(name);
+            console.log(`   ❌ 删除响应方法: ${name} (协议中已移除)`);
+        }
+    }
+
+    // 检查需要删除的请求方法
+    for (const [name] of existingRequests) {
+        if (!newRequests.has(name)) {
+            toRemoveRequests.push(name);
+            console.log(`   ❌ 删除请求方法: ${name} (协议中已移除)`);
+        }
+    }
+
+    // 添加新响应方法
+    for (const [name, code] of newResponses) {
+        if (!existingResponses.has(name)) {
+            toAddResponses.push({ name, code });
+            console.log(`   ➕ 新增响应方法: ${name}`);
+        } else {
+            console.log(`   ⏭️ 响应方法已存在，跳过: ${name}`);
+        }
+    }
+
+    // 添加新请求方法
+    for (const [name, code] of newRequests) {
+        if (!existingRequests.has(name)) {
+            toAddRequests.push({ name, code });
+            console.log(`   ➕ 新增请求方法: ${name}`);
+        } else {
+            console.log(`   ⏭️ 请求方法已存在，跳过: ${name}`);
+        }
+    }
+
+    // 标记是否有变化
+    let hasChanges = false;
+    let newRequestSection = existingRequestSection;
+    let newResponseSection = existingResponseSection;
+
+    // 删除需要移除的请求方法
+    for (const name of toRemoveRequests) {
+        const methodRegex = new RegExp(
+            `(?:---[^\\r\\n]*[\\r\\n]+)?` +
+            `function\\s+${className}:${name}\\s*\\([^)]*\\)[\\r\\n]+` +
+            `[\\s\\S]*?[\\r\\n]+end(?=[\\r\\n]+|$)`,
+            'gm'
+        );
+        newRequestSection = newRequestSection.replace(methodRegex, '');
+        hasChanges = true;
+        console.log(`   🗑️ 已删除请求方法: ${name}`);
+    }
+
+    // 删除需要移除的响应方法
+    for (const name of toRemoveResponses) {
+        const methodRegex = new RegExp(
+            `(?:---[^\\r\\n]*[\\r\\n]+)?` +
+            `function\\s+${className}:${name}\\s*\\([^)]*\\)[\\r\\n]+` +
+            `[\\s\\S]*?[\\r\\n]+end(?=[\\r\\n]+|$)`,
+            'gm'
+        );
+        newResponseSection = newResponseSection.replace(methodRegex, '');
+        hasChanges = true;
+        console.log(`   🗑️ 已删除响应方法: ${name}`);
+    }
+
+    // 清理删除后可能留下的多余空行
+    newRequestSection = newRequestSection.replace(/\n{3,}/g, '\n\n');
+    newResponseSection = newResponseSection.replace(/\n{3,}/g, '\n\n');
+
+    // 【关键修复】只有真正要添加请求方法时，才移除占位符
+    if (toAddRequests.length > 0 && existingRequests.size === 0) {
+        const placeholderPattern = /^[\s]*--\s*暂无请求方法[\s]*\n?/gm;
+        if (placeholderPattern.test(newRequestSection)) {
+            newRequestSection = newRequestSection.replace(placeholderPattern, '');
+            hasChanges = true;
+            console.log(`   🗑️ 移除占位符: -- 暂无请求方法`);
+        }
+    }
+
+    // 【关键修复】只有真正要添加响应方法时，才移除占位符
+    if (toAddResponses.length > 0 && existingResponses.size === 0) {
+        const placeholderPattern = /^[\s]*--\s*暂无响应方法[\s]*\n?/gm;
+        if (placeholderPattern.test(newResponseSection)) {
+            newResponseSection = newResponseSection.replace(placeholderPattern, '');
+            hasChanges = true;
+            console.log(`   🗑️ 移除占位符: -- 暂无响应方法`);
+        }
+    }
+
+    // 添加新方法到请求区域
+    if (toAddRequests.length > 0) {
+        if (newRequestSection.trim().length > 0 && !newRequestSection.endsWith('\n')) {
+            newRequestSection += '\n';
+        }
+        if (newRequestSection.trim().length > 0 && !newRequestSection.endsWith('\n\n')) {
+            newRequestSection += '\n';
+        }
+        newRequestSection += toAddRequests.map(m => m.code).join('\n\n');
+        if (!newRequestSection.endsWith('\n')) {
+            newRequestSection += '\n';
+        }
+        hasChanges = true;
+    }
+
+    // 添加新方法到响应区域
+    if (toAddResponses.length > 0) {
+        if (newResponseSection.trim().length > 0 && !newResponseSection.endsWith('\n')) {
+            newResponseSection += '\n';
+        }
+        if (newResponseSection.trim().length > 0 && !newResponseSection.endsWith('\n\n')) {
+            newResponseSection += '\n';
+        }
+        newResponseSection += toAddResponses.map(m => m.code).join('\n\n');
+        if (!newResponseSection.endsWith('\n')) {
+            newResponseSection += '\n';
+        }
+        hasChanges = true;
+    }
+
+    // 清理多余空行（保留最多一个空行）
+    newRequestSection = newRequestSection.replace(/\n\s*\n/g, '\n');     // 多个空行变一个
+    newRequestSection = newRequestSection.replace(/^\s*\n/, '');         // 删除开头的空行
+    newRequestSection = newRequestSection.replace(/\n\s*$/, '\n');        // 确保末尾只有一个换行
+
+    newResponseSection = newResponseSection.replace(/\n\s*\n/g, '\n');
+    newResponseSection = newResponseSection.replace(/^\s*\n/, '');
+    newResponseSection = newResponseSection.replace(/\n\s*$/, '\n\n');    // 末尾加两个换行（一个空行）
+
+    // 确保区域不为空（添加占位符）
+    if (!newRequestSection.trim()) {
+        newRequestSection = '    -- 暂无请求方法\n';
+        hasChanges = true;
+        console.log(`   📝 添加占位符: -- 暂无请求方法`);
+    }
+
+    if (!newResponseSection.trim()) {
+        newResponseSection = '    -- 暂无响应方法\n';
+        hasChanges = true;
+        console.log(`   📝 添加占位符: -- 暂无响应方法`);
+    }
+
+    // 如果没有变化，返回null
+    if (!hasChanges) {
+        console.log(`   ⏭️ 没有新方法需要添加，也没有旧方法需要删除`);
+        return null;
+    }
+
+    // 重新组装文件
+    const headerPart = existingContent.substring(0, boundaries.requestStartIdx);
+    const afterResponsePart = existingContent.substring(boundaries.responseEndIdx + boundaries.responseEndLength);
+
+    const newContent = headerPart +
+        MARKERS.requestStart + '\n' +
+        newRequestSection +
+        MARKERS.requestEnd +
+        middleSection +
+        MARKERS.responseStart + '\n' +
+        newResponseSection +
+        MARKERS.responseEnd +
+        afterResponsePart;
+
+    // 输出变更统计
+    console.log(`   📊 变更统计: 响应(+${toAddResponses.length}/-${toRemoveResponses.length}) 请求(+${toAddRequests.length}/-${toRemoveRequests.length})`);
+
+    return {
+        content: newContent,
+        newResponseCount: toAddResponses.length,
+        newRequestCount: toAddRequests.length,
+        removedResponseCount: toRemoveResponses.length,
+        removedRequestCount: toRemoveRequests.length
+    };
+}
+
+// 深度修复文件（处理各种异常情况）
+function deepFixFile(filePath, className) {
+    console.log(`   🔧 执行深度修复: ${path.basename(filePath)}`);
+
+    let content = fs.readFileSync(filePath, 'utf8');
+    let fixed = false;
+    const originalContent = content;
+
+    // 1. 移除重复的标记区域，只保留第一次出现的
+    for (const [key, marker] of Object.entries(MARKERS)) {
+        const regex = new RegExp(marker.replace(/[-]/g, '\\-'), 'g');
+        let firstOccurrence = true;
+        content = content.replace(regex, (match) => {
+            if (firstOccurrence) {
+                firstOccurrence = false;
+                return match;
+            }
+            fixed = true;
+            console.log(`   🗑️ 移除重复标记: ${key}`);
+            return '';
+        });
+    }
+
+    // 2. 确保标记顺序正确（请求在前，响应在后）
+    const requestStartIdx = content.indexOf(MARKERS.requestStart);
+    const responseStartIdx = content.indexOf(MARKERS.responseStart);
+
+    if (requestStartIdx > responseStartIdx && requestStartIdx !== -1 && responseStartIdx !== -1) {
+        console.log(`   ⚠️ 标记顺序错误，正在修正...`);
+        fixed = true;
+
+        const beforeFirst = content.substring(0, Math.min(requestStartIdx, responseStartIdx));
+        const requestSection = content.substring(requestStartIdx, content.indexOf(MARKERS.requestEnd) + MARKERS.requestEnd.length);
+        const responseSection = content.substring(responseStartIdx, content.indexOf(MARKERS.responseEnd) + MARKERS.responseEnd.length);
+        const afterLast = content.substring(Math.max(
+            content.indexOf(MARKERS.requestEnd) + MARKERS.requestEnd.length,
+            content.indexOf(MARKERS.responseEnd) + MARKERS.responseEnd.length
+        ));
+
+        content = beforeFirst + requestSection + '\n' + responseSection + afterLast;
+    }
+
+    // 3. 清理响应区域中的请求方法（移到请求区域）
+    const responseStart = content.indexOf(MARKERS.responseStart);
+    const responseEnd = content.indexOf(MARKERS.responseEnd);
+
+    if (responseStart !== -1 && responseEnd !== -1 && responseStart < responseEnd) {
+        const beforeResponse = content.substring(0, responseStart + MARKERS.responseStart.length);
+        let responseSection = content.substring(responseStart + MARKERS.responseStart.length, responseEnd);
+        const afterResponse = content.substring(responseEnd);
+
+        const requestMethodRegex = /(---[^\n]*\nfunction\s+\w+Data:Request\w+\([\s\S]*?\nend)/g;
+        const movedMethods = [];
+
+        responseSection = responseSection.replace(requestMethodRegex, (match) => {
+            movedMethods.push(match);
+            fixed = true;
+            return '';
+        });
+
+        if (movedMethods.length > 0) {
+            console.log(`   📦 将 ${movedMethods.length} 个请求方法移回请求区域`);
+
+            const requestStart = content.indexOf(MARKERS.requestStart);
+            const requestEndIdx = content.indexOf(MARKERS.requestEnd);
+
+            if (requestStart !== -1 && requestEndIdx !== -1) {
+                const beforeRequest = content.substring(0, requestEndIdx);
+                const afterRequest = content.substring(requestEndIdx);
+                const newRequestSection = '\n' + movedMethods.join('\n\n') + '\n';
+                content = beforeRequest + newRequestSection + afterRequest;
+            }
+        }
+
+        content = beforeResponse + '\n' + responseSection + '\n' + afterResponse;
+    }
+
+    // 4. 清理请求区域中的响应方法（移到响应区域）
+    const requestStart = content.indexOf(MARKERS.requestStart);
+    const requestEndIdx = content.indexOf(MARKERS.requestEnd);
+
+    if (requestStart !== -1 && requestEndIdx !== -1 && requestStart < requestEndIdx) {
+        const beforeRequest = content.substring(0, requestStart + MARKERS.requestStart.length);
+        let requestSection = content.substring(requestStart + MARKERS.requestStart.length, requestEndIdx);
+        const afterRequest = content.substring(requestEndIdx);
+
+        const responseMethodRegex = /(---[^\n]*\nfunction\s+\w+Data:Response\w+\([\s\S]*?\nend)/g;
+        const movedMethods = [];
+
+        requestSection = requestSection.replace(responseMethodRegex, (match) => {
+            movedMethods.push(match);
+            fixed = true;
+            return '';
+        });
+
+        if (movedMethods.length > 0) {
+            console.log(`   📦 将 ${movedMethods.length} 个响应方法移回响应区域`);
+
+            const responseStartIdx = content.indexOf(MARKERS.responseStart);
+            const responseEndIdx = content.indexOf(MARKERS.responseEnd);
+
+            if (responseStartIdx !== -1 && responseEndIdx !== -1) {
+                const beforeResponse = content.substring(0, responseEndIdx);
+                const afterResponse = content.substring(responseEndIdx);
+                const newResponseSection = '\n' + movedMethods.join('\n\n') + '\n';
+                content = beforeResponse + newResponseSection + afterResponse;
+            }
+        }
+
+        content = beforeRequest + '\n' + requestSection + '\n' + afterRequest;
+    }
+
+    // 5. 去重：每个区域内的重复方法
+    const classNamePattern = className || path.basename(filePath, '.lua');
+
+    for (const markerType of ['request', 'response']) {
+        const startMarker = MARKERS[markerType + 'Start'];
+        const endMarker = MARKERS[markerType + 'End'];
+        const startIdx = content.indexOf(startMarker);
+        const endIdx = content.indexOf(endMarker);
+
+        if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+            const before = content.substring(0, startIdx + startMarker.length);
+            const section = content.substring(startIdx + startMarker.length, endIdx);
+            const after = content.substring(endIdx);
+
+            const methods = extractMethodsFromSection(section, classNamePattern);
+            const uniqueMethods = Array.from(methods.values()).join('\n\n');
+
+            if (uniqueMethods !== section.trim()) {
+                content = before + '\n' + uniqueMethods + '\n' + after;
+                fixed = true;
+                console.log(`   🗑️ 已清理 ${markerType} 区域的重复方法`);
+            }
+        }
+    }
+
+    if (fixed) {
+        const backupPath = filePath + '.backup_' + Date.now();
+        fs.writeFileSync(backupPath, originalContent, 'utf8');
+        fs.writeFileSync(filePath, content, 'utf8');
+        console.log(`   ✅ 深度修复完成，备份文件: ${path.basename(backupPath)}`);
+        return true;
+    }
+
+    console.log(`   ✅ 文件结构正常，无需修复`);
+    return false;
+}
+
+// 验证并修复已存在的文件
+function validateAndFixFile(filePath) {
+    if (!fs.existsSync(filePath)) return false;
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const className = path.basename(filePath, '.lua');
+
+    let hasIssue = false;
+
+    // 检查是否有重复的标记区域
+    for (const [key, marker] of Object.entries(MARKERS)) {
+        const regex = new RegExp(marker.replace(/[-]/g, '\\-'), 'g');
+        const count = (content.match(regex) || []).length;
+        if (count !== 1) {
+            console.log(`   ⚠️ 检测到标记重复: ${key} (出现 ${count} 次)`);
+            hasIssue = true;
+        }
+    }
+
+    // 检查标记是否都存在
+    for (const [key, marker] of Object.entries(MARKERS)) {
+        if (content.indexOf(marker) === -1) {
+            console.log(`   ⚠️ 检测到缺少标记: ${key}`);
+            hasIssue = true;
+        }
+    }
+
+    // 检查响应区域中是否有请求方法
+    const responseStartIdx = content.indexOf(MARKERS.responseStart);
+    const responseEndIdx = content.indexOf(MARKERS.responseEnd);
+    if (responseStartIdx !== -1 && responseEndIdx !== -1 && responseStartIdx < responseEndIdx) {
+        const responseSection = content.substring(responseStartIdx, responseEndIdx);
+        if (responseSection.match(/function\s+\w+Data:Request\w+\(/)) {
+            console.log(`   ⚠️ 检测到响应区域包含请求方法`);
+            hasIssue = true;
+        }
+    }
+
+    // 检查请求区域中是否有响应方法
+    const requestStartIdx = content.indexOf(MARKERS.requestStart);
+    const requestEndIdx = content.indexOf(MARKERS.requestEnd);
+    if (requestStartIdx !== -1 && requestEndIdx !== -1 && requestStartIdx < requestEndIdx) {
+        const requestSection = content.substring(requestStartIdx, requestEndIdx);
+        if (requestSection.match(/function\s+\w+Data:Response\w+\(/)) {
+            console.log(`   ⚠️ 检测到请求区域包含响应方法`);
+            hasIssue = true;
+        }
+    }
+
+    if (hasIssue) {
+        console.log(`   🔧 检测到文件异常，执行深度修复...`);
+        return deepFixFile(filePath, className);
+    }
+
+    return false;
+}
+
+// 生成管理器类
+function generateManagerClass(modules, author, template) {
+    const dateTime = getDateTime();
+    const moduleNames = Array.from(modules.keys())
+        .filter(name => modules.get(name).responseMethods.length > 0 || modules.get(name).requestMethods.length > 0)
+        .sort();
+
+    let requireLines = '';
+    if (moduleNames.length > 0) {
+        requireLines = moduleNames.map(name => {
+            return `    ---@type ${name}Data\n    ssrFuncDataMgr.${name}Data = SL:Require("GUILayout/ssrgame/funcData/${name}Data", true)`;
+        }).join('\n');
+    } else {
+        requireLines = '    -- 暂无模块';
+    }
+
+    return template
+        .replace(/\{AUTHOR\}/g, author)
+        .replace(/\{DATETIME\}/g, dateTime)
+        .replace(/\{REQUIRE_LINES\}/g, requireLines);
+}
+
+function hasManagerContentChanged(managerPath, newContent) {
+    if (!fs.existsSync(managerPath)) {
+        return true;
+    }
+    try {
+        const oldContent = fs.readFileSync(managerPath, 'utf-8');
+        const normalize = (c) => c.split('\n').filter(l => !l.includes('-- 日期:')).join('\n');
+        return normalize(oldContent) !== normalize(newContent);
+    } catch (err) {
+        return true;
+    }
+}
+
+// ==================== 主流程 ====================
+function main() {
+    if (!fs.existsSync(bPath)) {
+        console.error(`❌ NetMsgCfg.lua 不存在: ${bPath}`);
+        console.log('   请先运行 A4_sync-netmsg.js 同步协议');
+        process.exit(1);
+    }
+
+    console.log('\n=== 解析协议阶段 ===');
+    const content = fs.readFileSync(bPath, 'utf8');
+    const modules = parseModulesWithProtocols(content);
+
+    console.log(`📋 解析到 ${modules.size} 个模块`);
+
+    let totalResponseMethods = 0;
+    let totalRequestMethods = 0;
+    for (const [name, module] of modules) {
+        totalResponseMethods += module.responseMethods.length;
+        totalRequestMethods += module.requestMethods.length;
+        if (module.responseMethods.length > 0 || module.requestMethods.length > 0) {
+            console.log(`   📦 ${name}: 响应${module.responseMethods.length}个, 请求${module.requestMethods.length}个`);
+        }
+    }
+    console.log(`📡 共 ${totalResponseMethods} 个响应方法, ${totalRequestMethods} 个请求方法`);
+
+    // 创建目录
+    if (!fs.existsSync(funcDataDir)) {
+        fs.mkdirSync(funcDataDir, { recursive: true });
+        console.log(`📁 创建目录: ${funcDataDir}`);
+    }
+    if (!fs.existsSync(mgrDir)) {
+        fs.mkdirSync(mgrDir, { recursive: true });
+        console.log(`📁 创建目录: ${mgrDir}`);
+    }
+
+    // 验证现有文件（修复之前可能存在的问题）
+    console.log('\n=== 验证现有文件阶段 ===');
+    if (fs.existsSync(funcDataDir)) {
+        const existingFiles = fs.readdirSync(funcDataDir).filter(f => f.endsWith('Data.lua'));
+        for (const file of existingFiles) {
+            const filePath = path.join(funcDataDir, file);
+            if (validateAndFixFile(filePath)) {
+                console.log(`   ✅ 已修复: ${file}`);
+            }
+        }
+    }
+
+    // 生成数据类
+    console.log('\n=== 生成 funcData 阶段 ===');
+    let generatedCount = 0, updatedCount = 0, skippedCount = 0;
+    let committedFiles = [];
+
+    for (const [moduleName, moduleData] of modules) {
+        if (moduleData.responseMethods.length === 0 && moduleData.requestMethods.length === 0) {
+            skippedCount++;
+            continue;
+        }
+
+        const fileName = `${moduleName}Data.lua`;
+        const filePath = path.join(funcDataDir, fileName);
+        const newResponseContent = generateResponseMethods(moduleData.responseMethods, moduleName);
+        const newRequestContent = generateRequestMethods(moduleData.requestMethods, moduleName);
+
+        if (fs.existsSync(filePath)) {
+            console.log(`\n📄 处理: ${fileName}`);
+
+            // 再次验证并修复当前文件
+            validateAndFixFile(filePath);
+
+            const existingContent = fs.readFileSync(filePath, 'utf8');
+            const mergeResult = mergeWithExisting(existingContent, newResponseContent, newRequestContent, moduleName);
+
+            if (mergeResult) {
+                // 备份原文件
+                const backupPath = filePath + '.backup';
+                fs.writeFileSync(backupPath, existingContent, 'utf8');
+
+                try {
+                    fs.writeFileSync(filePath, mergeResult.content, 'utf8');
+                    console.log(`   ✅ 更新完成 (新增响应${mergeResult.newResponseCount}个, 请求${mergeResult.newRequestCount}个)`);
+                    updatedCount++;
+
+                    // 删除备份
+                    fs.unlinkSync(backupPath);
+
+                    if (commitToSvn(filePath, '更新', mergeResult.newResponseCount, mergeResult.newRequestCount)) {
+                        committedFiles.push(fileName);
+                    }
+                } catch (err) {
+                    console.log(`   ❌ 写入失败，正在恢复备份...`);
+                    if (fs.existsSync(backupPath)) {
+                        fs.writeFileSync(filePath, fs.readFileSync(backupPath, 'utf8'), 'utf8');
+                        fs.unlinkSync(backupPath);
+                    }
+                    throw err;
+                }
+            } else {
+                console.log(`   ⏭️ 无需更新`);
+                skippedCount++;
+            }
+        } else {
+            const fullContent = generateModuleClass(moduleName, moduleData, config.author, dataTemplate);
+            fs.writeFileSync(filePath, fullContent, 'utf8');
+            console.log(`✅ 生成: ${fileName} (响应${moduleData.responseMethods.length}个, 请求${moduleData.requestMethods.length}个)`);
+            generatedCount++;
+            if (commitToSvn(filePath, '创建', moduleData.responseMethods.length, moduleData.requestMethods.length)) {
+                committedFiles.push(fileName);
+            }
+        }
+    }
+
+    console.log(`\n📊 数据类统计: 新增 ${generatedCount}, 更新 ${updatedCount}, 跳过 ${skippedCount}`);
+    if (committedFiles.length > 0) {
+        console.log(`📤 已提交: ${committedFiles.join(', ')}`);
+    }
+
+    // 生成管理器
+    console.log('\n=== 生成管理器阶段 ===');
+    const managerPath = path.join(mgrDir, 'FuncDataMgr.lua');
+    const managerContent = generateManagerClass(modules, config.author, managerTemplate);
+    const hasModules = Array.from(modules.keys()).some(name =>
+        modules.get(name).responseMethods.length > 0 || modules.get(name).requestMethods.length > 0
+    );
+
+    if (hasModules) {
+        const needCommit = !fs.existsSync(managerPath) || hasManagerContentChanged(managerPath, managerContent);
+
+        if (needCommit) {
+            fs.writeFileSync(managerPath, managerContent, 'utf8');
+            const action = !fs.existsSync(managerPath) ? '创建' : '更新';
+            const registeredCount = Array.from(modules.keys()).filter(name =>
+                modules.get(name).responseMethods.length > 0 || modules.get(name).requestMethods.length > 0
+            ).length;
+            console.log(`✅ ${action}管理器: ${managerPath}`);
+            console.log(`📋 管理器注册了 ${registeredCount} 个模块`);
+
+            if (commitToSvn(managerPath, action, registeredCount)) {
+                console.log(`📤 已提交: FuncDataMgr.lua`);
+            }
+        } else {
+            console.log(`✨ 管理器内容无变化，跳过提交`);
+        }
+    } else {
+        console.log(`⚠️ 没有可注册的模块，跳过生成管理器`);
+    }
+
+    console.log('\n🎉 所有操作完成！');
+}
+
+if (require.main === module) {
+    main();
+}
+
+module.exports = {
+    parseModulesWithProtocols,
+    generateModuleClass,
+    mergeWithExisting,
+    generateManagerClass,
+    commitToSvn,
+    validateAndFixFile,
+    deepFixFile
+};