pyscreeps-arena 0.3.6__py3-none-any.whl → 0.5.7.1__py3-none-any.whl

pyscreeps_arena/compiler.py

@@ -9,6 +9,7 @@ import chardet
 import subprocess
 import pyperclip
 from colorama import Fore
+from typing import List, Optional, Tuple, Union
 
 WAIT = Fore.YELLOW + ">>>" + Fore.RESET
 GREEN = Fore.GREEN + "{}" + Fore.RESET
@@ -16,6 +17,27 @@ python_version_info = sys.version_info
 python_version_info = f"{python_version_info.major}.{python_version_info.minor}.{python_version_info.micro}"
 
 
+def replace_src_prefix(file_list):
+    """
+    将列表中以'./src.'开头的字符串替换为'./'
+
+    参数:
+        file_list: 字符串列表
+
+    返回:
+        替换后的新列表
+    """
+    _ = []
+    
+    for item in file_list:
+        if isinstance(item, str) and item.startswith('./src.'):
+            _new = item.replace('./src.', './', 1)
+            if _new in file_list:
+                continue
+        _.append(item)
+    
+    return _
+
 # def InsertPragmaBefore(content:str) -> str:
 #     """
 #     在content的开头插入__pragma__('noalias', 'undefined')等内容 |
@@ -43,7 +65,7 @@ class Compiler_Const:
 
     TOTAL_INSERT_AT_HEAD = """
 import { createConstructionSite, findClosestByPath, findClosestByRange, findInRange, findPath, getCpuTime, getDirection, getHeapStatistics, getObjectById, getObjects, getObjectsByPrototype, getRange, getTerrainAt, getTicks,} from 'game/utils';
-import { ConstructionSite, Creep, GameObject, OwnedStructure, Resource, Source, Structure, StructureContainer, StructureExtension, StructureRampart, StructureRoad, StructureSpawn, StructureWall, StructureTower} from 'game/prototypes';
+import { ConstructionSite as GameConstructionSite, Creep as GameCreep, GameObject as GameObjectProto, OwnedStructure, Resource as GameResource, Source as GameSource, Structure as GameStructure, StructureContainer as GameStructureContainer, StructureExtension as GameStructureExtension, StructureRampart as GameStructureRampart, StructureRoad as GameStructureRoad, StructureSpawn as GameStructureSpawn, StructureWall as GameStructureWall, StructureTower as GameStructureTower, Flag as GameFlag} from 'game/prototypes';
 import { ATTACK, ATTACK_POWER, BODYPART_COST, BODYPART_HITS, BOTTOM, BOTTOM_LEFT, BOTTOM_RIGHT, BUILD_POWER, CARRY, CARRY_CAPACITY, CONSTRUCTION_COST, CONSTRUCTION_COST_ROAD_SWAMP_RATIO, CONSTRUCTION_COST_ROAD_WALL_RATIO, CONTAINER_CAPACITY, CONTAINER_HITS, CREEP_SPAWN_TIME, DISMANTLE_COST, DISMANTLE_POWER, ERR_BUSY, ERR_FULL, ERR_INVALID_ARGS, ERR_INVALID_TARGET, ERR_NAME_EXISTS, ERR_NOT_ENOUGH_ENERGY, ERR_NOT_ENOUGH_EXTENSIONS, ERR_NOT_ENOUGH_RESOURCES, ERR_NOT_FOUND, ERR_NOT_IN_RANGE, ERR_NOT_OWNER, ERR_NO_BODYPART, ERR_NO_PATH, ERR_TIRED, EXTENSION_ENERGY_CAPACITY, EXTENSION_HITS, HARVEST_POWER, HEAL, HEAL_POWER, LEFT, MAX_CONSTRUCTION_SITES, MAX_CREEP_SIZE, MOVE, OBSTACLE_OBJECT_TYPES, OK, RAMPART_HITS, RAMPART_HITS_MAX, RANGED_ATTACK, RANGED_ATTACK_DISTANCE_RATE, RANGED_ATTACK_POWER, RANGED_HEAL_POWER, REPAIR_COST, REPAIR_POWER, RESOURCES_ALL, RESOURCE_DECAY, RESOURCE_ENERGY, RIGHT, ROAD_HITS, ROAD_WEAROUT, SOURCE_ENERGY_REGEN, SPAWN_ENERGY_CAPACITY, SPAWN_HITS, STRUCTURE_PROTOTYPES, TERRAIN_PLAIN, TERRAIN_SWAMP, TERRAIN_WALL, TOP, TOP_LEFT, TOP_RIGHT, TOUGH, TOWER_CAPACITY, TOWER_COOLDOWN, TOWER_ENERGY_COST, TOWER_FALLOFF, TOWER_FALLOFF_RANGE, TOWER_HITS, TOWER_OPTIMAL_RANGE, TOWER_POWER_ATTACK, TOWER_POWER_HEAL, TOWER_POWER_REPAIR, TOWER_RANGE, WALL_HITS, WALL_HITS_MAX, WORK} from 'game/constants';
 
 import {arenaInfo} from "game";
@@ -56,27 +78,40 @@ import {searchPath, CostMatrix} from "game/path-finder"
 
     TOTAL_APPEND_ATEND = """
 export var sch = Scheduler();
