gmd-editor 0.1.0__py3-none-any.whl

gmd_editor/__init__.py

@@ -0,0 +1,10 @@
+"""
+gmdlib - A library for decoding, encoding, and editing Geometry Dash .gmd files.
+"""
+
+from .level import GMDLevel
+from .objects import GDObject
+from .io import load, save
+
+__version__ = "0.1.0"
+__all__ = ["GMDLevel", "GDObject", "load", "save"]

gmd_editor/codec.py

@@ -0,0 +1,62 @@
+"""
+Low-level codec functions for Geometry Dash .gmd base64/gzip encoding.
+"""
+
+import gzip
+import base64
+
+
+def fix_padding(gmd: str) -> str:
+    """Fix broken base64 padding that GD sometimes writes into .gmd files."""
+    gmd = gmd.replace("AAA</s><k>k", "AAA==</s><k>k")
+    gmd = gmd.replace("AA</s><k>k",  "AA=</s><k>k")
+    gmd = gmd.replace("A</s><k>k",   "A=</s><k>k")
+    return gmd
+
+
+def extract_b64(gmd: str) -> str:
+    """Extract the raw base64-encoded level string from a .gmd file."""
+    marker = "k4</k><s>"
+    start = gmd.find(marker)
+    if start == -1:
+        raise ValueError("Could not find level data marker 'k4</k><s>' in .gmd file.")
+    start += len(marker)
+    end = gmd.find("<", start)
+    return gmd[start:end]
+
+
+def inject_b64(gmd: str, new_b64: str) -> str:
+    """Replace the encoded level data inside a .gmd string with new_b64."""
+    marker = "k4</k><s>"
+    start = gmd.find(marker)
+    if start == -1:
+        raise ValueError("Could not find level data marker 'k4</k><s>' in .gmd file.")
+    start += len(marker)
+    end = gmd.find("<", start)
+    return gmd[:start] + new_b64 + gmd[end:]
+
+
+def decode_level_string(b64url: str) -> str:
+    """
+    Decode a GD-format base64url+gzip level string into a plain text level string.
+
+    GD uses URL-safe base64 (- and _ instead of + and /) and strips padding.
+    """
+    b64 = b64url.replace("-", "+").replace("_", "/")
+    # Restore padding
+    remainder = len(b64) % 4
+    if remainder:
+        b64 += "=" * (4 - remainder)
+    compressed = base64.b64decode(b64)
+    return gzip.decompress(compressed).decode("utf-8")
+
+
+def encode_level_string(level_str: str) -> str:
+    """
+    Encode a plain text level string into GD-format base64url+gzip.
+
+    Compresses with gzip, encodes as URL-safe base64, and strips padding.
+    """
+    compressed = gzip.compress(level_str.encode("utf-8"))
+    b64 = base64.b64encode(compressed).decode("ascii")
+    return b64.replace("+", "-").replace("/", "_").replace("=", "")

gmd_editor/io.py

