#!/usr/bin/env python # -*- coding: utf-8 -*- import json import os import sys import re def format_coord(num): return round(float(num), 2) def calculate_distance(x1, y1, x2, y2): return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 # 定义区域排序顺序 REGION_ORDER = { "蒙德": 1, "璃月": 2, "稻妻": 3, "须弥": 4, "枫丹": 5, "纳塔": 6, "未知区域": 99 # 未知区域放最后 } def get_region_sort_key(region_name): """获取区域的排序键值，用于排序""" # 从完整区域名称（如"枫丹1-1"）中提取基本区域名称（如"枫丹"） base_region = re.match(r"^([^0-9]+)", region_name) if base_region: base_region = base_region.group(1) return REGION_ORDER.get(base_region, 99) return 99 def normalize_region_name(region_name, region_num, route_num, route_sub_num=None): """规范化区域名称，确保命名一致性 例如： - 标准格式: 蒙德3, 奔狼领, 2 -> 蒙德3-2 - 特殊格式: 蒙德2, 清泉镇, 4, 1 -> 蒙德2-4-1 """ if route_sub_num is not None: # 特殊格式 return f"{region_name}{region_num}-{route_num}-{route_sub_num}" else: # 标准格式 return f"{region_name}{region_num}-{route_num}" def is_same_region_base(region1, region2): """检查两个区域名称是否属于同一基本区域 例如，"蒙德2-4-1"和"蒙德2-4-2"属于同一基本区域"蒙德2-4" """ # 提取区域名称的基本部分（例如从"蒙德2-4-1"提取"蒙德2-4"） base_region1 = re.match(r"^([^-]+-\d+)", region1) base_region2 = re.match(r"^([^-]+-\d+)", region2) return (base_region1 and base_region2 and base_region1.group(1) == base_region2.group(1)) def parse_region_area_number(filename): """从文件名解析区域、地区和编号 支持两种格式: 1. 标准格式: 蒙德3-奔狼领-2.json -> ("蒙德", 3, "奔狼领", 2) 2. 特殊格式: 蒙德2-清泉镇-4-1.json -> ("蒙德", 2, "清泉镇", 4, 1) """ # 先尝试匹配特殊格式（带有额外连字符的格式） special_pattern = r"^([^0-9]+)(\d+)-(.+)-(\d+)-(\d+(?:\.\d+)?)\.json$" match = re.match(special_pattern, filename) if match: region_name = match.group(1) region_num = int(match.group(2)) area = match.group(3) route_num = int(match.group(4)) route_sub_num = int(match.group(5)) return region_name, region_num, area, route_num, route_sub_num # 如果不是特殊格式，尝试匹配标准格式 standard_pattern = r"^([^0-9]+)(\d+)-(.+)-(\d+(?:\.\d+)?)\.json$" match = re.match(standard_pattern, filename) if match: region_name = match.group(1) region_num = int(match.group(2)) area = match.group(3) route_num = int(match.group(4)) return region_name, region_num, area, route_num # 如果都不匹配，返回默认值 print(f"警告：无法解析文件名 {filename}") return None, None, None, None def generate_new_data_structure_from_pathing(): """直接从assets/pathing目录读取文件生成新的数据结构""" # 获取脚本所在目录 script_dir = os.path.dirname(os.path.abspath(__file__)) pathing_dir = os.path.join(script_dir, "assets", "pathing") target_dir = os.path.join(pathing_dir, "target") # 检查目录是否存在 if not os.path.exists(pathing_dir): print(f"错误：找不到路径目录 {pathing_dir}") return None # 初始化新数据结构，分开存储 blossom 和 teleport new_data = { "teleports": [], # 传送点节点 "blossoms": [], # 地脉花节点 "edges": [], # 边集合 "indexes": { "edgesBySource": {}, "edgesByTarget": {} } } # 创建独立的ID计数器和节点映射 next_teleport_id = 1 # 传送点专用ID计数器 next_blossom_id = 1000 # 地脉花专用ID计数器 teleport_nodes = {} # 按坐标存储传送点节点 (x, y) -> node_id target_nodes = {} # 按坐标存储目标点节点 (x, y) -> node_id # 创建文件路径映射 file_paths = {} # 第一遍：读取所有路径文件并创建节点 print("第一遍：读取路径文件并创建节点...") for root, _, files in os.walk(pathing_dir): for file in sorted(files): # 跳过非JSON文件和重运行文件 if not file.endswith('.json') or 'rerun' in file or 'rerun' in root: continue # 跳过target目录 if "target" in root.split(os.path.sep): continue file_path = os.path.join(root, file) try: with open(file_path, 'r', encoding='utf-8') as f: path_data = json.load(f) # 记录文件路径 relative_path = os.path.relpath(file_path, script_dir) relative_path = relative_path.replace("\\", "/") file_paths[file] = relative_path # 检查文件是否有position数据 if "positions" not in path_data or not path_data["positions"]: continue # 获取第一个位置点（通常是传送点） first_pos = path_data["positions"][0] if "type" in first_pos and first_pos["type"] == "teleport": x = format_coord(first_pos["x"]) y = format_coord(first_pos["y"]) # 解析区域信息 result = parse_region_area_number(file) if len(result) == 5: # 特殊格式 region_name, region_num, _, _, _ = result else: # 标准格式或无法解析 region_name, region_num, _, _ = result # 传送点仅显示区域名称，不显示编号 region = f"{region_name}" if region_name else "未知区域" # 检查是否已存在相同坐标的传送点 existing_node = False for coord, node_id in teleport_nodes.items(): if calculate_distance(coord[0], coord[1], x, y) < 10: # 将阈值从50降低到10 existing_node = True break if not existing_node: # 创建新的传送点节点 teleport_node = { "id": next_teleport_id, "region": region, "position": {"x": x, "y": y} } new_data["teleports"].append(teleport_node) teleport_nodes[(x, y)] = next_teleport_id next_teleport_id += 1 print(f" 创建传送点: ID={teleport_node['id']}, 区域={region}, 坐标=({x}, {y})") except Exception as e: print(f" 警告：处理文件 {file} 时出错: {e}") # 第二遍：读取target目录文件并创建目标节点 print("\n第二遍：读取target文件并创建目标节点...") for file in sorted(os.listdir(target_dir)): if not file.endswith('.json'): continue file_path = os.path.join(target_dir, file) try: with open(file_path, 'r', encoding='utf-8') as f: target_data = json.load(f) # 检查文件是否有position数据 if "positions" not in target_data or not target_data["positions"]: continue # 获取第一个位置点（通常是目标点） target_pos = target_data["positions"][0] x = format_coord(target_pos["x"]) y = format_coord(target_pos["y"]) result = parse_region_area_number(file) if len(result) == 5: # 特殊格式 region_name, region_num, area, route_num, route_sub_num = result # 使用规范化函数来生成区域名 region = normalize_region_name(region_name, region_num, route_num, route_sub_num) else: # 标准格式或无法解析 region_name, region_num, area, route_num = result # 使用规范化函数来生成区域名 region = normalize_region_name(region_name, region_num, route_num) if region_name and region_num and route_num else "未知区域" # 检查是否已存在相同坐标的目标点和相同区域名 existing_node = False existing_node_id = None for coord, node_id in target_nodes.items(): if calculate_distance(coord[0], coord[1], x, y) < 10: # 阈值为10 # 找到这个节点，检查它的区域是否与当前区域相同 for blossom in new_data["blossoms"]: if blossom["id"] == node_id: # 检查区域名完全相同 if blossom["region"] == region: existing_node = True existing_node_id = node_id break # 检查区域名基本部分是否相同（如"蒙德2-4"和"蒙德2-4-2"） # 提取区域名称的基本部分（例如从"蒙德2-4-1"提取"蒙德2-4"） current_base_region = re.match(r"^([^-]+-\d+)", region) existing_base_region = re.match(r"^([^-]+-\d+)", blossom["region"]) if (current_base_region and existing_base_region and current_base_region.group(1) == existing_base_region.group(1)): print(f" 注意: 坐标 ({x}, {y}) 与已存在节点 '{blossom['region']}' 区域基本部分相同，视为同一节点") existing_node = True existing_node_id = node_id break if not existing_node: print(f" 注意: 坐标 ({x}, {y}) 附近有另一个区域的节点，但将创建新节点") if not existing_node: # 创建新的目标点节点 target_node = { "id": next_blossom_id, "region": region, "position": {"x": x, "y": y} } new_data["blossoms"].append(target_node) target_nodes[(x, y)] = next_blossom_id next_blossom_id += 1 print(f" 创建目标点: ID={target_node['id']}, 区域={region}, 坐标=({x}, {y})") except Exception as e: print(f" 警告：处理目标文件 {file} 时出错: {e}") # 第三遍：创建边和索引 print("\n第三遍：创建边和索引...") for file in sorted(os.listdir(pathing_dir)): if not file.endswith('.json') or 'rerun' in file: continue # 跳过target和rerun目录中的文件 if file not in file_paths: continue # 解析文件名 result = parse_region_area_number(file) if len(result) == 5: # 特殊格式 region_name, region_num, area, route_num, route_sub_num = result else: # 标准格式 region_name, region_num, area, route_num = result route_sub_num = None if not region_name or not region_num or not area or not route_num: continue # 构建对应的target文件名 target_file = file # 检查target文件是否存在 target_path = os.path.join(target_dir, target_file) if not os.path.exists(target_path): print(f" 警告：找不到对应的目标文件 {target_file}") continue try: # 读取路径文件获取源传送点 file_path = os.path.join(pathing_dir, file) with open(file_path, 'r', encoding='utf-8') as f: path_data = json.load(f) # 读取目标文件获取目标点 with open(target_path, 'r', encoding='utf-8') as f: target_data = json.load(f) # 获取传送点坐标 if "positions" in path_data and path_data["positions"]: first_pos = path_data["positions"][0] source_x = format_coord(first_pos["x"]) source_y = format_coord(first_pos["y"]) # 获取目标点坐标 if "positions" in target_data and target_data["positions"]: target_pos = target_data["positions"][0] target_x = format_coord(target_pos["x"]) target_y = format_coord(target_pos["y"]) # 查找源节点ID source_id = None for coord, node_id in teleport_nodes.items(): if calculate_distance(coord[0], coord[1], source_x, source_y) < 10: # 将阈值从50降低到10 source_id = node_id break # 查找目标节点ID target_id = None for coord, node_id in target_nodes.items(): if calculate_distance(coord[0], coord[1], target_x, target_y) < 10: # 将阈值从50降低到10 target_id = node_id break # 如果找到了源节点和目标节点，创建边 if source_id and target_id: # 添加边 edge = { "source": source_id, "target": target_id, "route": file_paths[file], # 保存原始位置信息，用于在排序后更新ID（稍后会删除） "sourcePosition": { "x": source_x, "y": source_y }, "targetPosition": { "x": target_x, "y": target_y } } new_data["edges"].append(edge) # 更新索引 if str(source_id) not in new_data["indexes"]["edgesBySource"]: new_data["indexes"]["edgesBySource"][str(source_id)] = [] new_data["indexes"]["edgesBySource"][str(source_id)].append(target_id) if str(target_id) not in new_data["indexes"]["edgesByTarget"]: new_data["indexes"]["edgesByTarget"][str(target_id)] = [] new_data["indexes"]["edgesByTarget"][str(target_id)].append(source_id) print(f" 创建边: {source_id} -> {target_id}, 路径={file_paths[file]}") except Exception as e: print(f" 警告：处理边关系时出错 {file}: {e}") # 检查每个目标点是否至少有一条有向边 print("\n检查目标点的连通性...") orphaned_targets = [] for blossom in new_data["blossoms"]: target_id = blossom["id"] # 检查是否有边指向此目标点 has_edge = False for edge in new_data["edges"]: if edge["target"] == target_id: has_edge = True break if not has_edge: orphaned_targets.append(blossom) print(f" 警告: 目标点 ID={target_id}, 区域={blossom['region']}, 坐标=({blossom['position']['x']}, {blossom['position']['y']}) 没有入边") # 处理没有边的目标点 - 尝试使用连续编号的路径 if orphaned_targets: print(f"\n尝试为 {len(orphaned_targets)} 个孤立目标点寻找连续路径...") # 先按区域分组目标点 region_targets = {} for orphan in orphaned_targets: region = orphan["region"] if region not in region_targets: region_targets[region] = [] region_targets[region].append(orphan) # 然后按区域处理 for region, targets in region_targets.items(): print(f"\n处理区域 {region} 的 {len(targets)} 个孤立目标点...") # 获取该区域的所有边 region_edges = [] for edge in new_data["edges"]: # 找到起点对应的传送点 source_teleport = None for teleport in new_data["teleports"]: if teleport["id"] == edge["source"]: source_teleport = teleport break if source_teleport and source_teleport["region"] == region: region_edges.append(edge) if not region_edges: print(f" 区域 {region} 没有现有路径，无法连接孤立目标点") continue # 从每条边的路径中提取区域和编号 route_info = [] for edge in region_edges: route = edge["route"] file_name = os.path.basename(route) result = parse_region_area_number(file_name) if len(result) == 5: # 特殊格式 region_name, region_num, area, route_num, route_sub_num = result else: # 标准格式 region_name, region_num, area, route_num = result route_sub_num = None if region_name and region_num and area and route_num: info = { "edge": edge, "region_name": region_name, "region_num": region_num, "area": area, "route_num": route_num, "file_name": file_name } if route_sub_num is not None: info["route_sub_num"] = route_sub_num route_info.append(info) # 按区域和地区分组 area_routes = {} for info in route_info: key = f"{info['region_name']}{info['region_num']}-{info['area']}" if key not in area_routes: area_routes[key] = [] area_routes[key].append(info) # 对每个地区内的路线按编号排序 for key, routes in area_routes.items(): routes.sort(key=lambda x: x["route_num"]) # 查找区域内每个孤立目标点附近的路径 for orphan in targets: print(f" 处理目标点 ID={orphan['id']}, 坐标=({orphan['position']['x']}, {orphan['position']['y']})") # 找到最近的传送点 nearest_teleport = None min_distance = float('inf') for teleport in new_data["teleports"]: if teleport["region"] == orphan["region"]: distance = calculate_distance( teleport["position"]["x"], teleport["position"]["y"], orphan["position"]["x"], orphan["position"]["y"] ) if distance < min_distance: min_distance = distance nearest_teleport = teleport if not nearest_teleport: print(f" 未找到区域 {orphan['region']} 内的传送点") continue # 查找以这个传送点为起点的所有路径 teleport_routes = [] for key, routes in area_routes.items(): for info in routes: if info["edge"]["source"] == nearest_teleport["id"]: teleport_routes.append(info) if not teleport_routes: print(f" 未找到以传送点 ID={nearest_teleport['id']} 为起点的路径") continue # 按路线编号排序 teleport_routes.sort(key=lambda x: x["route_num"]) # 找到编号最大的路径 last_route = teleport_routes[-1] next_num = last_route["route_num"] + 1 print(f" 找到传送点 ID={nearest_teleport['id']} 的最后一条路径: {last_route['file_name']}") # 检查是否是特殊格式路径 if "-" in last_route['area']: # 特殊格式路径（如"清泉镇-4"） area_parts = last_route['area'].split("-") if len(area_parts) == 2: print(f" 建议手动创建新路径: {last_route['region_name']}{last_route['region_num']}-{area_parts[0]}-{area_parts[1]}-{next_num}.json") else: print(f" 建议手动创建新路径: {last_route['region_name']}{last_route['region_num']}-{last_route['area']}-{next_num}.json") else: # 标准格式路径 print(f" 建议手动创建新路径: {last_route['region_name']}{last_route['region_num']}-{last_route['area']}-{next_num}.json") print(f" 从传送点 ({nearest_teleport['position']['x']}, {nearest_teleport['position']['y']}) 到目标点 ({orphan['position']['x']}, {orphan['position']['y']})") # 按区域排序传送点和地脉花 print("\n按区域对节点进行排序...") # 对传送点按区域排序 new_data["teleports"] = sorted(new_data["teleports"], key=lambda x: get_region_sort_key(x["region"])) # 对地脉花按区域排序 new_data["blossoms"] = sorted(new_data["blossoms"], key=lambda x: get_region_sort_key(x["region"])) # 更新排序后的ID（可选） for i, teleport in enumerate(new_data["teleports"]): teleport["id"] = i + 1 for i, blossom in enumerate(new_data["blossoms"]): blossom["id"] = i + 1000 # 更新边的引用 for edge in new_data["edges"]: # 查找新的source ID for teleport in new_data["teleports"]: if calculate_distance(teleport["position"]["x"], teleport["position"]["y"], edge["sourcePosition"]["x"], edge["sourcePosition"]["y"]) < 10: edge["source"] = teleport["id"] break # 查找新的target ID for blossom in new_data["blossoms"]: if calculate_distance(blossom["position"]["x"], blossom["position"]["y"], edge["targetPosition"]["x"], edge["targetPosition"]["y"]) < 10: edge["target"] = blossom["id"] break # 在更新ID后删除位置信息 print("\n删除边数据中的位置信息...") for edge in new_data["edges"]: if "sourcePosition" in edge: del edge["sourcePosition"] if "targetPosition" in edge: del edge["targetPosition"] # 按照target的顺序排列edges print("\n按照目标节点(target)的顺序排列边...") new_data["edges"] = sorted(new_data["edges"], key=lambda x: x["target"]) # 创建节点到节点的顺序边 sequential_edges_count = create_sequential_edges(new_data) # 重新排序所有边（包括新的顺序边） print("\n重新排序所有边...") new_data["edges"] = sorted(new_data["edges"], key=lambda x: (x.get("type", "teleport"), x["target"])) # 重建索引 new_data["indexes"] = { "edgesBySource": {}, "edgesByTarget": {} } for edge in new_data["edges"]: source_id = edge["source"] target_id = edge["target"] if str(source_id) not in new_data["indexes"]["edgesBySource"]: new_data["indexes"]["edgesBySource"][str(source_id)] = [] new_data["indexes"]["edgesBySource"][str(source_id)].append(target_id) if str(target_id) not in new_data["indexes"]["edgesByTarget"]: new_data["indexes"]["edgesByTarget"][str(target_id)] = [] new_data["indexes"]["edgesByTarget"][str(target_id)].append(source_id) # 保存新数据结构 output_file = os.path.join(script_dir, "LeyLineOutcropData.json") with open(output_file, 'w', encoding='utf-8') as f: json.dump(new_data, f, ensure_ascii=False, indent=2) print(f"\n已生成新的数据结构: {output_file}") print(f"传送点数量: {len(new_data['teleports'])}") print(f"地脉花数量: {len(new_data['blossoms'])}") print(f"总节点数量: {len(new_data['teleports']) + len(new_data['blossoms'])}") print(f"传送点到地脉花边数量: {len([e for e in new_data['edges'] if e.get('type', 'teleport') == 'teleport'])}") print(f"节点间顺序边数量: {sequential_edges_count}") print(f"总边数量: {len(new_data['edges'])}") print(f"区域排序顺序: {', '.join([k for k, v in sorted(REGION_ORDER.items(), key=lambda item: item[1]) if v < 99])}") # 报告孤立目标点 remaining_orphans = 0 orphaned_blossoms = [] for blossom in new_data["blossoms"]: target_id = blossom["id"] has_edge = False for edge in new_data["edges"]: if edge["target"] == target_id: has_edge = True break if not has_edge: remaining_orphans += 1 orphaned_blossoms.append(blossom) if remaining_orphans > 0: print(f"\n注意: 仍有 {remaining_orphans} 个目标点没有入边") print("这些目标点按区域排序如下:") # 按区域分组展示孤立目标点 orphaned_by_region = {} for orphan in orphaned_blossoms: region = orphan["region"] base_region = re.match(r"^([^0-9]+)", region) if base_region: base_region = base_region.group(1) if base_region not in orphaned_by_region: orphaned_by_region[base_region] = [] orphaned_by_region[base_region].append(orphan) # 按照指定顺序显示区域 for region_name, _ in sorted(REGION_ORDER.items(), key=lambda item: item[1]): if region_name in orphaned_by_region: print(f"\n {region_name}区域的孤立目标点:") for orphan in orphaned_by_region[region_name]: print(f" ID={orphan['id']}, 区域={orphan['region']}, 坐标=({orphan['position']['x']}, {orphan['position']['y']})") print("\n请按照之前的建议手动创建连续编号的路径文件") else: print("\n✓ 所有目标点都至少有一条入边") return new_data def create_sequential_edges(new_data): """创建节点到节点的顺序边，实现正确的分支逻辑 正确的分支规则： 1. 主路线到分支: 蒙德2-3 → 蒙德2-4-1, 蒙德2-4-2 2. 分支到同序号分支: 蒙德2-4-1 → 蒙德2-5-1 (优先) → 蒙德2-5 (备选) → 终点 3. 分支到同序号分支: 蒙德2-4-2 → 蒙德2-5-2 (优先) → 蒙德2-5 (备选) → 终点 4. 分支内部不连接: 蒙德2-4-1 和 蒙德2-4-2 之间不相互连接 5. 主路线到主路线: 当没有分支时的直接连接 基于实际路径文件查找对应的路线 """ print("\n创建节点到节点的顺序边...") script_dir = os.path.dirname(os.path.abspath(__file__)) pathing_dir = os.path.join(script_dir, "assets", "pathing") # 按基本区域分组地脉花节点（区域名+区域编号，如"蒙德2"） region_groups = {} for blossom in new_data["blossoms"]: region = blossom["region"] parts = region.split("-") if len(parts) >= 2: # 提取基本区域名：区域名+区域编号（如"蒙德2"） import re match = re.match(r'^([^0-9]+)(\d+)', parts[0]) if match: region_name = match.group(1) # 如 "蒙德" region_num = match.group(2) # 如 "2" base_region = region_name + region_num # 如 "蒙德2" if base_region not in region_groups: region_groups[base_region] = [] region_groups[base_region].append(blossom) # 创建地脉花节点的映射：region -> blossom region_to_blossom = {} for blossom in new_data["blossoms"]: region_to_blossom[blossom["region"]] = blossom # 收集所有存在的路径文件 available_routes = {} for root, _, files in os.walk(pathing_dir): for file in sorted(files): if not file.endswith('.json') or 'rerun' in file or 'rerun' in root: continue if "target" in root.split(os.path.sep): continue relative_path = os.path.relpath(os.path.join(root, file), script_dir) relative_path = relative_path.replace("\\", "/") available_routes[file] = relative_path sequential_edges = [] # 为每个区域创建顺序边 for base_region, blossoms in region_groups.items(): print(f"\n处理区域: {base_region}") # 将节点分为主路线和分支路线 main_routes = {} # {route_num: blossom} branch_routes = {} # {route_num: {branch_num: blossom}} for blossom in blossoms: region = blossom["region"] parts = region.split("-") if len(parts) == 2: # 主路线格式："蒙德2-3" try: route_num = int(parts[1]) main_routes[route_num] = blossom print(f" 主路线: {region} (路线{route_num})") except ValueError: print(f" 警告：无法解析主路线编号: {region}") elif len(parts) == 3: # 分支路线格式："蒙德2-4-1" try: route_num = int(parts[1]) branch_num = int(parts[2]) if route_num not in branch_routes: branch_routes[route_num] = {} branch_routes[route_num][branch_num] = blossom print(f" 分支路线: {region} (路线{route_num}, 分支{branch_num})") except ValueError: print(f" 警告：无法解析分支路线编号: {region}") print(f" 找到 {len(main_routes)} 个主路线，{len(branch_routes)} 个分支组") # 辅助函数：查找路径文件 def find_route_file(source_region, target_region): # 从目标区域推断文件名 result = None print(f" 查找路径文件: {source_region} → {target_region}") for blossom in new_data["blossoms"]: if blossom["region"] == target_region: # 尝试通过目标区域构造文件名 parts = target_region.split("-") print(f" 目标区域部分: {parts}") if len(parts) == 2: # 主路线 # 例如: 蒙德2-3 -> 蒙德2-xxx-3.json pattern = f"-{parts[1]}.json" print(f" 主路线模式: {pattern}") for filename in available_routes.keys(): if pattern in filename and parts[0] in filename: result = available_routes[filename] print(f" 找到匹配文件: {filename} -> {result}") break elif len(parts) == 3: # 分支路线 # 例如: 蒙德2-4-1 -> 蒙德2-xxx-4-1.json pattern = f"-{parts[1]}-{parts[2]}.json" print(f" 分支路线模式: {pattern}") for filename in available_routes.keys(): if pattern in filename and parts[0] in filename: result = available_routes[filename] print(f" 找到匹配文件: {filename} -> {result}") break if not result: print(f" 警告：未找到匹配的路径文件") print(f" 可用文件: {list(available_routes.keys())[:10]}...") # 只显示前10个 break return result# 1. 创建主路线到分支路线的连接 for main_route_num, main_blossom in main_routes.items(): # 找到下一个路线号，看是否有分支 next_route_num = main_route_num + 1 if next_route_num in branch_routes: # 连接到下一个路线号的所有分支 for branch_num, branch_blossom in branch_routes[next_route_num].items(): route_file = find_route_file(main_blossom["region"], branch_blossom["region"]) if route_file: edge = { "source": main_blossom["id"], "target": branch_blossom["id"], "route": route_file } sequential_edges.append(edge) print(f" 主路线到分支: {main_blossom['region']} → {branch_blossom['region']}") # 2. 创建分支到下一个分支的连接（同序号优先） for route_num, branches in branch_routes.items(): next_route_num = route_num + 1 for branch_num, branch_blossom in branches.items(): # 优先连接到同序号的下一个分支 target_found = False # 第一优先级：同序号分支 (蒙德2-4-1 → 蒙德2-5-1) if next_route_num in branch_routes and branch_num in branch_routes[next_route_num]: target_blossom = branch_routes[next_route_num][branch_num] route_file = find_route_file(branch_blossom["region"], target_blossom["region"]) if route_file: edge = { "source": branch_blossom["id"], "target": target_blossom["id"], "route": route_file } sequential_edges.append(edge) print(f" 分支到同序号分支: {branch_blossom['region']} → {target_blossom['region']}") target_found = True # 第二优先级：主路线 (蒙德2-4-1 → 蒙德2-5) if not target_found and next_route_num in main_routes: target_blossom = main_routes[next_route_num] route_file = find_route_file(branch_blossom["region"], target_blossom["region"]) if route_file: edge = { "source": branch_blossom["id"], "target": target_blossom["id"], "route": route_file } sequential_edges.append(edge) print(f" 分支到主路线: {branch_blossom['region']} → {target_blossom['region']}") target_found = True # 如果没有找到目标，则为路线终点 if not target_found: print(f" 分支终点: {branch_blossom['region']} (无下一个目标)") # 3. 创建主路线到主路线的连接（当没有分支时） sorted_main_routes = sorted(main_routes.keys()) for i in range(len(sorted_main_routes) - 1): current_route = sorted_main_routes[i] next_route = sorted_main_routes[i + 1] # 只有在下一个路线没有分支时，才创建主路线到主路线的连接 if next_route not in branch_routes: source_blossom = main_routes[current_route] target_blossom = main_routes[next_route] route_file = find_route_file(source_blossom["region"], target_blossom["region"]) if route_file: edge = { "source": source_blossom["id"], "target": target_blossom["id"], "route": route_file } sequential_edges.append(edge) print(f" 主路线连接: {source_blossom['region']} → {target_blossom['region']}") # 将新的顺序边添加到数据中 new_data["edges"].extend(sequential_edges) print(f"\n总共创建了 {len(sequential_edges)} 条顺序边") return len(sequential_edges) def test_filename_parsing(): """测试文件名解析功能，确保能正确处理各种格式""" test_files = [ "蒙德1-风啸山岭-1.json", # 标准格式 "璃月3-轻策庄-2.json", # 标准格式 "蒙德2-清泉镇-4-1.json", # 特殊格式（双连字符数字） "须弥2-须弥城-3-2.json", # 特殊格式 "纳塔1-区域-5.5.json" # 小数点路线编号 ] print("测试文件名解析结果:") for filename in test_files: result = parse_region_area_number(filename) if len(result) == 5: # 特殊格式 region_name, region_num, area, route_num, route_sub_num = result print(f"文件: {filename} (特殊格式)") print(f" 区域名称: {region_name}") print(f" 区域编号: {region_num}") print(f" 地区: {area}") print(f" 路线编号: {route_num}") print(f" 路线子编号: {route_sub_num}") else: # 标准格式 region_name, region_num, area, route_num = result print(f"文件: {filename} (标准格式)") print(f" 区域名称: {region_name}") print(f" 区域编号: {region_num}") print(f" 地区: {area}") print(f" 路线编号: {route_num}") # 测试格式化逻辑 if region_name and region_num and route_num: if len(result) == 5: # 特殊格式 route_sub_num = result[4] # 特殊格式显示为: 蒙德2-5-1 (区域名-区域编号-路线编号-路线子编号) formatted = f"{region_name}{region_num}-{int(route_num)}-{int(route_sub_num)}" else: # 标准格式 # 标准格式显示为: 枫丹1-1 (区域名-区域编号-路线编号) formatted = f"{region_name}{region_num}-{int(route_num)}" print(f" 格式化区域: {formatted}") else: print(f" 解析失败") print("") if __name__ == "__main__": # 测试文件名解析 if len(sys.argv) > 1 and sys.argv[1] == "--test": test_filename_parsing() else: generate_new_data_structure_from_pathing()