Files
myrzx_bot/analysis/V1_2_RUNTIME_IMPLEMENTATION.md
T

282 lines
17 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# v1.2 original offline battle runtime — development build
Updated 2026-11-08. The original compiled engine now completes actual offline
scenes through `BattleCenter → BattleGround → BattlePanel.battleCompleteHandler`.
Ordinary stage, embedded task battle, and task `passStage` each have a completed
snapshot-driven native scene with original statistics and original checks.
This is executable development functionality; complete game coverage, matching
the current live resources, and server acceptance have not been established.
No game API actions were performed for this validation.
**Frozen development checkpoint:** scope stopped at the user's quota request.
The fixed bridge completed the cached roster in all three contexts with
`cheatNum=0` and two retained player checks per scene. Its actual cached team has
two occupied slots. The final identity comparison accepts original decimal-string
audit IDs without modifying either output. Revalidation of all three existing
executed callback bodies passes; no additional native trial was launched.
Automatic native admission is deliberately disabled by
`NATIVE_ADMISSION_ENABLED=False` pending final Engine/native/fake-client integration
QA. Offline execution remains available. This is an integration checkpoint,
not a restriction based solely on untested server acceptance.
## Public integration contract
The runtime accepts `BattleRequest` or the equivalent dictionary:
```python
request = BattleRequest(
context="ordinary_stage", stage_id="0101", difficulty=1,
original_data={"battle": canonical_original_battle},
roster=raw_master_snapshot, team="teamB",
battle_position={"battleType": "stage", "stageId": "0101",
"stageLevel": "1", "taskTypeId": None, "taskStep": 0},
)
runtime = BattleRuntime() # optional config: {"backend": "original_air"}
capability = runtime.inspect(request)
result = runtime.run(request, cancel_event=event, timeout=None)
```
`roster={"snapshot": raw_master_snapshot, "team_name": "teamB"}` is also
accepted for CLI callers. Both forms normalize to the same native input.
An explicit team is required. Conflicting selectors refuse; no default changes
`teamB` to `teamA`. Requests are copied once before inspection and execution.
`original_data` optionally accepts `source="original_apk"` and the exact pinned
`resource_identity`; it never accepts executable commands, replacement tables,
an estimated result, or a manifest claiming verification.
| Context | Original config selected | Native BattlePosition |
| --- | --- | --- |
| `ordinary_stage` | `stage_info[stage_id].level[difficulty].battle` | `battleType=stage`, string stage ID/level |
| `task_battle` | `task_info[type_id].steps[step_index].battle`, status `battle` | `battleType=task`, task type and zero-based step |
| `task_pass_stage` | stage/level from the original step's `statusValue`, status `passStage` | Same task position; no ordinary-stage result substitution |
With canonical orchestration requests, `battle_position.taskTypeId` identifies
the original task definition; `task_id` may retain the account task-instance ID.
Without `battle_position`, legacy CLI task requests use `task_id` for the original
task type. Task step conflicts and wrong supplied positions refuse. The supplied
battle must equal the independently decoded original config for that context.
The engine-side `runtime_request` must retain `battle`, `team`, and
`battle_position`; an identity-only request cannot reconstruct the selected team.
`inspect` returns `supported`, `offline_supported`, specific `reasons`, original
resource identity, input coverage, native position, original battle duration, and
derived watchdog. Support refers to offline execution of those supplied inputs,
not to every stage or skill having an observed test. The complete original SWF
contains the combat implementations; this adapter does not handport skill math.
Unknown controllers, effects, formations, data shapes, and required missing images
refuse. The native bridge additionally validates and constructs the snapshot.
An unseen dynamic dependency can still fail execution and produce no outcome.
Validated snapshot execution reports original-code fidelity (`faithful=True`,
`approximate=False`); diagnostic fixtures and invalid inputs do not qualify.
`settlement_eligible=False` remains enforced at this frozen checkpoint pending
final integration QA. `server_acceptance_verified=False` and the compatibility
alias `server_validated=False` are independent of original-code fidelity.
The implemented eligibility path requires original input/resource validation,
natural completion, zero original check points, callback/roster/route binding,
complete original statistics, and a valid asset audit. Strict synchronized trace
parity and current server resource matching remain unverified. Online orchestration
must gate before starting a battle.
Successful `run` results contain `status="completed"`, `battle_executed=True`,
`battle_completed=True`, `outcome`, and `offline_result` with the actual original
`battle_data`, `anomaly_records`, per-unit original records, timing, and terminal
reason. Positive original `cheatNum` yields `status="anomaly"`, preserves the
completed native evidence, and keeps eligibility false. Unsupported, cancelled,
technical timeout, or failed jobs do not return an outcome or BattleData.
Interrupted worker execution is `battle_executed=None` when progress is unknown;
pre-start refusal/cancellation is `False`.
## Native execution and artifact identity
REA inspected the shipped original APK; retained AS3 was used for focused call
inspection, not rebuilt as a replacement engine. The shipped identities are:
| Resource | Identity |
| --- | --- |
| APK 1.9.68 SHA-256 | `01678ee3a8465d818d32cbbd94baa0d8253b04b4c57b70ebc5544ed341f1015d` |
| `assets/MYRMain.app` SHA-256 | `c6838331a198a22ffa486cbf61cc74c97619e011bc3364c8bb8dc99e269036cf` |
| Main SWF header | Version 50, **50 FPS**, 640×960 RECT; FPS was decoded separately from the version byte |
| Local SDK | Official AIR SDK 51.5.1.1, Windows x64; executable/JAR/SWC pins in `trusted.py` |
`swf_library.py` removes document-class binding ID 0 and makes DoABC blocks lazy.
All 1,641 main ABC payloads remain byte-identical; 1,324 eager flags change.
Executable/import tags are refused. Neither the original game document class nor
the loader's login/update startup executes. Framework, main, UI, and movieclip
library copies load into one child ApplicationDomain. No native extension, phone,
rooting, protection bypass, rebuilt APK, or modified battle code is required.
`OriginalProbe.as` is a small compiled bootstrap. It injects original compressed
AMF tables using native `ByteArray.readObject`, initializes the generic display
framework, invokes `SnapshotBridge.build`, and starts the stock BattleCenter.
Stock movement, AP, AI, skills, collisions, animation callbacks, timers, result
statistics, and cheat checks execute. Only local win/loss observers are installed;
the harness never forces a winner. Component probes are a separate action, so they
do not consume random values or temporary unit IDs before a scene.
All original NetCenter service bases are replaced with a nonexistent local file
URI before snapshot/scene construction. The image hook refuses URL/colon/path
traversal inputs; sounds are disabled through original settings. Completion checks
the original NetCenter request counter is zero. Python execution imports no game
transport. This is deliberate transport isolation and neutralized startup,
not a claim of an OS network sandbox around arbitrary AIR code.
The correct launcher is `adl64.exe -runtime ... -nodebug -profile
extendedDesktop descriptor.xml -- ...`. The x86 launcher returned exit 4;
misordered `-runtime` arguments were rejected. ADL uses the SDK runtime without a
global installation. `-cmd` is unsuitable because its stage is null; the game uses
display objects and frame callbacks. See [official ADL documentation](https://airsdk.dev/docs/building/air-debug-launcher).
## Assets, callbacks, and timing
Normal preparation builds a ZIP-entry index directly from the pinned APK:
original hashed resource key, local-header data offset, compressed size, size,
method, and CRC32. It verifies local/central metadata and entry bounds. Native
FileStream reads the original packed bytes, decompresses ZIP deflate, verifies
size/CRC, and passes those bytes to the original image decoder. Reading a new
unit's assets does not require extracting the 1.4 GB resource tree. Existing
earlier extracts remain ignored. Post-run audit compares every observed resource
with the APK ZIP metadata. The native compression API is documented in the
[official ByteArray reference](https://airsdk.dev/reference/actionscript/3.0/flash/utils/ByteArray.html).
An absent required image refuses. Empty optional frame declarations that are
also absent from the original APK retain the original local IO-error callback;
their paths remain in evidence. No replacement pixels or fabricated completion
callbacks are supplied. The base slime's original `1001010_q_2s.png` absence is one
such observed fallback. Native skill effects and additional spawned-unit assets
are audited when read; an unapproved missing dependency stops the scene.
The stage runs hidden, 640×960, at the original 50 FPS. The harness records a
separate ENTER_FRAME/100 ms Timer sample and full-scene frames/wall time, plus
original frame-driver callback/delta observations. Initial short cold samples
were about 42.7 FPS; full 1-1 scenes were about 49 FPS. New measurements include a
300 ms warm-up and 2.5-second observation window. The subsequent three hidden
samples measured 48.26–48.30 FPS and 22 Timer ticks over 2.505–2.527 seconds;
the repeated task scene measured 47.45 FPS over 7.566 seconds. Requested FPS is
never presented as measured FPS. Hidden-window execution is demonstrated on this workstation;
timing under another host's background throttling remains an environment limit.
A critical bootstrap error was fixed: original EnterFrameDriver's constructor
already calls `startup()`. Calling it again created a second ENTER_FRAME source,
corrupted delta timing, and froze a skill pause. The harness now only registers
its observer. Earlier 30-FPS and stalled 50-FPS evidence remains retained, and is
not counted as correct original-timing validation.
The default technical watchdog is `2 × original battle seconds + 90` (690 s for
the original 300-second normal limit). An explicit caller deadline is preserved,
including source inspection and bootstrap. Cold APK hashing checks cancellation
and the deadline between chunks; a 0.1-second cold deadline returned in 0.103 s
without launching combat. Natural native clock completion is a completed native
result with `terminal_reason="time_limit"`; winner still comes from original
rules, including survival scenes that win on time. A technical watchdog supplies
no BattleData and never changes the battle's original time limit.
## Observed completed native scenes
The following runs use unchanged original battle configs. Synthetic selected IDs
exceed the NPC/player-check exemption threshold. Every row has retained original
player check records; callback data is original `BattleData.getObj()`.
| Input and route | Outcome | Original clock used | Scene wall time / frames | Original checks |
| --- | --- | --- | --- | --- |
| Three level-1 adult green slimes, mean original growth, master level 1, ordinary `0101/1` | Win | 37.127 s | 41.112 s / 2,020 = 49.13 FPS | `cheatNum=0`, 3 player records |
| Complete synthetic snapshot, original levels 1/2/3, ordinary `0101/1` | Win | 38.883 s | 44.299 s / 2,190 = 49.44 FPS | `cheatNum=0`, 3 player records |
| Same snapshot, original task `2002014`, zero-based step 2 | Natural loss | 5.133 s of 60 s | 8.701 s / 405 = 46.55 FPS | `cheatNum=0`, 3 player records |
| Same snapshot, task `1001004`, step 0 (`passStage` 0101/1) | Win | 30.943 s | 35.473 s / 1,750 = 49.33 FPS | `cheatNum=0`, 3 player records |
The first row read 12 distinct asset members with one genuine original optional
absence and zero CRC/size mismatches. It retained 11 original unit records:
player-side damage 784; enemy-side damage 371; five enemies dead. Native final
AP was 13 and `aliveNum` was 5. These are actual engine outputs, not expected
values filled by the harness. Randomness is native and unseeded, so subsequent
valid fights need not reproduce those numbers.
Legacy `killNum`, `totalDamage`, `deadNum`, and `bossDamage` remained zero as in the
retained original code path. `killMonster={}` in 1-1 follows the original mode-2
enemy counting condition; its five enemies are juvenile mode 1. No counters are
repaired. `anomaly_records` has four fields, not four anomalies: the count is
`battle_data.cheatNum`, and even a zero count may retain `+0uneqmon` audit text.
Additional bounded experiments: an authored 30-second survival/spawn-controller
scene completed in a natural loss before time expired, `cheatNum=0`. An invalid
synthetic level-90/potential-1 roster triggered three original `+50overlv` records:
`cheatNum=150`, adapter status `anomaly`, all records retained. That attempt is
negative validation, not a successful timing or valid-roster proof.
## Snapshot bridge status and resolved bootstrap blockers
The independently owned `SnapshotBridge.as` compiles with the native harness.
It uses original History/Monster/Bag/Team/global/addition builders and original
AP getters, preserves input, and restores prior master on construction failure.
The complete synthetic snapshots above passed the real bridge and full scenes.
The first authorized cached-snapshot attempt stopped before combat at:
```text
phase: original_snapshot_bridge
SnapshotBridge[missing_attributes] monsterAttributes:
a complete attribute row is required for every selected monster instance
```
Original MasterCenter allows a complete empty independent-addition list; the
earlier bridge instead required every selected row. It also indexed
`Table.skin_info.skins`, whereas original
Table startup and this harness expose the flat `Table.skin_info` dictionary.
The helper owner fixed both issues. No zero rows or nested table wrappers were
fabricated. Cached-roster scenes now complete in all three contexts with zero
original check points; their callback bodies pass the corrected binding validator.
The original audit IDs may be strings while BattleData IDs are numbers; comparison
normalizes identity only and retains original output types. A full skin/equipment
scene and final Engine/native/fake-client integration remain pending at freeze.
Private roster content,
account identifiers, paths, statistics, and logs are omitted from this document.
## Process isolation and validation
Every worker has a fresh cwd/log directory, input/result nonce, captured compiler
sources and their hashes, unique AIR application ID, and distinct native storage
directory. Fixed Python → Java → ADL commands run without a shell. The Windows
Job Object kills the worker and descendants on cancellation, deadline, or parent
close. A process-tree test confirms the descendant is terminated. Imported runtime
commands/paths/env/support manifests and unsigned verification claims are refused.
SDK and prepared libraries use bundled reviewed hashes; native result verification
also checks APK/main identity, input digest, nonce, route, outcome, anomaly count,
actual execution/completion, and resource audit.
Two simultaneous native component probes passed with different native app IDs,
storage directories, and nonces. The first concurrent trial exposed Windows
`WinError 5` replacing a shared asset index during a read. Preparation now reuses
identical immutable verified bytes and safely accepts a competing identical write;
the repeated simultaneous trial passed. No cross-account invoke forwarding or
shared application storage was observed.
Focused validation: **46 no-network unit tests pass**. They cover data/route/team
contracts, unknown mechanics/assets, native result binding, anomaly preservation,
time-limit result semantics versus watchdogs, default/explicit deadlines, arbitrary
command rejection, SWF document neutralization/ABC preservation, ZIP offsets/CRC,
resource preparation races, cancellation, and process-tree termination. Native
execution is explicit opt-in and is not part of routine unit tests.
The same 46 tests also passed with Python socket connection methods blocked.
Combined runtime/orchestration validation passed **130 tests**. The latest
explicit native task/concurrency validator exited 0, and no ADL worker remained
after completion.
```powershell
python -B -m unittest ranch_assistant.tests.test_battle_runtime -v
python -B -m tools.battle_runtime.prepare
python -B -m tools.battle_runtime.probe --compile-only
python -B -m tools.battle_runtime.validate_native
python -B -m tools.battle_runtime.validate_native --contexts task_battle --concurrent
```
`validate_native --request <local JSON>` runs the public API against a data-only
request, writes full evidence under ignored local_state, and prints aggregate
results. `--rich` selects synthetic gear/skin inputs; their full-scene validation
remains pending at freeze. The opt-in `acquire_air` tool downloads pinned
51.5.1.1 dependencies into ignored local_state using official ZIP ranges; normal
runtime/test execution never downloads anything or alters PATH/global config.
This owner changed only `battle_runtime.py`, its runtime tools/tests, and this
document. Engine/UI/progression/AMF fixes belong to their respective owners.
No commit, push, game request, battle submission, or reward action was performed.