@@ -0,0 +1,106 @@
+"""
+Convenience file I/O functions for .gmd files.
+"""
+
+from __future__ import annotations
+import os
+from .level import GMDLevel
+
+
+def load(path: str) -> GMDLevel:
+    """
+    Load a .gmd file from *path* and return a decoded GMDLevel.
+
+    Parameters
+    ----------
+    path : str
+        Path to the .gmd file.
+
+    Returns
+    -------
+    GMDLevel
+        The decoded level, ready to inspect and edit.
+
+    Example
+    -------
+    >>> from gmdlib import load
+    >>> level = load("MyLevel.gmd")
+    >>> print(level.object_count)
+    """
+    with open(path, "r", encoding="utf-8") as f:
+        gmd = f.read()
+    return GMDLevel.from_gmd_string(gmd)
+
+
+def save(level: GMDLevel, path: str) -> None:
+    """
+    Save a GMDLevel back to a .gmd file at *path*.
+
+    The level data is re-compressed and injected back into the original
+    .gmd XML wrapper. The output path does not need to match the input path,
+    so you can easily save a modified copy.
+
+    Parameters
+    ----------
+    level : GMDLevel
+        The level to save (must have been loaded from a .gmd file).
+    path : str
+        Destination file path.
+
+    Example
+    -------
+    >>> from gmdlib import load, save
+    >>> level = load("MyLevel.gmd")
+    >>> save(level, "MyLevel_modified.gmd")
+    """
+    gmd_str = level.to_gmd_string()
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(gmd_str)
+
+
+def save_copy(level: GMDLevel, suffix: str = "_modified") -> str:
+    """
+    Convenience wrapper that saves a modified copy next to the original file.
+
+    Only works when the level was loaded with ``load()``, since the original
+    path is embedded in ``GMDLevel._raw_gmd``.  Actually, this just generates
+    a path from the original -- you must supply an explicit path via ``save()``
+    if you need full control.
+
+    Parameters
+    ----------
+    level : GMDLevel
+        Level to save.
+    suffix : str
+        String appended before the extension (default ``"_modified"``).
+
+    Returns
+    -------
+    str
+        The path the file was written to.
+
+    Raises
+    ------
+    ValueError
+        If the level has no associated file path.
+    """
+    if not hasattr(level, "_source_path") or level._source_path is None:  # type: ignore[attr-defined]
+        raise ValueError(
+            "Level has no associated source path. "
+            "Use save(level, path) and supply an explicit path instead."
+        )
+    src: str = level._source_path  # type: ignore[attr-defined]
+    base, ext = os.path.splitext(src)
+    out_path = base + suffix + ext
+    save(level, out_path)
+    return out_path
+
+
+# Patch load to attach source path
+_original_load = load
+
+
+def load(path: str) -> GMDLevel:  # noqa: F811
+    level = _original_load(path)
+    level._source_path = os.path.abspath(path)  # type: ignore[attr-defined]
+    return level

gmd_editor/level.py

