pyscreeps-arena 0.5.7.3__tar.gz → 0.5.7.4__tar.gz

{pyscreeps_arena-0.5.7.3 → pyscreeps_arena-0.5.7.4}/PKG-INFO

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

{pyscreeps_arena-0.5.7.3 → pyscreeps_arena-0.5.7.4}/pyscreeps_arena/core/const.py

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

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/__init__.py

@@ -0,0 +1 @@
+from pyscreeps_arena.ui.qmapker.qmapmarker import QPSAMapMarker

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/qmapmarker.py

@@ -0,0 +1,339 @@
+# -*- coding: utf-8 -*-
+"""
+QPSA Map Marker Component - 地图标记组件
+左右大布局，右边是QPSAMapViewer，左边是信息栏
+"""
+from typing import List, Dict, Any, Optional
+import json
+from PyQt6.QtWidgets import (QWidget, QHBoxLayout, QVBoxLayout, QPushButton, 
+                             QListWidget, QListWidgetItem, QFrame, QSpacerItem,
+                             QSizePolicy, QApplication)
+from PyQt6.QtCore import Qt, pyqtSignal, pyqtSlot
+from PyQt6.QtGui import QPixmap
+
+from pyscreeps_arena.ui.qmapv.qmapv import QPSAMapViewer
+from pyscreeps_arena.ui.qmapv.qcinfo import QPSACellInfo
+from pyscreeps_arena.ui.qmapker.qvariable import QPSACoVariable
+from pyscreeps_arena.ui.qmapker.to_code import json2code
+
+
+class AddVariableWidget(QWidget):
+    """Special widget with centered + button to add new variable."""
+    
+    # Signal emitted when add button is clicked
+    addRequested = pyqtSignal()
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._init_ui()
+        
+    def _init_ui(self):
+        """Initialize UI components."""
+        # Main layout with center alignment
+        layout = QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        
+        # Add button with + symbol
+        self._add_button = QPushButton("➕")
+        self._add_button.setFixedSize(40, 40)
+        self._add_button.setStyleSheet("""
+            QPushButton {
+                border: 2px dashed #ccc;
+                border-radius: 20px;
+                background-color: #f9f9f9;
+                font-size: 20px;
+                color: #666;
+            }
+            QPushButton:hover {
+                border-color: #2196f3;
+                background-color: #e3f2fd;
+                color: #2196f3;
+            }
+            QPushButton:pressed {
+                background-color: #bbdefb;
+            }
+        """)
+        self._add_button.clicked.connect(self.addRequested.emit)
+        layout.addWidget(self._add_button)
+        
+        self.setLayout(layout)
+
+
+class QPSAMapMarker(QWidget):
+    """Map marker component with left info panel and right map viewer."""
+    
+    # Signals
+    onVariableChanged = pyqtSignal()  # Emitted when any variable is changed
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._variables: List[QPSACoVariable] = []
+        self._selected_cell_info: Optional[Dict[str, Any]] = None
+        self._init_ui()
+        
+    def _init_ui(self):
+        """Initialize UI components."""
+        # Main horizontal layout (left-right)
+        main_layout = QHBoxLayout()
+        main_layout.setContentsMargins(6, 6, 6, 6)
+        main_layout.setSpacing(8)
+        
+        # Left panel (info栏)
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        left_layout.setContentsMargins(0, 0, 0, 0)
+        left_layout.setSpacing(8)
+        
+        # First row - selected cell info
+        self._cell_info = QPSACellInfo()
+        self._cell_info.setMinimumWidth(200)
+        # self._cell_info.setMaximumHeight(200)
+        left_layout.addWidget(self._cell_info)
+        
+        # Second row - variables list
+        self._variables_list = QListWidget()
+        self._variables_list.setFrameStyle(QFrame.Shape.Box)
+        self._variables_list.setStyleSheet("""
+            QListWidget {
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                background-color: white;
+            }
+            QListWidget::item {
+                border-bottom: 1px solid #eee;
+            }
+            QListWidget::item:selected {
+                background-color: #e3f2fd;
+            }
+        """)
+        self._variables_list.setSpacing(4)
+        self._variables_list.setMinimumWidth(200)
+        # self._variables_list.setMaximumHeight(200)
+        left_layout.addWidget(self._variables_list)
+        
+        # Third row - control buttons
+        button_layout = QHBoxLayout()
+        button_layout.setContentsMargins(0, 0, 0, 0)
+        button_layout.setSpacing(8)
+        
+        # Reset button
+        self._reset_button = QPushButton("Reset")
+        self._reset_button.setFixedHeight(30)
+        self._reset_button.setFixedWidth(80)
+        self._reset_button.setStyleSheet("""
+            QPushButton {
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                background-color: #f44336;
+                color: white;
+                font-size: 12px;
+                font-weight: bold;
+            }
+            QPushButton:hover {
+                background-color: #d32f2f;
+            }
+            QPushButton:pressed {
+                background-color: #b71c1c;
+            }
+        """)
+        self._reset_button.clicked.connect(self._on_reset_clicked)
+        button_layout.addWidget(self._reset_button)
+        
+        # Copy button
+        self._copy_button = QPushButton("Copy")
+        self._copy_button.setFixedHeight(30)
+        self._copy_button.setFixedWidth(80) 
+        self._copy_button.setStyleSheet("""
+            QPushButton {
+                border: 1px solid #ccc;
+                border-radius: 4px;
+                background-color: #2196f3;
+                color: white;
+                font-size: 12px;
+                font-weight: bold;
+            }
+            QPushButton:hover {
+                background-color: #1976d2;
+            }
+            QPushButton:pressed {
+                background-color: #1565c0;
+            }
+        """)
+        self._copy_button.clicked.connect(self._on_copy_clicked)
+        button_layout.addWidget(self._copy_button)
+        
+        button_layout.addStretch()
+        left_layout.addLayout(button_layout)
+        
+        # Add initial add widget
+        self._add_add_widget()
+        
+        main_layout.addWidget(left_panel, 1)  # Left panel takes 1/4 space
+        
+        # Right panel - map viewer
+        self._map_viewer = QPSAMapViewer()
+        main_layout.addWidget(self._map_viewer, 3)  # Map viewer takes 3/4 space
+        
+        self.setLayout(main_layout)
+        
+        # Connect map viewer signals
+        self._map_viewer.selectChanged.connect(self._on_cell_selected)
+        
+    def _add_add_widget(self):
+        """Add the special add widget to the list."""
+        add_widget = AddVariableWidget()
+        add_widget.addRequested.connect(self._on_add_variable)
+        
+        # Create list item
+        list_item = QListWidgetItem()
+        list_item.setSizeHint(add_widget.sizeHint())
+        
+        self._variables_list.addItem(list_item)
+        self._variables_list.setItemWidget(list_item, add_widget)
+        
+    def _add_variable_widget(self, variable: QPSACoVariable):
+        """Add a variable widget to the list."""
+        # Create list item first
+        list_item = QListWidgetItem()
+        list_item.setSizeHint(variable.sizeHint())
+        
+        # Connect variable signals
+        variable.onItemChanged.connect(self._on_variable_changed)
+        variable.removeRequested.connect(lambda: self._on_remove_variable(variable))
+        
+        # Connect to dual button clicks to update size
+        variable._dual_button.clicked.connect(lambda: self._on_variable_dual_changed(variable, list_item))
+        
+        self._variables_list.insertItem(self._variables_list.count() - 1, list_item)
+        self._variables_list.setItemWidget(list_item, variable)
+        
+        self._variables.append(variable)
+        
+    @pyqtSlot()
+    def _on_add_variable(self):
+        """Handle add variable button click."""
+        print("[DEBUG] Adding new variable")
+        new_variable = QPSACoVariable()
+        new_variable.showRemoveButton = True  # Set remove button to be visible
+        self._add_variable_widget(new_variable)
+        
+    def _on_remove_variable(self, variable: QPSACoVariable):
+        """Handle remove variable request."""
+        print("[DEBUG] Removing variable")
+        
+        # Find the variable in the list
+        if variable in self._variables:
+            # Find the corresponding list item
+            for i in range(self._variables_list.count()):
+                item = self._variables_list.item(i)
+                if item:
+                    widget = self._variables_list.itemWidget(item)
+                    if widget == variable:
+                        # Remove from list
+                        self._variables_list.takeItem(i)
+                        # Remove from variables list
+                        self._variables.remove(variable)
+                        # Delete the widget
+                        variable.deleteLater()
+                        print(f"[DEBUG] Variable removed at index {i}")
+                        break
+        
+        self.onVariableChanged.emit()
+        
+    def _on_variable_dual_changed(self, variable: QPSACoVariable, list_item: QListWidgetItem):
+        """Handle dual mode change for a variable."""
+        # Update the list item size hint when dual mode changes
+        new_size = variable.sizeHint()
+        list_item.setSizeHint(new_size)
+        print(f"[DEBUG] Dual mode changed, updated item size: {new_size}")
+    
+    @pyqtSlot()
+    def _on_copy_clicked(self):
+        """Handle copy button click to copy variables to clipboard as Python code."""
+        print("[DEBUG] Copying variables to clipboard as Python code")
+        
+        # Get variables data
+        variables_data = self.variables
+        print(f"[DEBUG] Variables data: {variables_data}")
+        
+        # Convert to Python code using json2code function
+        try:
+            code = json2code(variables_data)
+            print(f"[DEBUG] Generated code: {code}")
+            
+            # Copy to clipboard
+            clipboard = QApplication.clipboard()
+            clipboard.setText(code)
+            print("[DEBUG] Python code copied to clipboard")
+        except Exception as e:
+            print(f"[DEBUG] Error generating code: {e}")
+            # Fallback to JSON if code generation fails
+            json_str = json.dumps(variables_data, ensure_ascii=False, indent=2)
+            clipboard = QApplication.clipboard()
+            clipboard.setText(json_str)
+            print("[DEBUG] JSON fallback copied to clipboard")
+        
+    @pyqtSlot()
+    def _on_reset_clicked(self):
+        """Handle reset button click."""
+        print("[DEBUG] Resetting info panel")
+        
+        # Clear cell info
+        self._cell_info.data = None
+        self._selected_cell_info = None
+        
+        # Clear all variables
+        for variable in self._variables:
+            variable.reset()
+            
+        # Remove all variable widgets from list (keep only add widget)
+        while self._variables_list.count() > 1:
+            item = self._variables_list.takeItem(0)
+            if item:
+                widget = self._variables_list.itemWidget(item)
+                if widget and widget != self._variables_list.itemWidget(self._variables_list.item(self._variables_list.count() - 1)):
+                    widget.deleteLater()
+        
+        self._variables.clear()
+        
+    @pyqtSlot(object)
+    def _on_cell_selected(self, cell_info):
+        """Handle cell selection from map viewer."""
+        print(f"[DEBUG] Cell selected: {cell_info}")
+        if cell_info:
+            self._cell_info.data = cell_info
+            # Transfer screenshot to QPSACellInfo
+            self._cell_info.image = self._map_viewer.image
+            self._selected_cell_info = {
+                'x': cell_info.x,
+                'y': cell_info.y,
+                'terrain': cell_info.terrain,
+                'objects': cell_info.objects.copy() if cell_info.objects else []
+            }
+        else:
+            self._cell_info.data = None
+            self._selected_cell_info = None
+            
+    @pyqtSlot()
+    def _on_variable_changed(self):
+        """Handle variable changes."""
+        print("[DEBUG] Variable changed")
+        self.onVariableChanged.emit()
+        
+    # Properties
+    @property
+    def variables(self) -> List[Dict[str, Any]]:
+        """Get all variables as list of dictionaries."""
+        return [var.data for var in self._variables]
+        
+    @property
+    def selectedCellInfo(self) -> Optional[Dict[str, Any]]:
+        """Get selected cell information."""
+        return self._selected_cell_info.copy() if self._selected_cell_info else None
+        
+    @property
+    def mapViewer(self) -> QPSAMapViewer:
+        """Get the map viewer component."""
+        return self._map_viewer

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/qvariable.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+"""
+QPSA Co Variable Component - 对称变量组件
+"""
+from typing import List, Dict, Any
+from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
+                             QLineEdit, QPushButton, QFrame, QSpacerItem,
+                             QSizePolicy)
+from PyQt6.QtCore import Qt, pyqtSignal, pyqtSlot, QSize
+from PyQt6.QtGui import QPalette, QColor
+
+from pyscreeps_arena.ui.qmapv import QPSACellObject
+
+# Import configuration from build.py
+import sys
+import os
+# Add the project root directory to Python path
+from pyscreeps_arena import config
+
+# Language mapping
+LANG = {
+    'cn': {
+        'symmetric': '对称',
+    },
+    'en': {
+        'symmetric': 'Symmetric',
+    }
+}
+
+def lang(key: str) -> str:
+    """Helper function to get translated text"""
+    return LANG[config.language if hasattr(config, 'language') and config.language in LANG else 'cn'][key]
+
+
+class QPSACoVariable(QWidget):
+    """Co-variable component with symmetric option."""
+    
+    # Class variable to track instance count
+    _instance_count = 0
+    
+    # Signals
+    onItemChanged = pyqtSignal()  # Emitted when any item is added or removed
+    removeRequested = pyqtSignal()  # Emitted when remove button is clicked
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._dual = False
+        self._true_objects = []
+        self._false_objects = []
+        self._show_remove_btn = False  # New property to control remove button
+        
+        # Increment instance count and get the current number
+        QPSACoVariable._instance_count += 1
+        self._instance_number = QPSACoVariable._instance_count
+        
+        self._init_ui()
+        
+    def _init_ui(self):
+        """Initialize UI components."""
+        # Main vertical layout
+        main_layout = QVBoxLayout()
+        main_layout.setContentsMargins(4, 4, 4, 4)  # Reduced margins
+        main_layout.setSpacing(3)  # Reduced spacing
+        
+        # First row - input, checkbox, and remove button in 7:3:2 ratio
+        top_row = QHBoxLayout()
+        top_row.setContentsMargins(0, 0, 0, 0)
+        top_row.setSpacing(2)  # Reduced spacing
+        
+        # Input box with placeholder (70%)
+        self._input = QLineEdit()
+        self._input.setPlaceholderText(f"VAR{self._instance_number}")
+        self._input.setStyleSheet("font-size: 11px;")  # Reduced font size
+        self._input.setFixedHeight(24)  # Reduced height
+        top_row.addWidget(self._input, 7)
+        
+        # Button-style checkbox for dual mode (30%)
+        self._dual_button = QPushButton(lang('symmetric'))
+        self._dual_button.setCheckable(True)
+        self._dual_button.setFixedHeight(24)  # Reduced from 22 to 18
+        self._dual_button.setStyleSheet("""
+            QPushButton {
+                border: 1px solid #ccc;
+                border-radius: 2px;
+                background-color: #f0f0f0;
+                font-size: 9px;
+                padding: 1px;
+            }
+            QPushButton:checked {
+                background-color: #e3f2fd;
+                border-color: #2196f3;
+            }
+        """)
+        self._dual_button.clicked.connect(self._on_dual_changed)
+        top_row.addWidget(self._dual_button, 3)
+        
+        # Remove button (20% - shown based on property)
+        self._remove_btn = QPushButton("⛔")
+        self._remove_btn.setFixedHeight(24)
+        self._remove_btn.setFixedWidth(24)  # Make it square
+        self._remove_btn.setStyleSheet("""
+            QPushButton {
+                border: 1px solid #ff6b6b;
+                border-radius: 12px;
+                background-color: #ffe6e6;
+                color: #ff6b6b;
+                font-size: 10px;
+                font-weight: bold;
+            }
+            QPushButton:hover {
+                background-color: #ff6b6b;
+                color: white;
+            }
+            QPushButton:pressed {
+                background-color: #ff5252;
+            }
+        """)
+        self._remove_btn.clicked.connect(self._on_remove_clicked)
+        self._remove_btn.setVisible(self._show_remove_btn)
+        top_row.addWidget(self._remove_btn, 2)
+        
+        main_layout.addLayout(top_row)
+        
+        # Second row - QPSACellObject components
+        objects_widget = QWidget()
+        self._objects_layout = QVBoxLayout(objects_widget)
+        self._objects_layout.setContentsMargins(0, 0, 0, 0)
+        self._objects_layout.setSpacing(2)  # Reduced spacing
+        
+        # True objects section
+        self._true_objects_widget = QPSACellObject()
+        self._true_objects_widget.objectAdded.connect(self._on_item_changed)
+        self._true_objects_widget.objectRemoved.connect(self._on_item_changed)
+        self._true_objects_widget.itemChanged.connect(self._on_item_changed)
+        self._objects_layout.addWidget(self._true_objects_widget)
+        
+        # Separator for dual mode
+        self._mid_separator = QFrame()
+        self._mid_separator.setFrameShape(QFrame.Shape.HLine)
+        self._mid_separator.setFrameShadow(QFrame.Shadow.Sunken)
+        self._mid_separator.setVisible(False)
+        self._objects_layout.addWidget(self._mid_separator)
+        
+        # False objects section (for dual mode)
+        self._false_objects_widget = QPSACellObject()
+        self._false_objects_widget.objectAdded.connect(self._on_item_changed)
+        self._false_objects_widget.objectRemoved.connect(self._on_item_changed)
+        self._false_objects_widget.itemChanged.connect(self._on_item_changed)
+        # Set background color to #FFF0F5 (light red) for the list content
+        self._false_objects_widget.set_list_background_color("#FFF0F5")
+        self._false_objects_widget.setVisible(False)
+        self._objects_layout.addWidget(self._false_objects_widget)
+        
+        main_layout.addWidget(objects_widget)
+        
+        self.setLayout(main_layout)
+        self.setMinimumWidth(182)
+        self.setMaximumWidth(182)
+        
+    @pyqtSlot(bool)
+    def _on_dual_changed(self, checked: bool):
+        """Handle dual mode toggle."""
+        self._dual = checked
+        self._false_objects_widget.setVisible(checked)
+        self._mid_separator.setVisible(checked)
+        self._on_item_changed()
+    
+    @pyqtSlot()
+    def _on_remove_clicked(self):
+        """Handle remove button click."""
+        self.removeRequested.emit()  # Request removal from parent
+    
+    @pyqtSlot()
+    def _on_item_changed(self):
+        """Handle item changes in QPSACellObject components."""
+        # Update internal lists
+        self._true_objects = self._true_objects_widget.objects
+        if self._dual:
+            self._false_objects = self._false_objects_widget.objects
+        else:
+            self._false_objects = []
+        
+        # Emit callback
+        self.onItemChanged.emit()
+    
+    # Properties
+    @property
+    def dual(self) -> bool:
+        """Get/set dual mode status."""
+        return self._dual
+    
+    @dual.setter
+    def dual(self, value: bool):
+        """Set dual mode status."""
+        self._dual = value
+        self._dual_button.setChecked(value)
+        self._false_objects_widget.setVisible(value)
+        self._mid_separator.setVisible(value)
+        self._on_item_changed()
+        
+        # Recalculate height by updating size hint and notifying parent
+        self.updateGeometry()
+        if self.parent():
+            # Notify parent layout to recalculate
+            self.parent().updateGeometry()
+            
+            # If this is in a QListWidget, update the item size
+            if hasattr(self.parent(), 'parent') and self.parent().parent():
+                list_widget = self.parent().parent()
+                if hasattr(list_widget, 'itemWidget'):
+                    # Find the corresponding item and update its size hint
+                    for i in range(list_widget.count()):
+                        item = list_widget.item(i)
+                        if item and list_widget.itemWidget(item) == self:
+                            item.setSizeHint(self.sizeHint())
+                            print(f"[DEBUG] Updated item size hint for dual mode: {self.sizeHint()}")
+                            break
+    
+    @property
+    def trueObjects(self) -> List[Dict[str, Any]]:
+        """Get true objects list."""
+        return self._true_objects.copy()
+    
+    @trueObjects.setter
+    def trueObjects(self, value: List[Dict[str, Any]]):
+        """Set true objects list."""
+        # Clear current objects
+        self._true_objects_widget.clear_objects()
+        # Add new objects
+        for obj in value:
+            self._true_objects_widget.add_object(obj)
+        self._on_item_changed()
+    
+    @property
+    def falseObjects(self) -> List[Dict[str, Any]]:
+        """Get false objects list."""
+        return self._false_objects.copy()
+    
+    @falseObjects.setter
+    def falseObjects(self, value: List[Dict[str, Any]]):
+        """Set false objects list."""
+        # Clear current objects
+        self._false_objects_widget.clear_objects()
+        # Add new objects
+        for obj in value:
+            self._false_objects_widget.add_object(obj)
+        self._on_item_changed()
+    
+    @property
+    def showRemoveButton(self) -> bool:
+        """Get/set whether to show the remove button."""
+        return self._show_remove_btn
+    
+    @showRemoveButton.setter
+    def showRemoveButton(self, value: bool):
+        """Set whether to show the remove button."""
+        self._show_remove_btn = value
+        self._remove_btn.setVisible(value)
+    
+    def reset(self):
+        """Reset component to default state."""
+        self._input.clear()
+        self.dual = False
+        self._true_objects_widget.clear_objects()
+        self._false_objects_widget.clear_objects()
+    
+    def sizeHint(self):
+        """Calculate preferred size based on dual mode."""
+        # Base height for single mode
+        base_height = 120
+        
+        # Add height for dual mode (additional objects widget)
+        if self._dual:
+            base_height += 80  # Additional space for false objects
+            
+        # Add height based on content
+        true_count = len(self._true_objects_widget.objects)
+        false_count = len(self._false_objects_widget.objects) if self._dual else 0
+        
+        # Estimate height based on object count (roughly 25px per object)
+        content_height = max(true_count, false_count) * 25
+        total_height = base_height + content_height
+        
+        # Keep width fixed
+        return QSize(182, min(total_height, 400))  # Cap at 400px max height
+    
+    @property
+    def data(self) -> Dict[str, Any]:
+        """Get component data as a dictionary."""
+        # Use placeholder text as key if input is empty
+        key = self._input.text() if self._input.text() else self._input.placeholderText()
+        return {
+            'key': key,
+            'dual': self._dual,
+            'pos': self._true_objects.copy(),
+            'neg': self._false_objects.copy()
+        }
+    
+    # Static method to get current instance count
+    @staticmethod
+    def get_instance_count() -> int:
+        """Get current instance count."""
+        return QPSACoVariable._instance_count

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/test_compact_variable.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test script for compact QPSACoVariable component
+"""
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from PyQt6.QtWidgets import QApplication, QVBoxLayout, QWidget, QPushButton, QLabel
+from PyQt6.QtCore import Qt
+from pyscreeps_arena.ui.qmapker.qvariable import QPSACoVariable
+
+
+def test_compact_variable():
+    """Test the compact QPSACoVariable component."""
+    app = QApplication(sys.argv)
+    
+    # Create main window
+    window = QWidget()
+    window.setWindowTitle("Compact QPSACoVariable Test")
+    window.resize(400, 300)
+    
+    # Create layout
+    layout = QVBoxLayout()
+    layout.setContentsMargins(10, 10, 10, 10)
+    layout.setSpacing(5)
+    
+    # Add title
+    title = QLabel("Compact QPSACoVariable Components")
+    title.setStyleSheet("font-weight: bold; font-size: 14px;")
+    title.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    layout.addWidget(title)
+    
+    # Create multiple compact QPSACoVariable components
+    for i in range(3):
+        variable = QPSACoVariable()
+        variable._input.setText(f"Test{i+1}")
+        layout.addWidget(variable)
+    
+    # Add button to test dual mode
+    def toggle_dual():
+        for widget in window.findChildren(QPSACoVariable):
+            widget.dual = not widget.dual
+    
+    test_button = QPushButton("Toggle Dual Mode")
+    test_button.clicked.connect(toggle_dual)
+    layout.addWidget(test_button)
+    
+    # Add stretch to push everything up
+    layout.addStretch()
+    
+    window.setLayout(layout)
+    window.show()
+    
+    print("[DEBUG] Compact QPSACoVariable test window initialized")
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    test_compact_variable()

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/test_qmapmarker.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test script for QPSAMapMarker component
+"""
+import sys
+import os
+
+# Add the parent directory to the path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
+
+from PyQt6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel
+from PyQt6.QtCore import Qt
+from pyscreeps_arena.ui.qmapker.qmapmarker import QPSAMapMarker
+from pyscreeps_arena.core import config
+config.language = 'en'
+
+class TestWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("QPSAMapMarker Test")
+        self.setGeometry(100, 100, 1200, 800)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        
+        # Main layout
+        layout = QVBoxLayout()
+        
+        # Title
+        title_label = QLabel("QPSAMapMarker Component Test")
+        title_label.setStyleSheet("font-size: 18px; font-weight: bold; padding: 10px;")
+        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(title_label)
+        
+        # Create map marker component
+        self.map_marker = QPSAMapMarker()
+        layout.addWidget(self.map_marker)
+        
+        # Status label
+        self.status_label = QLabel("Select a cell on the map to see its info")
+        self.status_label.setStyleSheet("font-size: 12px; color: #666; padding: 10px;")
+        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.status_label)
+        
+        # Connect signals
+        self.map_marker.onVariableChanged.connect(self.on_variable_changed)
+        
+        central_widget.setLayout(layout)
+        
+        print("[DEBUG] QPSAMapMarker test window initialized")
+        
+    def on_variable_changed(self):
+        """Handle variable changes."""
+        variables = self.map_marker.variables
+        self.status_label.setText(f"Variables updated: {len(variables)} variables")
+        print(f"[DEBUG] Variables changed: {len(variables)} variables")
+        
+        # Print variable details
+        for i, variable in enumerate(variables):
+            print(f"  Variable {i+1}: {len(variable['pos'])} true objects, {len(variable['neg'])} false objects")
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    window = TestWindow()
+    window.show()
+    sys.exit(app.exec())
+
+
+    

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/test_qvariable.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+"""
+Test script for QPSACoVariable component
+"""
+import sys
+from PyQt6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
+from pyscreeps_arena.ui.qmapker.qvariable import QPSACoVariable
+
+
+class TestWindow(QMainWindow):
+    """Test window to display QPSACoVariable component."""
+    
+    def __init__(self):
+        super().__init__()
+        self._init_ui()
+        
+    def _init_ui(self):
+        """Initialize UI."""
+        self.setWindowTitle("QPSACoVariable Test")
+        self.setGeometry(100, 100, 800, 400)
+        
+        # Central widget
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        
+        # Main layout
+        main_layout = QVBoxLayout(central_widget)
+        
+        # Add multiple QPSACoVariable components to test instance counting
+        for i in range(3):
+            co_var = QPSACoVariable()
+            co_var.onItemChanged.connect(self._on_item_changed)
+            main_layout.addWidget(co_var)
+    
+    def _on_item_changed(self):
+        """Handle item changed signal."""
+        print("Item changed!")
+
+
+def main():
+    """Main function."""
+    app = QApplication(sys.argv)
+    window = TestWindow()
+    window.show()
+    sys.exit(app.exec())
+
+
+if __name__ == '__main__':
+    main()

