#!/usr/bin/env python3
"""Group CNS field maps by their source map_* tileset family."""
from __future__ import annotations
import argparse
import html
import json
import re
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
OUT = ROOT / "out"
FAMILY_RE = re.compile(r"^map_([a-z])([0-9]+)$")
def load_json(path: Path, default: Any) -> Any:
if not path.exists():
return default
return json.loads(path.read_text(encoding="utf-8"))
def parse_map_index(path: Path) -> dict[str, dict]:
text = path.read_text(encoding="utf-8")
for marker in ("window.HWANSE_MAP_INDEX = ", "window.HWANSE_MAPS = "):
start = text.find(marker)
if start >= 0:
break
else:
raise ValueError(f"{path} does not contain Hwanse map data")
start += len(marker)
payload = text[start:].strip()
if payload.endswith(";"):
payload = payload[:-1]
return json.loads(payload)
def family_for_tileset(name: str | None) -> str:
match = FAMILY_RE.match(str(name or ""))
return match.group(1) if match else "unknown"
def compact_maps(maps: list[dict], limit: int = 8) -> list[dict]:
return [
{
"name": row["name"],
"width": row.get("width"),
"height": row.get("height"),
"layerTilesets": row.get("layerTilesets") or [],
}
for row in maps[:limit]
]
def build_summary(map_index: dict[str, dict], cns_payloads: list[dict]) -> dict:
cns_by_stem = {
str(row.get("name", "")).removesuffix(".cns"): row
for row in cns_payloads
if row.get("name")
}
source_tilesets: dict[str, list[dict]] = defaultdict(list)
for stem, row in sorted(cns_by_stem.items()):
match = FAMILY_RE.match(stem)
if not match or row.get("kind") != "image":
continue
family = match.group(1)
tile_w = int(row.get("width") or 0) // 16
tile_h = int(row.get("height") or 0) // 16
source_tilesets[family].append({
"stem": stem,
"name": f"{stem}.cns",
"webPath": f"../extract_fld/{stem}.cns",
"width": row.get("width"),
"height": row.get("height"),
"bpp": row.get("bpp"),
"paletteColors": row.get("paletteColors"),
"tileColumns": tile_w,
"tileRows": tile_h,
"tileCount": tile_w * tile_h,
})
maps_by_family: dict[str, list[dict]] = defaultdict(list)
for name, row in sorted(map_index.items()):
layer_tilesets = row.get("layerTilesets") or []
family = family_for_tileset(layer_tilesets[0] if layer_tilesets else row.get("tileset"))
maps_by_family[family].append({
"name": name,
"sourceCns": f"{name}.cns",
"width": row.get("width"),
"height": row.get("height"),
"tileCount": int(row.get("width") or 0) * int(row.get("height") or 0),
"layerTilesets": layer_tilesets,
"observedSceneTilesets": row.get("observedSceneTilesets") or [],
"sceneTilesetVariants": row.get("sceneTilesetVariants") or [],
"sceneIdHex": row.get("sceneIdHex"),
"sceneRecordVa": row.get("sceneRecordVa"),
})
families = []
for family in sorted(set(source_tilesets) | set(maps_by_family)):
maps = maps_by_family.get(family, [])
tilesets = sorted(source_tilesets.get(family, []), key=lambda row: row["stem"])
selected_pairs = Counter(",".join(row.get("layerTilesets") or []) for row in maps)
observed_variants = Counter()
for row in maps:
for variant in row.get("sceneTilesetVariants") or []:
observed_variants[",".join(variant)] += 1
families.append({
"family": family,
"label": f"map_{family}*",
"sourceTilesets": tilesets,
"sourceTilesetCount": len(tilesets),
"mapCount": len(maps),
"maps": maps,
"sampleMaps": compact_maps(maps),
"selectedTilesetPairs": [
{"tilesets": key.split(",") if key else [], "count": count}
for key, count in selected_pairs.most_common()
],
"observedSceneVariants": [
{"tilesets": key.split(",") if key else [], "count": count}
for key, count in observed_variants.most_common()
],
})
return {
"scope": "CNS source tileset families and derived tilemap maps",
"mapCount": sum(len(rows) for rows in maps_by_family.values()),
"sourceTilesetCount": sum(len(rows) for rows in source_tilesets.values()),
"familyCount": len(families),
"families": families,
"model": {
"sourceTileset": "map_[family][layer].cns image payload; a 16x16 tile sheet",
"tilemap": "mapN_NNfamily.cns tilemap payload; width/height plus layer0/layer1 tile index grids",
"rendering": "tile word value is used as a 0-based index into a 40-column 16x16 tileset sheet in the accepted renderer",
},
}
def html_page(summary: dict) -> str:
data = json.dumps(summary, ensure_ascii=False)
return "\n".join([
"",
'',
"",
' ',
' ',
" CNS Tileset Families",
" ",
"",
"",
" ",
" ",
' ',
" ",
"",
"",
"",
])
def write_outputs(summary: dict, out_dir: Path) -> None:
out_dir.mkdir(parents=True, exist_ok=True)
(out_dir / "cns_tileset_families.json").write_text(
json.dumps(summary, ensure_ascii=False, separators=(",", ":")) + "\n",
encoding="utf-8",
)
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--maps", type=Path, default=OUT / "maps.js")
parser.add_argument("--cns-payloads", type=Path, default=OUT / "cns_payloads.json")
parser.add_argument("--out-dir", type=Path, default=OUT)
args = parser.parse_args()
summary = build_summary(
parse_map_index(args.maps),
load_json(args.cns_payloads, []),
)
write_outputs(summary, args.out_dir)
print(
"wrote CNS tileset families summary -> "
f"{args.out_dir / 'cns_tileset_families.json'} "
f"({summary['familyCount']} families, {summary['mapCount']} maps)"
)
if __name__ == "__main__":
main()