@@ -0,0 +1,214 @@
+"""
+GMDLevel - high-level representation of a decoded Geometry Dash .gmd level.
+"""
+
+from __future__ import annotations
+from typing import Callable, Iterable, Iterator, List, Optional
+
+from .codec import (
+    fix_padding,
+    extract_b64,
+    inject_b64,
+    decode_level_string,
+    encode_level_string,
+)
+from .objects import GDObject
+
+
+class GMDLevel:
+    """
+    A decoded Geometry Dash level loaded from a .gmd file.
+
+    Attributes
+    ----------
+    header : str
+        The level settings/header string (everything before the first object).
+    objects : list[GDObject]
+        All objects in the level.
+
+    Examples
+    --------
+    Load, edit, and save::
+
+        from gmdlib import load, save
+
+        level = load("myLevel.gmd")
+
+        # Move all objects up by 30 units
+        for obj in level:
+            if obj.y is not None:
+                obj.y += 30
+
+        save(level, "myLevel_modified.gmd")
+
+    Filter objects by type::
+
+        spikes = level.filter(lambda o: o.id == 8)
+
+    Bulk transform::
+
+        level.transform(lambda o: setattr(o, "y", (o.y or 0) + 30))
+    """
+
+    def __init__(
+        self,
+        header: str,
+        objects: List[GDObject],
+        _raw_gmd: Optional[str] = None,
+    ) -> None:
+        self.header = header
+        self.objects = objects
+        self._raw_gmd = _raw_gmd  # original .gmd XML wrapper (preserved for saving)
+
+    # ------------------------------------------------------------------
+    # Class methods
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_gmd_string(cls, gmd: str) -> "GMDLevel":
+        """
+        Parse a full .gmd file string into a GMDLevel.
+
+        Parameters
+        ----------
+        gmd : str
+            Raw text contents of a .gmd file.
+        """
+        gmd = fix_padding(gmd)
+        b64 = extract_b64(gmd)
+        level_str = decode_level_string(b64)
+        header, objects = _parse_level_string(level_str)
+        return cls(header=header, objects=objects, _raw_gmd=gmd)
+
+    @classmethod
+    def from_level_string(cls, level_str: str) -> "GMDLevel":
+        """
+        Parse a raw (decompressed) GD level string directly.
+
+        Parameters
+        ----------
+        level_str : str
+            Plain text level string (semicolon-separated objects).
+        """
+        header, objects = _parse_level_string(level_str)
+        return cls(header=header, objects=objects, _raw_gmd=None)
+
+    # ------------------------------------------------------------------
+    # Serialisation
+    # ------------------------------------------------------------------
+
+    def to_level_string(self) -> str:
+        """Reconstruct the plain text level string from current state."""
+        parts = [self.header] + [obj.to_string() for obj in self.objects]
+        return ";".join(parts) + ";"
+
+    def to_gmd_string(self) -> str:
+        """
+        Reconstruct the full .gmd file string with the modified level injected.
+
+        Raises
+        ------
+        ValueError
+            If this GMDLevel was not created from a .gmd file (no wrapper XML).
+        """
+        if self._raw_gmd is None:
+            raise ValueError(
+                "No .gmd wrapper available. "
+                "Use GMDLevel.from_gmd_string() to load from a .gmd file, "
+                "or call to_level_string() to get only the level data."
+            )
+        level_str = self.to_level_string()
+        new_b64 = encode_level_string(level_str)
+        return inject_b64(self._raw_gmd, new_b64)
+
+    # ------------------------------------------------------------------
+    # Iteration / filtering / bulk transforms
+    # ------------------------------------------------------------------
+
+    def __iter__(self) -> Iterator[GDObject]:
+        return iter(self.objects)
+
+    def __len__(self) -> int:
+        return len(self.objects)
+
+    def __getitem__(self, index: int) -> GDObject:
+        return self.objects[index]
+
+    def filter(self, predicate: Callable[[GDObject], bool]) -> List[GDObject]:
+        """Return a list of objects matching *predicate*."""
+        return [obj for obj in self.objects if predicate(obj)]
+
+    def filter_by_id(self, obj_id: int) -> List[GDObject]:
+        """Return all objects with the given GD object ID."""
+        return [obj for obj in self.objects if obj.id == obj_id]
+
+    def transform(self, fn: Callable[[GDObject], None]) -> None:
+        """
+        Apply *fn* to every object in-place.
+
+        Parameters
+        ----------
+        fn : Callable[[GDObject], None]
+            A function that receives each GDObject and mutates it.
+
+        Example
+        -------
+        >>> level.transform(lambda o: setattr(o, "y", (o.y or 0) + 30))
+        """
+        for obj in self.objects:
+            fn(obj)
+
+    def add_object(self, obj: GDObject) -> None:
+        """Append a new object to the level."""
+        self.objects.append(obj)
+
+    def remove_objects(self, predicate: Callable[[GDObject], bool]) -> int:
+        """
+        Remove all objects matching *predicate*.
+
+        Returns
+        -------
+        int
+            Number of objects removed.
+        """
+        before = len(self.objects)
+        self.objects = [obj for obj in self.objects if not predicate(obj)]
+        return before - len(self.objects)
+
+    # ------------------------------------------------------------------
+    # Statistics / introspection
+    # ------------------------------------------------------------------
+
+    @property
+    def object_count(self) -> int:
+        return len(self.objects)
+
+    def bounding_box(self):
+        """
+        Return the axis-aligned bounding box of all objects as
+        (min_x, min_y, max_x, max_y), or None if there are no objects.
+        """
+        xs = [obj.x for obj in self.objects if obj.x is not None]
+        ys = [obj.y for obj in self.objects if obj.y is not None]
+        if not xs:
+            return None
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def unique_object_ids(self) -> set[int]:
+        """Return the set of unique GD object IDs used in this level."""
+        return {obj.id for obj in self.objects if obj.id is not None}
+
+    def __repr__(self) -> str:
+        return f"GMDLevel(objects={self.object_count})"
+
+
+# ------------------------------------------------------------------
+# Internal helpers
+# ------------------------------------------------------------------
+
+def _parse_level_string(level_str: str):
+    """Split a GD level string into (header, [GDObject, ...])."""
+    parts = level_str.split(";")
+    header = parts[0]
+    objects = [GDObject.from_string(p) for p in parts[1:] if p]
+    return header, objects

gmd_editor/objects.py

