mirror of
https://github.com/soarqin/DSP_Mods.git
synced 2026-11-19 17:05:20 +08:00
- Add a URL-driven Chinese overlay page rendering item rate tables, tech levels, current research, and Dyson sphere power for streams. - Add the offline GameIcons layer and generate_icons.py, which extracts every item and tech icon from a local DSP install into js/generated/dsp-icons.js. - Reuse the proto extraction in generate_text.py and cover the new page with test_dashboard.js.
399 lines
14 KiB
Python
399 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
"""Convert DSP Locale files and prototype tables into LiveStreamAssist JS text data."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
|
|
DSP_APPID = "1366540"
|
|
DEFAULT_UNITY_VERSION = "2022.3.7"
|
|
KIND_FROM_SET = {
|
|
"ItemProtoSet": "item",
|
|
"TechProtoSet": "tech",
|
|
"RecipeProtoSet": "recipe",
|
|
"SignalProtoSet": "signal",
|
|
"VeinProtoSet": "vein",
|
|
"EnemyProtoSet": "enemy",
|
|
"ModelProtoSet": "model",
|
|
"ThemeProtoSet": "theme",
|
|
"AchievementProtoSet": "achievement",
|
|
"TutorialProtoSet": "tutorial",
|
|
"MilestoneProtoSet": "milestone",
|
|
"GoalProtoSet": "goal",
|
|
"AudioProtoSet": "audio",
|
|
"PromptProtoSet": "prompt",
|
|
"AdvisorTipProtoSet": "advisorTip",
|
|
"JournalPatternProtoSet": "journalPattern",
|
|
"CosmicMessageProtoSet": "cosmicMessage",
|
|
"DoodadProtoSet": "doodad",
|
|
"AbnormalityProtoSet": "abnormality",
|
|
"FleetProtoSet": "fleet",
|
|
"CreationPartProtoSet": "creationPart",
|
|
"EffectEmitterProtoSet": "effectEmitter",
|
|
"MIDIProtoSet": "midi",
|
|
"PlayerProtoSet": "player",
|
|
"VegeProtoSet": "vege",
|
|
}
|
|
EXTRA_STRING_KEYS = ("千分分隔符", "小数点", "杠等级")
|
|
|
|
|
|
def unescape_string(text: str) -> str:
|
|
out = []
|
|
i = 0
|
|
while i < len(text):
|
|
ch = text[i]
|
|
if ch == "\\" and i + 1 < len(text):
|
|
i += 1
|
|
nxt = text[i]
|
|
mapping = {"\\": "\\", "r": "\r", "n": "\n", "t": "\t", "v": "\v", "f": "\f"}
|
|
if nxt in mapping:
|
|
out.append(mapping[nxt])
|
|
else:
|
|
out.append("\\")
|
|
out.append(nxt)
|
|
else:
|
|
out.append(ch)
|
|
i += 1
|
|
return "".join(out)
|
|
|
|
|
|
def first_field(line: str) -> str:
|
|
tab = line.find("\t")
|
|
raw = line if tab < 0 else line[:tab]
|
|
return unescape_string(raw)
|
|
|
|
|
|
def translation_field(line: str) -> str | None:
|
|
tab1 = line.find(" ")
|
|
if tab1 < 0:
|
|
return None
|
|
tab2 = line.find(" ", tab1 + 1)
|
|
if tab2 < 0:
|
|
return None
|
|
tab3 = line.find(" ", tab2 + 1)
|
|
if tab3 < 0:
|
|
return None
|
|
return unescape_string(line[tab3 + 1 :])
|
|
|
|
|
|
def read_locale_text(path: Path) -> str:
|
|
data = path.read_bytes()
|
|
if data.startswith((b'\xff\xfe', b'\xfe\xff')):
|
|
return data.decode('utf-16')
|
|
if data.startswith(b'\xef\xbb\xbf'):
|
|
return data.decode('utf-8-sig')
|
|
try:
|
|
return data.decode('utf-8')
|
|
except UnicodeDecodeError:
|
|
return data.decode('utf-16')
|
|
|
|
|
|
def parse_header(header_path: Path) -> tuple[list[dict], list[str]]:
|
|
text = read_locale_text(header_path)
|
|
lines = text.splitlines()
|
|
languages: list[dict] = []
|
|
page_order: dict[str, int] = {}
|
|
in_langs = False
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
if stripped.startswith("Version="):
|
|
in_langs = True
|
|
continue
|
|
if in_langs and stripped and "," in stripped and not stripped.startswith("[") and "=" not in stripped.split(",", 1)[0]:
|
|
parts = stripped.split(",")
|
|
if len(parts) < 2:
|
|
continue
|
|
try:
|
|
lcid = int(parts[0])
|
|
except ValueError:
|
|
continue
|
|
if lcid <= 0 or any(lang["lcid"] == lcid for lang in languages):
|
|
continue
|
|
languages.append(
|
|
{
|
|
"lcid": lcid,
|
|
"name": parts[1],
|
|
"abbr": parts[2] if len(parts) > 2 else parts[1].lower(),
|
|
"abbr2": parts[3] if len(parts) > 3 else (parts[2] if len(parts) > 2 else parts[1].lower()),
|
|
"fallback": int(parts[4]) if len(parts) > 4 and parts[4].isdigit() else 0,
|
|
}
|
|
)
|
|
continue
|
|
if "=" in stripped:
|
|
key, _, value = stripped.partition("=")
|
|
key = key.strip()
|
|
try:
|
|
page_order[key] = int(value.strip())
|
|
except ValueError:
|
|
continue
|
|
pages = sorted(page_order, key=page_order.get)
|
|
return languages, [name + ".txt" for name in pages]
|
|
|
|
|
|
def load_name_keys(names_dir: Path, pages: list[str]) -> list[str]:
|
|
keys: list[str] = []
|
|
seen: set[str] = set()
|
|
for page in pages:
|
|
path = names_dir / page
|
|
if not path.is_file():
|
|
continue
|
|
for line in read_locale_text(path).splitlines():
|
|
if not line:
|
|
continue
|
|
key = first_field(line)
|
|
if not key or key in seen:
|
|
continue
|
|
seen.add(key)
|
|
keys.append(key)
|
|
return keys
|
|
|
|
|
|
def load_language_strings(lang_dir: Path, pages: list[str], keys: list[str]) -> dict[str, str]:
|
|
index = {key: i for i, key in enumerate(keys)}
|
|
values: list[str | None] = [None] * len(keys)
|
|
for page in pages:
|
|
path = lang_dir / page
|
|
if not path.is_file():
|
|
continue
|
|
for line in read_locale_text(path).splitlines():
|
|
if not line:
|
|
continue
|
|
key = first_field(line)
|
|
if key not in index:
|
|
continue
|
|
slot = index[key]
|
|
if values[slot] is not None:
|
|
continue
|
|
translated = translation_field(line)
|
|
if translated is None:
|
|
continue
|
|
values[slot] = translated
|
|
result = {}
|
|
for key, value in zip(keys, values):
|
|
result[key] = key if value is None else value
|
|
return result
|
|
|
|
|
|
def steam_path() -> Path | None:
|
|
if os.name != "nt":
|
|
return None
|
|
try:
|
|
import winreg
|
|
except ImportError:
|
|
return None
|
|
roots = [
|
|
(winreg.HKEY_CURRENT_USER, r"Software\Valve\Steam"),
|
|
(winreg.HKEY_LOCAL_MACHINE, r"Software\Valve\Steam"),
|
|
(winreg.HKEY_LOCAL_MACHINE, r"Software\Wow6432Node\Valve\Steam"),
|
|
]
|
|
for hive, key in roots:
|
|
try:
|
|
with winreg.OpenKey(hive, key) as handle:
|
|
value, _ = winreg.QueryValueEx(handle, "SteamPath")
|
|
except OSError:
|
|
continue
|
|
if value:
|
|
path = Path(str(value))
|
|
if path.exists():
|
|
return path
|
|
return None
|
|
|
|
|
|
def parse_library_folders(vdf_text: str) -> list[Path]:
|
|
block_re = re.compile(r'"(?:\d+)"\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}', re.S)
|
|
path_re = re.compile(r'"path"\s+"([^"]+)"')
|
|
app_re = re.compile(r'"' + DSP_APPID + r'"\s+"[^"]+"')
|
|
paths = []
|
|
for block in block_re.finditer(vdf_text):
|
|
text = block.group(1)
|
|
if not app_re.search(text):
|
|
continue
|
|
match = path_re.search(text)
|
|
if not match:
|
|
continue
|
|
raw = match.group(1).replace("\\\\", "\\").replace("/", "\\")
|
|
paths.append(Path(raw))
|
|
return paths
|
|
|
|
|
|
def find_game_root(explicit: str | None) -> Path | None:
|
|
if explicit:
|
|
path = Path(explicit)
|
|
if (path / "DSPGAME_Data").is_dir():
|
|
return path
|
|
raise SystemExit(f"DSP game root not found at {path}")
|
|
env = os.environ.get("DSP_ROOT") or os.environ.get("DSPGAME_ROOT")
|
|
if env:
|
|
path = Path(env)
|
|
if (path / "DSPGAME_Data").is_dir():
|
|
return path
|
|
steam = steam_path()
|
|
if steam is None:
|
|
return None
|
|
vdf = steam / "steamapps" / "libraryfolders.vdf"
|
|
if not vdf.is_file():
|
|
return None
|
|
for library in parse_library_folders(vdf.read_text(encoding="utf-8", errors="ignore")):
|
|
candidate = library / "steamapps" / "common" / "Dyson Sphere Program"
|
|
if (candidate / "DSPGAME_Data").is_dir():
|
|
return candidate
|
|
fallback = steam / "steamapps" / "common" / "Dyson Sphere Program"
|
|
if (fallback / "DSPGAME_Data").is_dir():
|
|
return fallback
|
|
return None
|
|
|
|
|
|
def extract_proto_map(
|
|
game_root: Path, unity_version: str, class_names: set[str] | None = None
|
|
) -> dict[str, dict[int, dict]]:
|
|
"""Extract prototype entries keyed by kind and ID, keeping the raw fields."""
|
|
try:
|
|
import UnityPy
|
|
from UnityPy.helpers.TypeTreeGenerator import TypeTreeGenerator
|
|
except ImportError as exc:
|
|
raise SystemExit(
|
|
"UnityPy and TypeTreeGeneratorAPI are required to extract prototype IDs. "
|
|
"Install LiveStreamAssist/js/scripts/requirements.txt."
|
|
) from exc
|
|
|
|
wanted = class_names or KIND_FROM_SET
|
|
data_dir = game_root / "DSPGAME_Data"
|
|
generator = TypeTreeGenerator(unity_version)
|
|
generator.load_local_game(str(game_root))
|
|
ggm = UnityPy.load(str(data_dir / "globalgamemanagers.assets"))
|
|
script_ids = {}
|
|
for obj in ggm.objects:
|
|
if getattr(obj.type, "name", str(obj.type)) != "MonoScript":
|
|
continue
|
|
script = obj.read()
|
|
class_name = getattr(script, "m_ClassName", "")
|
|
if class_name in wanted:
|
|
script_ids[obj.path_id] = class_name
|
|
|
|
resources = UnityPy.load(str(data_dir / "resources.assets"))
|
|
nodes = {
|
|
class_name: generator.get_nodes_up("Assembly-CSharp.dll", class_name)
|
|
for class_name in wanted
|
|
}
|
|
protos: dict[str, dict[int, dict]] = {KIND_FROM_SET[cn]: {} for cn in wanted}
|
|
for obj in resources.objects:
|
|
if getattr(obj.type, "name", str(obj.type)) != "MonoBehaviour":
|
|
continue
|
|
try:
|
|
peek = obj.read_typetree(check_read=False)
|
|
except Exception:
|
|
continue
|
|
script = peek.get("m_Script") or {}
|
|
class_name = script_ids.get(script.get("m_PathID"))
|
|
if class_name is None:
|
|
continue
|
|
kind = KIND_FROM_SET[class_name]
|
|
tree = obj.read_typetree(nodes[class_name], check_read=False)
|
|
for proto in tree.get("dataArray") or []:
|
|
proto_id = proto.get("ID")
|
|
if not proto_id:
|
|
continue
|
|
protos[kind][int(proto_id)] = proto
|
|
return {kind: mapping for kind, mapping in protos.items() if mapping}
|
|
|
|
|
|
def extract_proto_ids(game_root: Path, unity_version: str) -> dict[str, dict[str, str]]:
|
|
ids: dict[str, dict[str, str]] = {}
|
|
for kind, protos in extract_proto_map(game_root, unity_version).items():
|
|
mapping: dict[str, str] = {}
|
|
for proto_id, proto in protos.items():
|
|
name = proto.get("Name")
|
|
if not name:
|
|
continue
|
|
mapping[str(proto_id)] = name
|
|
ids[kind] = mapping
|
|
return {kind: mapping for kind, mapping in ids.items() if mapping}
|
|
|
|
|
|
def collect_needed_keys(all_keys: list[str], ids: dict[str, dict[str, str]]) -> list[str]:
|
|
needed = set(EXTRA_STRING_KEYS)
|
|
for mapping in ids.values():
|
|
needed.update(mapping.values())
|
|
ordered = [key for key in all_keys if key in needed]
|
|
for key in EXTRA_STRING_KEYS:
|
|
if key not in ordered:
|
|
ordered.append(key)
|
|
return ordered
|
|
|
|
|
|
def build_payload(game_root: Path, unity_version: str) -> dict:
|
|
locale_dir = game_root / "Locale"
|
|
header = locale_dir / "Header.txt"
|
|
if not header.is_file():
|
|
raise SystemExit(f"Locale header not found: {header}")
|
|
languages, pages = parse_header(header)
|
|
keys = load_name_keys(locale_dir / "Names", pages)
|
|
ids = extract_proto_ids(game_root, unity_version)
|
|
if not ids.get("item") or not ids.get("tech"):
|
|
raise SystemExit("Prototype extraction did not produce item and tech IDs; generated data was not written.")
|
|
needed_keys = collect_needed_keys(keys, ids)
|
|
strings: dict[str, dict[str, str]] = {key: {} for key in needed_keys}
|
|
language_meta = {}
|
|
for lang in languages:
|
|
lang_dir = locale_dir / str(lang["lcid"])
|
|
if not lang_dir.is_dir():
|
|
continue
|
|
table = load_language_strings(lang_dir, pages, keys)
|
|
language_meta[str(lang["lcid"])] = lang
|
|
for key in needed_keys:
|
|
strings[key][str(lang["lcid"])] = table.get(key, key)
|
|
return {
|
|
"version": "1.0.0",
|
|
"languages": language_meta,
|
|
"ids": ids,
|
|
"strings": strings,
|
|
}
|
|
|
|
|
|
def emit_js(payload: dict) -> str:
|
|
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
|
|
return (
|
|
"/* Generated from a local Dyson Sphere Program install by generate_text.py. Do not edit. */\n"
|
|
"globalThis.LiveStreamAssistTextData = "
|
|
+ body
|
|
+ ";\n"
|
|
)
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--game-root", help="DSP install directory containing DSPGAME_Data and Locale")
|
|
parser.add_argument("--unity-version", default=DEFAULT_UNITY_VERSION)
|
|
parser.add_argument(
|
|
"--out",
|
|
default=str(Path(__file__).resolve().parents[1] / "generated" / "dsp-text.js"),
|
|
help="Output JS path",
|
|
)
|
|
parser.add_argument("--json-out", help="Optional JSON output path")
|
|
args = parser.parse_args(argv)
|
|
game_root = find_game_root(args.game_root)
|
|
if game_root is None:
|
|
raise SystemExit("Dyson Sphere Program install not found. Pass --game-root.")
|
|
payload = build_payload(game_root, args.unity_version)
|
|
out_path = Path(args.out)
|
|
out_path.parent.mkdir(parents=True, exist_ok=True)
|
|
out_path.write_text(emit_js(payload), encoding="utf-8", newline="\n")
|
|
if args.json_out:
|
|
json_path = Path(args.json_out)
|
|
json_path.parent.mkdir(parents=True, exist_ok=True)
|
|
json_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8", newline="\n")
|
|
item_count = len(payload["ids"].get("item", {}))
|
|
tech_count = len(payload["ids"].get("tech", {}))
|
|
print(f"Wrote {out_path} (items={item_count}, techs={tech_count}, strings={len(payload['strings'])})")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|