422 lines
27 KiB
ActionScript
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);
|
|
}
|
|
}
|
|
}
|