pyscreeps-arena 0.5.1.0__tar.gz → 0.5.7.6__tar.gz

{pyscreeps_arena-0.5.1.0 → pyscreeps_arena-0.5.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscreeps-arena
-Version: 0.5.1.0
+Version: 0.5.7.6
 Summary: Python api|interface to play game: Screeps: Arena.
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby
@@ -16,6 +16,7 @@ Requires-Dist: colorama
 Requires-Dist: py7zr
 Requires-Dist: chardet
 Requires-Dist: Transcrypt==3.9.1
+Requires-Dist: PyQt6
 Requires-Dist: mkdocs
 Requires-Dist: mkdocstrings[python]
 Requires-Dist: mkdocs-material

pyscreeps_arena-0.5.7.6/pyscreeps_arena/__init__.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import shutil
+import py7zr
+from pyscreeps_arena.core import const, config
+from pyscreeps_arena.ui.mapviewer import run_mapviewer
+from pyscreeps_arena.ui.project_ui import run_project_creator
+from pyscreeps_arena.ui.creeplogic_edit import run_creeplogic_edit
+
+def CMD_NewProject():
+    """
+    cmd:
+        pyscreeps-arena  [project_path]
+        arena [project_path]
+
+    * 复制"src" "game" "build.py" 到指定目录
+
+    Returns:
+
+    """
+    if len(sys.argv) < 2:
+        print("Usage: pyarena new [project_path]\n# or\narena new [project_path]")
+        return
+    project_path = sys.argv[1]
+    if not os.path.exists(project_path):
+        os.makedirs(project_path)
+    this_path = os.path.dirname(os.path.abspath(__file__))
+    extract_7z(os.path.join(this_path, 'project.7z'), project_path)
+    print("Project created at", project_path)
+
+def CMD_OpenUI():
+    """
+    cmd:
+        psaui 无参数，启用project ui
+        psaui -c/-e 启用creeplogic edit
+        psaui -m [-c/-e] 启用mapviewer. 默认cn，可以指定-c/-e
+        psaui -h 显示帮助信息
+
+    * 打开UI界面
+
+    Returns:
+
+    """
+    try:
+        # 显示帮助信息
+        if len(sys.argv) > 1 and sys.argv[1] == '-h':
+            print("Usage:")
+            print("  psaui                 启用project ui")
+            print("  psaui -c/-e           启用creeplogic edit (-c: 中文, -e: 英文)")
+            print("  psaui -m [-c/-e]      启用mapviewer (-c: 中文, -e: 英文, 默认: 中文)")
+            print("  psaui -h              显示帮助信息")
+            print("  --------------------------------------------------------------")
+            print("  psaui                 run `project ui`")
+            print("  psaui -c/-e           run `creeplogic edit` (-c: chinese, -e: english)")
+            print("  psaui -m [-c/-e]      run `mapviewer` (-c: chinese, -e: english, default: chinese)")
+            print("  psaui -h              Show this help message")
+
+            return
+        
+        # 检查是否使用mapviewer
+        if len(sys.argv) > 1 and sys.argv[1] == '-m':
+            # 检查语言参数
+            if len(sys.argv) > 2 and sys.argv[2] == '-e':
+                from pyscreeps_arena.core import config
+                config.language = 'en'
+            run_mapviewer()
+        # 检查是否使用creeplogic edit
+        elif len(sys.argv) > 1 and sys.argv[1] == '-c':
+            run_creeplogic_edit()
+        elif len(sys.argv) > 1 and sys.argv[1] == '-e':
+            from pyscreeps_arena.core import config
+            config.language = 'en'
+            run_creeplogic_edit()
+        # 默认启用project ui
+        else:
+            run_project_creator()
+    except ImportError as e:
+        print(f"错误: 无法导入UI模块 - {e}")
+        print("请确保已安装PyQt6: pip install PyQt6")
+    except Exception as e:
+        print(f"错误: 打开UI界面失败 - {e}")
+
+def extract_7z(file_path, output_dir):
+    with py7zr.SevenZipFile(file_path, mode='r') as archive:
+        archive.extractall(path=output_dir)
+
+if __name__ == '__main__':
+    CMD_OpenUI()

{pyscreeps_arena-0.5.1.0 → pyscreeps_arena-0.5.7.6}/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')等内容 |
@@ -60,7 +82,7 @@ var monitor = Monitor(1);
 know.now = 0;
 
 StageMachineLogicMeta.__types__ = [];  // 清空js首次构造时引入的数据
-__init_my_exists_creep_before_k__();
+__init_before_k__();
 let knowCost = 0;
 let monitorCost = 0;
 let stepCost = 0;
@@ -71,24 +93,25 @@ export var loop = function () {
 	timeLine = get.cpu_us();
     know.handle();
     knowCost = get.cpu_us() - timeLine;
-	if (know.now === 1) {
-	    std.show_welcome();
-		init (know);
-		
-	}
-	
+
     timeLine = get.cpu_us();
     monitor.handle();
     monitorCost = get.cpu_us() - timeLine;
-    for (const creep of get.creeps()){
+    for (const creep of know.creeps){
         creep.handle();
     }
+    if (know.now === 1) {
+	    std.show_welcome();
+		init (know);
+		
+	}
 	step (know);
     timeLine = get.cpu_us();
-	sch.handle();
+	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();
 };
     """
 
@@ -126,7 +149,7 @@ export var loop = function () {
 
     ARENA_IMPORTS_GETTER = {
         const.ARENA_GREEN: lambda: f"""
-const ARENA_COLOR_TYPE = "green";
+const ARENA_COLOR_TYPE = "GREEN";
 class GameAreaEffect{{
     constructor(){{ 
     }}
@@ -136,8 +159,9 @@ class GameConstructionBoost{{
     }}
 }};
 import {{ Portal as GamePortal}} from 'arena/season_{config.season}/{const.ARENA_GREEN}/{"advanced" if config.level in ["advance", "advanced"] else "basic"}/prototypes';
-
         """,
+# import {Portal} from 'arena/season_1/portal_exploration/basic/prototypes';
+        
         const.ARENA_BLUE: lambda: f"""
 const ARENA_COLOR_TYPE = "BLUE";
 const GameScoreCollector = GameStructureSpawn;
@@ -178,11 +202,6 @@ class GameConstructionBoost{{
     constructor(){{ 
     }}
 }};
-let GameFlag = GameStructureSpawn;
-import * as GAME_PROTO_MODULE from 'game/prototypes';
-if (GAME_PROTO_MODULE.Flag){{
-    GameFlag = GAME_PROTO_MODULE.Flag;
-}}
         """,
     }
 
@@ -212,12 +231,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:
         """
@@ -318,6 +341,102 @@ class Compiler_Utils(Compiler_Const):
 
         return '\n'.join(result)  # 将处理后的所有代码行连接成一个字符串，并返回最终结果 | join all processed lines into a string and return
 
+    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
@@ -468,15 +587,63 @@ class Compiler_Utils(Compiler_Const):
         return jsimps
 
     # ---------- 自定义函数 ---------- #
+
     @staticmethod
-    def stage_recursive_replace(content:str) -> str:
-        r"""
-        替换'@recursive'为'@recursive(<fname>)', 其中<fname>为被装饰器标记的函数名 |
-            Replace '@recursive' with '@recursive(<fname>)', where <fname> is the name of the decorated function.
+    def stage_recursive_replace(content: str) -> str:
+        """
+        移除 '@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):
@@ -524,6 +691,167 @@ class Compiler_Utils(Compiler_Const):
         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):
 
@@ -626,6 +954,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)
@@ -664,10 +994,11 @@ class Compiler(CompilerBase):
             else:
                 _pre_sort_[fname] = 65535
 