@@ -0,0 +1,297 @@
+"""
+GDObject - represents a single Geometry Dash level object with named property access.
+"""
+
+from __future__ import annotations
+from typing import Any, Dict, Iterator, Optional
+
+
+# Well-known GD property IDs → human-readable names
+_PROP_NAMES: Dict[str, str] = {
+    "1":  "id",
+    "2":  "x",
+    "3":  "y",
+    "4":  "h_flip",
+    "5":  "v_flip",
+    "6":  "rotation",
+    "7":  "red",
+    "8":  "green",
+    "9":  "blue",
+    "10": "duration",
+    "11": "touch_triggered",
+    "12": "secret_coin_id",
+    "13": "twoplayermode",
+    "14": "passthrough",
+    "15": "hide",
+    "17": "move_x",
+    "18": "move_y",
+    "19": "ease_type",
+    "20": "text",
+    "21": "color_channel",
+    "22": "main_color",
+    "23": "detail_color",
+    "24": "group_parent",
+    "25": "opacity",
+    "28": "editor_layer",
+    "29": "high_detail",
+    "30": "unknown_30",
+    "31": "dont_fade",
+    "32": "dont_enter",
+    "35": "texture_id",
+    "36": "scale",
+    "41": "group_ids",
+    "43": "hsv_enabled",
+    "44": "hsv_value",
+    "45": "fade_in",
+    "46": "hold",
+    "47": "fade_out",
+    "48": "pulse_mode",
+    "49": "copied_color",
+    "50": "copy_opacity",
+    "51": "editor_layer2",
+    "52": "spawn_triggered",
+    "57": "link_id",
+    "58": "reversed",
+    "59": "locked_to_camera",
+    "60": "activate_group",
+    "62": "stop_when_exit",
+    "63": "animation_id",
+    "64": "count",
+    "65": "subtract_count",
+    "66": "pickup_mode",
+    "67": "item_id",
+    "68": "hold_mode",
+    "69": "interval",
+    "71": "toggle_mode",
+    "72": "follow_y_offset",
+    "73": "follow_y_speed",
+    "74": "follow_y_delay",
+    "75": "follow_y_max_speed",
+    "76": "follow_y_reversed",
+    "84": "orderpriority",
+    "85": "unknown_85",
+    "86": "multi_trigger",
+    "87": "color_type",
+    "88": "yellow_teleport",
+    "89": "activate_on_exit",
+    "94": "dynamic_block",
+    "95": "block_b",
+    "96": "glow_disabled",
+    "97": "custom_respawn",
+    "98": "no_retry",
+    "99": "rotate_degrees",
+    "100": "times_360",
+    "101": "lock_object_rotation",
+    "105": "target_pos_coordinates",
+    "106": "use_target",
+    "107": "target_pos_id",
+    "108": "editor_disable",
+    "110": "no_touch",
+    "111": "transform_scale_x",
+    "112": "transform_scale_y",
+    "114": "override_player_1",
+    "116": "enter_channel",
+    "117": "scale_x",
+    "118": "scale_y",
+    "121": "enter_effect_id",
+    "125": "particle_data",
+    "128": "unlock_item_id",
+    "129": "unlock_item_type",
+    "132": "camera_static",
+    "133": "camera_mode",
+    "134": "camera_edge_value",
+    "135": "camera_zoom",
+    "138": "unknown_138",
+    "141": "unknown_141",
+    "142": "unknown_142",
+    "143": "unknown_143",
+    "155": "unknown_155",
+}
+
+# Reverse mapping: name → id string
+_NAME_TO_ID: Dict[str, str] = {v: k for k, v in _PROP_NAMES.items()}
+
+
+class GDObject:
+    """
+    A single Geometry Dash level object.
+
+    Properties are stored as raw string key/value pairs matching the GD format.
+    Named access is provided for well-known properties (x, y, id, rotation, etc.).
+
+    Examples
+    --------
+    >>> obj = GDObject.from_string("1,1,2,300,3,150,6,90")
+    >>> obj.x
+    300.0
+    >>> obj.y
+    150.0
+    >>> obj.rotation
+    90.0
+    >>> obj["2"]          # raw access
+    '300'
+    >>> obj.set("2", 400) # raw set
+    >>> obj.x
+    400.0
+    """
+
+    def __init__(self, props: Optional[Dict[str, str]] = None) -> None:
+        self._props: Dict[str, str] = props or {}
+
+    # ------------------------------------------------------------------
+    # Serialisation
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_string(cls, obj_str: str) -> "GDObject":
+        """Parse a GD object string (comma-separated key/value pairs)."""
+        parts = obj_str.split(",")
+        props: Dict[str, str] = {}
+        for i in range(0, len(parts) - 1, 2):
+            props[parts[i]] = parts[i + 1]
+        return cls(props)
+
+    def to_string(self) -> str:
+        """Serialise back to a GD object string."""
+        out: list[str] = []
+        for k, v in self._props.items():
+            out.append(k)
+            out.append(str(v))
+        return ",".join(out)
+
+    def __repr__(self) -> str:
+        obj_id = self._props.get("1", "?")
+        x = self._props.get("2", "?")
+        y = self._props.get("3", "?")
+        return f"GDObject(id={obj_id}, x={x}, y={y})"
+
+    # ------------------------------------------------------------------
+    # Raw dict-style access
+    # ------------------------------------------------------------------
+
+    def __getitem__(self, key: str) -> str:
+        return self._props[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._props[key] = str(value)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._props
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._props)
+
+    def get(self, key: str, default: Any = None) -> Optional[str]:
+        return self._props.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._props[key] = str(value)
+
+    def remove(self, key: str) -> None:
+        """Remove a property by its numeric key string."""
+        self._props.pop(key, None)
+
+    @property
+    def props(self) -> Dict[str, str]:
+        """Direct access to the underlying property dict."""
+        return self._props
+
+    # ------------------------------------------------------------------
+    # Named property helpers (float where numeric, else str)
+    # ------------------------------------------------------------------
+
+    def _get_float(self, key: str) -> Optional[float]:
+        val = self._props.get(key)
+        if val is None:
+            return None
+        try:
+            return float(val)
+        except ValueError:
+            return None
+
+    def _set_numeric(self, key: str, value: Any) -> None:
+        self._props[key] = str(value)
+
+    # Geometry
+    @property
+    def id(self) -> Optional[int]:
+        v = self._get_float("1")
+        return int(v) if v is not None else None
+
+    @id.setter
+    def id(self, value: int) -> None:
+        self._set_numeric("1", value)
+
+    @property
+    def x(self) -> Optional[float]:
+        return self._get_float("2")
+
+    @x.setter
+    def x(self, value: float) -> None:
+        self._set_numeric("2", value)
+
+    @property
+    def y(self) -> Optional[float]:
+        return self._get_float("3")
+
+    @y.setter
+    def y(self, value: float) -> None:
+        self._set_numeric("3", value)
+
+    @property
+    def rotation(self) -> Optional[float]:
+        return self._get_float("6")
+
+    @rotation.setter
+    def rotation(self, value: float) -> None:
+        self._set_numeric("6", value)
+
+    @property
+    def scale(self) -> Optional[float]:
+        return self._get_float("36")
+
+    @scale.setter
+    def scale(self, value: float) -> None:
+        self._set_numeric("36", value)
+
+    @property
+    def h_flip(self) -> bool:
+        return self._props.get("4", "0") == "1"
+
+    @h_flip.setter
+    def h_flip(self, value: bool) -> None:
+        self._props["4"] = "1" if value else "0"
+
+    @property
+    def v_flip(self) -> bool:
+        return self._props.get("5", "0") == "1"
+
+    @v_flip.setter
+    def v_flip(self, value: bool) -> None:
+        self._props["5"] = "1" if value else "0"
+
+    # Groups
+    @property
+    def groups(self) -> list[int]:
+        """Return list of group IDs (property 57 is space-separated)."""
+        raw = self._props.get("57", "")
+        if not raw:
+            return []
+        try:
+            return [int(g) for g in raw.split(".") if g]
+        except ValueError:
+            return []
+
+    @groups.setter
+    def groups(self, value: list[int]) -> None:
+        self._props["57"] = ".".join(str(g) for g in value)
+
+    # Editor layer
+    @property
+    def editor_layer(self) -> Optional[int]:
+        v = self._get_float("20")
+        return int(v) if v is not None else None
+
+    @editor_layer.setter
+    def editor_layer(self, value: int) -> None:
+        self._set_numeric("20", value)

