pyscreeps-arena 0.5.4a0__py3-none-any.whl → 0.5.7b0__py3-none-any.whl

pyscreeps_arena/__init__.py

@@ -35,8 +35,13 @@ 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()
+        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")
@@ -47,4 +52,5 @@ 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/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,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();
 	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();
 };
     """
 
@@ -147,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(){{ 
     }}
@@ -199,11 +201,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;
-}}
         """,
     }
 
@@ -233,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:
         """
@@ -689,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):
 
@@ -831,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)
 
@@ -923,9 +1086,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()
@@ -1220,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/core/const.py

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

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/ui/P2PY.py

@@ -1,105 +1,108 @@
-# png_to_py.py - 将PNG图片转换为Python模块
+# png_to_py.py - 将PNG图片转换为Python模块（最终验证版）
 import base64
 import sys
 from pathlib import Path
+import re
 
 
 def png_to_py(png_path, py_path=None, var_name=None):
     """
     将PNG图片转换为Python模块文件
-    
+
     :param png_path: PNG图片路径
     :param py_path: 输出的.py文件路径（默认为图片同名.py）
     :param var_name: 变量名（默认为文件名的大写形式）
-    
-    :raises: FileNotFoundError: 若PNG文件不存在
-    :warns: 若文件不是PNG格式，将输出警告
-    
-    :usage:
-        # 基本用法
-        png_to_py('icon.png')
-        # 指定输出路径和变量名
-        png_to_py('logo.png', 'resources/logo.py', 'LOGO_ICON')
     """
     png_file = Path(png_path)
-    
+
     if not png_file.exists():
         raise FileNotFoundError(f"文件 '{png_path}' 不存在")
-    
+
     if png_file.suffix.lower() != '.png':
         print(f"[警告] 文件 '{png_path}' 不是PNG格式")
         return False
-    
+
     # 自动生成输出路径
     if py_path is None:
         py_path = png_file.with_suffix('.py')
     else:
         py_path = Path(py_path)
-    
+
     # 自动生成变量名
     if var_name is None:
-        var_name = png_file.stem.replace('-', '_').replace(' ', '_').upper()
-    
+        base_name = png_file.stem.replace('-', '_').replace(' ', '_')
+        base_name = re.sub(r'[^0-9a-zA-Z_]', '', base_name)
+        if base_name and base_name[0].isdigit():
+            base_name = f'ICON_{base_name}'
+        var_name = base_name.upper()
+
     try:
         # 读取PNG文件并转换为base64
         with open(png_file, 'rb') as f:
             png_data = f.read()
             base64_data = base64.b64encode(png_data).decode('utf-8')
-        
-        print(f"[DEBUG] 读取PNG文件: {len(png_data)} 字节")  # 调试输出：查看文件大小
-        print(f"[DEBUG] Base64编码长度: {len(base64_data)} 字符")  # 调试输出：查看编码长度
-        
-        # 生成Python代码
+
+        print(f"[DEBUG] 读取PNG文件: {len(png_data)} 字节")
+        print(f"[DEBUG] Base64编码长度: {len(base64_data)} 字符")
+
+        # 生成Python代码（关键修复：使用 len({var_name})）
         py_content = f'''# -*- coding: utf-8 -*-
 """
 PyQt6资源模块: {png_file.name}
 由 png_to_py.py 自动生成
 """
 
-{var_name} = b"""
-{base64_data}
-"""
+# Base64编码的PNG数据（单行，无换行符）
+{var_name} = b"{base64_data}"
 
 def get_pixmap():
-    """返回QPixmap对象"""
+    \"\"\"返回QPixmap对象\"\"\"
     from PyQt6.QtGui import QPixmap
     from PyQt6.QtCore import QByteArray
+
+    byte_array = QByteArray.fromBase64({var_name})
     pixmap = QPixmap()
-    pixmap.loadFromData(QByteArray({var_name}))
+    pixmap.loadFromData(byte_array)
     return pixmap
 
 def get_icon():
-    """返回QIcon对象"""
+    \"\"\"返回QIcon对象\"\"\"
     from PyQt6.QtGui import QIcon
-    icon = QIcon(get_pixmap())
-    return icon
+    return QIcon(get_pixmap())
 
 if __name__ == '__main__':
-    print(f"资源模块 {var_name} 已生成")
-    print(f"图片大小: {len(png_data)} 字节")
-    print(f"Base64长度: {len(base64_data)} 字符")
+    import sys
+    from PyQt6.QtWidgets import QApplication
+
+    app = QApplication.instance() or QApplication(sys.argv)
+
+    print(f"资源模块 {var_name} 已加载")
+    print(f"字节数据长度: {{len({var_name})}} 字节")  # ✅ 修复：使用 {var_name}
+
+    # 验证能否正确加载
+    pixmap = get_pixmap()
+    print(f"QPixmap加载成功: 尺寸 {{pixmap.width()}}x{{pixmap.height()}}")
 '''
-        
+
         # 写入Python文件
         with open(py_path, 'w', encoding='utf-8') as f:
             f.write(py_content)
-        
+
         print(f"✓ 成功: {png_path} -> {py_path}")
         print(f"  变量名: {var_name}")
         return True
-        
+
     except Exception as e:
         print(f"错误: 转换失败 - {e}")
+        import traceback
+        traceback.print_exc()
         return False
 
 
 if __name__ == '__main__':
-    # 命令行使用示例
-    if len(sys.argv) < 2:
-        print("用法: python png_to_py.py <图片路径> [输出路径]")
-        print("示例: python png_to_py.py logo.png")
-        print("      python png_to_py.py icon.png resources/icon.py")
+    if len(sys.argv) > 1:
+        target = sys.argv[1]
     else:
-        png_path = sys.argv[1]
-        py_path = sys.argv[2] if len(sys.argv) > 2 else None
-        png_to_py(png_path, py_path)
+        target = "icon.png"
+
+    png_to_py(target, "rs_icon.py")

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/ui/project_ui.py

@@ -10,8 +10,10 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                              QFileDialog, QMessageBox)
 from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QFont
+from PyQt6.QtGui import QIcon
 from pyscreeps_arena.core import const
-from pyscreeps_arena.ui.rs_icon import get_icon
+from pyscreeps_arena.ui.rs_icon import get_pixmap
+
 
 
 class ProjectCreatorUI(QMainWindow):
@@ -24,7 +26,7 @@ class ProjectCreatorUI(QMainWindow):
     def _init_ui(self):
         """初始化UI界面"""
         self.setWindowTitle("PyScreeps Arena - 项目创建器")
-        self.setWindowIcon(get_icon())
+        self.setWindowIcon(QIcon(get_pixmap()))
         self.setFixedSize(500, 350)
         
         # 主窗口部件
@@ -210,4 +212,4 @@ def run_project_creator():
 
 
 if __name__ == '__main__':
-    run_project_creator()
+    run_project_creator()

pyscreeps_arena/ui/qcreeplogic/__init__.py

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

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__()