-        # ------------------------------------ 自定义:调用process_mate_code ------------------------------------ #
+        # ------------------------------------ 自定义: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)
 
@@ -756,9 +1087,9 @@ class Compiler(CompilerBase):
         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()
@@ -978,7 +1309,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)
 
@@ -1053,6 +1384,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)}")

{pyscreeps_arena-0.5.1.0 → pyscreeps_arena-0.5.7.6}/pyscreeps_arena/core/const.py

@@ -9,7 +9,7 @@
 #
 import re
 
-VERSION = "0.5.1.0"
+VERSION = "0.5.7.6"
 AUTHOR = "●ω＜🤍♪"
 STEAM_ID = "1029562896"
 GITHUB_NAME = "EagleBaby"

{pyscreeps_arena-0.5.1.0 → pyscreeps_arena-0.5.7.6}/pyscreeps_arena/localization.py

@@ -17,6 +17,10 @@ LOC_FILE_NOT_EXISTS = {
     'en': "{} File not exists: {}. You can ignore if it's a not used file.",
     'cn': "{} 文件不存在: {}. 如果它是一个未使用的文件，您可以忽略它。",
 }
+LOC_FILE_READ_FAILED = {
+    'en': "Failed to read file: {}({})\nDetails:\n{}",
+    'cn': "读取文件失败: {}({})\n详细信息:\n{}",
+}
 LOC_PREPROCESSING = {
     'en': "Preprocessing ...",
     'cn': "预处理中 ...",
@@ -135,6 +139,12 @@ LOC_NOT_SUPPORT_PYFILE_INIT = {
     'cn': '不支持 __init__.py！请删除它(初始化文件)并使用 from directory.xxx import xxxx 代替之。',
 }
 
+# V0.5.4
+LOC_DIR_UNDER_NONINIT_DIR = {
+    'en': "Directory [{}] is located under [{}] without __init__.py, therefore it is ignored.",
+    'cn': "目录 [{}] 位于 `无__init__.py`的目录[{}]下，因此被忽略。",
+}
+
 if __name__ == '__main__':
     lprint(TEMPLATE)