gmd_editor-0.1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: gmd-editor
+Version: 0.1.0
+Summary: Decode, encode, and edit Geometry Dash .gmd level files
+Project-URL: Source, https://github.com/cool101wool/gmd_editor
+License: MIT
+Keywords: gamefiles,geometry-dash,gmd,level
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# gmdlib
+
+A Python library for decoding, encoding, and editing Geometry Dash `.gmd` level files.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from gmdlib import load, save
+
+# Load a .gmd file
+level = load("MyLevel.gmd")
+
+print(f"Object count: {level.object_count}")
+print(f"Bounding box: {level.bounding_box()}")
+
+# Iterate over objects
+for obj in level:
+    print(f"id={obj.id}  x={obj.x}  y={obj.y}")
+
+# Move all objects up by 30 units
+level.transform(lambda o: setattr(o, "y", (o.y or 0) + 30))
+
+# Save the modified level
+save(level, "MyLevel_modified.gmd")
+```
+
+## API Reference
+
+### `load(path)` / `save(level, path)`
+
+```python
+from gmdlib import load, save
+
+level = load("level.gmd")
+save(level, "level_out.gmd")
+```
+
+### `GMDLevel`
+
+| Attribute / Method | Description |
+|--------------------|-------------|
+| `level.objects` | `list[GDObject]` — all objects |
+| `level.header` | The level settings string |
+| `level.object_count` | Number of objects |
+| `level.bounding_box()` | `(min_x, min_y, max_x, max_y)` |
+| `level.unique_object_ids()` | Set of GD object IDs used |
+| `level.filter(fn)` | Filter objects by predicate |
+| `level.filter_by_id(id)` | Filter objects by GD object ID |
+| `level.transform(fn)` | Apply a function to every object in-place |
+| `level.add_object(obj)` | Append a new object |
+| `level.remove_objects(fn)` | Remove matching objects; returns count removed |
+| `level.to_level_string()` | Serialise to raw level string |
+| `level.to_gmd_string()` | Serialise back to full .gmd XML |
+
+### `GDObject`
+
+Named property shortcuts (all gettable and settable):
+
+| Property | Key | Type |
+|----------|-----|------|
+| `obj.id` | `"1"` | `int` |
+| `obj.x` | `"2"` | `float` |
+| `obj.y` | `"3"` | `float` |
+| `obj.h_flip` | `"4"` | `bool` |
+| `obj.v_flip` | `"5"` | `bool` |
+| `obj.rotation` | `"6"` | `float` |
+| `obj.scale` | `"36"` | `float` |
+| `obj.groups` | `"57"` | `list[int]` |
+
+Raw access for any property:
+
+```python
+obj["21"]          # get by numeric key string
+obj["21"] = "3"    # set
+obj.get("21", "0") # with default
+obj.remove("21")   # delete
+```
+
+### Low-level codec
+
+```python
+from gmdlib.codec import (
+    decode_level_string,  # base64url+gzip → plain text
+    encode_level_string,  # plain text → base64url+gzip
+    extract_b64,          # pull encoded data from .gmd XML
+    inject_b64,           # put encoded data back into .gmd XML
+    fix_padding,          # fix GD's broken base64 padding
+)
+```
+
+## Examples
+
+### Teleport all objects to a fixed X position
+
+```python
+level = load("level.gmd")
+level.transform(lambda o: setattr(o, "x", 0.0))
+save(level, "level_out.gmd")
+```
+
+### Remove all objects of a specific type
+
+```python
+level = load("level.gmd")
+removed = level.remove_objects(lambda o: o.id == 8)  # remove all spike objects
+print(f"Removed {removed} spikes")
+save(level, "level_out.gmd")
+```
+
+### Create a new object and add it
+
+```python
+from gmdlib import load, save
+from gmdlib import GDObject
+
+level = load("level.gmd")
+
+new_obj = GDObject()
+new_obj.id = 1        # block
+new_obj.x = 300.0
+new_obj.y = 0.0
+level.add_object(new_obj)
+
+save(level, "level_out.gmd")
+```
+
+### Work directly with the level string
+
+```python
+from gmdlib.level import GMDLevel
+
+level = GMDLevel.from_level_string("kA,1;1,1,2,100,3,200;")
+print(level[0].x)   # 100.0
+raw = level.to_level_string()
+```

gmd_editor-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+gmd_editor/__init__.py,sha256=nD9aXELA8kAdwPuZnbmLYci7cPlp3wrMcG13C_uvkE0,249
+gmd_editor/codec.py,sha256=_5ZCO-NkCVOarb5i_ej9lQAxmxp0FKTNmfmKFIPIMkI,1997
+gmd_editor/io.py,sha256=qyzUfE_pk3FaRxkc9HjrPekodJYyvaVwntgf3JNpln4,2818
+gmd_editor/level.py,sha256=V1y0_ZtgkRF7yCU2Pi-sJcfYzbkPCcR7c9w2lW-IIOw,6670
+gmd_editor/objects.py,sha256=O5L30GcCQoP1TZFKZEig2TfJDjYNJR_1GnwPDMkM01A,8069
+gmd_editor-0.1.0.dist-info/METADATA,sha256=XYjWVlUPRGtbzP8KP3DRh5JRUdYjzfs-pVJ0wzOkYtA,3683
+gmd_editor-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+gmd_editor-0.1.0.dist-info/RECORD,,

gmd_editor-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any