Files

422 lines
27 KiB
ActionScript

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.SecurityErrorEvent;
import flash.events.UncaughtErrorEvent;
import flash.events.TimerEvent;
import flash.filesystem.File;
import flash.filesystem.FileMode;
import flash.filesystem.FileStream;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import flash.system.System;
import flash.utils.ByteArray;
import flash.utils.describeType;
import flash.utils.getTimer;
import flash.utils.setTimeout;
import flash.utils.Timer;
import flash.utils.Endian;
/** No game startup, login, update, networking or settlement callbacks. */
public class OriginalProbe extends Sprite {
private var domain:ApplicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
private var libraries:Array = ["framework", "main", "baseui", "mainui", "mainui2", "mainui3", "movieclip"];
private var loaders:Array = [];
private var tables:Object;
private var request:Object;
private var events:Array = [];
private var output:File;
private var root:File;
private var index:int = 0;
private var finished:Boolean = false;
private var phase:String = "invoke";
private var sceneStarted:Boolean = false;
private var sceneResult:Object = null;
private var observedFrames:int = 0;
private var sceneStartMs:int = 0;
private var originalFrameRate:Number;
private var engineFrameCallbacks:int = 0;
private var assetIndex:Object;
private var archiveStream:FileStream;
private var crcTable:Array;
public function OriginalProbe() {
System.output("ORIGINAL_PROBE_CONSTRUCTOR\n");
loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaught);
NativeApplication.nativeApplication.addEventListener(InvokeEvent.INVOKE, invoke);
}
private function invoke(e:InvokeEvent):void {
System.output("ORIGINAL_PROBE_INVOKE " + e.arguments.length + "\n");
if (output != null) return;
try {
if (e.arguments.length != 3) throw new Error("Expected original-directory request-json output-json");
root = new File(e.arguments[0]);
output = new File(e.arguments[2]);
request = JSON.parse(readText(new File(e.arguments[1])));
assetIndex = JSON.parse(readText(root.resolvePath("asset_index.json")));
if (assetIndex.apk_sha256 != "01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d")
throw new Error("Original asset archive identity mismatch");
archiveStream = new FileStream(); archiveStream.open(new File(assetIndex.apk_path),FileMode.READ);
tables = {};
var tableNames:Array = JSON.parse(readText(root.resolvePath("table_index.json"))) as Array;
for each (var tableName:String in tableNames) {
var bytes:ByteArray = readBytes(root.resolvePath("tables/" + tableName + ".amf.zlib"));
bytes.uncompress(); bytes.objectEncoding = 3;
tables[tableName] = bytes.readObject();
if (bytes.bytesAvailable != 0) throw new Error("Trailing AMF bytes: " + tableName);
}
var mainBytes:ByteArray = readBytes(root.resolvePath("main.library.swf"));
var rectangleBits:uint = uint(mainBytes[8]) >> 3;
mainBytes.position = 8 + Math.ceil((5 + 4 * rectangleBits) / 8);
mainBytes.endian = Endian.LITTLE_ENDIAN;
originalFrameRate = mainBytes.readUnsignedShort() / 256;
if (originalFrameRate != 50) throw new Error("Pinned original main SWF frame rate mismatch");
stage.frameRate = originalFrameRate;
var watchdog:Number = request.watchdog_ms == null ? 690000 : Number(request.watchdog_ms);
if (!isFinite(watchdog) || watchdog <= 0) throw new Error("Invalid technical watchdog");
setTimeout(function():void { fail(new Error("Technical watchdog exceeded")); },watchdog);
loadNext();
} catch (error:Error) { fail(error); }
}
private function readText(file:File):String {
var stream:FileStream = new FileStream(); stream.open(file, FileMode.READ);
var result:String = stream.readUTFBytes(stream.bytesAvailable); stream.close(); return result;
}
private function readBytes(file:File):ByteArray {
var stream:FileStream = new FileStream(); stream.open(file, FileMode.READ);
var result:ByteArray = new ByteArray(); stream.readBytes(result); stream.close(); return result;
}
private function record(kind:String, data:Object = null):void {
var event:Object = {kind:kind, elapsed_ms:getTimer(), phase:phase, data:data};
events.push(event); trace("ORIGINAL_PROBE " + JSON.stringify(event));
}
private function loadNext():void {
if (index == libraries.length) { measureClock(); return; }
phase = "load_" + libraries[index++];
var loader:Loader = new Loader(); loaders.push(loader);
loader.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR, uncaught);
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, function(e:Event):void {
record("library_loaded", {name:phase, document_class:String(describeType(loader.content).@name)});
loadNext();
});
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, function(e:IOErrorEvent):void { fail(new Error(e.text)); });
loader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, function(e:SecurityErrorEvent):void { fail(new Error(e.text)); });
var context:LoaderContext = new LoaderContext(false, domain); context.allowCodeImport = true;
loader.loadBytes(readBytes(root.resolvePath(libraries[index-1] + ".library.swf")), context);
}
private function cls(name:String):Class { return domain.getDefinition(name) as Class; }
private function measureClock():void {
phase = "measure_hidden_clock";
stage.frameRate = originalFrameRate;
// Let startup/loading work drain before measuring the hidden stage.
setTimeout(measureClockWindow,300);
}
private function measureClockWindow():void {
var start:int = getTimer(), frames:int = 0, ticks:int = 0;
var timer:Timer = new Timer(100);
var frame:Function = function(e:Event):void { frames++; };
timer.addEventListener(TimerEvent.TIMER, function(e:TimerEvent):void { ticks++; });
stage.addEventListener(Event.ENTER_FRAME, frame); timer.start();
setTimeout(function():void {
timer.stop(); stage.removeEventListener(Event.ENTER_FRAME, frame);
var elapsed:int = getTimer() - start;
record("clock_measured", {requested_fps:stage.frameRate, observed_frames:frames,
elapsed_ms:elapsed, observed_fps:frames * 1000 / elapsed,
stage_width:stage.stageWidth,stage_height:stage.stageHeight,
timer_period_ms:100, timer_ticks:ticks, native_window_visible:stage.nativeWindow.visible});
probe();
}, 2500);
}
private function reflect(name:String):void {
var type:XML = describeType(cls(name));
var stream:FileStream = new FileStream();
stream.open(output.parent.resolvePath(name.replace(/\./g,"_") + ".xml"), FileMode.WRITE);
stream.writeUTFBytes(type.toXMLString()); stream.close();
record("definition_resolved", {name:name});
}
private function probe():void {
try {
phase = "inject_original_tables";
var table:Class = cls("net.pixvi.myr.center.Table");
for (var key:String in tables) {
if (key == "monster_fix") continue;
var value:Object = tables[key];
if (key != "team_info" && value != null && value.hasOwnProperty("datas")) value = value.datas;
table[key] = value;
}
table["skin_info"] = tables.skin_info.skins;
table["upstar_info"] = tables.upstar_info;
table["city_info"] = table["game_setting"].cityInfo;
table["entangle_skill"] = table["entangle_info"].entangleSkill;
table["stage_info"] = cls("net.pixvi.pfw.utils.ObjectUtil")["tableToObject"](tables.stage_info.datas);
table["monster_group"] = table["monster_setting"].group;
table["monster_element"] = table["monster_setting"].element;
record("tables_injected");
phase = "initialize_synthetic_master";
var gameClass:Class = cls("net.pixvi.myr.center.Game");
var masterClass:Class = cls("net.pixvi.myr.element.master.MasterVo");
var master:Object = new masterClass();
gameClass["getIns"]()["master"] = master; master["init"]();
master["history"]["monLib"] = [];
record("synthetic_master_initialized", {source:"original MasterVo.init",account:false});
phase = "original_framework_bootstrap";
addChild(cls("net.pixvi.common.center.StartUpCenter")["startUp"](stage,true,false,false,false));
record("original_framework_layers_initialized");
var rm:Class = cls("net.pixvi.common.manager.resource.RM");
rm["getInstance"]();
record("original_resource_managers_initialized");
var stringLoader:Class = cls("net.pixvi.pfw.net.PiStringLoader");
var cryptor:Class = cls("net.pixvi.myrcryptor.MYRCryptor");
stringLoader["globalCryptoMode"] = true;
stringLoader["globalJsonCryptoModeFunction"] = cryptor["jsonDecodeHandler"];
var resourceClass:Class = cls("net.pixvi.common.net.resource.ResourceVo");
for (var tableKey:String in tables) {
var resource:Object = new resourceClass("data/table/" + tableKey + ".json");
resource["crypto"] = true;
resource["data"] = readBytes(root.resolvePath("tables/" + tableKey + ".amf.zlib"));
rm["TXT"]["push"](resource);
}
var netImg:Class = cls("net.pixvi.pfw.display.NetImg");
netImg["globalImgCryptoMode"] = true;
netImg["globalImgCryptoGetBytes"] = originalAssetBytes;
netImg["globalImgSrcHack"] = localAssetPath;
var net:Class = cls("net.pixvi.myr.net.NetCenter");
var offlineBase:String = output.parent.resolvePath("__offline_game_api_denied__/").url + "/";
net["SERVER"] = net["PAY_SERVER"] = net["CENTER_SERVER"] = offlineBase;
if (request.scene === true) {
bootstrapDisplay();
var sceneData:Object = request.original_data != null ? request.original_data.battle :
table["stage_info"][request.stage_id].level[String(request.difficulty)].battle;
startScene(master,cls("net.pixvi.myr.element.mon.MonsterVo"),sceneData);
return;
}
phase = "original_GameMath";
var math:Class = cls("net.pixvi.myr.GameMath");
var rolls:Array = [];
for (var i:int=0; i<8; i++) rolls.push(math["damage"](100,20,20,30));
record("GameMath_executed", {damage_rolls:rolls, ap_cd:math["apCD"], dex_attack_adjustment:math["addAtkSpdByDex"](40)});
phase = "reflect_original_framework";
for each (var name:String in ["net.pixvi.common.driver.StageDriver", "net.pixvi.common.driver.SecondDriver",
"net.pixvi.common.manager.resource.RM", "net.pixvi.common.view.FF", "net.pixvi.pfw.display.BitFactory",
"net.pixvi.myr.center.BattleCenter", "net.pixvi.myr.element.mon.MonsterVo",
"net.pixvi.myr.element.battle.BattleMonVo", "net.pixvi.myr.element.battle.BattleVo",
"net.pixvi.common.utils.StageLocator", "net.pixvi.common.utils.PiFixVo", "net.pixvi.pfw.driver.EnterFrameDriver"]) reflect(name);
phase = "original_MonsterVo";
var monsterClass:Class = cls("net.pixvi.myr.element.mon.MonsterVo");
var monster:Object = new monsterClass(1001010);
monster["buildByArea"](); monster["level"] = 1; monster["mode"] = 2;
record("MonsterVo_executed", {type:monster["type"],level:monster["level"],hp:monster["hp"],atk:monster["atk"],dex:monster["dex"]});
phase = "original_BattleMonVo";
var monClass:Class = cls("net.pixvi.myr.element.battle.BattleMonVo");
var mon:Object = new monClass(); mon["buildByMonster"](monster);
record("BattleMonVo_executed", {hp:mon["hp"],atk:mon["atk"],spd_atk:mon["spd_atk"],spd_mov:mon["spd_mov"],skill_1:mon["skill_1"]});
phase = "original_BattleVo";
var battleClass:Class = cls("net.pixvi.myr.element.battle.BattleVo");
var battle:Object = new battleClass();
var stages:Object = table["stage_info"];
if (stages is Array) {
var mapped:Object = {};
for each (var row:Object in stages) mapped[row.id] = row;
stages = mapped;
}
var battleData:Object = stages[request.stage_id].level[String(request.difficulty)].battle;
battle["buildByObject"](battleData);
record("BattleVo_executed", {time:battle["time"],teams:battle["teams"].length,enemy_count:battle["teams"][0].mons.length});
bootstrapDisplay();
phase = "original_BattleGround_constructor";
reflect("net.pixvi.myr.battle.BattleGround");
var groundClass:Class = cls("net.pixvi.myr.battle.BattleGround");
groundClass["firstStartUp"]();
var ground:Object = new groundClass();
record("BattleGround_constructed");
finish("probe_completed", null);
} catch (error:Error) { fail(error); }
}
private function bootstrapDisplay():void {
phase = "original_display_bootstrap";
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]);
// The ORIGINAL constructor calls startup(). Calling it again
// creates another ENTER_FRAME source and corrupts delta timing.
cls("net.pixvi.pfw.driver.EnterFrameDriver")["getInstance"]()["regist"](countEngineFrame);
cls("net.pixvi.common.driver.SecondDriver")["getInstance"]()["startup"]();
}
private function startScene(master:Object, monsterClass:Class, battleData:Object):void {
phase = "original_BattleCenter_startBattle";
if (request.roster != null && request.roster.snapshot != null) {
phase = "original_snapshot_bridge";
var bridge:Class = ApplicationDomain.currentDomain.getDefinition("SnapshotBridge") as Class;
var built:Object = bridge["build"](domain,request.roster.snapshot,request.roster.team_name);
master = built.master;
cls("net.pixvi.myr.center.Game")["getIns"]()["master"] = master;
master["curBattleTeam"] = request.roster.team_name;
record("snapshot_bridge_built",built.metadata == null ? built.validation : built.metadata);
} else {
var teamClass:Class = cls("net.pixvi.myr.element.team.TeamVo");
var team:Object = new teamClass(); team["monsters"] = [1000001,1000002,1000003,0,0,0,0,0];
master["teams"] = [team]; master["name"] = "offline synthetic fixture";
for (var i:int = 1; i <= 3; i++) {
var mon:Object = new monsterClass(1001010);
mon["buildByArea"](); mon["level"] = 1; mon["mode"] = 2; mon["id"] = 1000000+i;
master["monsters"].push(mon);
}
}
phase = "original_BattleCenter_startBattle";
var sound:Class = cls("net.pixvi.common.center.SoundCenter");
sound["getIns"]()["setBgmEnable"](false); sound["getIns"]()["setEffectEnable"](false);
var positionClass:Class = cls("net.pixvi.myr.element.battle.BattlePosition");
var position:Object = new positionClass();
if (request.position != null) {
cls("net.pixvi.pfw.utils.Mapper")["fillVariables"](position,request.position);
} else {
position["battleType"] = "stage"; position["stageId"] = request.stage_id; position["stageLevel"] = String(request.difficulty);
}
var panelClass:Class = cls("net.pixvi.myr.panel.battle.BattlePanel");
var panel:Object = panelClass["getIns"]();
panel["onWinCallBack"] = sceneComplete; panel["onLoseCallBack"] = sceneComplete;
cls("net.pixvi.myr.center.BattleCenter")["getIns"]()["startBattle"](position,battleData,{},null,null);
record("BattleCenter_started", {context:request.context,master_level:master["level"], ap:master["ap"],
callbacks:"original BattlePanel checks followed by local result collection only"});
setTimeout(function():void {
try {
phase = "original_battle_ready_animation";
panel["battleStartReady"]();
stage.addEventListener(Event.ENTER_FRAME, countSceneFrame);
sceneStartMs = getTimer();
observeScene();
} catch (error:Error) { fail(error); }
}, 700);
}
private function countSceneFrame(e:Event):void { observedFrames++; }
private function countEngineFrame():void { engineFrameCallbacks++; }
private function observeScene():void {
if (finished) return;
try {
var panelClass:Class = cls("net.pixvi.myr.panel.battle.BattlePanel");
var panel:Object = panelClass["getIns"]();
var ground:Object = panel["ground"];
sceneStarted = sceneStarted || ground["battleIsStart"];
phase = sceneStarted ? "original_battle_frames" : "original_battle_ready_animation";
var units:Array = [];
for each (var mon:Object in ground["monsters"]) {
units.push({id:mon["monVo"]["mid"],team:mon["team"],x:mon["x"],y:mon["y"],
hp:mon["monVo"]["hp"],skill_1:mon["monVo"]["skill_1"],skill_2:mon["monVo"]["skill_2"]});
}
record("scene_sample", {started:ground["battleIsStart"], paused:ground["paused"],
requested_fps:stage.frameRate,
engine_frame_callbacks:engineFrameCallbacks,
engine_frame_delta_ms:cls("net.pixvi.pfw.driver.EnterFrameDriver")["frameSpaceTime"],
left_ms:ground["battleTime"]["leftTime"],ap:ground["vo"]["teamDic"][1]["ap"],
units:units, observed_frames:observedFrames, wall_ms:getTimer()-sceneStartMs});
if (!sceneStarted) panel["startMovTouchHandler"]();
setTimeout(observeScene, 1000);
} catch (error:Error) { fail(error); }
}
private function sceneComplete(data:Object):void {
try {
phase = "original_BattlePanel_result_callback";
sceneStarted = true;
var raw:Object = data["cheatRecords"];
if (cls("net.pixvi.myr.net.NetCenter")["getIns"]()["reqid"] != 0)
throw new Error("Original scene attempted an unavailable offline game API");
var unitRecords:Array = [];
var panelClass:Class = cls("net.pixvi.myr.panel.battle.BattlePanel");
var ground:Object = panelClass["getIns"]()["ground"];
var objectUtil:Class = cls("net.pixvi.pfw.utils.ObjectUtil");
for each (var team:Object in ground["vo"]["teams"]) {
var allUnits:Array = team["mons"].concat(team["stageMons"]).concat(team["deadMons"]);
for each (var mon:Object in allUnits) {
unitRecords.push({team:mon["team"],mode:mon["monVo"]["mode"],
summon:mon["monVo"]["summonUnit"],dead:mon["monVo"]["dead"],hp_left:mon["monVo"]["hp"],
original_hurt_record:mon["getTotalHurtRecort"](),
original_record:objectUtil["deepClone"](mon["makeRecord"]())});
}
}
sceneResult = {outcome:data["win"] ? "win" : "loss",terminal_reason:data["leftTime"] == 0 ? "time_limit" : (data["win"] ? "victory_condition" : "loss_condition"), battle_data:data["getObj"](),
anomaly_records:{mons:raw["mons"],damages:raw["damages"],master:raw["master"],text:raw["text"]},
original_unit_records:unitRecords,
requested_fps:stage.frameRate,observed_fps:observedFrames*1000/(getTimer()-sceneStartMs),
engine_frame_callbacks:engineFrameCallbacks,game_api_requests:0,
observed_frames:observedFrames, wall_ms:getTimer()-sceneStartMs};
record("original_battle_completed", sceneResult);
finish("scene_completed", null);
} catch (error:Error) { fail(error); }
}
private function uncaught(e:UncaughtErrorEvent):void {
e.preventDefault(); fail(e.error is Error ? e.error as Error : new Error(String(e.error)));
}
private function localAssetPath(path:String):String {
if (path.indexOf(":") >= 0 || path.indexOf("..") >= 0 || path.indexOf("\\") >= 0 || path.charAt(0) == "/")
throw new Error("Offline resource path refused: " + path);
return path;
}
private function originalAssetBytes(path:String):ByteArray {
localAssetPath(path);
var cryptor:Class = cls("net.pixvi.myrcryptor.MYRCryptor");
var hashed:String = cryptor["getHashSrc"](path);
var entry:Object = assetIndex.entries[hashed.substr(6)];
if (entry == null) {
record("original_asset_read", {path:path, member:hashed, crc32:null});
// Match MYRCryptor.getHashSrcBytes. NetBitImg then attempts the
// relative local file and dispatches its ORIGINAL error/complete
// callbacks. Do not manufacture pixels or suppress the record.
record("original_asset_missing", {path:path, member:hashed, behavior:"original local IO-error fallback"});
var permitted:Array = request.allowed_missing_assets == null ? ["data/img/monster/q/1001010_q_2s.png"] : request.allowed_missing_assets as Array;
if (permitted == null || permitted.indexOf(path) < 0) throw new Error("Unknown original asset dependency: " + path);
return null;
}
if (entry.size > 67108864 || entry.compressed_size > 67108864 || entry.offset < 0)
throw new Error("Original image resource exceeds supported bounds: " + path);
var bytes:ByteArray = new ByteArray();
archiveStream.position = entry.offset;
archiveStream.readBytes(bytes,0,entry.compressed_size);
if (entry.method == 8) bytes.uncompress("deflate");
else if (entry.method != 0) throw new Error("Unsupported original ZIP method");
var checksum:uint = crc32(bytes);
if (bytes.length != entry.size || checksum != uint(entry.crc32))
throw new Error("Original asset ZIP content mismatch: " + path);
record("original_asset_read", {path:path, member:hashed, crc32:checksum, bytes:bytes.length});
bytes.position = 0;
return bytes;
}
private function crc32(bytes:ByteArray):uint {
if (crcTable == null) {
crcTable = [];
for (var n:uint=0; n<256; n++) {
var value:uint=n;
for (var bit:uint=0; bit<8; bit++) value=(value & 1) ? uint(0xedb88320 ^ (value >>> 1)) : value >>> 1;
crcTable.push(value);
}
}
var checksum:uint=0xffffffff;
for (var i:uint=0; i<bytes.length; i++) checksum=uint(crcTable[(checksum ^ bytes[i]) & 255]) ^ (checksum >>> 8);
return uint(checksum ^ 0xffffffff);
}
private function fail(error:Error):void {
finish("blocked", {phase:phase, name:error.name, message:error.message, stack:error.getStackTrace()});
}
private function finish(status:String, error:Object):void {
if (finished) return; finished = true;
if (archiveStream != null) { archiveStream.close(); archiveStream = null; }
var result:Object = {schema:1, status:status, scope:request != null && request.scene === true ? "original_scene_experiment" : "original_component_probe",
nonce:request == null ? null : request.nonce,
application_id:NativeApplication.nativeApplication.applicationID,
storage_directory:File.applicationStorageDirectory.nativePath,
battle_executed:sceneStarted, scene_result:sceneResult,
settlement_eligible:false, events:events, error:error};
trace("ORIGINAL_PROBE_RESULT " + JSON.stringify(result));
if (output != null) {
var stream:FileStream = new FileStream(); stream.open(output, FileMode.WRITE);
stream.writeUTFBytes(JSON.stringify(result)); stream.close();
}
NativeApplication.nativeApplication.exit(status == "probe_completed" || status == "scene_completed" ? 0 : 2);
}
}
}