Tiled 1.9 Compatibility Update

Author: Cleptomania

pytiled_parser/layer.py

@@ -43,6 +43,7 @@ class Layer:
         size: Ordered pair of size of map in tiles.
         properties: Properties for the layer.
         tint_color: Tint color that is multiplied with any graphics in this layer.
+        class_: The Tiled class of this Layer.
     """
 
     name: str
@@ -54,6 +55,7 @@ class Layer:
     offset: OrderedPair = OrderedPair(0, 0)
 
     id: Optional[int] = None
+    class_: Optional[str] = None
     size: Optional[Size] = None
     properties: Optional[Properties] = None
     tint_color: Optional[Color] = None

pytiled_parser/parsers/json/layer.py

@@ -40,51 +40,55 @@
     zstd = None
 
 
-class RawChunk(TypedDict):
-    """The keys and their types that appear in a Tiled JSON Chunk Object.
+RawChunk = TypedDict("RawChunk", {
+    "data": Union[List[int], str],
+    "height": int,
+    "width": int,
+    "x": int,
+    "y": int
+})
+RawChunk.__doc__ = """
+    The keys and their types that appear in a Tiled JSON Chunk Object.
 
     Tiled Doc: https://doc.mapeditor.org/en/stable/reference/json-map-format/#chunk
-    """
+"""
 
-    data: Union[List[int], str]
-    height: int
-    width: int
-    x: int
-    y: int
 
 
-class RawLayer(TypedDict):
-    """The keys and their types that appear in a Tiled JSON Layer Object.
+RawLayer = TypedDict("RawLayer", {
+    "chunks": List[RawChunk],
+    "compression": str,
+    "data": Union[List[int], str],
+    "draworder": str,
+    "encoding": str,
+    "height": int,
+    "id": int,
+    "image": str,
+    "layers": List[Any],
+    "name": str,
+    "objects": List[RawObject],
+    "offsetx": float,
+    "offsety": float,
+    "parallaxx": float,
+    "parallaxy": float,
+    "opacity": float,
+    "properties": List[RawProperty],
+    "startx": int,
+    "starty": int,
+    "tintcolor": str,
+    "transparentcolor": str,
+    "class": str,
+    "type": str,
+    "visible": bool,
+    "width": int,
+    "x": int,
+    "y": int
+})
+RawLayer.__doc__ = """
+    The keys and their types that appear in a Tiled JSON Layer Object.
 
     Tiled Doc: https://doc.mapeditor.org/en/stable/reference/json-map-format/#layer
-    """
-
-    chunks: List[RawChunk]
-    compression: str
-    data: Union[List[int], str]
-    draworder: str
-    encoding: str
-    height: int
-    id: int
-    image: str
-    layers: List[Any]
-    name: str
-    objects: List[RawObject]
-    offsetx: float
-    offsety: float
-    parallaxx: float
-    parallaxy: float
-    opacity: float
-    properties: List[RawProperty]
-    startx: int
-    starty: int
-    tintcolor: str
-    transparentcolor: str
-    type: str
-    visible: bool
-    width: int
-    x: int
-    y: int
+"""
 
 
 def _convert_raw_tile_layer_data(data: List[int], layer_width: int) -> List[List[int]]:
@@ -229,6 +233,9 @@ def _parse_common(raw_layer: RawLayer) -> Layer:
     if raw_layer.get("properties") is not None:
         common.properties = parse_properties(raw_layer["properties"])
 
+    if raw_layer.get("class") is not None:
+        common.class_ = raw_layer["class"]
+
     parallax = [1.0, 1.0]
 
     if raw_layer.get("parallaxx") is not None:

pytiled_parser/parsers/json/tiled_map.py

@@ -17,39 +17,40 @@
 from pytiled_parser.tiled_map import TiledMap, TilesetDict
 from pytiled_parser.util import check_format, parse_color
 
-
-class RawTilesetMapping(TypedDict):
-
-    firstgid: int
-    source: str
-
-
-class RawTiledMap(TypedDict):
-    """The keys and their types that appear in a Tiled JSON Map Object.
+RawTilesetMapping = TypedDict("RawTilesetMapping", {
+    "firstgid": int,
+    "source": str
+})
+
+
+RawTiledMap = TypedDict("RawTiledMap", {
+    "backgroundcolor": str,
+    "compressionlevel": int,
+    "height": int,
+    "hexsidelength": int,
+    "infinite": bool,
+    "layers": List[RawLayer],
+    "nextlayerid": int,
+    "nextobjectid": int,
+    "orientation": str,
+    "properties": List[RawProperty],
+    "renderorder": str,
+    "staggeraxis": str,
+    "staggerindex": str,
+    "tiledversion": str,
+    "tileheight": int,
+    "tilesets": List[RawTilesetMapping],
+    "tilewidth": int,
+    "class": str,
+    "type": str,
+    "version": Union[str, float],
+    "width": int
+})
+RawTiledMap.__doc__ = """
+    The keys and their types that appear in a Tiled JSON Map Object.
 
     Tiled Docs: https://doc.mapeditor.org/en/stable/reference/json-map-format/#map
-    """
-
-    backgroundcolor: str
-    compressionlevel: int
-    height: int
-    hexsidelength: int
-    infinite: bool
-    layers: List[RawLayer]
-    nextlayerid: int
-    nextobjectid: int
-    orientation: str
-    properties: List[RawProperty]
-    renderorder: str
-    staggeraxis: str
-    staggerindex: str
-    tiledversion: str
-    tileheight: int
-    tilesets: List[RawTilesetMapping]
-    tilewidth: int
-    type: str
-    version: Union[str, float]
-    width: int
+"""
 
 
 def parse(file: Path) -> TiledMap:
@@ -152,6 +153,9 @@ def parse(file: Path) -> TiledMap:
                 tiled_object.new_tileset = None
                 tiled_object.new_tileset_path = None
 
+    if raw_tiled_map.get("class") is not None:
+        map_.class_ = raw_tiled_map["class"]
+
     if raw_tiled_map.get("backgroundcolor") is not None:
         map_.background_color = parse_color(raw_tiled_map["backgroundcolor"])
 

pytiled_parser/parsers/json/tiled_object.py

@@ -22,53 +22,52 @@
 )
 from pytiled_parser.util import load_object_template, parse_color
 
-
-class RawText(TypedDict):
-    """The keys and their types that appear in a Tiled JSON Text Object.
+RawText = TypedDict("RawText", {
+    "text": str,
+    "color": str,
+    "fontfamily": str,
+    "pixelsize": float,  # this is `font_size` in Text
+    "bold": bool,
+    "italic": bool,
+    "strikeout": bool,
+    "underline": bool,
+    "kerning": bool,
+    "halign": str,
+    "valign": str,
+    "wrap": bool
+})
+RawText.__doc__ = """
+    The keys and their types that appear in a Tiled JSON Text Object.
 
     Tiled Doc: https://doc.mapeditor.org/en/stable/reference/json-map-format/#text-example
-    """
-
-    text: str
-    color: str
-
-    fontfamily: str
-    pixelsize: float  # this is `font_size` in Text
-
-    bold: bool
-    italic: bool
-    strikeout: bool
-    underline: bool
-    kerning: bool
-
-    halign: str
-    valign: str
-    wrap: bool
+"""
 
 
-class RawObject(TypedDict):
-    """The keys and their types that appear in a Tiled JSON Object.
+RawObject = TypedDict("RawObject", {
+    "id": int,
+    "gid": int,
+    "template": str,
+    "x": float,
+    "y": float,
+    "width": float,
+    "height": float,
+    "rotation": float,
+    "visible": bool,
+    "name": str,
+    "class": str,
+    "type": str,
+    "properties": List[RawProperty],
+    "ellipse": bool,
+    "point": bool,
+    "polygon": List[Dict[str, float]],
+    "polyline": List[Dict[str, float]],
+    "text": RawText
+})
+RawObject.__doc__ = """
+    The keys and their types that appear in a Tiled JSON Object.
 
     Tiled Doc: https://doc.mapeditor.org/en/stable/reference/json-map-format/#object
-    """
-
-    id: int
-    gid: int
-    template: str
-    x: float
-    y: float
-    width: float
-    height: float
-    rotation: float
-    visible: bool
-    name: str
-    type: str
-    properties: List[RawProperty]
-    ellipse: bool
-    point: bool
-    polygon: List[Dict[str, float]]
-    polyline: List[Dict[str, float]]
-    text: RawText
+"""
 
 
 def _parse_common(raw_object: RawObject) -> TiledObject:
@@ -88,9 +87,14 @@ def _parse_common(raw_object: RawObject) -> TiledObject:
         size=Size(raw_object["width"], raw_object["height"]),
         rotation=raw_object["rotation"],
         name=raw_object["name"],
-        type=raw_object["type"],
     )
 
+    if raw_object.get("type") is not None:
+        common.class_ = raw_object["type"]
+
+    if raw_object.get("class") is not None:
+        common.class_ = raw_object["class"]
+
     if raw_object.get("properties") is not None:
         common.properties = parse_properties(raw_object["properties"])