rwmap 2.0.0__tar.gz → 3.2.4__tar.gz

{rwmap-2.0.0/src/rwmap.egg-info → rwmap-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwmap
-Version: 2.0.0
+Version: 3.2.4
 Summary: 一个精简的铁锈战争TMX地图操作工具
 Author: KEND
 License-Expression: GPL-3.0-or-later

{rwmap-2.0.0 → rwmap-3.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rwmap"
-version = "2.0.0"
+version = "3.2.4"
 description = "一个精简的铁锈战争TMX地图操作工具"
 readme = "README.md"
 authors = [

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/__init__.py

@@ -5,16 +5,8 @@ from .properties import Property
 from .tiles import Tile, Tileset
 from .templates import Template, template
 
-from .rw import *
-
 
 __all__ = [
     "Property", "Shape", "Object", "ObjectGroup", "Layer", "Tile", "Tileset", "Map",
     "Template", "template",
-    "unit", "UnitSpec",
-    "Trigger", "TriggerLayer", "RwMap",
-    "map_info", "team_info", "unit_detect", "unit_add", "unit_remove",
-    "map_text", "point", "move", "rotate", "change_credits",
-    "basic", "objective", "camera_start", "fall", "set_team", "ai_allow_full_use",
-    "unit_info",
 ]

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/layers.py

@@ -36,6 +36,12 @@ class Layer:
         self.properties = properties or []
         self.data = data[:] if data is not None else [0] * (width * height)
 
+    def property(self, name: str) -> Property:
+        try:
+            return next(prop for prop in self.properties if prop.name == name)
+        except StopIteration:
+            raise KeyError(f"Property '{name}' not found")
+
     def get_tile(self, key: Tuple[int, int]) -> int:
         x, y = key
         if not (0 <= x < self.width and 0 <= y < self.height):

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/maps.py

@@ -1,5 +1,5 @@
 import xml.etree.ElementTree as ET
-from typing import List, Dict, Optional
+from typing import List, Optional
 import os
 
 from .properties import Property
@@ -8,6 +8,7 @@ from .objects import ObjectGroup
 from .layers import Layer
 
 
+
 class Map:
 
     def __init__(self, path: Optional[str] = None):
@@ -22,8 +23,8 @@ class Map:
         self.nextobjectid: int = 1
         self.properties: List[Property] = []
         self.tilesets: List[Tileset] = []
-        self.layers: Dict[str, Layer] = {}
-        self.objectgroups: Dict[str, ObjectGroup] = {}
+        self.layers: List[Layer] = []
+        self.objectgroups: List[ObjectGroup] = []
         if path and os.path.exists(path):
             self.load(path)
 
@@ -44,14 +45,14 @@ class Map:
             for prop_elem in props_elem.findall("property"):
                 self.properties.append(Property.from_xml(prop_elem))
         self.tilesets = [Tileset.from_xml(ts_elem) for ts_elem in root.findall("tileset")]
-        self.layers = {}
+        self.layers = []
         for layer_elem in root.findall("layer"):
             layer = Layer.from_xml(layer_elem)
-            self.layers[layer.name] = layer
-        self.objectgroups = {}
+            self.layers.append(layer)
+        self.objectgroups = []
         for og_elem in root.findall("objectgroup"):
             og = ObjectGroup.from_xml(og_elem)
-            self.objectgroups[og.name] = og
+            self.objectgroups.append(og)
         return self
 
     def save(self, path: Optional[str] = None, encoding: str = "utf-8", indent: Optional[int] = None) -> None:
@@ -74,30 +75,33 @@ class Map:
                 prop.to_xml(props_elem)
         for ts in self.tilesets:
             root.append(ts.to_xml())
-        for layer in self.layers.values():
+        for layer in self.layers:
             root.append(layer.to_xml())
-        for og in self.objectgroups.values():
+        for og in self.objectgroups:
             root.append(og.to_xml())
         if indent is not None:
             ET.indent(root, space=" " * indent)
         tree = ET.ElementTree(root)
         tree.write(out_path, encoding=encoding, xml_declaration=True)
 
+    def property(self, name: str) -> Property:
+        try:
+            return next(prop for prop in self.properties if prop.name == name)
+        except StopIteration:
+            raise KeyError(f"Property '{name}' not found")
+
     def layer(self, name: str) -> Layer:
-        if name not in self.layers:
+        try:
+            return next((layer for layer in self.layers if layer.name == name))
+        except StopIteration:
             raise KeyError(f"Layer '{name}' not found")
-        return self.layers[name]
 
     def objectgroup(self, name: str) -> ObjectGroup:
-        if name not in self.objectgroups:
+        try:
+            return next((og for og in self.objectgroups if og.name == name))
+        except StopIteration:
             raise KeyError(f"ObjectGroup '{name}' not found")
-        return self.objectgroups[name]
-
-    def add_objectgroup(self, group: ObjectGroup) -> None:
-        self.objectgroups[group.name] = group
 
-    def remove_objectgroup(self, name: str) -> None:
-        self.objectgroups.pop(name, None)
 
     def get_tileset_by_gid(self, gid: int) -> Optional[Tileset]:
         for ts in self.tilesets:
@@ -134,5 +138,5 @@ class Map:
         m.tileheight = tile_size
         if layer_names:
             for name in layer_names:
-                m.layers[name] = Layer(name, width, height)
+                m.layers.append(Layer(name, width, height))
         return m

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/objects.py

@@ -51,17 +51,18 @@ class Object:
         self.text = text
         self.properties = properties or []
 
+    def property(self, name: str) -> Property:
+        try:
+            return next(prop for prop in self.properties if prop.name == name)
+        except StopIteration:
+            raise KeyError(f"Property '{name}' not found")
+
     def set(self, **kwargs: Any) -> 'Object':
         for k, v in kwargs.items():
             self.properties = [p for p in self.properties if p.name != k]
             self.properties.append(Property(k, v))
         return self
 
-    def add_property(self, name: str, value: Any, type: Optional[str] = None) -> 'Object':
-        self.properties = [p for p in self.properties if p.name != name]
-        self.properties.append(Property(name, value, type))
-        return self
-
     def copy_xy_from(self, other: 'Object') -> 'Object':
         self.x = other.x
         self.y = other.y
@@ -178,6 +179,12 @@ class ObjectGroup:
         self.offsety = offsety
         self.properties = properties or []
 
+    def property(self, name: str) -> Property:
+        try:
+            return next(prop for prop in self.properties if prop.name == name)
+        except StopIteration:
+            raise KeyError(f"Property '{name}' not found")
+
     def add(self, obj: Object) -> 'ObjectGroup':
         self.objects.append(obj)
         return self

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/rw/__init__.py

@@ -1,5 +1,5 @@
 from .rwmaps import RwMap
-from .triggers import Trigger, TriggerLayer
+from .triggers import Trigger
 from .units import UnitSpec, unit
 from .factories import (
     map_info, team_info, unit_detect, unit_add, unit_remove,
@@ -10,7 +10,7 @@ from .factories import (
 
 __all__ = [
     "unit", "UnitSpec",
-    "Trigger", "TriggerLayer", "RwMap",
+    "Trigger", "RwMap",
     "map_info", "team_info", "unit_detect", "unit_add", "unit_remove",
     "map_text", "point", "move", "rotate", "change_credits",
     "basic", "objective", "camera_start", "fall", "set_team", "ai_allow_full_use",

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/rw/factories.py

@@ -105,13 +105,11 @@ def unit_add(
 
 def unit_remove(
     x: float, y: float, width: float, height: float,
-    team: int = 0,
     onlyIfEmpty: bool = False,
     name: Optional[str] = None,
     **kwargs
 ) -> Trigger:
     obj = Trigger(name=name or f"remove_{x}_{y}", type="unitRemove", x=x, y=y, width=width, height=height)
-    obj.set(team=team)
     if onlyIfEmpty:
         obj.set(onlyIfEmpty=True)
     for k, v in kwargs.items():

rwmap-3.2.4/src/rwmap/rw/rwmaps.py

@@ -0,0 +1,70 @@
+from typing import List, Optional, cast
+
+from .triggers import Trigger
+from ..objects import Object, ObjectGroup
+from ..layers import Layer
+from ..maps import Map
+
+
+class RwMap(Map):
+
+    def __init__(self, path: Optional[str] = None) -> None:
+        super().__init__(path=path)
+
+    @property
+    def triggers(self) -> List[Trigger]:
+        og = self.objectgroup("Triggers")
+        if og is None:
+            og = ObjectGroup(name="Triggers", objects=[])
+            self.objectgroups.append(og)
+        return cast(List[Trigger], og.objects)
+
+    @triggers.setter
+    def triggers(self, triggers: List[Trigger]) -> None:
+        og = self.objectgroup("Triggers")
+        if og is None:
+            og = ObjectGroup(
+                name="Triggers",
+                objects=cast(List[Object], triggers),
+                color=None,
+                opacity=1.0,
+                visible=True,
+                offsetx=0.0,
+                offsety=0.0,
+                properties=None,
+            )
+            self.objectgroups.append(og)
+        else:
+            og.objects = cast(List[Object], triggers)
+
+    @property
+    def ground(self) -> Optional[Layer]:
+        return self.layer("Ground")
+
+    @property
+    def items(self) -> Optional[Layer]:
+        return self.layer("Items")
+
+    @property
+    def units(self) -> Optional[Layer]:
+        return self.layer("Units")
+
+    @classmethod
+    def create_empty(
+        cls,
+        width: int = 256,
+        height: int = 256,
+        tile_size: int = 20,
+        layer_names: Optional[List[str]] = None,
+    ) -> "RwMap":
+        if layer_names is None:
+            layer_names = ["Ground", "Items", "Units", "Set"]
+        m = cls()
+        m.width = width
+        m.height = height
+        m.tilewidth = tile_size
+        m.tileheight = tile_size
+        for name in layer_names:
+            m.layers.append(Layer(name=name, width=width, height=height))
+        _ = m.triggers
+        return m

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/rw/triggers.py

@@ -1,8 +1,7 @@
-import xml.etree.ElementTree as ET
 from typing import List, Optional, Union, Any
 
 from ..properties import Property
-from ..objects import Shape, Object, ObjectGroup
+from ..objects import Shape, Object
 from .units import UnitSpec
 
 
@@ -65,52 +64,3 @@ class Trigger(Object):
 
     def all_to_activate(self, value: bool) -> 'Trigger':
         return self.set(allToActivate=value)
-
-
-class TriggerLayer(ObjectGroup):
-
-    def __init__(
-        self,
-        triggers: Optional[List[Trigger]] = None,
-        color: Optional[str] = None,
-        opacity: float = 1.0,
-        visible: bool = True,
-        offsetx: float = 0.0,
-        offsety: float = 0.0,
-        properties: Optional[List[Property]] = None,
-    ):
-        super().__init__(
-            name="Triggers",
-            objects=triggers if triggers is not None else [],# type: ignore
-            color=color,
-            opacity=opacity,
-            visible=visible,
-            offsetx=offsetx,
-            offsety=offsety,
-            properties=properties,
-        )
-
-    def add(self, trigger: Trigger) -> 'TriggerLayer':# type: ignore
-        super().add(trigger)
-        return self
-
-    def extend(self, triggers: List[Trigger]) -> 'TriggerLayer':# type: ignore
-        super().extend(triggers)# type: ignore
-        return self
-
-    @property
-    def triggers(self) -> List[Trigger]:
-        return self.objects  # type: ignore
-
-    @classmethod
-    def from_xml(cls, elem: ET.Element) -> 'TriggerLayer':
-        og = ObjectGroup.from_xml(elem)
-        return cls(
-            triggers=og.objects,  # type: ignore
-            color=og.color,
-            opacity=og.opacity,
-            visible=og.visible,
-            offsetx=og.offsetx,
-            offsety=og.offsety,
-            properties=og.properties,
-        )

{rwmap-2.0.0 → rwmap-3.2.4}/src/rwmap/tiles.py

@@ -26,10 +26,11 @@ class Tile:
         self.image_height = image_height
         self.image_trans = image_trans
 
-    def set_property(self, name: str, value: Any, type: Optional[str] = None) -> 'Tile':
-        self.properties = [p for p in self.properties if p.name != name]
-        self.properties.append(Property(name, value, type))
-        return self
+    def property(self, name: str) -> Property:
+        try:
+            return next(prop for prop in self.properties if prop.name == name)
+        except StopIteration:
+            raise KeyError(f"Property '{name}' not found")
 
     @classmethod
     def from_xml(cls, elem: ET.Element) -> 'Tile':
@@ -107,6 +108,9 @@ class Tileset:
         self.properties = properties or []
         self.tiles: Dict[int, Tile] = {}
 
+    def property(self, name: str) -> Property | None:
+        return next((prop for prop in self.properties if prop.name == name), None)
+
     def add_tile(self, tile: Tile) -> 'Tileset':
         self.tiles[tile.id] = tile
         return self

{rwmap-2.0.0 → rwmap-3.2.4/src/rwmap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rwmap
-Version: 2.0.0
+Version: 3.2.4
 Summary: 一个精简的铁锈战争TMX地图操作工具
 Author: KEND
 License-Expression: GPL-3.0-or-later

rwmap-2.0.0/src/rwmap/rw/rwmaps.py

@@ -1,77 +0,0 @@
-from typing import List, Optional
-
-from .triggers import TriggerLayer
-from ..layers import Layer
-from ..maps import Map
-
-
-class RwMap(Map):
-
-    def __init__(self, path: Optional[str] = None):
-        super().__init__(path)
-        self._triggers: Optional[TriggerLayer] = None
-        if "Triggers" in self.objectgroups:
-            og = self.objectgroups["Triggers"]
-            if isinstance(og, TriggerLayer):
-                self._triggers = og
-            else:
-                self._triggers = TriggerLayer(
-                    triggers=og.objects,  # type: ignore
-                    color=og.color,
-                    opacity=og.opacity,
-                    visible=og.visible,
-                    offsetx=og.offsetx,
-                    offsety=og.offsety,
-                    properties=og.properties,
-                )
-                self.objectgroups["Triggers"] = self._triggers
-
-    @property
-    def triggers(self) -> TriggerLayer:
-        if self._triggers is None:
-            self._triggers = TriggerLayer()
-            self.objectgroups["Triggers"] = self._triggers
-        return self._triggers
-
-    @triggers.setter
-    def triggers(self, layer: TriggerLayer) -> None:
-        self._triggers = layer
-        self.objectgroups["Triggers"] = layer
-
-    @property
-    def ground(self) -> Optional[Layer]:
-        return self.layers.get("Ground")
-
-    @property
-    def items(self) -> Optional[Layer]:
-        return self.layers.get("Items")
-
-    @property
-    def units(self) -> Optional[Layer]:
-        return self.layers.get("Units")
-
-    @property
-    def set_layer(self) -> Optional[Layer]:
-        return self.layers.get("Set")
-
-    @classmethod
-    def create_empty(
-        cls,
-        width: int = 256,
-        height: int = 256,
-        tile_size: int = 20,
-        layer_names: Optional[List[str]] = None
-    ) -> 'RwMap':
-        if layer_names is None:
-            layer_names = ["Ground", "Items", "Units", "Set"]
-        m = cls()
-        m.width = width
-        m.height = height
-        m.tilewidth = tile_size
-        m.tileheight = tile_size
-        for name in layer_names:
-            m.layers[name] = Layer(name, width, height)
-        _ = m.triggers  # 触发自动创建
-        return m
-
-