pyscreeps_arena-0.5.7.4/pyscreeps_arena/ui/qmapker/to_code.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import json
+
+
+def json2code(data: list) -> str:
+    """
+    Convert data to Python code according to the specified rules.
+    Args:
+        data: List of variable dictionaries to convert
+    Returns: Generated Python code as a string
+    """
+    # Ensure the data is a list
+    if not isinstance(data, list):
+        raise ValueError("Data must be a list")
+    
+    generated_code = []
+    
+    for element in data:
+        key = element.get('key', '')
+        dual = element.get('dual', False)
+        pos = element.get('pos', [])
+        neg = element.get('neg', [])
+        
+        # Check if pos is empty
+        if not pos:
+            print(f"Warning: pos is empty for key '{key}', skipping this element.")
+            continue
+        
+        # Check if neg is empty when dual is enabled
+        if dual and not neg:
+            print(f"Warning: neg is empty for key '{key}' with dual=True, skipping this element.")
+            continue
+        
+        # Step 2: Generate pk and epk if dual is enabled
+        pk = key
+        epk = None
+        if dual:
+            if pk.startswith('E'):
+                epk = f'E_{pk}'
+            else:
+                epk = f'E{pk}'
+        
+        # Step 3: Process pos list
+        pos_translations = []
+        for item in pos:
+            method = item.get('method', '')
+            x = item.get('x', 0)
+            y = item.get('y', 0)
+            pos_translations.append(f"{method}({x}, {y})")
+        
+        # Format posv based on length
+        if len(pos_translations) > 1:
+            posv = f"[{', '.join(pos_translations)}]"
+        else:
+            posv = pos_translations[0]
+        
+        # Step 4: Process neg list if dual is enabled
+        negv = None
+        if dual:
+            neg_translations = []
+            for item in neg:
+                method = item.get('method', '')
+                x = item.get('x', 0)
+                y = item.get('y', 0)
+                neg_translations.append(f"{method}({x}, {y})")
+            
+            # Format negv based on length
+            if len(neg_translations) > 1:
+                negv = f"[{', '.join(neg_translations)}]"
+            else:
+                negv = neg_translations[0]
+        
+        # Step 6: Generate code lines for this element
+        element_code = []
+        
+        # Base line for pos
+        element_code.append(f"{pk} = {posv}")
+        
+        # Additional lines if dual is enabled
+        if dual and epk and negv:
+            element_code.append(f"{epk} = {negv}")
+            element_code.append(f"if SIDE == 1: {pk}, {epk} = {epk}, {pk}")
+        
+        element_code.append('')  # empty
+
+        # Add to generated code
+        generated_code.extend(element_code)
+    
+    # Step 7: Join all lines and return
+    return '\n'.join(generated_code)
+
+
+# Test the function
+if __name__ == "__main__":
+    # Read the test.json file for testing
+    with open('test.json', 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    code = json2code(data)
+    print(code)

{pyscreeps_arena-0.5.7.3 → pyscreeps_arena-0.5.7.4}/pyscreeps_arena.egg-info/PKG-INFO

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

{pyscreeps_arena-0.5.7.3 → pyscreeps_arena-0.5.7.4}/pyscreeps_arena.egg-info/SOURCES.txt

@@ -27,6 +27,13 @@ pyscreeps_arena/ui/rs_icon.py
 pyscreeps_arena/ui/qcreeplogic/__init__.py
 pyscreeps_arena/ui/qcreeplogic/model.py
 pyscreeps_arena/ui/qcreeplogic/qcreeplogic.py
+pyscreeps_arena/ui/qmapker/__init__.py
+pyscreeps_arena/ui/qmapker/qmapmarker.py
+pyscreeps_arena/ui/qmapker/qvariable.py
+pyscreeps_arena/ui/qmapker/test_compact_variable.py
+pyscreeps_arena/ui/qmapker/test_qmapmarker.py
+pyscreeps_arena/ui/qmapker/test_qvariable.py
+pyscreeps_arena/ui/qmapker/to_code.py
 pyscreeps_arena/ui/qmapv/__init__.py
 pyscreeps_arena/ui/qmapv/qcinfo.py
 pyscreeps_arena/ui/qmapv/qco.py

{pyscreeps_arena-0.5.7.3 → pyscreeps_arena-0.5.7.4}/setup.py

@@ -7,7 +7,7 @@ with open(r"T:\New_PC\Import_Project\uploads\pyscreeps-arena_upload\pyscreeps-ar
     long_description = f.read()
 setup(
     name='pyscreeps-arena',
-    version='0.5.7.3',
+    version='0.5.7.4',
     description='Python api|interface to play game: Screeps: Arena.',
     long_description=long_description,
     long_description_content_type='text/markdown',