Files

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()