Add v1.2 development quest progression and experimental battle runtime
This commit is contained in:
@@ -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)
|
||||
Reference in New Issue
Block a user