143 lines
6.6 KiB
Python
143 lines
6.6 KiB
Python
"""Verified, offline progression configuration from the original 1.9.68 APK.
|
|
|
|
The application reads derived static files only. Stage battle dictionaries live
|
|
in a separate archive and are read one stage at a time by a battle worker.
|
|
Nothing in this module opens an APK, imports the research tools, or uses a
|
|
network client. The existing commission-only Catalog is deliberately untouched.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from functools import lru_cache
|
|
import gzip
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import zipfile
|
|
|
|
|
|
DATA_DIR = Path(__file__).with_name("data")
|
|
MANIFEST_NAME = "progression_manifest.json"
|
|
DATA_NAME = "progression.json.gz"
|
|
BATTLES_NAME = "progression_battles.zip"
|
|
SCHEMA_VERSION = 1
|
|
ORIGINAL_APK_SHA256 = "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d"
|
|
|
|
|
|
class ProgressionDataError(ValueError):
|
|
"""Missing, inconsistent, or damaged derived configuration."""
|
|
|
|
|
|
class ProgressionData:
|
|
"""Small task/index data; optional stage battles are loaded lazily.
|
|
|
|
Public tables: tasks/task_info, stages/stage_info, scripts, setting,
|
|
game_setting, npc_info, stage_sp, areas, mines, farming, manifest. ``data`` exposes the index
|
|
mapping for integrations. This is shared read-only configuration; callers
|
|
must keep character state and credentials elsewhere.
|
|
"""
|
|
|
|
def __init__(self, data=None, *, directory=None):
|
|
self.directory = Path(directory or DATA_DIR)
|
|
self.manifest = {}
|
|
if data is None:
|
|
try:
|
|
self.manifest = json.loads((self.directory / MANIFEST_NAME).read_text(encoding="utf-8"))
|
|
if self.manifest.get("schema_version") != SCHEMA_VERSION:
|
|
raise ProgressionDataError("Unsupported progression manifest version")
|
|
if self.manifest.get("source", {}).get("apk_sha256") != ORIGINAL_APK_SHA256:
|
|
raise ProgressionDataError("Progression data is not bound to the original APK")
|
|
artifact = (self.directory / DATA_NAME).read_bytes()
|
|
expected = self.manifest["artifacts"][DATA_NAME]["sha256"]
|
|
if hashlib.sha256(artifact).hexdigest() != expected:
|
|
raise ProgressionDataError("Progression artifact hash mismatch")
|
|
decoded = gzip.decompress(artifact)
|
|
if hashlib.sha256(decoded).hexdigest() != self.manifest["artifacts"][DATA_NAME]["decoded_sha256"]:
|
|
raise ProgressionDataError("Progression decoded data hash mismatch")
|
|
data = json.loads(decoded)
|
|
except (OSError, KeyError, ValueError, EOFError) as exc:
|
|
if isinstance(exc, ProgressionDataError):
|
|
raise
|
|
raise ProgressionDataError(f"Cannot load static progression data: {exc}") from exc
|
|
if not isinstance(data, dict) or not isinstance(data.get("task_info"), dict):
|
|
raise ProgressionDataError("Progression data must contain a full task_info mapping")
|
|
if data.get("schema_version", SCHEMA_VERSION) != SCHEMA_VERSION:
|
|
raise ProgressionDataError("Unsupported progression data version")
|
|
self.data = data
|
|
self.tasks = self.task_info = data["task_info"]
|
|
self.stages = self.stage_info = data.get("stage_info", {})
|
|
self.scripts = data.get("scripts", {})
|
|
self.setting = data.get("setting", {})
|
|
self.game_setting = data.get("game_setting", {})
|
|
self.npc_info = data.get("npc_info", {})
|
|
self.stage_sp = data.get("stage_sp", {})
|
|
self.areas = (data.get("area_info") or {}).get("areaInfo", {})
|
|
self.area_maps = (data.get("area_info") or {}).get("areaMap", {})
|
|
self.mines = (data.get("mine_info") or {}).get("mines", {})
|
|
self.positions = {}
|
|
self.farming = data.get("farming") or {"kills": {}, "items": {}}
|
|
for parent, area in self.area_maps.items():
|
|
for entry in area.get("positions") or []:
|
|
if entry.get("posId"):
|
|
self.positions.setdefault(entry["posId"], []).append(entry | {"parent_area": parent})
|
|
|
|
def task(self, type_id):
|
|
return self.tasks.get(str(type_id))
|
|
|
|
def stage(self, stage_id):
|
|
return self.stages.get(str(stage_id))
|
|
|
|
def script(self, name):
|
|
return self.scripts.get(str(name))
|
|
|
|
def npc_name(self, key):
|
|
return self.npc_info.get(str(key), {}).get("name") or str(key or "")
|
|
|
|
def stage_battle(self, stage_id, difficulty=1):
|
|
"""Read one original stage's battle config, never the entire archive.
|
|
|
|
Call this from the battle worker, not the GUI thread. The per-member
|
|
digest is itself covered by the checked index artifact digest.
|
|
"""
|
|
stage_id = str(stage_id)
|
|
stage = self.stage(stage_id) or {}
|
|
# Injected data can carry full stage dictionaries for offline tests.
|
|
level = (stage.get("level") or {}).get(str(difficulty), {})
|
|
if "battle" in level:
|
|
return level["battle"]
|
|
record = self.data.get("battle_members", {}).get(stage_id)
|
|
if not record:
|
|
raise ProgressionDataError(f"Missing original battle configuration for stage {stage_id}")
|
|
try:
|
|
with zipfile.ZipFile(self.directory / BATTLES_NAME) as archive:
|
|
raw = archive.read(record["member"])
|
|
if hashlib.sha256(raw).hexdigest() != record["sha256"]:
|
|
raise ProgressionDataError(f"Stage {stage_id} battle hash mismatch")
|
|
return json.loads(raw).get(str(difficulty))
|
|
except (OSError, KeyError, ValueError, zipfile.BadZipFile) as exc:
|
|
if isinstance(exc, ProgressionDataError):
|
|
raise
|
|
raise ProgressionDataError(f"Cannot load stage {stage_id}: {exc}") from exc
|
|
|
|
def task_battle(self, type_id, step_number):
|
|
"""Resolve source battle data; step_number is the one-based wire step."""
|
|
task = self.task(type_id) or {}
|
|
steps = task.get("steps") or []
|
|
if not 1 <= int(step_number) <= len(steps):
|
|
raise ProgressionDataError("Task battle step is outside the configured task")
|
|
step = steps[int(step_number) - 1]
|
|
if step.get("statusType") == "passStage":
|
|
value = step.get("statusValue") or {}
|
|
return self.stage_battle(value["stage"], value.get("level", 1))
|
|
if step.get("statusType") == "battle":
|
|
return step.get("battle")
|
|
raise ProgressionDataError("Task step is not a battle")
|
|
|
|
|
|
GameData = ProgressionData
|
|
|
|
|
|
@lru_cache(maxsize=1)
|
|
def load_progression_data():
|
|
"""Load the packaged static index once; does not parse an APK."""
|
|
return ProgressionData()
|