-var monitor = Monitor(2);
+var monitor = Monitor(1);
 know.now = 0;
 
-_SchedulerMeta.__types__ = [];  // 清空js首次构造时引入的数据
-_StageMachineMeta.__recursive__ = [];  // 清空js首次构造时引入的数据
-__init_my_exists_creep_before_k__();
+StageMachineLogicMeta.__types__ = [];  // 清空js首次构造时引入的数据
+__init_before_k__();
+let knowCost = 0;
+let monitorCost = 0;
+let stepCost = 0;
+let timeLine = 0;
 export var loop = function () {
-	know.now = get.ticks ();
+	get.handle();
+	know.now = get.now;
+	timeLine = get.cpu_us();
     know.handle();
-	if (know.now === 1) {
+    knowCost = get.cpu_us() - timeLine;
+
+    timeLine = get.cpu_us();
+    monitor.handle();
+    monitorCost = get.cpu_us() - timeLine;
+    for (const creep of know.creeps){
+        creep.handle();
+    }
+    if (know.now === 1) {
 	    std.show_welcome();
 		init (know);
+		
 	}
-	
-    monitor.handle();
-    for (const creep of know._creeps){
-        creep.motion.handle();
-    }
 	step (know);
-	sch.handle();
+    timeLine = get.cpu_us();
+	if (get._SCH_FLAG) sch.handle();
+	stepCost = get.cpu_us() - timeLine;
 	std.show_usage ();
+	print("knowCost:", knowCost, "monitorCost:", monitorCost, "stepCost:", stepCost);
+	if (know.draw) know.draw();
 };
     """
 
@@ -114,42 +149,60 @@ export var loop = function () {
 
     ARENA_IMPORTS_GETTER = {
         const.ARENA_GREEN: lambda: f"""
-class BodyPart{{
-    constructor(){{
+const ARENA_COLOR_TYPE = "GREEN";
+class GameAreaEffect{{
+    constructor(){{ 
     }}
 }};
-const ScoreCollector = StructureSpawn;
+class GameConstructionBoost{{
+    constructor(){{ 
+    }}
+}};
+import {{ Portal as GamePortal}} from 'arena/season_{config.season}/{const.ARENA_GREEN}/{"advanced" if config.level in ["advance", "advanced"] else "basic"}/prototypes';
+
         """,
         const.ARENA_BLUE: lambda: f"""
-const ScoreCollector = StructureSpawn;
-import {{ Flag, BodyPart}} from 'arena/season_{config.season}/capture_the_flag/basic';
+const ARENA_COLOR_TYPE = "BLUE";
+const GameScoreCollector = GameStructureSpawn;
+class GameAreaEffect{{
+    constructor(){{ 
+    }}
+}};
+class GamePortal{{
+    constructor(){{ 
+    }}
+}};
+class GameConstructionBoost{{
+    constructor(){{ 
+    }}
+}};
         """,
         const.ARENA_RED: lambda: f"""
-class BodyPart{{
-    constructor(){{
+const ARENA_COLOR_TYPE = "RED";
+class GamePortal{{
+    constructor(){{ 
     }}
 }};
-import {{ RESOURCE_SCORE, ScoreCollector, AreaEffect, EFFECT_DAMAGE, EFFECT_FREEZE }} from 'arena/season_{config.season}/collect_and_control/basic';
+import {{ ConstructionBoost as GameConstructionBoost, AreaEffect as GameAreaEffect }} from 'arena/season_{config.season}/{const.ARENA_RED}/{"advanced" if config.level in ["advance", "advanced"] else "basic"}/prototypes';
+import {{ EFFECT_CONSTRUCTION_BOOST, EFFECT_SLOWDOWN }} from 'arena/season_{config.season}/{const.ARENA_RED}/{"advanced" if config.level in ["advance", "advanced"] else "basic"}/constants';
 
-import ("arena/season_{config.season}/collect_and_control/basic")
-.then((module) => {{ const RESOURCE_SCORE_X = module.RESOURCE_SCORE_X; const RESOURCE_SCORE_Y = module.RESOURCE_SCORE_Y; const RESOURCE_SCORE_Z = module.RESOURCE_SCORE_Z; }})
-.catch((error) => {{ }});
         """,
         const.ARENA_GRAY: lambda: f"""
-class BodyPart{{
-    constructor(){{
+const ARENA_COLOR_TYPE = "GRAY";
+class GameAreaEffect{{
+    constructor(){{ 
+    }}
+}};
+class GamePortal{{
+    constructor(){{ 
+    }}
+}};
+class GameConstructionBoost{{
+    constructor(){{ 
     }}
 }};
-const ScoreCollector = StructureSpawn;
-import("game/prototypes")
-.then((module) => {{ const Flag = module.Flag; }})
-.catch((error) => {{ }});
         """,
     }
-    ARENA_IMPORTS_NOT_BLUE = ""
-    ARENA_IMPORTS_NOT_BLUE1 = """
-import { StructureTower } from 'game/prototypes'
-    """
 
 
 class Compiler_Utils(Compiler_Const):
@@ -165,7 +218,7 @@ class Compiler_Utils(Compiler_Const):
             if not Compiler_Utils.last_output:
                 Compiler_Utils.last_output = True
                 print()
-            core.warn('Compiler_Utils.auto_read', core.lformat(LOC_FILE_NOT_EXISTS, [fpath]), end='', head='\n', ln=config.language)
+            core.warn('Compiler_Utils.auto_read', core.lformat(LOC_FILE_NOT_EXISTS, ["", fpath]), end='', head='\n', ln=config.language)
             return ""
 
         try:
@@ -177,12 +230,16 @@ class Compiler_Utils(Compiler_Const):
                     return f.read()
             except UnicodeDecodeError:
                 # 如果使用检测到的编码读取失败，尝试使用chardet检测编码
-                with open(fpath, 'rb') as f:  # 以二进制模式打开文件
-                    raw_data = f.read()  # 读取文件的原始数据
-                    result = chardet.detect(raw_data)  # 使用chardet检测编码
-                    encoding = result['encoding']  # 获取检测到的编码
-                with open(fpath, 'r', encoding=encoding) as f:  # 使用检测到的编码打开文件
-                    return f.read()
+                try:
+                    with open(fpath, 'rb') as f:  # 以二进制模式打开文件
+                        raw_data = f.read()  # 读取文件的原始数据
+                        result = chardet.detect(raw_data)  # 使用chardet检测编码
+                        encoding = result['encoding']  # 获取检测到的编码
+                    with open(fpath, 'r', encoding=encoding) as f:  # 使用检测到的编码打开文件
+                        return f.read()
+                except UnicodeDecodeError as e:
+                    core.error('Compiler_Utils.auto_read', core.lformat(LOC_FILE_READ_FAILED, [fpath, "UnicodeError", e]), end='', head='\n', ln=config.language)
+                    quit(-1)
 
     def copy_to(self) -> list:
         """
@@ -283,8 +340,104 @@ class Compiler_Utils(Compiler_Const):
 
         return '\n'.join(result)  # 将处理后的所有代码行连接成一个字符串，并返回最终结果 | join all processed lines into a string and return
 
-    def find_chain_import(self, fpath: str, search_dirs: list[str], project_path: str = None, records: dict[str, None] = None) -> list[str]:
+    def expand_folder_imports(self, fpath: str, project_path: str = None):
+        """
+        扩展文件夹导入语句：将 `from folder import *` 替换为 `from folder.module import *`
+        仅在文件夹没有 __init__.py 时执行此操作
+
+        :param fpath: 要处理的文件路径
+        :param project_path: 项目根路径，用于解析相对导入，默认为 None（使用文件所在目录）
         """
+        if not os.path.exists(fpath):
+            return
+
+        content = self.auto_read(fpath)
+        lines = content.split('\n')
+        new_lines = []
+        changed = False
+
+        for line in lines:
+            m = self.PY_IMPORT_PAT.match(line)
+            if not m:
+                new_lines.append(line)
+                continue
+
+            original_target = m.group(1)
+            target = original_target
+            target_path = project_path or os.path.dirname(fpath)
+
+            # 处理相对路径（向前定位）
+            if target.startswith('.'):
+                target_path = os.path.dirname(fpath)
+                count = 0
+                for c in target:
+                    if c == '.':
+                        count += 1
+                    else:
+                        break
+
+                # 向上移动目录
+                if count > 1:
+                    for _ in range(count - 1):
+                        target_path = os.path.dirname(target_path)
+
+                # 移除开头的点
+                target = target[count:]
+
+            # 如果 target 为空，跳过
+            if not target:
+                new_lines.append(line)
+                continue
+
+            # 向后定位，构建完整路径
+            temp_target = target
+            while (_idx := temp_target.find('.')) != -1:
+                part = temp_target[:_idx]
+                target_path = os.path.join(target_path, part)
+                temp_target = temp_target[_idx + 1:]
+
+            # 最终的文件夹路径
+            final_dir_path = os.path.join(target_path, temp_target) if temp_target else target_path
+
+            # 检查是否是文件夹且没有 __init__.py
+            if os.path.isdir(final_dir_path):
+                init_path = os.path.join(final_dir_path, '__init__.py')
+                if not os.path.exists(init_path):
+                    # 找到所有 .py 文件（排除 __init__.py）| 如果包含子目录，产生一个警告
+                    # try:
+                    #     py_files = [f for f in os.listdir(final_dir_path) if f.endswith('.py') and f != '__init__.py']
+                    # except (FileNotFoundError, PermissionError):
+                    py_files = []
+                    for item in os.listdir(final_dir_path):
+                        _path = os.path.join(final_dir_path, item)
+                        if os.path.isfile(_path) and item.endswith('.py') and item != '__init__.py':
+                            py_files.append(item)
+                        elif os.path.isdir(_path):
+                            rel = os.path.relpath(final_dir_path, project_path)
+                            core.warn(f'Compiler.expand_folder_imports', core.lformat(LOC_DIR_UNDER_NONINIT_DIR, [item, rel]), end='', head='\n', ln=config.language )
+                            
+
+                    # 为每个 .py 文件生成导入语句
+                    if py_files:
+                        for py_file in py_files:
+                            module_name = py_file[:-3]
+                            new_import = f"from {original_target}.{module_name} import *"
+                            new_lines.append(new_import)
+                        changed = True
+                        continue
+
+            # 保留原行
+            new_lines.append(line)
+
+        # 如果文件有修改，写回
+        if changed:
+            new_content = '\n'.join(new_lines)
+            with open(fpath, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+
+
+    def find_chain_import(self, fpath: str, search_dirs: list[str], project_path: str = None, records: dict[str, None] = None) -> list[str]:
+        r"""
         查找文件中的所有import语句，并返回所有import的文件路径 | find all import statements in a file and return the paths of all imported files
         PY_IMPORT_PAT: re.compile(r'\s+from\s+(.+)(?=\s+import)\s+import\s+\*')
         :param fpath: str 目标文件路径 | target file path
@@ -296,7 +449,7 @@ class Compiler_Utils(Compiler_Const):
         if records is None:
             records = {}
         if not os.path.exists(fpath):
-            core.error('Compiler.find_chain_import', core.lformat(LOC_FILE_NOT_EXISTS, [fpath]), head='\n', ln=config.language)
+            core.error('Compiler.find_chain_import', core.lformat(LOC_FILE_NOT_EXISTS, ["py", fpath]), head='\n', ln=config.language)
         imps = []
         content = self.auto_read(fpath)
         project_path = project_path or os.path.dirname(fpath)
@@ -342,6 +495,81 @@ class Compiler_Utils(Compiler_Const):
 
         return imps
 
+    def find_chain_import2(self, fpath: str, search_dirs: list[str], project_path: str = None, records: dict[str, None] = None) -> list[str]:
+        r"""
+        查找文件中的所有import语句，并返回所有import的文件路径 | find all import statements in a file and return the paths of all imported files
+        PY_IMPORT_PAT: re.compile(r'\s+from\s+(.+)(?=\s+import)\s+import\s+\*')
+        :param fpath: str 目标文件路径 | target file path
+        :param search_dirs: list[str] 搜索目录 | search directories
+        :param project_path=None: str python项目中的概念，指根文件所在的目录。如果不指定，默认使用第一次调用时给定的fpath，并且稍后的递归会全部使用此路径 |
+            concept in python-project, refers to the directory where the root file is located. If not specified, the fpath given at the first call is used by default, and all subsequent recursions will use this path
+        :param records=None: dict[str, None] 记录已经查找过的文件路径，避免重复查找 | record the file paths that have been searched to avoid duplicate searches
+        """
+        if records is None:
+            records = {}
+        if not os.path.exists(fpath):
+            core.error('Compiler.find_chain_import', core.lformat(LOC_FILE_NOT_EXISTS, [fpath]), head='\n', ln=config.language)
+        imps = []
+        content = self.auto_read(fpath)
+        project_path = project_path or os.path.dirname(fpath)
+
+        # 添加根目录和 src 目录到 search_dirs
+        root_dir = os.path.dirname(project_path)  # 根目录
+        src_dir = os.path.join(root_dir, 'src')  # src 目录
+        if root_dir not in search_dirs:
+            search_dirs = [root_dir] + search_dirs
+        if src_dir not in search_dirs:
+            search_dirs = [src_dir] + search_dirs
+
+        for no, line in enumerate(content.split('\n')):
+            m = self.PY_IMPORT_PAT.match(line)
+            if m:
+                target = m.group(1)
+                target_path = project_path
+
+                ## 向前定位 | locate forward
+                if target.startswith('.'):
+                    target_path = os.path.dirname(fpath)  # 因为使用了相对路径，所以需要先定位到当前文件所在的目录 |
+                    # because relative path is used, need to locate the directory where the current file is located first
+                    count = 0
+                    for c in target:
+                        if c == '.':
+                            count += 1
+                        else:
+                            break
+                    if count > 1:
+                        for _ in range(count - 1):
+                            target_path = os.path.dirname(target_path)
+
+                ## 向后定位 | locate backward
+                while (_idx := target.find('.')) != -1:
+                    first_name = target[:_idx]
+                    target_path = os.path.join(target_path, first_name)
+                    target = target[_idx + 1:]
+
+                ## 检查是否存在 | check if exists
+                this_path = os.path.join(target_path, target)
+                if os.path.isdir(this_path):
+                    this_path = os.path.join(this_path, '__init__.py')
+                else:
+                    this_path += '.py'
+
+                if not os.path.exists(this_path):
+                    # 如果当前路径不存在，尝试在 search_dirs 中查找
+                    for search_dir in search_dirs:
+                        search_path = os.path.join(search_dir, target.replace('.', os.sep)) + ('.py' if not os.path.isdir(this_path) else os.sep + '__init__.py')
+                        if os.path.exists(search_path):
+                            this_path = search_path
+                            break
+                    else:
+                        core.error('Compiler.find_chain_import', core.lformat(LOC_CHAIN_FILE_NOT_EXISTS, [fpath, no + 1, this_path]), head='\n', ln=config.language)
+                if this_path not in records:
+                    records[this_path] = None
+                    tmp = self.find_chain_import(this_path, search_dirs, project_path, records) + [this_path]
+                    imps.extend(tmp)
+
+        return imps
+
     @staticmethod
     def relist_pyimports_to_jsimports(base_dir:str, pyimps:list[str]) -> list[str]:
         """
@@ -358,21 +586,277 @@ class Compiler_Utils(Compiler_Const):
         return jsimps
 
     # ---------- 自定义函数 ---------- #
+
     @staticmethod
-    def stage_recursive_replace(content:str) -> str:
+    def stage_recursive_replace(content: str) -> str:
         """
-        替换'@recursive'为'@recursive(<fname>)', 其中<fname>为被装饰器标记的函数名 |
-            Replace '@recursive' with '@recursive(<fname>)', where <fname> is the name of the decorated function.
+        移除 '@recursive' 装饰器行，并在文末添加对应的 _recursiveLogin 调用。
 
-        @\s*recursive\s+def\s+([^\s\(]+)
+        对于类方法: _recursiveLogin("ClassName", "method_name")
+        对于普通函数: _recursiveLogin("", "function_name")
         """
-        return re.sub(r'@\s*recursive(\s+def\s+)([^\s\(]+)', r'@recursive("\2")\1\2', content)
+        calls_to_add = []
+        deletions = []
 
+        # 1. 收集所有类定义的位置和缩进
+        class_pattern = re.compile(r'^(\s*)class\s+(\w+)', re.MULTILINE)
+        classes = [(m.start(), len(m.group(1)), m.group(2))
+                   for m in class_pattern.finditer(content)]
+
+        # 2. 查找所有 @recursive 装饰器
+        decorator_pattern = re.compile(r'^\s*@\s*recursive\s*$\n?', re.MULTILINE)
+
+        for dec_match in decorator_pattern.finditer(content):
+            dec_end = dec_match.end()
+
+            # 查找接下来的函数定义（跳过可能的空行）
+            after_decorator = content[dec_end:]
+            func_match = re.search(r'^(\s*)def\s+([^\s\(]+)', after_decorator, re.MULTILINE)
+
+            if not func_match:
+                continue
+
+            func_indent_len = len(func_match.group(1))
+            func_name = func_match.group(2)
+
+            # 3. 确定类名：查找装饰器前最近的、缩进小于函数缩进的类
+            class_name = ""
+            for cls_pos, cls_indent_len, cls_name in reversed(classes):
+                if cls_pos < dec_match.start() and func_indent_len > cls_indent_len:
+                    class_name = cls_name
+                    break
+
+            # 4. 记录删除位置和调用信息
+            deletions.append((dec_match.start(), dec_end))
+            calls_to_add.append(f'_recursiveLogin("{class_name}", "{func_name}")')
+
+        # 5. 应用删除（倒序避免位置偏移）
+        if not deletions:
+            return content
+
+        result = content
+        for start, end in sorted(deletions, key=lambda x: x[0], reverse=True):
+            result = result[:start] + result[end:]
+
+        # 6. 在文末添加调用
+        if calls_to_add:
+            result = '\n'.join(calls_to_add) + '\n' + result
+
+        return result
+    
+    @staticmethod
+    def process_mate_code(code):
+        # 用于存储匹配到的信息
+        mate_assignments = []
+        # 匹配变量赋值为Mate()的正则表达式，允许变量定义中包含或不包含类型注解
+        assign_pattern = re.compile(r'(\w+)\s*(?:\:\s*\w*)?\s*=\s*Mate\s*\(')
+        # 匹配类定义的正则表达式
+        class_pattern = re.compile(r'class\s+(\w+)')
+        # 用于记录当前所在的类名
+        current_class = None
+        # 将代码按行分割
+        lines = code.split('\n')
+        # 遍历每一行
+        for i, line in enumerate(lines):
+            # 匹配类定义
+            class_match = class_pattern.match(line)
+            if class_match:
+                current_class = class_match.group(1)
+            # 匹配变量赋值为Mate()
+            assign_match = assign_pattern.search(line)
+            if assign_match:
+                # 检查group(1)前面同一行内是否有#，如果有则忽略
+                comment = re.search(r'#', line[:assign_match.start()])
+                if comment:
+                    continue
+                variable_name = assign_match.group(1)
+                # 存储匹配到的信息
+                mate_assignments += [(variable_name, current_class)]
+
+        output_strings = []
+        for variable_name, class_name in mate_assignments:
+            output_string = f"# > insert Object.defineProperty ({class_name}, '{variable_name}', property.call ({class_name}, {class_name}.{variable_name}._MateGet_, {class_name}.{variable_name}._MateSet_));"
+            output_strings.append(output_string)
+        
+        return code + '\n'.join(output_strings)
+
+
+    @staticmethod
+    def remove_long_docstring(content:str) -> str:
+        """
+        移除长注释 | remove long docstring
+        """
+        code = re.sub(r'"""[^"]*"""', '', content)
+        code = re.sub(r"'''[^']*'''", '', code)
+        return code
+
+    @classmethod
+    def _collect_logical_line(cls, lines: List[str], start_idx: int) -> Tuple[str, int]:
+        """收集从start_idx开始的逻辑行（处理多行语句，直到遇到:结尾）"""
+        if start_idx >= len(lines):
+            return "", start_idx
+
+        parts = [lines[start_idx].rstrip()]
+        i = start_idx
+
+        # 持续收集直到找到以:结尾的行
+        while i < len(lines) and not parts[-1].endswith(':'):
+            i += 1
+            if i < len(lines):
+                parts.append(lines[i].rstrip())
+
+        return " ".join(parts), i
+
+    @classmethod
+    def _convert_block(cls, lines: List[str], match_counter: Optional[List[int]] = None) -> List[str]:
+        if match_counter is None:
+            match_counter = [0]
+
+        result = []
+        i = 0
+
+        while i < len(lines):
+            line = lines[i].rstrip()
+
+            # 检测match语句（支持多行）
+            if re.match(r'^\s*match\s+', line):
+                full_match, end_idx = cls._collect_logical_line(lines, i)
+
+                match_stmt = re.match(r'^(\s*)match\s+(.+?)\s*:', full_match)
+                if not match_stmt:
+                    result.append(line)
+                    i += 1
+                    continue
+
+                indent = match_stmt.group(1)
+                subject = match_stmt.group(2).strip()
+                i = end_idx + 1  # 跳过match语句
+
+                # 生成临时变量
+                var_name = f"__MATCH_{match_counter[0]}__"
+                match_counter[0] += 1
+                result.append(f"{indent}{var_name} = {subject}")
+
+                # 解析case语句
+                cases: List[Tuple[str, List[str]]] = []
+                case_indent = None
+
+                while i < len(lines):
+                    case_line = lines[i].rstrip()
+
+                    # 缩进检查 - case必须比match缩进更多
+                    if not case_line.startswith(indent + '    ') and case_line.strip():
+                        if re.match(r'^\s*case\s+', case_line):
+                            raise MatchCaseError(f"第 {i + 1} 行: case 缩进必须大于 match")
+                        break
+
+                    # 检测case语句（不再使用_collect_logical_line，而是单独处理每一行）
+                    case_match = re.match(r'^(\s+)case\s+(.+?)\s*:', case_line)
+                    if case_match:
+                        curr_case_indent = case_match.group(1)
+                        case_val = case_match.group(2).strip()
+
+                        # 验证缩进 - 允许不同的case缩进（用于嵌套）
+                        if len(curr_case_indent) <= len(indent):
+                            raise MatchCaseError(f"第 {i + 1} 行: case 缩进必须大于 match")
+
+                        # 不再强制要求所有case缩进一致，允许嵌套情况下的不同缩进
+                        if case_indent is None:
+                            case_indent = curr_case_indent
+
+                        # 提取内联代码（如果有）
+                        inline_code = ""
+                        if ':' in case_line:
+                            after_colon = case_line.split(':', 1)[1].strip()
+                            if after_colon:
+                                inline_code = after_colon
+
+                        i += 1
+
+                        # 收集case块
+                        block_lines = []
+                        if inline_code:
+                            block_lines.append(f"{curr_case_indent}    {inline_code}")
+
+                        while i < len(lines):
+                            block_line = lines[i].rstrip()
+                            if not block_line.strip():
+                                block_lines.append(block_line)
+                                i += 1
+                                continue
+
+                            # 检查是否是下一个case或者缩进回到当前match级别
+                            if re.match(r'^\s*case\s+', block_line):
+                                # 检查这个case是否属于当前match还是父级match
+                                next_case_indent = re.match(r'^\s*', block_line).group(0)
+                                if len(next_case_indent) <= len(indent):
+                                    # 属于父级match，退出当前match的处理
+                                    break
+                                # 仍然属于当前match，继续收集
+                                if block_line.startswith(curr_case_indent + '    '):
+                                    block_lines.append(block_line)
+                                    i += 1
+                                    continue
+                                else:
+                                    break
+
+                            if block_line.startswith(indent) and not block_line.startswith(curr_case_indent):
+                                break
+
+                            if block_line.startswith(curr_case_indent + '    '):
+                                block_lines.append(block_line)
+                                i += 1
+                                continue
+
+                            break
+
+                        cases.append((case_val, block_lines))
+                    else:
+                        break
+
+                # 验证case
+                seen = set()
+                for idx, (val, _) in enumerate(cases):
+                    if val == '_':
+                        if idx != len(cases) - 1:
+                            raise MatchCaseError(f"第 {i + 1} 行附近: case _ 必须在最后")
+                    else:
+                        if val in seen:
+                            raise MatchCaseError(f"第 {i + 1} 行附近: 重复的 case 值 '{val}'")
+                        seen.add(val)
+
+                # 生成if/elif/else
+                for idx, (case_val, blk_lines) in enumerate(cases):
+                    keyword = "else" if case_val == '_' else ("if" if idx == 0 else "elif")
+                    if keyword == "else":
+                        result.append(f"{indent}else:")
+                    else:
+                        result.append(f"{indent}{keyword} {var_name} == {case_val}:")
+
+                    if blk_lines:
+                        # 递归处理block_lines，以支持嵌套match
+                        converted_blk_lines = cls._convert_block(blk_lines, match_counter)
+                        result.extend(converted_blk_lines)
+
+                continue
+
+            result.append(line)
+            i += 1
+
+        return result
+
+    @classmethod
+    def convert_match_to_if(cls, code: str) -> str:
+        lines = code.split('\n')
+        converted_lines = cls._convert_block(lines, [0])
+        return '\n'.join(converted_lines)
 
 
 class CompilerBase(Compiler_Utils):
 
-    def __init__(self, src_dir, build_dir):
+    def __init__(self):
+        src_dir = "src"
+        build_dir = "build"
         # check
         if not os.path.exists(src_dir):
             core.error('Compiler.__init__', core.lformat(LOC_FILE_NOT_EXISTS, ['src', src_dir]), head='\n', ln=config.language)
@@ -435,6 +919,7 @@ class Compiler(CompilerBase):
                     # 将PYFILE_PRAGMA_INSERTS.replace("\t", "").replace("    ", "")插入到文件开头
                     content = self.auto_read(fpath)
                     content = self.PYFILE_PRAGMA_INSERTS.replace("\t", "").replace("    ", "") + content
+                    # content = self.remove_long_docstring(content)  # 移除长注释 | remove long docstring
 
                     with open(fpath, 'w', encoding='utf-8') as f:  # 注意，这里修改的是build目录下的文件，不是源文件 | Note that the file under the build directory is modified here, not the source file
                         f.write(content)
@@ -468,6 +953,8 @@ class Compiler(CompilerBase):
                 if m and (not m.group(2) or m.group(2)[0] != '*'):
                     core.error('Compiler.pre_compile', core.lformat(LOC_IMPORT_STAR2_ERROR, [m.group(1), m.group(2), m.group(1)]), head='\n', ln=config.language)
 
+            self.expand_folder_imports(fpath, self.build_dir)
+
         # -------------------------------- EXPAND IMPORT * -------------------------------- #
         _imports = self.find_chain_import(self.target_py, [os.path.dirname(self.src_dir), self.src_dir])
         _js_imports = self.relist_pyimports_to_jsimports(self.build_dir, _imports)
@@ -506,6 +993,14 @@ class Compiler(CompilerBase):
             else:
                 _pre_sort_[fname] = 65535
 
+        # ------------------------------------ 自定义:mate & match ------------------------------------ #
+        for fpath in py_fpath:
+            content = self.auto_read(fpath)
+            content = self.process_mate_code(content)  # 调用process_mate_code
+            content = self.convert_match_to_if(content)  # 调用convert_match_to_if
+            with open(fpath, 'w', encoding='utf-8') as f:
+                f.write(content)
+
         # ------------------------------------ DEFINE ------------------------------------ #
         # 扫描所有# > define的内容，然后在.py中移除这些行，并记录下来
         # | get all # > define in .py files, and record them
@@ -579,21 +1074,21 @@ class Compiler(CompilerBase):
             with open(fpath, 'w', encoding='utf-8') as f:
                 f.write(new_content)
 
-        # ------------------------------------ 自定义 ------------------------------------ #
-        # 调用stage_recursive_replace
+        # ------------------------------------ 自定义:调用stage_recursive_replace ------------------------------------ #
         for fpath in py_fpath:
             content = self.auto_read(fpath)
-            content = self.stage_recursive_replace(content)
+            content = self.stage_recursive_replace(content)  # 调用stage_recursive_replace
             with open(fpath, 'w', encoding='utf-8') as f:
                 f.write(content)
 
+
         core.lprint(GREEN.format('[2/6]'), LOC_DONE, " ", LOC_PREPROCESSING_FINISH, sep="", head="\r", ln=config.language)
         return _imports, _js_imports, _pre_sort_, _pre_define_, _js_replace_
 
     def transcrypt_cmd(self):
-        # 执行cmd命令: transcrypt -b -m -n -s -e 6 target | execute cmd: transcrypt -b -m -n -s -e 6 target
+        # 执行cmd命令: python -m transcrypt -b -m -n -s -e 6 target | execute cmd: python -m transcrypt -b -m -n -s -e 6 target
         # 并获取cmd得到的输出 | and get the output of the cmd
-        cmd = 'transcrypt -b -m -n -s -e 6 %s' % self.target_py
+        cmd = 'python -m transcrypt -b -m -n -s -e 6 %s' % self.target_py
         core.lprint(WAIT, core.lformat(LOC_TRANSCRYPTING, [cmd]), end="", ln=config.language)
         p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
         stdout, stderr = p.communicate()
@@ -721,9 +1216,8 @@ class Compiler(CompilerBase):
         """
         arena_name = const.ARENA_NAMES.get(config.arena, const.ARENA_NAMES['green'])  # like green -> spawn_and_swamp
         self.TOTAL_INSERT_AT_HEAD += self.ARENA_IMPORTS_GETTER[arena_name]()  # add arena imports
-        if config.arena != "blue":
-            self.TOTAL_INSERT_AT_HEAD += self.ARENA_IMPORTS_NOT_BLUE
         total_js = f"const __VERSION__ = '{const.VERSION}';\nconst __PYTHON_VERSION__ = '{python_version_info}';" + self.TOTAL_INSERT_AT_HEAD + f"\nexport var LANGUAGE = '{config.language}';\n"
+        total_js += f"const __AUTHOR__ = '{const.AUTHOR}';\nconst __AUTHOR_CN__ = '{const.BILIBILI_NAME}';"
 
         core.lprint(WAIT, LOC_GENERATING_TOTAL_MAIN_JS, end="", ln=config.language)
 
@@ -814,7 +1308,7 @@ class Compiler(CompilerBase):
         self.transcrypt_cmd()
         imports, modules = self.analyze_rebuild_main_js(defs, jimps)
         self.find_add_pure_js_files(sorts, modules)
-        total_js = imports + "\n" + self.generate_total_js(modules, imps, sorts, self.FILE_STRONG_REPLACE, reps)
+        total_js = imports + "\n" + self.generate_total_js(replace_src_prefix(modules), imps, sorts, self.FILE_STRONG_REPLACE, reps)
 
         core.lprint(WAIT, LOC_EXPORTING_TOTAL_MAIN_JS, end="", ln=config.language)
 
@@ -889,6 +1383,20 @@ class Compiler(CompilerBase):
 
 
 if __name__ == '__main__':
-    compiler = Compiler('src', 'library', 'build')
-    compiler.compile()
-    compiler.clean()
+    # compiler = Compiler('src', 'library', 'build')
+    # compiler.compile()
+    # compiler.clean()
+    test = """
+    
+def patrolling(self, c: Creep):
+    e = self.center.nearest(k.civilian.enemies, 5)
+    if e:
+        match c.test(e,
+            int(c.hpPer <= 0.9) * 2, 
+            int(c.info.melee) * -3
+        ):
+            case True: c.move(e, SWAMP_MOTION)
+            case False: c.move(self.bpos, SWAMP_MOTION)
+    
+    """
+    print(f"res=\n{Compiler.convert_match_to_if(test)}")