pyscreeps-arena 0.5.6.5__tar.gz → 0.5.7.0__tar.gz

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscreeps-arena
-Version: 0.5.6.5
+Version: 0.5.7.0
 Summary: Python api|interface to play game: Screeps: Arena.
 Author-email: 2229066748@qq.com
 Maintainer: Eagle'sBaby

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/pyscreeps_arena/__init__.py

@@ -35,8 +35,18 @@ def CMD_OpenUI():
 
     """
     try:
-        from pyscreeps_arena.ui.project_ui import run_project_creator
-        run_project_creator()
+        # 检查是否带 -c
+        if len(sys.argv) > 1 and sys.argv[1] == '-c':
+            from pyscreeps_arena.ui.creeplogic_edit import run_creeplogic_edit
+            run_creeplogic_edit()
+        elif len(sys.argv) > 1 and sys.argv[1] == '-e':
+            from pyscreeps_arena.ui.creeplogic_edit import run_creeplogic_edit
+            from pyscreeps_arena.core import config
+            config.language = 'en'
+            run_creeplogic_edit()
+        else:
+            from pyscreeps_arena.ui.project_ui import run_project_creator
+            run_project_creator()
     except ImportError as e:
         print(f"错误: 无法导入UI模块 - {e}")
         print("请确保已安装PyQt6: pip install PyQt6")

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/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
@@ -92,18 +93,18 @@ 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 know.creeps){
         creep.handle();
     }
+    if (know.now === 1) {
+	    std.show_welcome();
+		init (know);
+		
+	}
 	step (know);
     timeLine = get.cpu_us();
 	if (get._SCH_FLAG) sch.handle();
@@ -229,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:
         """
@@ -685,6 +690,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):
 
@@ -827,10 +993,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)
 
@@ -1216,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)}")

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/pyscreeps_arena/core/const.py

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

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/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': "预处理中 ...",

pyscreeps_arena-0.5.7.0/pyscreeps_arena/ui/creeplogic_edit.py

@@ -0,0 +1,14 @@
+import sys
+from PyQt6.QtWidgets import QApplication
+from pyscreeps_arena.ui.qcreeplogic import QPSACreepLogic
+
+
+
+def run_creeplogic_edit():
+    app = QApplication(sys.argv)
+    window = QPSACreepLogic()
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ == '__main__':
+    run_creeplogic_edit()

{pyscreeps_arena-0.5.6.5 → pyscreeps_arena-0.5.7.0}/pyscreeps_arena/ui/project_ui.py

@@ -15,6 +15,7 @@ from pyscreeps_arena.core import const
 from pyscreeps_arena.ui.rs_icon import get_pixmap
 
 
+
 class ProjectCreatorUI(QMainWindow):
     def __init__(self):
         super().__init__()

pyscreeps_arena-0.5.7.0/pyscreeps_arena/ui/qcreeplogic/__init__.py

@@ -0,0 +1,3 @@
+from pyscreeps_arena.ui.qcreeplogic.qcreeplogic import QPSACreepLogic
+
+

pyscreeps_arena-0.5.7.0/pyscreeps_arena/ui/qcreeplogic/model.py

@@ -0,0 +1,72 @@
+from typing import List, Optional, Union
+from pyscreeps_arena.ui.qrecipe.model import PartsVector
+
+class NamedRecipe:
+    def __init__(self, name: str, recipe: List[str]):
+        self.name = name
+        self.recipe = recipe
+
+class CreepLogicSettings:
+    """
+    爬虫逻辑设置类，用于定义爬虫的基本属性和行为。
+    """
+    
+    def __init__(self):
+        # ---------------------- 爬虫本体 | Creep --------------------------- #
+        self.draw: bool = False  # 是否绘制爬虫信息
+        self.layer: int = 10  # 爬虫绘制图层，默认为10
+        
+        # ---------------------- 流程与结构 | Flow & Struct --------------------------- #
+        self.link: Union[List[str], str, None] = None  # 爬虫逻辑链接
+        self.once: bool = True  # 是否禁用死亡后重生
+        
+        # ---------------------- 孵化选项 | Spawning --------------------------- #
+        self.spawnable = True  # 是否可以孵化标志
+        self.recipe: Union[List[str], NamedRecipe] = ["MOVE"]  # 爬虫配方，默认为["MOVE"]
+        self.optimise: bool = True  # 自动优化配方标志
+        self.extension: bool = True  # 使用extension标志
+        self.direction: Optional[int] = None  # 出生方向
+        
+        # ---------------------- 基本信息 | Basic Info --------------------------- #
+        self.name: str = ""  # 爬虫名称
+    
+    def to_dict(self) -> dict:
+        """
+        将设置转换为字典格式
+        """
+        return {
+            "name": self.name,
+            "draw": self.draw,
+            "layer": self.layer,
+            "link": self.link,
+            "once": self.once,
+            "spawnable": self.spawnable,
+            "recipe": self.recipe if isinstance(self.recipe, list) else self.recipe.name,
+            "optimise": self.optimise,
+            "extension": self.extension,
+            "direction": self.direction
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "CreepLogicSettings":
+        """
+        从字典格式创建设置对象
+        """
+        settings = cls()
+        settings.name = data.get("name", "")
+        settings.draw = data.get("draw", False)
+        settings.layer = data.get("layer", 10)
+        settings.link = data.get("link", None)
+        settings.once = data.get("once", True)
+        settings.spawnable = data.get("spawnable", True)
+        settings.recipe = data.get("recipe", ["MOVE"])
+        settings.optimise = data.get("optimise", True)
+        settings.extension = data.get("extension", True)
+        settings.direction = data.get("direction", None)
+        return settings
+    
+    def reset(self):
+        """
+        重置所有设置为默认值
+        """
+        self.__init__()