git4subeditor 0.1.20__py3-none-any.whl

git4subeditor/gitformat.py

@@ -0,0 +1,427 @@
+"""Convert .sub files to and from a Git-friendly XML bundle.
+
+The bundle contains a canonical, line-oriented XML file and, when present, the
+submarine preview image extracted from the ``previewimage`` attribute. The XML
+references the image through a relative ``preview`` attribute. Packing
+re-embeds the preview image and writes a deterministic gzip-compressed .sub
+file, backing up an existing target first.
+"""
+
+import base64
+import binascii
+import gzip
+import shutil
+import sys
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+
+from git4subeditor.l10n import t
+from git4subeditor.subfile import (
+    GZIP_MAGIC,
+    SubFileError,
+    decode_xml,
+    decompress_sub,
+    read_sub_bytes,
+)
+from git4subeditor.utils import format_message
+
+PREVIEW_ATTRIBUTE: str = "previewimage"
+PREVIEW_LINK_ATTRIBUTE: str = "preview"
+INDENT: str = "  "
+
+_IMAGE_SIGNATURES: tuple[tuple[bytes, str], ...] = (
+    (b"\x89PNG\r\n\x1a\n", ".png"),
+    (b"\xff\xd8\xff", ".jpg"),
+    (b"GIF87a", ".gif"),
+    (b"GIF89a", ".gif"),
+    (b"BM", ".bmp"),
+)
+# Barotrauma stores these comma-separated attributes as unordered sets. The
+# game may write them in a different order every time a submarine is saved.
+_UNORDERED_COMMA_ATTRIBUTES: frozenset[str] = frozenset(
+    {
+        "Tags",
+        "items",
+        "excludedidentifiers",
+        "DisallowedUpgrades",
+        "DisallowAttachingOverTags",
+        "ContainableRestrictions",
+        "idcardtags",
+        "outposttags",
+    }
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ExportResult:
+    """Paths written by :func:`export_sub`.
+
+    Attributes:
+        xml_path: The canonical XML file.
+        preview_path: The extracted preview image, or None when the source has
+            no preview image.
+    """
+
+    xml_path: Path
+    preview_path: Path | None
+
+
+def parse_xml(text: str) -> ET.Element:
+    """Parse XML text while preserving comments and processing instructions.
+
+    Args:
+        text: XML text.
+
+    Returns:
+        The root element.
+
+    Raises:
+        SubFileError: If the text is not well-formed XML.
+    """
+    parser = ET.XMLParser(target=ET.TreeBuilder(insert_comments=True, insert_pis=True))
+    try:
+        return ET.fromstring(text, parser=parser)
+    except ET.ParseError as exc:
+        raise SubFileError(t("err.invalid_xml", error=exc)) from exc
+
+
+def serialize_xml(
+    root: ET.Element,
+    *,
+    sort_attributes: bool = False,
+    trailing_newline: bool = True,
+) -> str:
+    """Serialize an XML tree in canonical, line-oriented form.
+
+    The tree is modified in place: elements are indented with two spaces and,
+    when requested, attributes are sorted alphabetically. Comma-separated
+    game set attributes such as ``Tags`` and ``items`` are always sorted so
+    that saving the same submarine again does not produce meaningless diffs.
+
+    Args:
+        root: Root element to serialize.
+        sort_attributes: Whether to sort attributes of every element.
+        trailing_newline: Whether to end the result with a newline.
+
+    Returns:
+        The serialized XML text using LF line endings.
+    """
+    _canonicalize_unordered_attributes(root)
+    if sort_attributes:
+        _sort_attributes(root)
+    ET.indent(root, space=INDENT)
+    text = ET.tostring(root, encoding="unicode", short_empty_elements=True)
+    if trailing_newline and not text.endswith("\n"):
+        text += "\n"
+    return text
+
+
+def extract_preview_image(root: ET.Element) -> tuple[bytes, str] | None:
+    """Remove the preview image from the root and decode it.
+
+    Args:
+        root: Root element of a submarine XML document. It is modified in
+            place.
+
+    Returns:
+        A tuple of image bytes and a file suffix such as ``".png"``, or None
+        when the root has no preview image.
+
+    Raises:
+        SubFileError: If the ``previewimage`` attribute is not valid base64.
+    """
+    encoded = root.attrib.get(PREVIEW_ATTRIBUTE)
+    if encoded is None:
+        return None
+
+    compact = "".join(encoded.split())
+    if not compact:
+        del root.attrib[PREVIEW_ATTRIBUTE]
+        return None
+
+    try:
+        image = base64.b64decode(compact, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise SubFileError(t("err.invalid_base64", error=exc)) from exc
+
+    del root.attrib[PREVIEW_ATTRIBUTE]
+    return image, _guess_image_suffix(image)
+
+
+def embed_preview_image(root: ET.Element, image: bytes) -> None:
+    """Add a preview image to the root as a base64 attribute.
+
+    Existing ``previewimage`` attributes are left untouched.
+
+    Args:
+        root: Root element of a submarine XML document. It is modified in
+            place.
+        image: The image file contents to embed.
+    """
+    if PREVIEW_ATTRIBUTE in root.attrib:
+        return
+    root.set(PREVIEW_ATTRIBUTE, base64.b64encode(image).decode("ascii"))
+
+
+def export_sub(
+    src: Path,
+    out_dir: Path | None = None,
+    *,
+    force: bool = False,
+    sort_attributes: bool = False,
+) -> ExportResult:
+    """Export a .sub file into a Git-friendly XML bundle.
+
+    The XML is written as ``<stem>.xml`` in the output directory. When the
+    source has a preview image, it is written as ``<stem>.<ext>`` and the root
+    element receives a relative ``preview`` attribute pointing to it.
+
+    Args:
+        src: Path to the input .sub file.
+        out_dir: Output directory. Defaults to the input file's directory.
+        force: Whether to overwrite existing output files.
+        sort_attributes: Whether to sort XML attributes alphabetically.
+
+    Returns:
+        The paths of the written XML file and preview image.
+
+    Raises:
+        SubFileError: If reading, decompressing, parsing, or writing fails, or
+            if an output file already exists and force is False.
+    """
+    raw: bytes = read_sub_bytes(src)
+    text: str = decode_xml(decompress_sub(raw))
+    root: ET.Element = parse_xml(text)
+    _require_submarine_root(root)
+
+    preview: tuple[bytes, str] | None = extract_preview_image(root)
+
+    target_dir: Path = out_dir if out_dir is not None else src.parent
+    try:
+        target_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        raise SubFileError(t("err.create_dir", path=target_dir, error=exc)) from exc
+
+    xml_path = target_dir / f"{src.stem}.xml"
+    preview_path = (
+        target_dir / f"{src.stem}{preview[1]}" if preview is not None else None
+    )
+
+    root.attrib.pop(PREVIEW_LINK_ATTRIBUTE, None)
+    if preview_path is not None:
+        root.set(PREVIEW_LINK_ATTRIBUTE, preview_path.name)
+
+    canonical: str = serialize_xml(
+        root,
+        sort_attributes=sort_attributes,
+        trailing_newline=True,
+    )
+
+    _ensure_writable(xml_path, force)
+    if preview_path is not None:
+        _ensure_writable(preview_path, force)
+
+    _write_text(xml_path, canonical)
+    if preview is not None and preview_path is not None:
+        _write_bytes(preview_path, preview[0])
+
+    return ExportResult(xml_path=xml_path, preview_path=preview_path)
+
+
+def pack_sub(
+    xml_path: Path,
+    out: Path | None = None,
+    *,
+    preview_override: bytes | None = None,
+    sort_attributes: bool = False,
+    compresslevel: int = 9,
+) -> Path:
+    """Pack an exported XML file back into a .sub file.
+
+    The relative ``preview`` attribute is resolved against the XML directory
+    and embedded as base64 in ``previewimage``. If the linked image is missing,
+    a warning is printed and the preview is omitted. An existing target is
+    copied to ``<target>.bak`` before it is overwritten.
+
+    When ``preview_override`` is provided, those image bytes take priority
+    over the XML ``preview`` link and are embedded instead.
+
+    The output is gzip-compressed with a fixed timestamp, so packing the same
+    XML twice produces identical bytes.
+
+    Args:
+        xml_path: Path to the exported XML file.
+        out: Output .sub path. Defaults to the XML file with a ``.sub`` suffix.
+        preview_override: Optional preview image bytes that override the XML
+            ``preview`` link.
+        sort_attributes: Whether to sort XML attributes before packing.
+        compresslevel: gzip compression level from 0 to 9.
+
+    Returns:
+        The path of the written .sub file.
+
+    Raises:
+        SubFileError: If reading, parsing, resolving the preview link, backing
+            up the target, or writing fails, or if the override image is
+            empty.
+        ValueError: If compresslevel is outside the range 0 to 9.
+    """
+    if not 0 <= compresslevel <= 9:
+        raise ValueError(f"compresslevel must be between 0 and 9, got {compresslevel}")
+
+    try:
+        raw: bytes = xml_path.read_bytes()
+    except OSError as exc:
+        raise SubFileError(t("err.read_file", path=xml_path, error=exc)) from exc
+
+    if raw.startswith(GZIP_MAGIC):
+        raise SubFileError(t("err.pack_sub_input", path=xml_path))
+
+    root: ET.Element = parse_xml(decode_xml(raw))
+    _require_submarine_root(root)
+
+    link = root.attrib.pop(PREVIEW_LINK_ATTRIBUTE, None)
+    if PREVIEW_ATTRIBUTE not in root.attrib:
+        if preview_override is not None:
+            if not preview_override:
+                raise SubFileError(t("err.empty_preview", path=xml_path))
+            embed_preview_image(root, preview_override)
+        elif link is not None:
+            preview_path = _resolve_preview_link(xml_path, link)
+            try:
+                preview = preview_path.read_bytes()
+            except FileNotFoundError:
+                print(
+                    format_message(
+                        t("warning.preview_missing", path=preview_path),
+                        label="warning",
+                    ),
+                    file=sys.stderr,
+                )
+                preview = None
+            except OSError as exc:
+                raise SubFileError(
+                    t("err.read_preview", path=preview_path, error=exc)
+                ) from exc
+            if preview is not None:
+                if not preview:
+                    raise SubFileError(t("err.empty_preview", path=preview_path))
+                embed_preview_image(root, preview)
+
+    text: str = serialize_xml(
+        root,
+        sort_attributes=sort_attributes,
+        trailing_newline=False,
+    )
+    compressed: bytes = _compress_xml(text.encode("utf-8"), compresslevel)
+
+    dst = _resolve_pack_output(xml_path, out)
+    try:
+        dst.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        raise SubFileError(t("err.create_dir", path=dst.parent, error=exc)) from exc
+    _backup_existing(dst)
+    _write_bytes(dst, compressed)
+    return dst
+
+
+def _require_submarine_root(root: ET.Element) -> None:
+    """Check that the root element is a Submarine element."""
+    if root.tag != "Submarine":
+        raise SubFileError(t("err.submarine_root", tag=root.tag))
+
+
+def _canonicalize_unordered_attributes(root: ET.Element) -> None:
+    """Sort comma-separated set attributes of the root and its descendants."""
+    for element in root.iter():
+        for name in _UNORDERED_COMMA_ATTRIBUTES:
+            value = element.attrib.get(name)
+            if value is None or "," not in value:
+                continue
+            parts = [part.strip() for part in value.split(",")]
+            element.attrib[name] = ",".join(sorted(parts, key=str.casefold))
+
+
+def _sort_attributes(root: ET.Element) -> None:
+    """Sort the attributes of the root and all its descendants."""
+    for element in root.iter():
+        element.attrib = dict(sorted(element.attrib.items()))
+
+
+def _guess_image_suffix(image: bytes) -> str:
+    """Return a file suffix based on image magic bytes."""
+    for signature, suffix in _IMAGE_SIGNATURES:
+        if image.startswith(signature):
+            return suffix
+    if image[:4] == b"RIFF" and image[8:12] == b"WEBP":
+        return ".webp"
+    return ".bin"
+
+
+def _resolve_pack_output(xml_path: Path, out: Path | None) -> Path:
+    """Resolve the output path for pack_sub."""
+    if out is None:
+        return xml_path.with_suffix(".sub")
+    if out.is_dir():
+        return out / f"{xml_path.stem}.sub"
+    return out
+
+
+def _resolve_preview_link(xml_path: Path, link: str) -> Path:
+    """Resolve a relative preview link against the XML file's directory."""
+    if not link.strip():
+        raise SubFileError(t("err.empty_preview_link"))
+    path = Path(link)
+    return path if path.is_absolute() else xml_path.parent / path
+
+
+def _backup_existing(path: Path) -> Path | None:
+    """Copy an existing target to ``<name>.bak`` before overwriting it."""
+    if not path.exists():
+        return None
+    if not path.is_file():
+        raise SubFileError(t("err.not_regular_file", path=path))
+
+    backup = path.with_name(f"{path.name}.bak")
+    try:
+        shutil.copy2(path, backup)
+    except OSError as exc:
+        raise SubFileError(
+            t("err.backup", path=path, backup=backup, error=exc)
+        ) from exc
+    return backup
+
+
+def _ensure_writable(path: Path, force: bool) -> None:
+    """Raise when a target cannot be written."""
+    if not path.exists():
+        return
+    if not force:
+        raise SubFileError(t("err.output_exists", path=path))
+    if not path.is_file():
+        raise SubFileError(t("err.not_regular_file", path=path))
+
+
+def _write_text(path: Path, text: str) -> None:
+    """Write UTF-8 text with LF line endings."""
+    try:
+        path.write_text(text, encoding="utf-8", newline="\n")
+    except OSError as exc:
+        raise SubFileError(t("err.write", path=path, error=exc)) from exc
+
+
+def _write_bytes(path: Path, data: bytes) -> None:
+    """Write raw bytes, wrapping OSError as SubFileError."""
+    try:
+        path.write_bytes(data)
+    except OSError as exc:
+        raise SubFileError(t("err.write", path=path, error=exc)) from exc
+
+
+def _compress_xml(data: bytes, compresslevel: int) -> bytes:
+    """Gzip-compress XML bytes with a stable timestamp."""
+    try:
+        return gzip.compress(data, compresslevel=compresslevel, mtime=0)
+    except OSError as exc:
+        raise SubFileError(t("err.gzip_compress", error=exc)) from exc

git4subeditor/l10n.py

@@ -0,0 +1,107 @@
+"""Localization support for command-line messages."""
+
+import xml.etree.ElementTree as ET
+from functools import cache
+from importlib import resources
+from pathlib import Path
+
+DEFAULT_LANGUAGE = "en"
+SUPPORTED_LANGUAGES: tuple[str, ...] = ("en", "cn", "ru")
+
+_language: str = DEFAULT_LANGUAGE
+
+
+def configured_language(directory: Path | None = None) -> str | None:
+    """Return the language configured in the project file, if valid.
+
+    Args:
+        directory: Directory containing ``git4subeditor.xml``. Defaults to the
+            current working directory.
+
+    Returns:
+        A supported language code, or None when no valid language is set.
+    """
+    base: Path = directory if directory is not None else Path.cwd()
+    try:
+        root: ET.Element = ET.parse(base / "git4subeditor.xml").getroot()
+    except (OSError, ET.ParseError):
+        return None
+
+    element: ET.Element | None = root.find("language")
+    if element is None:
+        return None
+    language: str = (element.text or "").strip().lower()
+    if language in SUPPORTED_LANGUAGES:
+        return language
+    return None
+
+
+def resolve_language(directory: Path | None = None) -> str:
+    """Return the configured language, falling back to English.
+
+    Args:
+        directory: Directory containing ``git4subeditor.xml``. Defaults to the
+            current working directory.
+
+    Returns:
+        A supported language code.
+    """
+    return configured_language(directory) or DEFAULT_LANGUAGE
+
+
+def set_language(language: str) -> str:
+    """Set the active language and return the effective language code.
+
+    Args:
+        language: Requested language code.
+
+    Returns:
+        The active supported language code.
+    """
+    global _language
+    normalized: str = language.strip().lower()
+    _language = normalized if normalized in SUPPORTED_LANGUAGES else DEFAULT_LANGUAGE
+    return _language
+
+
+def get_language() -> str:
+    """Return the active language code."""
+    return _language
+
+
+def t(key: str, **values: object) -> str:
+    """Translate a message key and format its placeholders.
+
+    Args:
+        key: Message key from a locale file.
+        **values: Values used by ``str.format`` placeholders.
+
+    Returns:
+        The translated message, or the key when no translation exists.
+    """
+    message: str | None = _catalog(_language).get(key)
+    if message is None:
+        message = _catalog(DEFAULT_LANGUAGE).get(key)
+    if message is None:
+        return key
+    if values:
+        return message.format(**values)
+    return message
+
+
+@cache
+def _catalog(language: str) -> dict[str, str]:
+    """Load and cache one locale catalog."""
+    catalog: dict[str, str] = {}
+    try:
+        path = resources.files("git4subeditor").joinpath("locales", f"{language}.xml")
+        with path.open("rb") as handle:
+            root: ET.Element = ET.parse(handle).getroot()
+    except (OSError, ET.ParseError):
+        return catalog
+
+    for element in root.findall("message"):
+        key: str | None = element.get("key")
+        if key:
+            catalog[key] = element.text or ""
+    return catalog

git4subeditor/locales/cn.xml

@@ -0,0 +1,135 @@
+<?xml version='1.0' encoding='utf-8'?>
+<locale language="cn">
+  <message key="app.description">在 Barotrauma .sub 文件与 Git 友好的 XML 之间转换.</message>
+  <message key="metavar.command">命令</message>
+  <message key="arg.version">显示程序版本并退出</message>
+  <message key="arg.help">显示帮助并退出</message>
+  <message key="help.usage">用法: </message>
+  <message key="help.positionals">位置参数</message>
+  <message key="help.options">选项</message>
+  <message key="repl.commands">命令</message>
+  <message key="repl.command.init">初始化/更新工作区</message>
+  <message key="repl.command.export">解压 .sub 并转为 Git 友好的 XML</message>
+  <message key="repl.command.pack">打包 XML 为 .sub</message>
+  <message key="repl.command.unpack">仅解压 .sub 为原始 XML</message>
+  <message key="repl.command.tree">递归搜索并显示仓库下所有潜艇</message>
+  <message key="repl.command.exit">退出交互模式</message>
+  <message key="repl.hint">Tab 补全 · ↑↓ 历史 · Ctrl-R 搜索 · Ctrl-D 退出 · ? 帮助</message>
+  <message key="repl.help"><![CDATA[<title>tree</title>
+  以目录树形式显示 Git 仓库下的潜艇 .sub 文件.
+  - 未注册文件末尾显示红色 (U)
+  - 已注册但哈希变化的文件末尾显示黄色 (M)
+
+<title>export</title>
+  导出 .sub 为 Git 友好的 XML.
+
+  <cmd>export</cmd>
+      导出所有发生改动的已注册潜艇
+  <cmd>export</cmd> "test/My Sub1.sub" "test/My Sub2.sub" ...
+      导出一个或多个已注册潜艇
+  <cmd>export</cmd> "test/My Sub1.sub" -o ./mydir
+      导出潜艇到指定目录
+
+  注意: 若潜艇名或目录名包含空格, 路径必须加上引号, 否则会被识别成多个参数
+
+<title>pack</title>
+  把导出的 XML 打包回 .sub.
+
+  <cmd>pack</cmd> "test/My Sub.xml"
+  <cmd>pack</cmd> "test/My Sub.xml" -o ./mydir
+      打包到指定目录
+
+  注意: 如果输出 .sub 已存在, 会先备份为 .sub.bak, 然后覆盖.
+
+<title>unpack</title>
+  只解压潜艇 .sub 文件为原始 XML, 此命令比较少用
+
+  <cmd>unpack</cmd> "test/My Sub.sub"
+]]></message>
+  <message key="repl.not_tty">交互模式需要终端; 请使用子命令</message>
+  <message key="repl.parse_error">无法解析命令行: {error}</message>
+  <message key="repl.workspace_missing">尚未初始化工作区</message>
+  <message key="repl.workspace">项目: {project} | Git 仓库: {git_repo} | 模组根目录: {mod_root}</message>
+  <message key="repl.cwd">CWD: {path}</message>
+
+  <message key="command.init">初始化/更新工作区</message>
+  <message key="command.unpack">从 .sub 文件中提取原始 XML</message>
+  <message key="command.export">将 .sub 文件导出为规范化 XML 和预览图</message>
+  <message key="command.pack">将导出的 XML 打包回 .sub 文件</message>
+  <message key="command.sub">列出已注册潜艇</message>
+
+  <message key="arg.inputs.sub">一个或多个 .sub 文件</message>
+  <message key="arg.inputs.xml">一个或多个导出的 XML 文件</message>
+  <message key="arg.output_dir">输出目录, 默认为每个输入文件所在目录</message>
+  <message key="arg.encoding">强制指定 XML 编码, 不自动检测 UTF-8/UTF-16</message>
+  <message key="arg.stdout">将 XML 输出到 stdout, 不写入文件</message>
+  <message key="arg.no_validate">跳过 XML 格式检查</message>
+  <message key="arg.force">直接覆盖已存在的输出文件, 不询问</message>
+  <message key="arg.sort_attributes">按字母顺序排序 XML 属性, 使 diff 更稳定</message>
+  <message key="arg.sort_attributes_pack">打包前按字母顺序排序 XML 属性</message>
+  <message key="arg.output">输出 .sub 文件, 或一个已存在的目录; 默认为 XML 文件所在目录</message>
+  <message key="arg.tree">以目录树形式显示已注册潜艇</message>
+  <message key="arg.force_init">自动同意所有初始化更改, 不询问</message>
+
+  <message key="err.stdout_single">--stdout 只能接受一个输入文件</message>
+  <message key="err.output_multi">打包多个文件时, --output 必须是已存在的目录</message>
+  <message key="prompt.overwrite">{path} 已存在. 是否覆盖? [y/N] </message>
+  <message key="prompt.submarines">是否添加/修改这些潜艇? [y/N] </message>
+  <message key="prompt.remove_submarines">是否移除这些潜艇? [y/N] </message>
+  <message key="prompt.mod_root_changed">MOD 根目录: {old} -> {new}, 是否更新? [y/N] </message>
+  <message key="prompt.git_repo_changed">Git 仓库: {old} -> {new}, 是否更新? [y/N] </message>
+  <message key="prompt.export_changed">是否导出这些潜艇? [y/N] </message>
+  <message key="status.skipped">已跳过: {path}</message>
+  <message key="status.no_changed_submarines">没有已改动的注册潜艇</message>
+  <message key="status.export_changed_header">已改动的已注册潜艇:</message>
+  <message key="status.export_declined">已取消导出</message>
+  <message key="status.export_preview">{src} -> {xml}, 预览图: {preview}</message>
+  <message key="status.export_no_preview">{src} -> {xml}, 无预览图</message>
+  <message key="status.pack">{src} -> {dst}</message>
+  <message key="status.unpack">{src} -> {dst}  [{kind}, {bytes} 字节]</message>
+  <message key="kind.gzip">gzip</message>
+  <message key="kind.plain_xml">纯 XML</message>
+  <message key="status.git_repo">Git repo: {path}</message>
+
+  <message key="warning.current_not_repo">当前目录不是 Git 仓库; 使用 {path}</message>
+  <message key="warning.no_repo">在模组根目录范围内未找到 Git 仓库; 请运行 'git init' 初始化</message>
+  <message key="warning.upper_repo">本项目还存在上级 Git 仓库: {path}</message>
+  <message key="warning.preview_missing">找不到预览图: {path}; 预览将留空</message>
+  <message key="warning.registry_preview_failed">潜艇{name}预览图读取失败, 按照默认方式读取</message>
+  <message key="warning.decode_replace">输入不是有效的 UTF-8/UTF-16, 将使用替换字符按 UTF-8 解码</message>
+
+  <message key="init.created_gitignore">已创建 {name}; 添加 {patterns}</message>
+  <message key="init.updated_gitignore">已更新 {name}; 添加 {patterns}</message>
+  <message key="init.gitignore_ok">{name} 已忽略 {patterns}</message>
+  <message key="init.config_created">已创建 {name}</message>
+  <message key="init.config_updated">已更新 {name}</message>
+  <message key="init.config_exists">{name} 已存在</message>
+  <message key="init.registered_header">已注册潜艇:</message>
+  <message key="init.pending_header">需要添加或修改的潜艇:</message>
+  <message key="init.removed_header">需要移除的已注册潜艇:</message>
+  <message key="init.registered">已注册 {count} 个潜艇文件</message>
+  <message key="init.submarines_skipped">未更新潜艇注册信息</message>
+  <message key="init.language_set">语言设置为中文</message>
+  <message key="err.init">无法初始化项目: {error}</message>
+  <message key="err.not_mod">不是一个 Barotrauma MOD 项目: 在 {path} 及其上级目录中找不到 filelist.xml</message>
+  <message key="err.invalid_config">项目配置无效 {path}: {error}</message>
+  <message key="err.not_registered">潜艇未在 git4subeditor.xml 中注册: {path}</message>
+  <message key="err.invalid_xml">XML 无效: {error}</message>
+  <message key="err.invalid_base64">previewimage 不是有效的 base64: {error}</message>
+  <message key="err.read_file">无法读取文件 {path}: {error}</message>
+  <message key="err.pack_sub_input">{path} 看起来是 .sub 文件; 请先导出为 XML</message>
+  <message key="err.read_preview">无法读取预览图 {path}: {error}</message>
+  <message key="err.empty_preview">预览图为空: {path}</message>
+  <message key="err.create_dir">无法创建输出目录 {path}: {error}</message>
+  <message key="err.submarine_root">需要 &lt;Submarine&gt; 根节点, 实际为 &lt;{tag}&gt;</message>
+  <message key="err.empty_preview_link">preview 链接为空</message>
+  <message key="err.not_regular_file">输出路径不是普通文件: {path}</message>
+  <message key="err.backup">无法将 {path} 备份到 {backup}: {error}</message>
+  <message key="err.output_exists">输出文件已存在: {path} (使用 --force)</message>
+  <message key="err.write">无法写入 {path}: {error}</message>
+  <message key="err.gzip_compress">gzip 压缩失败: {error}</message>
+  <message key="err.gzip_decompress">gzip 解压失败: {error}</message>
+  <message key="err.decode">无法按 {encoding} 解码: {error}</message>
+  <message key="err.decode_utf16">无法按 UTF-16 解码: {error}</message>
+  <message key="err.invalid_decompressed_xml">解压后的数据不是有效 XML: {error}</message>
+</locale>