LightGame 完成 Windows

2026-06-14 09:42:27 +08:00
parent 254a8ce5c8
commit 786170f40a
50 changed files with 85787 additions and 1392 deletions
@@ -0,0 +1,422 @@
+"""Convert Unity Tilemap data from SampleScene.unity into LevelTotalData.h.
+
+Workflow:
+  1. Parse the Unity scene YAML (no PyYAML dep — pure text scan,
+     because the file is huge and uses Unity-specific tags).
+  2. For each named Tilemap GameObject (e.g. "foreground", "background"),
+     extract:
+       - m_TileAssetArray  : ordered list of tile asset GUIDs
+       - m_Tiles           : list of (x, y, m_TileIndex)
+  3. Map each tile asset GUID -> a project TileId (uint16_t).
+  4. Crop to a fixed window (origin + width + height, in Unity cell coords)
+     and emit a C++ uint16_t[] array. Unity Y is up; the C++ array is
+     row-major with row 0 at the TOP, so we flip Y on output.
+
+Usage:
+    python tools/unity_to_level.py
+
+Edit FOREGROUND_GUID_TO_TILEID below to fill in the foreground mapping.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SCENE_PATH = os.path.join(REPO_ROOT, "SampleScene.unity")
+OUTPUT_PATH = os.path.join(
+    REPO_ROOT, "src", "Apps", "LightGame", "src", "levels", "LevelTotalData.h"
+)
+
+# Crop window in Unity cell coordinates. Aligned to the `background`
+# Tilemap's origin (-43, -24). LevelTotal is 96 wide x 54 tall.
+CROP_ORIGIN_X = -42
+CROP_ORIGIN_Y = -24
+CROP_WIDTH = 96
+CROP_HEIGHT = 54
+
+# TileId values mirror src/Apps/LightGame/src/engine/TileIds.h
+class TileId:
+    Empty = 0
+    Background1 = 1
+    Background2 = 2
+    Background3 = 3
+    Background4 = 4
+    GroundTopGreen = 5
+    GroundFillGreen = 6
+    GroundTopGray = 7
+    GroundFillGray = 8
+    GroundTopPurple = 9
+    GroundFillPurple = 10
+    Platform = 11
+    Spike = 12
+    LightPlatformOff = 13
+    LightPlatformOn = 14
+    ShadowPlatformOff = 15
+    ShadowPlatformOn = 16
+    DoorClosed = 17
+    DoorOpen = 18
+    Coin = 19
+    Flag = 20
+    Checkpoint = 21
+    SpikeCeiling = 22
+    DecorVine = 23
+
+# background Tilemap: m_TileAssetArray order (verified by user).
+# Indexes 0..3 in the array correspond to TileId 1..4.
+BACKGROUND_GUID_TO_TILEID: Dict[str, int] = {
+    "7a416b45749852649890b58c40c94382": TileId.Background1,
+    "3e398b33bfe59e8488e6622639e22680": TileId.Background2,
+    "9c0d8493a349d2d4c9394cd4db6c144c": TileId.Background3,
+    "c311fab5d43fea040b20ddf4109be8d4": TileId.Background4,
+}
+
+# foreground Tilemap: m_TileAssetArray order (16 entries in scene).
+# >>> FILL THIS IN <<< — map each GUID to the matching TileId.* constant.
+# Use TileId.Empty (= 0) to drop a tile, or comment a line out to leave
+# it as Empty (the default).
+FOREGROUND_GUID_TO_TILEID: Dict[str, int] = {
+    "fc664ce3f6082ba478b8d50ca2dce27e": 12,
+    "47a0287d160d89e449cfb63ece6bc64d": 10,
+    "9c787be8025ad3e4ea41faf8641b6542": 19,
+    "d317ceed21dc2844cbe35d377a237065": 9,
+    "228f030a961526742ac581cd160291f2": 1,
+    "5276bbe304866324fbd94b343f5d5716": 1,
+    "47822c4ae0c151848be71ecddbe3e363": 20,
+    "9dae7bdac3edf7e4996e186ac7ea8d42": 8,
+    "f3c8dcd4899bb144795bf74e61529d57": 6,
+    "430a6d0aec468d94d929e481d5082741": 5,
+    "dcd1ff73844513940941a7906732f790": 7,
+    "8caba5ecd24bd3143831d4f04096921f": 17,
+    "c0ea1f55905049745a90ea7d4772f95f": 22,
+    "0f7b94bca5b66ea4e8bf37ac8b2c1528": 16,
+    "67e0c92da848ffa49b3792338de741ac": 14,
+    "1289993ae67654b48a59c5743728e507": 20,
+}
+
+# Map Unity GameObject name -> tile id mapping table.
+LAYER_MAPPINGS: Dict[str, Dict[str, int]] = {
+    "foreground": FOREGROUND_GUID_TO_TILEID,
+    "background": BACKGROUND_GUID_TO_TILEID,
+}
+
+# ---------------------------------------------------------------------------
+# Parser
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TilemapBlock:
+    name: str
+    asset_guids: List[str] = field(default_factory=list)  # by m_TileIndex
+    cells: List[Tuple[int, int, int]] = field(default_factory=list)  # x, y, idx
+
+
+# Scene file blocks are separated by lines that start with "--- !u!".
+DOC_SEP = re.compile(r"^--- !u!(\d+) &(\d+)", re.MULTILINE)
+
+
+def split_documents(text: str) -> List[Tuple[int, int, str]]:
+    """Return a list of (class_id, file_id, body) for each YAML doc."""
+    matches = list(DOC_SEP.finditer(text))
+    docs: List[Tuple[int, int, str]] = []
+    for i, m in enumerate(matches):
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        docs.append((int(m.group(1)), int(m.group(2)), text[start:end]))
+    return docs
+
+
+def parse_gameobjects(docs) -> Dict[int, str]:
+    """Map GameObject fileID -> name."""
+    name_re = re.compile(r"^\s*m_Name:\s*(.+?)\s*$", re.MULTILINE)
+    out: Dict[int, str] = {}
+    for class_id, file_id, body in docs:
+        if class_id != 1:  # GameObject
+            continue
+        m = name_re.search(body)
+        if m:
+            out[file_id] = m.group(1)
+    return out
+
+
+GAMEOBJECT_REF_RE = re.compile(r"m_GameObject:\s*\{fileID:\s*(\d+)\}")
+TILE_FIRST_RE = re.compile(
+    r"-\s*first:\s*\{x:\s*(-?\d+),\s*y:\s*(-?\d+),\s*z:\s*-?\d+\}\s*"
+    r"second:\s*\n"
+    r"\s*serializedVersion:\s*\d+\s*\n"
+    r"\s*m_TileIndex:\s*(-?\d+)"
+)
+ASSET_ENTRY_RE = re.compile(
+    r"-\s*m_RefCount:\s*(-?\d+)\s*\n\s*m_Data:\s*\{fileID:\s*\d+,\s*guid:\s*([0-9a-f]+),"
+)
+
+
+def parse_tilemaps(docs, go_names: Dict[int, str]) -> Dict[str, TilemapBlock]:
+    """Find Tilemap docs (class 1839735485) and bucket by parent GO name."""
+    out: Dict[str, TilemapBlock] = {}
+    for class_id, _file_id, body in docs:
+        if class_id != 1839735485:  # Tilemap
+            continue
+        m = GAMEOBJECT_REF_RE.search(body)
+        if not m:
+            continue
+        go_id = int(m.group(1))
+        name = go_names.get(go_id)
+        if not name:
+            continue
+
+        # Slice out the m_Tiles ... m_AnimatedTiles section so the cell regex
+        # only sees real tile entries.
+        tiles_start = body.find("m_Tiles:")
+        tiles_end = body.find("m_AnimatedTiles", tiles_start if tiles_start >= 0 else 0)
+        tiles_body = body[tiles_start:tiles_end] if tiles_start >= 0 else ""
+
+        # Slice the m_TileAssetArray section.
+        asset_start = body.find("m_TileAssetArray:")
+        asset_end = body.find("m_TileSpriteArray", asset_start if asset_start >= 0 else 0)
+        asset_body = body[asset_start:asset_end] if asset_start >= 0 else ""
+
+        # Collect (refcount, guid) entries in their YAML order.
+        asset_entries: List[Tuple[int, str]] = []
+        for am in ASSET_ENTRY_RE.finditer(asset_body):
+            asset_entries.append((int(am.group(1)), am.group(2)))
+
+        # Collect raw cell entries (x, y, raw_idx).
+        raw_cells: List[Tuple[int, int, int]] = []
+        for tm in TILE_FIRST_RE.finditer(tiles_body):
+            raw_cells.append((int(tm.group(1)), int(tm.group(2)), int(tm.group(3))))
+
+        # Unity does NOT renumber m_TileIndex when entries are removed from
+        # m_TileAssetArray, so the YAML index of an entry is not necessarily
+        # equal to the m_TileIndex referencing it. Reconstruct the mapping
+        # by aligning the YAML-order asset entries with the *sorted distinct*
+        # m_TileIndex values that share the same refcount/usage-count.
+        from collections import Counter as _Counter
+        idx_counts = _Counter(c[2] for c in raw_cells)
+        sorted_idxs = sorted(idx_counts.keys())
+
+        block = TilemapBlock(name=name)
+        if len(sorted_idxs) == len(asset_entries):
+            # Pair entries in array order with idx values in ascending order.
+            # Sanity-check that refcount matches usage count for each pair.
+            for entry, idx in zip(asset_entries, sorted_idxs):
+                refcount, guid = entry
+                actual = idx_counts[idx]
+                if refcount != actual:
+                    print(
+                        f"  [warn] '{name}' refcount mismatch for guid {guid[:8]}: "
+                        f"asset refcount={refcount} but idx={idx} appears {actual} times",
+                        file=sys.stderr,
+                    )
+                # Grow asset_guids so [idx] -> guid works directly.
+                while len(block.asset_guids) <= idx:
+                    block.asset_guids.append("")
+                block.asset_guids[idx] = guid
+        else:
+            print(
+                f"  [warn] '{name}' has {len(asset_entries)} asset entries but "
+                f"{len(sorted_idxs)} distinct m_TileIndex values; falling back "
+                f"to positional mapping (results may be wrong)",
+                file=sys.stderr,
+            )
+            for entry in asset_entries:
+                block.asset_guids.append(entry[1])
+
+        block.cells = raw_cells
+        out[name] = block
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Conversion
+# ---------------------------------------------------------------------------
+
+def block_to_grid(
+    block: TilemapBlock,
+    guid_to_tile: Dict[str, int],
+    origin_x: int,
+    origin_y: int,
+    width: int,
+    height: int,
+) -> List[List[int]]:
+    """Convert a TilemapBlock to a row-major grid (row 0 = top).
+
+    Cells outside the crop window are dropped. Cells whose tile asset has no
+    mapping default to TileId.Empty (and a warning is printed once per GUID).
+    """
+    grid = [[0 for _ in range(width)] for _ in range(height)]
+    unmapped: Dict[str, int] = {}
+
+    for x, y, idx in block.cells:
+        if idx < 0 or idx >= len(block.asset_guids):
+            continue
+        guid = block.asset_guids[idx]
+        tile_id = guid_to_tile.get(guid)
+        if tile_id is None:
+            unmapped[guid] = unmapped.get(guid, 0) + 1
+            continue
+        if tile_id == 0:
+            continue
+
+        col = x - origin_x
+        # Unity Y is up; flip so row 0 is the top of the array.
+        row = (origin_y + height - 1) - y
+        if 0 <= col < width and 0 <= row < height:
+            grid[row][col] = tile_id
+
+    if unmapped:
+        print(
+            f"  [warn] {len(unmapped)} unmapped GUID(s) in '{block.name}' "
+            f"(treated as Empty):",
+            file=sys.stderr,
+        )
+        for guid, count in sorted(unmapped.items(), key=lambda kv: -kv[1]):
+            print(f"    {guid}  x{count}", file=sys.stderr)
+
+    return grid
+
+
+# ---------------------------------------------------------------------------
+# C++ emitter
+# ---------------------------------------------------------------------------
+
+HEADER_TEMPLATE = """#pragma once
+
+#include "LevelData.h"
+#include "tile_atlas.h"
+
+namespace LightGame
+{{
+    namespace LevelTotal
+    {{
+        static const int32_t kMapWidth = {width};
+        static const int32_t kMapHeight = {height};
+        static const int32_t kTileSize = 32;
+
+        static const uint16_t tiles[] = {{
+{tiles_body}
+        }};
+
+        static const uint16_t background_tiles[] = {{
+{background_body}
+        }};
+
+        static const ObjectSpawn spawns[] = {{
+            {{ GameObjectType::Player, 69, 29, 0, 0, TriggerAction::None, 0 }},
+        }};
+
+        static const RenderData::Image kAtlas(tile_atlas_pixels, tile_atlas_width, tile_atlas_height);
+
+        static const LevelData data = {{
+            tiles,
+            kMapWidth,
+            kMapHeight,
+            kTileSize,
+            &kAtlas,
+            tile_atlas_columns,
+            spawns,
+            1,
+            nullptr,
+            0,
+            Math::Vector2Int({spawn_px_x}, {spawn_px_y}),
+            0,
+            0,
+            {bounds_max_x},
+            {bounds_max_y},
+            background_tiles
+        }};
+    }}
+}}
+"""
+
+
+def format_grid(grid: List[List[int]], indent: str = "            ") -> str:
+    rows = []
+    for row in grid:
+        rows.append(indent + ", ".join(str(v) for v in row) + ",")
+    if rows:
+        rows[-1] = rows[-1].rstrip(",")
+    return "\n".join(rows)
+
+
+def emit_header(
+    fg_grid: List[List[int]],
+    bg_grid: List[List[int]],
+    width: int,
+    height: int,
+    tile_size: int = 32,
+) -> str:
+    spawn_tile_x, spawn_tile_y = 69, 29  # preserved from current LevelTotal
+    return HEADER_TEMPLATE.format(
+        width=width,
+        height=height,
+        tiles_body=format_grid(fg_grid),
+        background_body=format_grid(bg_grid),
+        spawn_px_x=spawn_tile_x * tile_size,
+        spawn_px_y=spawn_tile_y * tile_size,
+        bounds_max_x=width * tile_size,
+        bounds_max_y=height * tile_size,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    if not os.path.isfile(SCENE_PATH):
+        print(f"scene file not found: {SCENE_PATH}", file=sys.stderr)
+        return 1
+
+    with open(SCENE_PATH, "r", encoding="utf-8") as f:
+        text = f.read()
+
+    print(f"reading {SCENE_PATH} ({len(text)} bytes)")
+    docs = split_documents(text)
+    go_names = parse_gameobjects(docs)
+    tilemaps = parse_tilemaps(docs, go_names)
+
+    print(f"found Tilemaps: {sorted(tilemaps.keys())}")
+    for name, block in tilemaps.items():
+        print(f"  {name}: {len(block.cells)} cells, {len(block.asset_guids)} tile assets")
+
+    missing = [n for n in ("foreground", "background") if n not in tilemaps]
+    if missing:
+        print(f"missing Tilemap layers: {missing}", file=sys.stderr)
+        return 1
+
+    fg_grid = block_to_grid(
+        tilemaps["foreground"],
+        FOREGROUND_GUID_TO_TILEID,
+        CROP_ORIGIN_X, CROP_ORIGIN_Y, CROP_WIDTH, CROP_HEIGHT,
+    )
+    bg_grid = block_to_grid(
+        tilemaps["background"],
+        BACKGROUND_GUID_TO_TILEID,
+        CROP_ORIGIN_X, CROP_ORIGIN_Y, CROP_WIDTH, CROP_HEIGHT,
+    )
+
+    if not FOREGROUND_GUID_TO_TILEID:
+        print(
+            "\n[note] FOREGROUND_GUID_TO_TILEID is empty — foreground will be all 0.\n"
+            "       Edit tools/unity_to_level.py and re-run once you have the mapping.",
+            file=sys.stderr,
+        )
+
+    out = emit_header(fg_grid, bg_grid, CROP_WIDTH, CROP_HEIGHT)
+    with open(OUTPUT_PATH, "w", encoding="utf-8", newline="\n") as f:
+        f.write(out)
+    print(f"wrote {OUTPUT_PATH}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())