Add v1.2 development quest progression and experimental battle runtime

This commit is contained in:
AttilaNet
2026-11-08 19:29:28 +08:00
parent 79b7672471
commit 0d3e231cde
71 changed files with 14349 additions and 172 deletions
@@ -0,0 +1,376 @@
"""Offline, synthetic-only AIR checks for SnapshotBridge; never starts the game.
Generated AS3, SWFs, requests and results stay in the ignored local runtime
directory. The harness only loads the already prepared library SWFs and tables.
"""
from __future__ import annotations
import argparse
import hashlib
import json
import os
from pathlib import Path
import shutil
import subprocess
import uuid
ROOT = Path(__file__).resolve().parents[2]
SOURCE = Path(__file__).resolve().parent
LOCAL = ROOT / "local_state/battle_runtime"
HARNESS = r'''
package {
import flash.desktop.NativeApplication;
import flash.display.Loader;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.InvokeEvent;
import flash.events.UncaughtErrorEvent;
import flash.filesystem.File;
import flash.filesystem.FileMode;
import flash.filesystem.FileStream;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.utils.ByteArray;
import flash.utils.describeType;
public class SnapshotBridgeCheck extends Sprite {
private var domain:ApplicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
private var names:Array = ["framework", "main", "baseui", "mainui", "mainui2", "mainui3", "movieclip"];
private var loaders:Array = [];
private var index:int = 0;
private var root:File;
private var output:File;
private var request:Object;
private var finished:Boolean = false;
private var frameworkReady:Boolean = false;
public function SnapshotBridgeCheck() {
loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR,
function(e:UncaughtErrorEvent):void {
e.preventDefault(); finish({ok:false, error:String(e.error)});
});
NativeApplication.nativeApplication.addEventListener(InvokeEvent.INVOKE, invoke);
}
private function invoke(e:InvokeEvent):void {
try {
root = new File(e.arguments[0]); output = new File(e.arguments[2]);
request = JSON.parse(readText(new File(e.arguments[1])));
loadNext();
} catch (error:Error) { finish({ok:false,error:error.getStackTrace() || error.toString()}); }
}
private function readText(file:File):String {
var s:FileStream = new FileStream(); s.open(file,FileMode.READ);
var text:String = s.readUTFBytes(s.bytesAvailable); s.close(); return text;
}
private function readBytes(file:File):ByteArray {
var s:FileStream = new FileStream(); s.open(file,FileMode.READ);
var bytes:ByteArray = new ByteArray(); s.readBytes(bytes); s.close(); return bytes;
}
private function cls(name:String):Class { return domain.getDefinition(name) as Class; }
private function loadNext():void {
if (index == names.length) { check(); return; }
var loader:Loader = new Loader(); loaders.push(loader);
loader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void { loadNext(); });
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,
function(e:IOErrorEvent):void { finish({ok:false,error:e.text}); });
var context:LoaderContext = new LoaderContext(false,domain); context.allowCodeImport = true;
loader.loadBytes(readBytes(root.resolvePath(names[index++] + ".library.swf")),context);
}
private function check():void {
try {
var table:Class = cls("net.pixvi.myr.center.Table");
var names:Array = JSON.parse(readText(root.resolvePath("table_index.json"))) as Array;
var rm:Class = cls("net.pixvi.common.manager.resource.RM"); rm["getInstance"]();
var stringLoader:Class = cls("net.pixvi.pfw.net.PiStringLoader");
stringLoader["globalCryptoMode"] = true;
stringLoader["globalJsonCryptoModeFunction"] = cls("net.pixvi.myrcryptor.MYRCryptor")["jsonDecodeHandler"];
var resourceClass:Class = cls("net.pixvi.common.net.resource.ResourceVo");
for each (var name:String in names) {
var packed:ByteArray = readBytes(root.resolvePath("tables/" + name + ".amf.zlib"));
var resource:Object = new resourceClass("data/table/" + name + ".json");
resource["crypto"] = true; resource["data"] = packed; rm["TXT"]["push"](resource);
var bytes:ByteArray = readBytes(root.resolvePath("tables/" + name + ".amf.zlib"));
bytes.uncompress(); bytes.objectEncoding = 3;
var value:Object = bytes.readObject();
table[name] = name != "team_info" && value.hasOwnProperty("datas") ? value.datas : value;
// ORIGINAL Table.startUp flattens the skin resource wrapper.
if (name == "skin_info") table[name] = value.skins;
}
table["monster_group"] = table["monster_setting"].group;
table["monster_element"] = table["monster_setting"].element;
__ACTION__
} catch (error:Error) { finish({ok:false,error:error.getStackTrace() || error.toString()}); }
}
private function initializeFramework():void {
if (!frameworkReady) {
addChild(cls("net.pixvi.common.center.StartUpCenter")["startUp"](stage,true,false,false,false));
var fixClass:Class = cls("net.pixvi.common.utils.PiFixVo");
var fs1:Object = new fixClass(); fs1.id = "fs1"; fs1.maxHWScale = 1.775;
var fs2:Object = new fixClass(); fs2.id = "fs2"; fs2.maxHWScale = 1.9125;
cls("net.pixvi.common.utils.StageLocator")["autoFull"](720,1136,[fs1,fs2]);
cls("net.pixvi.myr.battle.BattleGround")["firstStartUp"](); frameworkReady = true;
}
}
private function integrity(roster:Object):Object {
// Exercise BattlePanel's private cheatCheck through its ORIGINAL
// public completion handler. Native units come from TeamCenter;
// skip movie loading and install only local result callbacks.
initializeFramework();
var panelClass:Class = cls("net.pixvi.myr.panel.battle.BattlePanel");
var panel:Object = panelClass["getIns"]();
var groundClass:Class = cls("net.pixvi.myr.battle.BattleGround");
var ground:Object = new groundClass(); panel.ground = ground;
var battleClass:Class = cls("net.pixvi.myr.element.battle.BattleVo");
var battle:Object = new battleClass(); ground.vo = battle; panel.battle = battle;
var table:Class = cls("net.pixvi.myr.center.Table");
var authored:Object = table["stage_info"];
if (authored is Array) for each (var stageRow:Object in authored) {
if (stageRow.id == "0101") { authored = {"0101":stageRow}; break; }
}
battle["buildByObject"](authored["0101"].level["1"].battle);
var nativeTeam:Object = cls("net.pixvi.myr.center.TeamCenter")["getIns"]()["getBattleTeamVo"](roster.selectedTeam.teamName);
battle.teamDic[1] = nativeTeam; battle.teams = [nativeTeam];
var viewClass:Class = cls("net.pixvi.myr.battle.view.BattleMon");
var skillClass:Class = cls("net.pixvi.myr.view.skill.SkillType");
for (var i:int = 0; i < nativeTeam.mons.length; i++) {
var nativeVo:Object = nativeTeam.mons[i];
var view:Object = new viewClass();
view.vo = nativeVo.monsterVo; view.monVo = nativeVo; view.teamVo = nativeTeam;
// The pure skill portion of BattleMon.init, without buildView
// or image/movie loading. Skill parameters stay in original code.
view.skill_1 = skillClass["getSkill"](view.vo.skill_1,view.vo.skill_1_lv);
view.skill_2 = skillClass["getSkill"](view.vo.skill_2,view.vo.skill_2_lv);
if (view.skill_1 != null) view.skill_1["init"](view);
if (view.skill_2 != null) view.skill_2["init"](view);
nativeTeam.mons[i] = view;
}
var cooldownClass:Class = cls("net.pixvi.common.utils.Cooldowner");
ground.battleTime = new cooldownClass(1000); ground.winnerTeam = 1;
var dataClass:Class = cls("net.pixvi.myr.element.battle.BattleData");
panelClass["battleData"] = new dataClass();
panel.battlePosition = null;
var result:Object = null;
var completed:Function = function(data:Object):void {
result = {cheatNum:data.cheatNum, text:data.cheatRecords.text,
records:data.cheatRecords.mons, master:data.cheatRecords.master};
};
panel.onWinCallBack = completed; panel.onLoseCallBack = completed;
panel["battleCompleteHandler"]();
return result;
}
private function finish(result:Object):void {
if (finished) return; finished = true;
var s:FileStream = new FileStream(); s.open(output,FileMode.WRITE);
s.writeUTFBytes(JSON.stringify(result)); s.close();
NativeApplication.nativeApplication.exit(result.ok ? 0 : 1);
}
}
}
'''
REFLECT = r'''
var masterClass:Class = cls("net.pixvi.myr.element.master.MasterVo");
var master:Object = new masterClass();
cls("net.pixvi.myr.center.Game")["getIns"]()["master"] = master; master["init"]();
finish({ok:true, master:describeType(master).toXMLString(),
history:describeType(master.history).toXMLString(),
activity:describeType(master.activityHistory).toXMLString()});
'''
CHECK = r'''
var outcomes:Array = [];
var game:Object = cls("net.pixvi.myr.center.Game")["getIns"]();
initializeFramework();
var panel:Object = cls("net.pixvi.myr.panel.battle.BattlePanel")["getIns"]();
var positionClass:Class = cls("net.pixvi.myr.element.battle.BattlePosition");
for each (var test:Object in request.cases) {
var before:String = JSON.stringify(test.snapshot);
var previous:Object = game.master;
var position:Object = new positionClass(); panel.battlePosition = position;
var outcome:Object = {name:test.name};
try {
var roster:Object = SnapshotBridge.build(domain,test.snapshot,test.teamName);
var nativeTeam:Object = cls("net.pixvi.myr.center.TeamCenter")["getIns"]()["getBattleTeamVo"](test.teamName);
var units:Array = [];
var loadedIds:Array = [];
for each (var mon:Object in roster.master.monsters) {
loadedIds.push(mon.id);
if (roster.validation.selectedIds.indexOf(mon.id) < 0) continue;
var native:Object = cls("net.pixvi.myr.center.MonsterCenter")["getIns"]()["getBattleMonVoByMid"](mon.id);
units.push({id:mon.id,type:mon.type,level:mon.level,tplevel:mon.tplevel,
feel:mon.feel,skin:mon.skin,skinVo:mon.skinVo == null ? null : mon.skinVo.typeId,
skinEntry:mon.skinVo == null ? null : {monType:mon.skinVo.table().monType,
ability:mon.skinVo.ability,
sameOriginalEntry:mon.skinVo.table() === table["skin_info"][String(mon.skin)]},
entangle:mon.entangle,entangleLevel:mon.entangleLevel,entangleSkill:mon.entangleSkill,
potential:mon.potential_atk.val,skill_1:mon.skill_1,skill_2:mon.skill_2,
atk:mon.atk,def:mon.def,hp:mon.hp,dex:mon.dex,equip1:mon.equip1,equip2:mon.equip2,
additions:mon.abilityAdd.getRecord(),special:{atkPoi:native.atkPoi,
atkPoiType:native.atkPoiType,crit:native.crit,thorns:native.thorns},
battle:{atk:native.atk,def:native.def,hp:native.hpMax,dex:native.dex}});
}
var inventory:Array = [];
for each (var item:Object in roster.master.bag.items) {
var itemRecord:Object = {id:item.id,type:item.type,num:item.num};
if ("isUsed" in item) {
itemRecord.isUsed = item.isUsed; itemRecord.atk = item.atk.val;
itemRecord.hp = item.hp.val; itemRecord.atkPoiType = item.atkPoiType;
}
inventory.push(itemRecord);
}
var members:Array = [];
for each (native in nativeTeam.mons) members.push({mid:native.mid,teamPos:native.teamPos});
outcome.ok = true; outcome.validation = roster.validation;
outcome.contextUnchanged = panel.battlePosition === position;
outcome.installed = game.master === roster.master;
outcome.selectedSlots = roster.selectedTeam.monsters;
outcome.nativeAP = nativeTeam.ap; outcome.nativeMembers = members;
outcome.apFromRawLevel = cls("net.pixvi.myr.GameMath")["apByLevel"](test.snapshot.master.level);
outcome.units = units; outcome.inventory = inventory;
outcome.loadedMonsterIds = loadedIds;
outcome.history = {monLib:roster.master.history.monLib,
guide_record:roster.master.history.guide_record,unlockStage:roster.master.history.unlockStage,
passStage:roster.master.history.passStage,unlockCity:roster.master.history.unlockCity};
if (test.integrity === true) outcome.integrity = integrity(roster);
} catch (error:Error) {
outcome.ok = false; outcome.error = error.getStackTrace() || error.toString();
outcome.previousMasterRestored = game.master === previous;
}
outcome.inputUnchanged = before == JSON.stringify(test.snapshot);
outcomes.push(outcome);
}
finish({ok:true,cases:outcomes});
'''
def synthetic_snapshot(*, rich: bool = False) -> dict:
"""Explicit fake-account INPUTS; all derived stats remain in original AS3."""
tables = json.loads((LOCAL / "original/tables.json").read_text(encoding="utf-8"))
monster_table = tables["monster_info"].get("datas", tables["monster_info"])
fields = ("atk", "def", "hp", "dex", "crit", "atkSpd", "atkVim", "selfCure", "deadBoom",
"atkStun", "defStun", "atkPoi", "atkPoiDmg", "apCostSave", "skillCooldown",
"sunFire", "moonHeal", "thorns")
monsters, attributes = [], []
for i in range(3):
type_id = 1003010 if rich and i == 1 else 1001010
row = monster_table[str(type_id)]
monsters.append(dict(id=100000001 + i, typeId=type_id, level=1 + i, exp=0,
tpLevel=0, tpExp=0, feel=0, upStar=0, process=3, mode=2,
gAtk=row["atk_grow_min"], gDef=row["def_grow_min"],
gHp=row["hp_grow_min"], gDex=row["dex_grow_min"],
lock=0, sysLock=0, nicName="", timeGet=0, timeStart=0, roomId=0,
inExploreTeam=0, equip1=0, equip2=0, equip3=0, equip4=0, equip5=0,
pAtk=0, pDef=0, pHp=0, pDex=0, potentialLevel=1, giftTime=0,
skin=0, entangle=0, entangleLevel=0, entangleSkills=None))
attributes.append(dict(monsterId=100000001 + i, **dict.fromkeys(fields, 0)))
items = []
if rich:
monsters[0].update(equip2=100000101, pAtk=1, pDef=2, pHp=3, pDex=1)
monsters[1].update(skin=1003011, entangle=1, entangleLevel=1,
entangleSkills='{"1":1001}')
# Aggregate supplied attributes are authoritative, exactly as the server
# snapshot represents them. Do not recalculate equipment/skin bonuses.
attributes[0].update(hp=50, dex=3, atkPoi=2, atkPoiDmg=3)
attributes[1].update({"atk": 13, "def": 15, "atkVim": 2})
params = dict.fromkeys(fields, 0)
params.update(hp=50, dex=3, atkPoi=2, atkPoiDmg=3, atkPoiType=1)
items = [dict(id=100000101, typeId=50001, num=1, isUsed=1, itemClass=3,
equipParams=json.dumps(params))]
return dict(
master=dict(id=1, level=30, roleName="Offline fixture", farmName="", avatar=0,
createTime=0, exp=0, money=0, ti=0, ke=0, timeTi=0,
globalAtk=2 if rich else 0, globalDef=1 if rich else 0,
globalHp=5 if rich else 0, globalDex=1 if rich else 0),
monsters=monsters, monsterAttributes=attributes, items=items,
teams=[dict(teamName="teamA", teamType="battleTeam",
monsters=[100000003, 0, 100000001, 100000002, 0, 0, 0])],
history=dict(numAddMoney=0, numFeedMonsters={}, numKillMonsters={}, numChicken=0,
countBattle=0, historyGacha={}, passAchi=[], passTask={}, unlockTask={},
loopTask={}, guide_main="", guide_record=["firstOut"], unlockCity=[1],
unlockStage={"0101": [1]}, passStage={"0101": [1]},
monLib=[1001010, 1003010], equipLib=["50001"], payTypeCount={},
everyDayBuyProductNum={}),
data2=dict(unlockSkins=[1003011], timeEggItems=[]),
activityHistory=dict(dailyGift=dict(dailyGiftCheckTime=0, dailyGiftLevel=1,
dailyGiftCount=0, signCount=0),
vipInfo=dict(vipTime=0, getTime=0)))
def dependencies_available() -> bool:
return (os.name == "nt" and shutil.which("java") is not None
and (LOCAL / "air_sdk/lib/mxmlc-cli.jar").is_file()
and (LOCAL / "original/main.library.swf").is_file())
def run_harness(request: dict, *, action: str = REFLECT) -> dict:
# Match the existing probe's reviewed, pinned dependencies, without prepare(),
# network acquisition, account caches, or writes into another owner's build.
from tools.battle_runtime.trusted import LIBRARY_FILES, SDK_FILES, verify_files
for root, pins in ((LOCAL / "air_sdk", SDK_FILES), (LOCAL / "original", LIBRARY_FILES)):
errors = verify_files(root, pins)
if errors:
raise RuntimeError(f"Untrusted local snapshot-check dependencies: {errors}")
build = LOCAL / "snapshot_bridge_checks" / uuid.uuid4().hex
build.mkdir(parents=True)
(build / "SnapshotBridgeCheck.as").write_text(HARNESS.replace("__ACTION__", action), encoding="utf-8")
(build / "compiler-config.xml").write_text("<flex-config/>", encoding="utf-8")
sdk = LOCAL / "air_sdk"
command = [shutil.which("java") or "java", "-Duser.language=en", "-Duser.country=US", "-jar",
str(sdk / "lib/mxmlc-cli.jar"), "-load-config=" + str(build / "compiler-config.xml"),
"-compiler.external-library-path=" + str(sdk / "frameworks/libs/air/airglobal.swc"),
"-compiler.library-path=" + str(sdk / "frameworks/libs/core.swc"),
"-compiler.source-path=" + str(SOURCE), "-swf-version=50", "-debug=true",
"-default-frame-rate=50", "-output=" + str(build / "SnapshotBridgeCheck.swf"),
str(build / "SnapshotBridgeCheck.as")]
compiler = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, encoding="utf-8",
errors="replace", timeout=60, creationflags=subprocess.CREATE_NO_WINDOW)
evidence = {"compiler_exit_code": compiler.returncode, "compiler_stdout": compiler.stdout,
"compiler_stderr": compiler.stderr,
"source_sha256": hashlib.sha256((SOURCE / "SnapshotBridge.as").read_bytes()).hexdigest()
if (SOURCE / "SnapshotBridge.as").is_file() else None}
if compiler.returncode:
raise RuntimeError("Snapshot bridge compilation failed: " + compiler.stdout + compiler.stderr)
(build / "check-app.xml").write_text('''<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://ns.adobe.com/air/application/51.1">
<id>local.snapshotbridge.c''' + uuid.uuid4().hex + '''</id><versionNumber>0.0.1</versionNumber>
<filename>SnapshotBridgeCheck</filename><initialWindow><content>SnapshotBridgeCheck.swf</content>
<visible>false</visible><systemChrome>none</systemChrome><renderMode>cpu</renderMode>
</initialWindow><supportedProfiles>extendedDesktop</supportedProfiles></application>''', encoding="utf-8")
(build / "request.json").write_text(json.dumps(request), encoding="utf-8")
command = [str(sdk / "bin/adl64.exe"), "-runtime", str(sdk / "runtimes/air/win64"), "-nodebug",
"-profile", "extendedDesktop", str(build / "check-app.xml"), "--", str(LOCAL / "original"),
str(build / "request.json"), str(build / "result.json")]
runtime = subprocess.run(command, cwd=build, capture_output=True, timeout=45,
creationflags=subprocess.CREATE_NO_WINDOW)
result_path = build / "result.json"
evidence.update(process_exit_code=runtime.returncode,
result=json.loads(result_path.read_text(encoding="utf-8")) if result_path.exists() else None,
directory=str(build))
(build / "evidence.json").write_text(json.dumps(evidence, indent=2), encoding="utf-8")
if evidence["result"] is None:
raise RuntimeError(f"AIR snapshot check produced no result (exit {runtime.returncode})")
return evidence
def run_checks(cases: list[dict] | None = None) -> dict:
if cases is None:
cases = [dict(name=name, snapshot=synthetic_snapshot(rich=rich),
teamName="teamA", integrity=True)
for name, rich in (("plain", False), ("equipment_skin_entangle", True))]
empty = synthetic_snapshot()
empty["monsterAttributes"] = []
cases.append(dict(name="empty_attributes", snapshot=empty, teamName="teamA", integrity=True))
return run_harness({"cases": cases}, action=CHECK)
if __name__ == "__main__":
import sys
sys.path.insert(0, str(ROOT))
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--reflect", action="store_true")
args = parser.parse_args()
evidence = run_harness({}) if args.reflect else run_checks()
print(json.dumps(evidence, indent=2))
sys.exit(0 if evidence["result"].get("ok") and
all(c["ok"] for c in evidence["result"].get("cases", [])) else 1)