tmerritt/disasm
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
df1185707587ddfbc7c07490fe52ecb8c43e76ae
disasm/NROM/Clu Clu Land (JU)/prg.s
T
tmerrittandClaude Opus 4.8 49e117bfcc Fix Pass 3 symbol application and add promotion criteria to PROMPTS.md 
- Apply symbols.inc hardware register names to Defender 2 (U) (51 operands)
- Apply symbols.inc hardware register names to Donkey Kong 3 (JUE) (36 operands)
- Add APU register symbols (-) to Defender 2 (U) and Donkey Kong 3 (JUE) symbols.inc
- Apply symbols to Donkey Kong Jr. Math (U) (80 operands: 11 single + 69 hardware)
- Apply symbols to Excitebike (JU) (786 operands: 785 single + 1 hardware)
- Add promotion criteria to PROMPTS.md: symbol/local substitution,
  ROM-specific semantic naming, and verification checklist

Add branch/jump target naming requirement to PROMPTS.md

All branches and jumps must target symbolic labels with descriptive names
derived from program flow role (e.g., _Loop, _Next, _Done, _Store, _Return),
never raw address literals. Adds criterion 8 to verification checklist.

Rename all OVERVIEW.md to README.md; add root README content to top-level

- Rename all OVERVIEW.md files to README.md throughout the repo (47 files)
- Prepend README.md content to top-level OVERVIEW.md before rename
- Fix apply_symbols.py NAME_RE regex to handle spaced assignments
- Apply symbols.inc to Defender 2 (U) (51 hardware operands)
- Apply symbols.inc to Donkey Kong 3 (JUE) (36 hardware operands)
- Apply symbols.inc to Donkey Kong Jr. Math (U) (80 operands: 11 single + 69 hardware)
- Apply symbols.inc to Excitebike (JU) (786 operands: 785 single + 1 hardware)
- Add missing Zp18/FrameCounter aliases to Excitebike prg.s
- Build all 27 top-level projects: byte-identical

Promote Donkey Kong Jr. Math back to _wip tier

Moves code from `copilot` folder and verifies each builds after

Add pre-commit hook for byte-identical verification

Add .git/hooks/pre-commit that runs 'make' then 'make clean' in each
project directory before committing. This ensures every project builds
byte-identical before any commit is accepted.

Also includes all file moves from the Donkey Kong Jr. Math (U) demotion
and other file restructuring from the session.

moves code out of copilot folder, its all AI generated.
Moves NROM games into NROM folder

removes copilot folder from Lunar Pool
Adds makefile to build all projects recursively

Updates docs to reflect changes in layout

Repromotes Donkey Kong Jr Math
Repromotes Excitebike
Promotes Popeye (JU) (PRG 1)
Updates Makefile to provide summary of build failure/success

Promote Raid on Bungeling Bay (U): Pass 2/3 partial, whole-ROM byte-identical

Move _wip/NROM/Raid on Bungeling Bay (U) to NROM/ and switch the build
from a PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to the space-containing original ROM name
  - Makefile builds header.o/prg.o/chr.o into reconstructed.nes and
    compares it against rom.nes ('Byte-identical ROM verified.')
  - one leftover neutral indirect operand jmp (Zp01) at $E2EC becomes
    jmp (IndDispatch01); apply_symbols.py reports 0 substitutions pending

README.md / TODO.md / AGENTS.md updated: 29 promoted, 7 in _wip/.

Pac-Man (U): Pass 2 complete (label renaming) + Pass 3 partial (ZP aliases, table names)

Pass 2 — fresh map derived from the committed split, not from any drafted
map (the drafted maps in other projects were audited and found not
applicable):

  - all 194 address-derived Label_XXXX definitions renamed to semantic
    routine-entry names plus <Routine>_<Role>_<addr> internal branch
    targets; zero Label_ remains
  - all 49 jsr/jmp call sites resolved from raw $XXXX to labels; zero
    raw $XXXX call operands remain
  - routinemap.tsv / derived_names.tsv record the derivation

Pass 3 (partial):

  - 15 proven semantic zero-page aliases added to locals.inc
    (GameState, NmiFlag, ScrollX/Y, PpuCtrlShadow, OamDmaPage,
    CocktailModeFlag, ActivePlayerFlag, GameplaySuspended, FrameCounter,
    StateTimer, Player1/2Input, ActiveInput, CopyrightVerified)
  - 112 operands substituted into prg.s (11 single + 101 hardware)
  - key data tables named: ProgrammerSig ($C0EB), GameStateDispatchTable
    ($C253), TitleScreenData ($C2FD), EntityPtrTable ($D912),
    AudioCommandTable ($EFDD)

Also corrects the README's claim that the RESET vector points at padding:
$FF00 holds real boot code (sei/cld, PPU off, double vblank wait, then
jmp ColdStart at $C042).

.gitignore: ignore reconstructed_prg.bin (build artifact of the _wip
Makefiles; '**/reconstructed.*' does not match the underscore form).

Promote Pac-Man (U): Pass 2/3 complete, whole-ROM byte-identical

Move _wip/NROM/Pac-Man (U) to NROM/ and switch the build from a PRG-only
compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pac-Man (U) [!].nes' (the original ROM name
    contains a space and brackets)
  - Makefile builds header.o/prg.o/chr.o into reconstructed.nes and
    compares it against rom.nes
  - reconstructed.nes is 24,592 bytes, MD5 a69d310f8cae9397fbd39f204672b5c7
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 3 residue closed.  The last 7 multi-alias zero-page operands are
resolved per site through a new sites.tsv, each proven from context
rather than guessed:

  - jmp ($0010) at $C250/$D3CA/$D90F/$D9B6 -> (DispatchPtrLo); each
    is immediately preceded by sta DispatchPtrLo/sta DispatchPtrHi
  - jmp ($00FE) at $EFDA -> (AudioHandlerPtrLo); preceded by
    sta AudioHandlerPtrLo/sta AudioHandlerPtrHi
  - sta a:$0000,y at $C048/$C089 -> a:Zp00,y; the literal zero-page
    base in the two ZP clear loops, so the neutral name is used rather
    than the semantic WorkPtrLo.  The 'a:' prefix survives the
    substitution, so the bytes stay 99 00 00 (sta abs,Y)

apply_symbols.py now reports 119 operands substituted (101 hardware,
11 single-name, 7 site) and 0 residue.

New tool _tools/align_audit_comments.py: re-aligns the audit comment to
column 35 after a substitution lengthens an operand (nesdis.py pads each
instruction to 31 characters).  Whitespace-only, so the byte identity
cannot change.  405 lines re-aligned in this project; all 2,387 audit
comments still match prg.bin at the stated PRG offset, 0 mismatches.

Docs: root README.md / TODO.md / AGENTS.md updated - 30 promoted, 6 in
_wip/; a per-project detail entry for Pac-Man (U) added; the stale
'Donkey Kong 3 (JUE) has no README.md' claim corrected (it has a
318-line one).

Promote Raid on Bungeling Bay (U) [a2]: Pass 3 complete, whole-ROM byte-identical

Move _wip/NROM/Raid on Bungeling Bay (U) [a2] to NROM/ and switch the build
from a PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Raid on Bungeling Bay (U) [a2].nes' (the original
    ROM name contains spaces and brackets)
  - reconstructed.nes is 24,592 bytes, MD5 659d340a1e9d420eee28df13319b0094
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 3 - 15 semantic zero-page aliases, each applied only at the sites
where its role is proven:

  - PpuCtrlShadow ($C2), 15 sites: the reset entry primes it right after
    'sta PPUCTRL', and every other use is an ora/and/eor followed by
    'sta PPUCTRL'
  - NmiPathSelector ($C4), 5 sites: written 1 at $C3E9 and 0 at $C962
  - GameState ($D6), 6 sites: 'cmp #$02' and used as an index at $C4C7
  - FrameSubCounter ($55), 6 sites: set to $0A at $C520, decremented per
    NMI at $C07B
  - PrngPeriodCounter ($EA) / PrngSeedB ($EB) / PrngState ($EC), 13 sites:
    the PRNG state
  - PtrLo ($00) / PtrHi ($01), 8 sites: the 16-bit pair $1C13 and $1610
    compared at $E785/$E791
  - IndDispatch01 ($01) / IndDispatch02 ($02), 3 sites: the computed
    dispatch at $E2EC
  - IndDispatch1B ($1B) / IndDispatch1C ($1C), 6 sites: the dispatch at
    $E7A3
  - IndDispatch17 ($17) / IndDispatch19 ($19): the dispatches at $E79D
    and $E7A0

Addresses that carry two names keep the neutral ZpXX name where the other
role applies - $01 is PtrHi at the 16-bit compare and IndDispatch01 at the
dispatch; $17 is IndDispatch17 at the dispatch and Zp17 for the absolute
RAM $0017 store in the copy loop at $E895/$E8D0.

New tool _tools/apply_zp_aliases.py does the per-site substitution:
apply_symbols.py only rewrites *numeric* operands, so it cannot rename an
operand that is already written as a neutral ZpXX name.  The tool keeps the
ca65 'a:' prefix (dropping it would turn 'sta a:Zp17,y' into a zero-page
store and change the bytes) and rewrites only the operand token, so the
audit comment survives byte for byte.

Naming correction in the promoted sibling.  Finishing this dump showed that
$EA was misnamed 'VBlankWaitCounter': the routine at $C412 is the game's
pseudo-random generator (the classic eor/asl/php/lsr/plp/rol scrambler,
called from thirteen gameplay sites, twice in a row at $CDF4/$CDF9 with the
second result masked #$07), so $EA is the scrambler's phase counter.
Renamed PrngPeriodCounter in both dumps and named $EB/$EC PrngSeedB /
PrngState.  The sibling's two 'sta a:IndDispatch17,y' operands were also
wrong - they are absolute stores to RAM $0017, not the dispatch pointer -
and are now 'a:Zp17,y', matching the file's 'a:' = absolute convention.

Audit-comment alignment re-done with _tools/align_audit_comments.py (1,040
lines here, 1,080 in the sibling).  Both files still match prg.bin at every
stated PRG offset: 5,467 and 5,483 audit comments, 0 mismatches.

Docs: root README.md / TODO.md / AGENTS.md updated - 31 promoted, 5 in
_wip/; per-project detail entries added for both Raid dumps.

Promote Pac-Man (Tengen) (U): Pass 2/3 from scratch, whole-ROM byte-identical

Move _wip/NROM/Pac-Man (Tengen) (U) to NROM/ and switch the build from a
PRG-only compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pac-Man (Tengen) (U) [!].nes'
  - reconstructed.nes is 24,592 bytes, MD5 d34e7a74d8d2c231b6cc601210e28ad0
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Disassembled from scratch.  No name, map or file was carried over from the
sibling 'Pac-Man (U)' dump; the map was derived from this dump's own
committed split and the two were only compared afterwards.

Pass 2 (new tool _tools/apply_pass2_map.py):
  - all 194 Label_XXXX definitions renamed to semantic routine entries plus
    <Routine>_<Role> branch targets; zero Label_ remains
  - all 48 raw $XXXX jsr/jmp operands resolved to labels; zero raw $XXXX
    call or branch operands remain
  - the map is in routinemap.tsv

Pass 3:
  - 30 semantic zero-page aliases, each applied only at the sites where its
    role is proven (per-site choice in sites.tsv; the addresses that carry
    two roles keep the neutral ZpXX name elsewhere).  _tools/
    derive_zp_aliases.py records how the set was derived, and locals.inc
    records the reason for every remaining neutral slot
  - 28 data tables named (new tool _tools/name_data_region.py), including
    CharacterDataTable ($C66A) and CharacterNameStrings ($C67E), where the
    ROM itself names Blinky, Pinky, Inky and Clyde - which is why the four
    indexed entities are called ghosts and not 'actors'
  - apply_symbols.py reports 0 substitutions pending and 0 residue
  - audit-comment alignment re-done with _tools/align_audit_comments.py;
    all 2,479 audit comments still match prg.bin at the stated PRG offset

Pass 1 correction - six command handlers recovered (new tool
_tools/recode_region.py).  ScriptCommandTable ($EFDD) is read by the traced
instruction at $EFCC, and six of its entries point at $F00A, $F022, $F03A,
$F052, $F062 and $F072 - all of which the tracer had left as data, and two
of which it had mis-split across the 'jmp $EF61' at $F01F and $F04F.
Those 120 bytes are code here, decoded straight from the ROM; the six
handlers tile $F00A-$F081 exactly.  The same gap exists in the promoted
'Pac-Man (U)' dump, which has not been corrected - recorded in both READMEs.

Residue (documented, not guessed): the unreached main game logic at
$C45A-$C55F is still .byte data.  It is code - the tracer's own decoder
walks it cleanly and the dispatch table at $C511 points into it - but
nothing reaches it, so it cannot be entered without a guess.  The same gap
exists in the promoted 'Pac-Man (U)' dump.  Re-deriving it is a Pass 1 job;
a Mesen Code Data Logger capture is the tool the repo uses for it.

Docs: root README.md / TODO.md / AGENTS.md updated - 32 promoted, 4 in
_wip/; a per-project detail entry added for the Tengen dump.

Promote Pyramid (U): Pass 1 corrected, Pass 2/3 complete, whole-ROM byte-identical

Move _wip/NROM/Pyramid (U) to NROM/ and switch the build from a PRG-only
compare to a whole-ROM one:

  - header.s/chr.s added (one-line .incbin of header.bin / chr.bin)
  - linker.cfg gains HEADER ($0000, $0010) and CHR ($0000, $2000)
    areas ahead of PRG ($C000, $4000)
  - rom.nes symlink to 'Pyramid (U) (Sachen).nes'
  - reconstructed.nes is 24,592 bytes, MD5 aa285ff17f25dd05da5996b7466c59e2
    - equal to the original ROM; the header/prg/chr splits were checked
    against the original before promotion and are byte-exact

Pass 1 correction - the committed split was a strict subset of the correct
one.  This game dispatches through 'jmp' trampoline tables that live
*inside* the data regions, and the tracer cannot follow a jmp there, so
828 bytes of code were still marked as data.  Four such tables were found
($C01E 3 entries, $C02A 6, $C042 2, $C054 5) plus ten more entries at
$C000-$C01B; all sixteen targets decode as valid instructions.  Seeding
them, the $C800 boot mainline and six further code starts recovers the
whole lot, plus a five-byte stub at $DF89 (lda $33 / jmp $DECB) that sat
in a hole between two routines.  The re-trace loses NO committed code byte
and takes the split from 34.5% to 39.6% (3,130 instructions / 6,493 code
bytes).  'make regen' reproduces it, so the split stays verifiable.

Pass 2 - a fresh map derived from this dump's own committed split:
  - 428 Label_XXXX definitions renamed; zero Label_ residue
  - 320 raw $XXXX jsr/jmp operands resolved; zero raw $XXXX branch
    operands remain
  - 431 routine entries and the 32 data blocks named from the code
  - the internal branch-target names are derived mechanically from the
    branch that reaches them by the new _tools/derive_branch_names.py
    (beq -> OnZero, bne -> OnNonzero, bcc/bcs -> the carry cases, a
    backwards branch -> Loop)
  - recorded in routinemap.tsv

Pass 3:
  - 24 semantic zero-page aliases, each applied only where its role is
    proven; the 57 slots that stay neutral are each listed with the reason
    in locals.inc (the neutral set lives in zp_aliases.inc so that
    'make regen' can rebuild locals.inc from prg.bin)
  - 32 data tables named - TaskVectorTable1/2, LevelScriptData,
    MusicPeriodTable, SoundEnvelopeTable, the actor tables - recorded in
    data_region_names.tsv
  - apply_symbols.py reports 0 substitutions pending and 0 residue; no
    hardware register is left as a raw literal
  - the audit comments are now canonical on every line, data included
    (the old file carried only 'PRG:$xxxx' on its 1,358 data lines);
    all 3,762 audit comments match prg.bin at their stated PRG offset

Kept as-is, not 'cleaned up':
  - sta $4100 stays a raw operand.  The iNES header claims mapper 0 but
    the boot code writes past the NES register space; the ROM does not
    explain it, so it is recorded rather than guessed
  - the 'A'/'V' check on RAM $0120/$0121 and its seed/clear routines
    are named for what they do, not for what they are for
  - the ninth entry of the $C3A6 task vector table ($D820) is a junk
    slot and stays data

Docs: root README.md / TODO.md / AGENTS.md updated - 33 promoted, 3 in
_wip/; a per-project detail entry added.

Hogan's Alley (JU): Pass 1 correction, Pass 2, Pass 3, promoted to NROM/

The light-gun game whose engine dispatches through *inline* tables:
`IndirectCall` at $C34D pops the return address of the `jsr` that called
it and reads a 16-bit handler pointer from the word that follows, so all
six handler tables ($C124 19 entries, $C219 4, $C89C 14, $CDD1 1, $D234 2,
$D3D6 14) live inside the code stream and the static tracer cannot follow
them.

Pass 1 correction.  The committed split was a strict subset of the correct
one -- 41.8% of the PRG was classified as code.  A fresh Mesen Code Data
Logger capture was merged with the four captures already in the folder
(hogans_merged.cdl, the OR of five per-byte flag arrays, 6,544 code bytes)
and _tools/cdl_reclass.py rewrote the split to match what the CPU actually
fetched: 1,216 bytes moved from data to code, five the other way, 59 labels
emitted.  The split is now 49.1% code (3,950 instructions, 8,041 bytes).
The four branch targets the reclassifier could not prove were turned into
labels by the new _tools/resolve_raw_branches.py.

Pass 2.  206 routine entries hand-named from this dump's own code and 413
internal branch targets derived mechanically by _tools/derive_branch_names.py:
630 Label_XXXX definitions gone, 484 raw $XXXX call operands resolved, 15
call targets the tracer had never labelled given a label.  Recorded in
routinemap.tsv.  No SubC<addr> residue was needed -- every entry the engine
reaches is named after what it does.

Pass 3.  60 semantic zero-page aliases, each applied only where its role is
proven (zp_aliases.inc, zp_alias_sites.tsv); the slots that stay neutral are
each listed with the reason.  All 34 data blocks named
(data_region_names.tsv).  apply_symbols.py reports 1 residue: `sta a:$00B4,y`
at $C203, the same address as Zp40/ActorPalette but forced to absolute
addressing, so it must stay numeric.

Promotion.  header.s, chr.s and a HEADER/PRG/CHR linker.cfg added, rom.nes
symlinked to the original ROM; the whole-ROM cmp passes on the first
promoted build.  There is deliberately no `make regen` target: the Pass 1
split here is the static trace corrected by a CDL capture, and the base the
correction was applied to is not what the current _tools/nesdis.py
produces, so prg.s is the maintained source of truth.

Tools changed:
  nesdis.py             --split/--note/--provenance options, so a data
                          region can carry its own name and explanation;
                          a forced-data address is no longer reported as a
                          recovered routine entry
  apply_pass2_map.py    can create the label for a call target the tracer
                          left unlabelled; no longer double-labels it
  apply_zp_aliases.py   --at-file, an address-based per-site list
  derive_branch_names.py keeps the map's own header instead of writing a
                          fixed one
  resolve_raw_branches.py  new: turns `bXX *+$NN` operands into labels
  build_hogans_map.py   new: the hand-written Pass 2 map builder

The existing regen pipelines (MUSCLE (U), Urban Champion (JU)) still
reproduce prg.s byte for byte.

Apply the symbols.inc register names at Pass 1; fix a dropped byte in cdl_reclass

nesdis.py now names the hardware registers as it renders the operands, so a
project's Pass 1 output already reads `lda PPUSTATUS` instead of `lda $2002`
and the Pass 3 apply_symbols.py step has nothing left to do for them.

  * nesdis.py --symbols FILE reads a symbols.inc-style file and substitutes
    the register names.  Only unambiguous entries in the $2000-$4017 window
    are used: $4017 is both JOY2 and APUFRAMECOUNTER, so it stays numeric
    and apply_symbols.py reports it as multi-alias residue, exactly as
    before.  The default is the symbols.inc next to --out, so a new project
    gets the names without asking; --no-symbols opts out.
  * The renderer records the operand's numeric value on the Insn, because
    operand_value() used to re-parse the operand text and could no longer
    read a name.
  * The controller bit masks in symbols.inc (PAD_A and friends) are
    constants, not addresses, and are still never substituted.

MUSCLE (U) and Urban Champion (JU) keep --no-symbols: their committed
prg.s was produced with the registers named by the Pass 3 apply_symbols.py
step, and the columns in those files reflect the in-place substitution.
Adding the missing apply_symbols.py step to both regen pipelines makes
them reproduce their committed prg.s byte for byte again - neither did
before this change (MUSCLE was 440 lines out, Urban Champion 772).

cdl_reclass.py had a bug that cost a byte: a region whose last source row
straddled the region's end was replaced by a regeneration of the region
only, so the tail of that row was dropped.  Mario Bros (JU) hit it at
$C595, where the rebuild came out one byte short and every label after it
shifted.  A region now covers the whole rows it replaces.

pass2.py reflow takes an optional column argument; the default is
unchanged (the ';' lands on the same column as before).

Mario Bros (JU): Pass 1 correction, Pass 2, Pass 3, promoted to NROM/

A two-player platformer whose handler tables are *inline*: the pointers sit
in the middle of the code stream, right after the `jsr` that reads them, so
the static tracer could never follow them.

Pass 1 correction.  The committed split was a strict subset of the correct
one -- only 72.0% of the PRG was classified as code.  A Mesen Code Data
Logger capture of this ROM (mario_mesen.cdl, 10,915 code bytes) showed
1,010 bytes the tracer had left as data were code; two branch targets the
capture never reached ($E4CB and $E639) were forced with --override for 57
more, so 1,067 bytes moved from data to code and 22 moved the other way.
The split is now 78.4% code (6,210 instructions, 12,847 bytes).  The three
branch targets the reclassifier could not prove were turned into labels by
_resolve_raw_branches.py, which now refuses to put a label on a `.byte` row.

Pass 2.  206 routine entries and 519 internal branch targets: 931
Label_XXXX definitions gone, 51 raw $XXXX call operands resolved and 12 call
targets the tracer had never labelled given a label.  Zero SubC residue --
the 185 entries a previous session had left as address-derived residue were
all named from this dump's own code.  Recorded in routinemap.tsv.

Pass 3.  25 semantic zero-page aliases, each applied only where its role is
proven (zp_aliases.inc); the slots that stay neutral are each listed with the
reason.  35 data tables named -- GameStateHandlerTable, EnemyBehaviourTable,
EnemyScriptTable, EnemyTypePointerTable, SoundRoutineTable,
NoteFrequencyTable and the rest -- and recorded in
data_region_names.tsv.  apply_symbols.py reports 0 residue.

Promotion.  header.s, chr.s and a HEADER/PRG/CHR linker.cfg added, rom.nes
symlinked to the original ROM; the whole-ROM cmp passes on the first
promoted build.  There is deliberately no `make regen` target: the Pass 1
split here is the static trace corrected by a CDL capture, and the base the
correction was applied to is not what the current _tools/nesdis.py
produces, so prg.s is the maintained source of truth.

Tools:
  apply_pass2_map.py     renames a label of any spelling -- SubC<addr> is
                          the honest residue form -- and its references
                          follow it; one combined pattern, so a 16,000-line
                          file does not need a substitution per label
  resolve_raw_branches.py refuses to label a data row
  build_mario_map.py      new: the hand-written Pass 2 map builder

Remove the old _wip/NROM/Mario Bros (JU) folder (promoted to NROM/)

Mario Bros (JU): add the promoted-tier header, CHR, rom.nes symlink and zero-page aliases

Moves _ROMS/<ROM> into _wip/<MAPPER>/<ROM>

Sync the docs and the skeleton tool with the 857-project _wip tier

The _wip/ tier now holds 857 projects across 30 mapper folders, all
building byte-identical for the whole ROM.  README.md, TODO.md and
AGENTS.md still described the old 39-project tier, so bring them in line
with WIP.md, which carries the tier's index.

The tier is no longer 39 projects of NROM-256 with a 16/32 KB PRG:
only two projects have a 16 KB PRG, 151 have 32 KB, 523 have 128 KB and
one has 1.5 MB, so most of it is a banked mapper whose image does not fit
the 6502's address space.  Those projects link their MEMORY areas at .nes
file offsets rather than CPU addresses, which is the only option and the
honest model; the 39 older projects keep the CPU-address layout because
their PRG really is one contiguous window.

make_skeleton.py gains the two layouts (--layout flat|cpu), the board
name for the mapper, and a fix for find_rom() mistaking the build
output reconstructed.nes for the source ROM.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-10-20 16:44:06 -04:00

9152 lines
389 KiB
ArmAsm
Raw Blame History

.include "symbols.inc"
.include "locals.inc"
.segment "PRG"
;------------------------------------------------------------
; Initial PRG data
; CPU $C000-$C195
; PRG $0000-$0195
;
; Pointer tables, title/credit text, resource descriptors, and
; startup lookup data. Boundaries below are conservative Pass-1
; classifications; uncertain structures remain explicit bytes.
;------------------------------------------------------------
; Embedded developer credit: "T.SAWANO".
DeveloperCreditText:
.byte $54, $2E, $53, $41, $57, $41, $4E, $4F ; CPU:$C000 PRG:0000 0B
; Pointers into the upper-PRG resource/script area.
ResourceScriptPointerTable:
.word $E75D, $E79A, $E7E1, $E826 ; CPU:$C008 PRG:0008 0B
.word $E869, $E8A6, $E8DF, $E916 ; CPU:$C010 PRG:0010 0B
.word $E949, $E988, $E9CD, $EA10 ; CPU:$C018 PRG:0018 0B
.word $EA4F, $EA96, $EAE7, $EB32 ; CPU:$C020 PRG:0020 0B
.word $EB7B, $EBB0, $EBE7, $EC1E ; CPU:$C028 PRG:0028 0B
.word $EC56, $ECF3, $ED1E, $ED5E ; CPU:$C030 PRG:0030 0B
.word $EDAF, $EE27, $EE90, $EF91 ; CPU:$C038 PRG:0038 0B
.word $F117, $F11D ; CPU:$C040 PRG:0040 0B
; Encoded title/message tile values; not ASCII text at runtime.
TitleOrMessageTileString:
.byte $28, $32, $33, $31, $34, $32, $30, $30, $29, $32, $29, $29, $31, $34, $34, $32 ; CPU:$C044 PRG:0044 0B
.byte $22, $24, $23, $24 ; CPU:$C054 PRG:0054 0B
; Variable-length resource descriptor records.
ResourceDescriptorData_C058:
.byte $66, $00, $01, $20, $00, $07, $29, $F2, $06, $00, $28, $EF, $06, $00, $2A, $AF ; CPU:$C058 PRG:0058 0B
.byte $06, $00, $20, $54, $03, $00, $29, $B6, $02, $00, $29, $49, $03, $01, $2B, $09 ; CPU:$C068 PRG:0068 0B
.byte $03, $01, $20, $4D, $02, $00, $00, $01, $04, $0C, $07, $22, $10, $03, $00, $00 ; CPU:$C078 PRG:0078 0B
.byte $01, $04, $0C, $07, $29, $E8, $03, $00, $00, $01, $0C, $00, $07, $22, $CE, $06 ; CPU:$C088 PRG:0088 0B
.byte $00, $23, $06, $06, $00, $23, $13, $06, $00, $0F, $E4, $00, $18, $0F, $E5, $00 ; CPU:$C098 PRG:0098 0B
.byte $28, $0F, $E4, $01, $D0, $0F, $E5, $01, $E0, $FF, $FF, $FF ; CPU:$C0A8 PRG:00A8 0B
; Small direction, coordinate, and signed-offset lookup tables.
DirectionAndCoordinateTables_C0B4:
.byte $FF, $00, $00, $00, $01, $A0, $80, $40, $00, $60, $80, $C0, $00, $64, $3C, $2C ; CPU:$C0B4 PRG:00B4 0B
.byte $1C, $44, $3C, $34, $2C, $80, $50, $30, $10, $40, $30, $20, $10, $02, $02, $04 ; CPU:$C0C4 PRG:00C4 0B
.byte $04, $01, $01, $01, $01, $01, $02, $02, $02, $00, $80, $B8, $D8, $F4, $14, $34 ; CPU:$C0D4 PRG:00D4 0B
.byte $54, $40, $02, $10, $00 ; CPU:$C0E4 PRG:00E4 0B
; Startup object/template records and compact lookup data.
StartupObjectTemplateData_C0E9:
.byte $04, $01, $00, $00, $00, $00, $00, $04, $00, $00, $00, $22, $00, $05, $05, $0B ; CPU:$C0E9 PRG:00E9 0B
.byte $0B, $10, $06, $0C, $20, $04, $01, $00, $00, $00, $00, $00, $01, $EE, $00, $00 ; CPU:$C0F9 PRG:00F9 0B
.byte $11, $10, $20, $08, $11, $00, $05, $01, $00, $00, $00, $00, $00, $02, $A0, $00 ; CPU:$C109 PRG:0109 0B
.byte $03, $00, $68, $00, $00, $00, $00, $00, $20, $04, $11, $80, $04, $01, $00, $00 ; CPU:$C119 PRG:0119 0B
.byte $00, $00, $00, $04, $7C, $00, $03, $22, $28, $02, $02, $0E, $0E, $00, $00, $01 ; CPU:$C129 PRG:0129 0B
.byte $06, $F6, $03, $08, $E6, $00, $02, $24, $E0, $20, $08, $11, $00, $06, $80, $00 ; CPU:$C139 PRG:0139 0B
.byte $00, $00, $00, $00, $02, $D0, $00, $00, $21, $A8, $04, $00, $0C, $08, $00, $10 ; CPU:$C149 PRG:0149 0B
.byte $04, $0D, $C0, $03, $01, $00, $00, $00, $00, $00, $02, $C8, $00, $03, $12, $C0 ; CPU:$C159 PRG:0159 0B
.byte $00, $40, $02, $0C, $00, $04, $00, $30, $00, $2C, $00, $00, $06, $70, $00, $00 ; CPU:$C169 PRG:0169 0B
.byte $23, $68, $20, $02, $0A, $80, $04, $00, $4A, $00, $30, $00, $00, $04, $7C, $00 ; CPU:$C179 PRG:0179 0B
.byte $03, $00, $01, $07, $E7, $00, $13, $2E, $24, $2F, $14, $0F, $30 ; CPU:$C189 PRG:0189 0B
;------------------------------------------------------------
; ResetEntry / IRQHandler
;
; Global:
; RESET and IRQ/BRK vector target. Initializes CPU, RAM, PPU,
; APU, startup resources, and enables NMI before entering the
; permanent main-program loop at $C1EB.
;
; Parameters:
; None.
;
; Returns:
; Never returns.
;------------------------------------------------------------
ResetEntry:
CLD ; CPU:$C196 PRG:0196 D8
LDA #$00 ; CPU:$C197 PRG:0197 A9 00
STA PPUCTRL ; CPU:$C199 PRG:0199 8D 00 20
SEI ; CPU:$C19C PRG:019C 78
LDX #$FF ; CPU:$C19D PRG:019D A2 FF
TXS ; CPU:$C19F PRG:019F 9A
LDX #$02 ; CPU:$C1A0 PRG:01A0 A2 02
InterruptPathLoop_C1A2:
LDA PPUSTATUS ; CPU:$C1A2 PRG:01A2 AD 02 20
BPL InterruptPathLoop_C1A2 ; CPU:$C1A5 PRG:01A5 10 FB
DEX ; CPU:$C1A7 PRG:01A7 CA
BNE InterruptPathLoop_C1A2 ; CPU:$C1A8 PRG:01A8 D0 F8
LDY #$24 ; CPU:$C1AA PRG:01AA A0 24
LDA StartupPreserveFlag0 ; CPU:$C1AC PRG:01AC A5 48
BNE InterruptPathOnNonZero_C1B4 ; CPU:$C1AE PRG:01AE D0 04
LDA StartupPreserveFlag1 ; CPU:$C1B0 PRG:01B0 A5 49
BEQ InterruptPathOnZero_C1B6 ; CPU:$C1B2 PRG:01B2 F0 02
InterruptPathOnNonZero_C1B4:
LDY #$18 ; CPU:$C1B4 PRG:01B4 A0 18
InterruptPathOnZero_C1B6:
LDA #$00 ; CPU:$C1B6 PRG:01B6 A9 00
InterruptPathLoop_C1B8:
STA $0000,Y ; CPU:$C1B8 PRG:01B8 99 00 00
INY ; CPU:$C1BB PRG:01BB C8
BNE InterruptPathLoop_C1B8 ; CPU:$C1BC PRG:01BC D0 FA
LDY #$07 ; CPU:$C1BE PRG:01BE A0 07
LDX #$06 ; CPU:$C1C0 PRG:01C0 A2 06
JSR RunGameTaskRoutine_CBA6 ; CPU:$C1C2 PRG:01C2 20 A6 CB
LDA #$55 ; CPU:$C1C5 PRG:01C5 A9 55
STA FrameShiftRegister0 ; CPU:$C1C7 PRG:01C7 85 10
LDA #$12 ; CPU:$C1C9 PRG:01C9 A9 12
STA PPUCTRL ; CPU:$C1CB PRG:01CB 8D 00 20
STA ShadowPPUCTRL ; CPU:$C1CE PRG:01CE 85 40
LDA #$06 ; CPU:$C1D0 PRG:01D0 A9 06
STA PPUMASK ; CPU:$C1D2 PRG:01D2 8D 01 20
STA ShadowPPUMASK ; CPU:$C1D5 PRG:01D5 85 41
LDA #$0F ; CPU:$C1D7 PRG:01D7 A9 0F
STA APUSTATUS ; CPU:$C1D9 PRG:01D9 8D 15 40
STA $0100 ; CPU:$C1DC PRG:01DC 8D 00 01
JSR RunGameTaskRoutine_C3E4 ; CPU:$C1DF PRG:01DF 20 E4 C3
LDA ShadowPPUCTRL ; CPU:$C1E2 PRG:01E2 A5 40
ORA #$80 ; CPU:$C1E4 PRG:01E4 09 80
STA ShadowPPUCTRL ; CPU:$C1E6 PRG:01E6 85 40
STA PPUCTRL ; CPU:$C1E8 PRG:01E8 8D 00 20
InterruptPathDispatch_C1EB:
JSR EnginePath_F58D ; CPU:$C1EB PRG:01EB 20 8D F5
JMP InterruptPathDispatch_C1EB ; CPU:$C1EE PRG:01EE 4C EB C1
;------------------------------------------------------------
; NMIHandler
;
; Global:
; Saves A and $00, performs OAM DMA and frame services,
; restores PPU state, then returns with RTI.
;
; Parameters:
; None.
;
; Returns:
; RTI.
;------------------------------------------------------------
NMIHandler:
PHA ; CPU:$C1F1 PRG:01F1 48
LDA WorkPtr0Lo ; CPU:$C1F2 PRG:01F2 A5 00
PHA ; CPU:$C1F4 PRG:01F4 48
LDA ShadowPPUCTRL ; CPU:$C1F5 PRG:01F5 A5 40
AND #$7F ; CPU:$C1F7 PRG:01F7 29 7F
STA ShadowPPUCTRL ; CPU:$C1F9 PRG:01F9 85 40
STA PPUCTRL ; CPU:$C1FB PRG:01FB 8D 00 20
LDA ShadowPPUMASK ; CPU:$C1FE PRG:01FE A5 41
AND #$E7 ; CPU:$C200 PRG:0200 29 E7
STA ShadowPPUMASK ; CPU:$C202 PRG:0202 85 41
STA PPUMASK ; CPU:$C204 PRG:0204 8D 01 20
JSR UpdateGameStateRoutine_C996 ; CPU:$C207 PRG:0207 20 96 C9
LDA #$00 ; CPU:$C20A PRG:020A A9 00
STA OAMADDR ; CPU:$C20C PRG:020C 8D 03 20
LDA #$02 ; CPU:$C20F PRG:020F A9 02
STA OAMDMA ; CPU:$C211 PRG:0211 8D 14 40
JSR ResourceAndLevelData ; CPU:$C214 PRG:0214 20 0B F2
JSR ObjectPath_E113 ; CPU:$C217 PRG:0217 20 13 E1
LDA ShadowPPUCTRL ; CPU:$C21A PRG:021A A5 40
STA PPUCTRL ; CPU:$C21C PRG:021C 8D 00 20
LDA ShadowPPUMASK ; CPU:$C21F PRG:021F A5 41
ORA #$18 ; CPU:$C221 PRG:0221 09 18
STA ShadowPPUMASK ; CPU:$C223 PRG:0223 85 41
STA PPUMASK ; CPU:$C225 PRG:0225 8D 01 20
JSR AudioDriverCode ; CPU:$C228 PRG:0228 20 C1 F7
JSR EnginePath_F5AE ; CPU:$C22B PRG:022B 20 AE F5
JSR ObjectPath_DDC1 ; CPU:$C22E PRG:022E 20 C1 DD
JSR RunGameTaskRoutine_C368 ; CPU:$C231 PRG:0231 20 68 C3
NMIReadPPUStatus_C234:
LDA PPUSTATUS ; CPU:$C234 PRG:0234 AD 02 20
LDA ShadowPPUCTRL ; CPU:$C237 PRG:0237 A5 40
ORA #$80 ; CPU:$C239 PRG:0239 09 80
STA ShadowPPUCTRL ; CPU:$C23B PRG:023B 85 40
STA PPUCTRL ; CPU:$C23D PRG:023D 8D 00 20
PLA ; CPU:$C240 PRG:0240 68
STA WorkPtr0Lo ; CPU:$C241 PRG:0241 85 00
PLA ; CPU:$C243 PRG:0243 68
RTI ; CPU:$C244 PRG:0244 40
;------------------------------------------------------------
; CoreGameCode
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
CoreGameCode:
JSR RunGameTaskRoutine_CBB9 ; CPU:$C245 PRG:0245 20 B9 CB
JSR ObjectPath_D34E ; CPU:$C248 PRG:0248 20 4E D3
BCS ProcessCurrentObjectContinue_C264 ; CPU:$C24B PRG:024B B0 17
JSR UpdateObjectRecord_D27D ; CPU:$C24D PRG:024D 20 7D D2
BCS ProcessCurrentObjectContinue_C264 ; CPU:$C250 PRG:0250 B0 12
LDY #$00 ; CPU:$C252 PRG:0252 A0 00
LDA (CurrentObjectPtrLo),Y ; CPU:$C254 PRG:0254 B1 08
BNE ProcessCurrentObjectContinue_C264 ; CPU:$C256 PRG:0256 D0 0C
JSR ProcessCurrentObjectRoutine_CBE3 ; CPU:$C258 PRG:0258 20 E3 CB
JSR ReadObjectRecord_DADA ; CPU:$C25B PRG:025B 20 DA DA
JSR ReadObjectRecord_CD7B ; CPU:$C25E PRG:025E 20 7B CD
JSR ReadObjectRecord_D11E ; CPU:$C261 PRG:0261 20 1E D1
ProcessCurrentObjectContinue_C264:
JSR ObjectPath_D06D ; CPU:$C264 PRG:0264 20 6D D0
JSR RunGameTaskRoutine_CBC6 ; CPU:$C267 PRG:0267 20 C6 CB
JSR ObjectPath_D34E ; CPU:$C26A PRG:026A 20 4E D3
BCS CorePathContinue_C286 ; CPU:$C26D PRG:026D B0 17
JSR UpdateObjectRecord_D27D ; CPU:$C26F PRG:026F 20 7D D2
BCS CorePathContinue_C286 ; CPU:$C272 PRG:0272 B0 12
LDY #$00 ; CPU:$C274 PRG:0274 A0 00
LDA (CurrentObjectPtrLo),Y ; CPU:$C276 PRG:0276 B1 08
BNE CorePathContinue_C286 ; CPU:$C278 PRG:0278 D0 0C
JSR ProcessCurrentObjectRoutine_CBE3 ; CPU:$C27A PRG:027A 20 E3 CB
JSR ReadObjectRecord_DADA ; CPU:$C27D PRG:027D 20 DA DA
JSR ReadObjectRecord_CD7B ; CPU:$C280 PRG:0280 20 7B CD
JSR ReadObjectRecord_D11E ; CPU:$C283 PRG:0283 20 1E D1
CorePathContinue_C286:
JSR ObjectPath_D08F ; CPU:$C286 PRG:0286 20 8F D0
JSR ObjectPath_DD10 ; CPU:$C289 PRG:0289 20 10 DD
JSR ObjectPath_DC5A ; CPU:$C28C PRG:028C 20 5A DC
JSR UpdateObjectBuffer_DB52 ; CPU:$C28F PRG:028F 20 52 DB
JSR ObjectPath_D856 ; CPU:$C292 PRG:0292 20 56 D8
JSR ObjectPath_D8BA ; CPU:$C295 PRG:0295 20 BA D8
JSR UpdateObjectBuffer_D64F ; CPU:$C298 PRG:0298 20 4F D6
JSR ObjectPath_D97B ; CPU:$C29B PRG:029B 20 7B D9
JSR UpdateObjectBuffer_D0C8 ; CPU:$C29E PRG:029E 20 C8 D0
JSR ObjectPath_CFA1 ; CPU:$C2A1 PRG:02A1 20 A1 CF
JSR ObjectPath_D0B1 ; CPU:$C2A4 PRG:02A4 20 B1 D0
JSR ProcessObjectStateRoutine_E6F3 ; CPU:$C2A7 PRG:02A7 20 F3 E6
JSR ObjectPath_DA91 ; CPU:$C2AA PRG:02AA 20 91 DA
JSR UpdateObjectBuffer_DBC7 ; CPU:$C2AD PRG:02AD 20 C7 DB
JSR ObjectPath_D0DF ; CPU:$C2B0 PRG:02B0 20 DF D0
JSR ObjectPath_D1D6 ; CPU:$C2B3 PRG:02B3 20 D6 D1
JSR UpdateObjectBuffer_DD8F ; CPU:$C2B6 PRG:02B6 20 8F DD
JSR UpdateObjectBuffer_D0F6 ; CPU:$C2B9 PRG:02B9 20 F6 D0
JSR UpdateGameStateRoutine_C47A ; CPU:$C2BC PRG:02BC 20 7A C4
JSR ObjectPath_D209 ; CPU:$C2BF PRG:02BF 20 09 D2
RTS ; CPU:$C2C2 PRG:02C2 60
CorePathLoop_C2C3:
JSR RunGameTaskRoutine_C84B ; CPU:$C2C3 PRG:02C3 20 4B C8
LDA #$00 ; CPU:$C2C6 PRG:02C6 A9 00
LDY #$1F ; CPU:$C2C8 PRG:02C8 A0 1F
CorePathLoop_C2CA:
STA a:$0080,Y ; CPU:$C2CA PRG:02CA 99 80 00
DEY ; CPU:$C2CD PRG:02CD 88
BPL CorePathLoop_C2CA ; CPU:$C2CE PRG:02CE 10 FA
STA RoundOrSubstate ; CPU:$C2D0 PRG:02D0 85 88
LDX ContextIndex ; CPU:$C2D2 PRG:02D2 A6 4A
InitializePlayerAndGameState:
STX PreviousContextIndex ; CPU:$C2D4 PRG:02D4 86 87
INX ; CPU:$C2D6 PRG:02D6 E8
CPX #$05 ; CPU:$C2D7 PRG:02D7 E0 05
BNE UpdateGameStateOnNonZero_C2DD ; CPU:$C2D9 PRG:02D9 D0 02
LDX #$00 ; CPU:$C2DB PRG:02DB A2 00
UpdateGameStateOnNonZero_C2DD:
STX $4A ; CPU:$C2DD PRG:02DD 86 4A
LDA $87 ; CPU:$C2DF PRG:02DF A5 87
ASL A ; CPU:$C2E1 PRG:02E1 0A
ASL A ; CPU:$C2E2 PRG:02E2 0A
ORA $88 ; CPU:$C2E3 PRG:02E3 05 88
STA $89 ; CPU:$C2E5 PRG:02E5 85 89
LDA #$01 ; CPU:$C2E7 PRG:02E7 A9 01
STA $4C ; CPU:$C2E9 PRG:02E9 85 4C
STA $8D ; CPU:$C2EB PRG:02EB 85 8D
STA $80 ; CPU:$C2ED PRG:02ED 85 80
STA $81 ; CPU:$C2EF PRG:02EF 85 81
UpdateGameStateDispatch_C2F1:
STA $8A ; CPU:$C2F1 PRG:02F1 85 8A
LDA #$02 ; CPU:$C2F3 PRG:02F3 A9 02
STA $8B ; CPU:$C2F5 PRG:02F5 85 8B
RTS ; CPU:$C2F7 PRG:02F7 60
CorePathLoop_C2F8:
LDA $7D ; CPU:$C2F8 PRG:02F8 A5 7D
BEQ CorePathLoop_C2C3 ; CPU:$C2FA PRG:02FA F0 C7
LDA $44 ; CPU:$C2FC PRG:02FC A5 44
AND #$20 ; CPU:$C2FE PRG:02FE 29 20
BEQ UpdatePlayerStateContinue_C310 ; CPU:$C300 PRG:0300 F0 0E
LDA $4F ; CPU:$C302 PRG:0302 A5 4F
BNE UpdatePlayerStateContinue_C310 ; CPU:$C304 PRG:0304 D0 0A
LDA $4B ; CPU:$C306 PRG:0306 A5 4B
EOR #$01 ; CPU:$C308 PRG:0308 49 01
STA $4B ; CPU:$C30A PRG:030A 85 4B
LDA #$40 ; CPU:$C30C PRG:030C A9 40
STA $7D ; CPU:$C30E PRG:030E 85 7D
UpdatePlayerStateContinue_C310:
STA $4F ; CPU:$C310 PRG:0310 85 4F
LDA #$90 ; CPU:$C312 PRG:0312 A9 90
LDX $4B ; CPU:$C314 PRG:0314 A6 4B
STX $4C ; CPU:$C316 PRG:0316 86 4C
BEQ CorePathOnZero_C31C ; CPU:$C318 PRG:0318 F0 02
LDA #$A0 ; CPU:$C31A PRG:031A A9 A0
CorePathOnZero_C31C:
STA $0200 ; CPU:$C31C PRG:031C 8D 00 02
LDA #$E5 ; CPU:$C31F PRG:031F A9 E5
STA $0201 ; CPU:$C321 PRG:0321 8D 01 02
LDA #$00 ; CPU:$C324 PRG:0324 A9 00
STA $0202 ; CPU:$C326 PRG:0326 8D 02 02
LDA #$40 ; CPU:$C329 PRG:0329 A9 40
STA $0203 ; CPU:$C32B PRG:032B 8D 03 02
LDA $44 ; CPU:$C32E PRG:032E A5 44
AND #$10 ; CPU:$C330 PRG:0330 29 10
BEQ CorePathContinue_C365 ; CPU:$C332 PRG:0332 F0 31
LDA $4E ; CPU:$C334 PRG:0334 A5 4E
BNE CorePathContinue_C365 ; CPU:$C336 PRG:0336 D0 2D
LDY #$1B ; CPU:$C338 PRG:0338 A0 1B
CorePathLoop_C33A:
STA a:$0024,Y ; CPU:$C33A PRG:033A 99 24 00
DEY ; CPU:$C33D PRG:033D 88
BPL CorePathLoop_C33A ; CPU:$C33E PRG:033E 10 FA
LDY #$1F ; CPU:$C340 PRG:0340 A0 1F
UpdatePlayerStateLoop_C342:
STA a:$0080,Y ; CPU:$C342 PRG:0342 99 80 00
DEY ; CPU:$C345 PRG:0345 88
BPL UpdatePlayerStateLoop_C342 ; CPU:$C346 PRG:0346 10 FA
JSR RunGameTaskRoutine_C84B ; CPU:$C348 PRG:0348 20 4B C8
LDA #$05 ; CPU:$C34B PRG:034B A9 05
STA $80 ; CPU:$C34D PRG:034D 85 80
LDX $4C ; CPU:$C34F PRG:034F A6 4C
BNE UpdateGameStateOnNonZero_C359 ; CPU:$C351 PRG:0351 D0 06
LDX #$01 ; CPU:$C353 PRG:0353 A2 01
STX $91 ; CPU:$C355 PRG:0355 86 91
LDA #$00 ; CPU:$C357 PRG:0357 A9 00
UpdateGameStateOnNonZero_C359:
STA $81 ; CPU:$C359 PRG:0359 85 81
LDA #$02 ; CPU:$C35B PRG:035B A9 02
STA $8B ; CPU:$C35D PRG:035D 85 8B
LDA #$01 ; CPU:$C35F PRG:035F A9 01
STA $8A ; CPU:$C361 PRG:0361 85 8A
STA $33 ; CPU:$C363 PRG:0363 85 33
CorePathContinue_C365:
STA $4E ; CPU:$C365 PRG:0365 85 4E
RTS ; CPU:$C367 PRG:0367 60
;------------------------------------------------------------
; RunGameTaskRoutine_C368
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C368:
LDA $92 ; CPU:$C368 PRG:0368 A5 92
BNE CorePathOnNonZero_C3CD ; CPU:$C36A PRG:036A D0 61
LDA $B0 ; CPU:$C36C PRG:036C A5 B0
BNE UpdateGameStateOnNonZero_C373 ; CPU:$C36E PRG:036E D0 03
JSR ProcessResourceStateRoutine_F577 ; CPU:$C370 PRG:0370 20 77 F5
UpdateGameStateOnNonZero_C373:
LDA $8A ; CPU:$C373 PRG:0373 A5 8A
BEQ CorePathLoop_C2F8 ; CPU:$C375 PRG:0375 F0 81
LDA $8D ; CPU:$C377 PRG:0377 A5 8D
BEQ CorePathOnZero_C38D ; CPU:$C379 PRG:0379 F0 12
LDA $90 ; CPU:$C37B PRG:037B A5 90
CMP #$01 ; CPU:$C37D PRG:037D C9 01
BNE CorePathOnNonZero_C387 ; CPU:$C37F PRG:037F D0 06
LDA $91 ; CPU:$C381 PRG:0381 A5 91
CMP #$01 ; CPU:$C383 PRG:0383 C9 01
BEQ RunGameTaskRoutine_C3E4 ; CPU:$C385 PRG:0385 F0 5D
CorePathOnNonZero_C387:
LDA $44 ; CPU:$C387 PRG:0387 A5 44
AND #$30 ; CPU:$C389 PRG:0389 29 30
BNE RunGameTaskRoutine_C3E4 ; CPU:$C38B PRG:038B D0 57
CorePathOnZero_C38D:
LDA $44 ; CPU:$C38D PRG:038D A5 44
AND #$10 ; CPU:$C38F PRG:038F 29 10
BEQ UpdateGameStateContinue_C3A9 ; CPU:$C391 PRG:0391 F0 16
LDA $4E ; CPU:$C393 PRG:0393 A5 4E
BNE UpdateGameStateContinue_C3A9 ; CPU:$C395 PRG:0395 D0 12
LDA #$01 ; CPU:$C397 PRG:0397 A9 01
EOR $B0 ; CPU:$C399 PRG:0399 45 B0
STA $B0 ; CPU:$C39B PRG:039B 85 B0
BNE CorePathOnNonZero_C3A3 ; CPU:$C39D PRG:039D D0 04
LDA #$06 ; CPU:$C39F PRG:039F A9 06
STA $92 ; CPU:$C3A1 PRG:03A1 85 92
CorePathOnNonZero_C3A3:
LDA #$20 ; CPU:$C3A3 PRG:03A3 A9 20
STA $FB ; CPU:$C3A5 PRG:03A5 85 FB
LDA #$01 ; CPU:$C3A7 PRG:03A7 A9 01
UpdateGameStateContinue_C3A9:
STA $4E ; CPU:$C3A9 PRG:03A9 85 4E
LDA $92 ; CPU:$C3AB PRG:03AB A5 92
BNE CorePathLoop_C3CC ; CPU:$C3AD PRG:03AD D0 1D
LDA $B0 ; CPU:$C3AF PRG:03AF A5 B0
BNE CorePathLoop_C3CC ; CPU:$C3B1 PRG:03B1 D0 19
LDA $8A ; CPU:$C3B3 PRG:03B3 A5 8A
CMP #$02 ; CPU:$C3B5 PRG:03B5 C9 02
BEQ CorePathOnZero_C3E0 ; CPU:$C3B7 PRG:03B7 F0 27
JSR CoreGameCode ; CPU:$C3B9 PRG:03B9 20 45 C2
;------------------------------------------------------------
; UpdateGameStateRoutine_C3BC
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateGameStateRoutine_C3BC:
LDA $8D ; CPU:$C3BC PRG:03BC A5 8D
BEQ CorePathLoop_C3CC ; CPU:$C3BE PRG:03BE F0 0C
LDA #$00 ; CPU:$C3C0 PRG:03C0 A9 00
STA $FB ; CPU:$C3C2 PRG:03C2 85 FB
STA $FC ; CPU:$C3C4 PRG:03C4 85 FC
STA $FD ; CPU:$C3C6 PRG:03C6 85 FD
STA $FE ; CPU:$C3C8 PRG:03C8 85 FE
STA $FF ; CPU:$C3CA PRG:03CA 85 FF
CorePathLoop_C3CC:
RTS ; CPU:$C3CC PRG:03CC 60
CorePathOnNonZero_C3CD:
CMP #$01 ; CPU:$C3CD PRG:03CD C9 01
BEQ CorePathOnZero_C400 ; CPU:$C3CF PRG:03CF F0 2F
DEC $93 ; CPU:$C3D1 PRG:03D1 C6 93
BPL CorePathContinue_C3DF ; CPU:$C3D3 PRG:03D3 10 0A
LDA #$0A ; CPU:$C3D5 PRG:03D5 A9 0A
STA $93 ; CPU:$C3D7 PRG:03D7 85 93
LDA $92 ; CPU:$C3D9 PRG:03D9 A5 92
BEQ CorePathContinue_C3DF ; CPU:$C3DB PRG:03DB F0 02
DEC $92 ; CPU:$C3DD PRG:03DD C6 92
CorePathContinue_C3DF:
RTS ; CPU:$C3DF PRG:03DF 60
CorePathOnZero_C3E0:
JSR RunGameTaskRoutine_C6BE ; CPU:$C3E0 PRG:03E0 20 BE C6
RTS ; CPU:$C3E3 PRG:03E3 60
;------------------------------------------------------------
; RunGameTaskRoutine_C3E4
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C3E4:
LDX $4D ; CPU:$C3E4 PRG:03E4 A6 4D
BNE CorePathOnNonZero_C3EE ; CPU:$C3E6 PRG:03E6 D0 06
LDA #$01 ; CPU:$C3E8 PRG:03E8 A9 01
STA $FB ; CPU:$C3EA PRG:03EA 85 FB
LDX #$04 ; CPU:$C3EC PRG:03EC A2 04
CorePathOnNonZero_C3EE:
DEX ; CPU:$C3EE PRG:03EE CA
STX $4D ; CPU:$C3EF PRG:03EF 86 4D
LDA #$40 ; CPU:$C3F1 PRG:03F1 A9 40
STA $7D ; CPU:$C3F3 PRG:03F3 85 7D
LDA #$01 ; CPU:$C3F5 PRG:03F5 A9 01
STA $4F ; CPU:$C3F7 PRG:03F7 85 4F
STA $4E ; CPU:$C3F9 PRG:03F9 85 4E
LDA #$00 ; CPU:$C3FB PRG:03FB A9 00
JMP UpdateGameStateDispatch_C2F1 ; CPU:$C3FD PRG:03FD 4C F1 C2
CorePathOnZero_C400:
DEC $92 ; CPU:$C400 PRG:0400 C6 92
;------------------------------------------------------------
; UpdateGameStateRoutine_C402
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateGameStateRoutine_C402:
LDA $8A ; CPU:$C402 PRG:0402 A5 8A
CMP #$01 ; CPU:$C404 PRG:0404 C9 01
BNE CorePathLoop_C3CC ; CPU:$C406 PRG:0406 D0 C4
LDA $78 ; CPU:$C408 PRG:0408 A5 78
BNE CorePathLoop_C3CC ; CPU:$C40A PRG:040A D0 C0
LDX #$10 ; CPU:$C40C PRG:040C A2 10
LDA $8F ; CPU:$C40E PRG:040E A5 8F
BNE CorePathContinue_C41C ; CPU:$C410 PRG:0410 D0 0A
LDX #$08 ; CPU:$C412 PRG:0412 A2 08
LDA $2E ; CPU:$C414 PRG:0414 A5 2E
CMP #$02 ; CPU:$C416 PRG:0416 C9 02
BCC CorePathContinue_C41C ; CPU:$C418 PRG:0418 90 02
LDX #$04 ; CPU:$C41A PRG:041A A2 04
CorePathContinue_C41C:
STX $FB ; CPU:$C41C PRG:041C 86 FB
JMP UpdateGameStateRoutine_C3BC ; CPU:$C41E PRG:041E 4C BC C3
CorePathLoop_C421:
LDA $55 ; CPU:$C421 PRG:0421 A5 55
BNE CorePathOnNonZero_C437 ; CPU:$C423 PRG:0423 D0 12
LDA #$04 ; CPU:$C425 PRG:0425 A9 04
STA $55 ; CPU:$C427 PRG:0427 85 55
LDA #$01 ; CPU:$C429 PRG:0429 A9 01
EOR $A7 ; CPU:$C42B PRG:042B 45 A7
STA $A7 ; CPU:$C42D PRG:042D 85 A7
BEQ CorePathLoop_C432 ; CPU:$C42F PRG:042F F0 01
INY ; CPU:$C431 PRG:0431 C8
CorePathLoop_C432:
LDX #$08 ; CPU:$C432 PRG:0432 A2 08
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$C434 PRG:0434 20 AE D1
CorePathOnNonZero_C437:
RTS ; CPU:$C437 PRG:0437 60
CorePathLoop_C438:
LDX #$01 ; CPU:$C438 PRG:0438 A2 01
UpdatePlayerStateLoop_C43A:
LDA $90,X ; CPU:$C43A PRG:043A B5 90
CMP #$02 ; CPU:$C43C PRG:043C C9 02
BCS CorePathOnCarry_C475 ; CPU:$C43E PRG:043E B0 35
DEX ; CPU:$C440 PRG:0440 CA
BPL UpdatePlayerStateLoop_C43A ; CPU:$C441 PRG:0441 10 F7
LDX $43 ; CPU:$C443 PRG:0443 A6 43
LDA $40 ; CPU:$C445 PRG:0445 A5 40
AND #$02 ; CPU:$C447 PRG:0447 29 02
BEQ CorePathOnZero_C45A ; CPU:$C449 PRG:0449 F0 0F
LDA $40 ; CPU:$C44B PRG:044B A5 40
AND #$FD ; CPU:$C44D PRG:044D 29 FD
STA $40 ; CPU:$C44F PRG:044F 85 40
LDY #$14 ; CPU:$C451 PRG:0451 A0 14
LDX #$0C ; CPU:$C453 PRG:0453 A2 0C
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$C455 PRG:0455 20 AE D1
LDX #$FF ; CPU:$C458 PRG:0458 A2 FF
CorePathOnZero_C45A:
INX ; CPU:$C45A PRG:045A E8
INX ; CPU:$C45B PRG:045B E8
INX ; CPU:$C45C PRG:045C E8
CPX #$F2 ; CPU:$C45D PRG:045D E0 F2
BEQ RunGameTaskRoutine_C463 ; CPU:$C45F PRG:045F F0 02
STX $43 ; CPU:$C461 PRG:0461 86 43
;------------------------------------------------------------
; RunGameTaskRoutine_C463
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C463:
LDY #$1F ; CPU:$C463 PRG:0463 A0 1F
LDA #$F4 ; CPU:$C465 PRG:0465 A9 F4
CorePathLoop_C467:
STA $02E0,Y ; CPU:$C467 PRG:0467 99 E0 02
DEY ; CPU:$C46A PRG:046A 88
BPL CorePathLoop_C467 ; CPU:$C46B PRG:046B 10 FA
RTS ; CPU:$C46D PRG:046D 60
CorePathLoop_C46E:
JSR UpdatePlayerStateRoutine_C504 ; CPU:$C46E PRG:046E 20 04 C5
JSR ProcessObjectStateRoutine_DA26 ; CPU:$C471 PRG:0471 20 26 DA
RTS ; CPU:$C474 PRG:0474 60
CorePathOnCarry_C475:
LDA #$0A ; CPU:$C475 PRG:0475 A9 0A
STA $78 ; CPU:$C477 PRG:0477 85 78
RTS ; CPU:$C479 PRG:0479 60
;------------------------------------------------------------
; UpdateGameStateRoutine_C47A
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateGameStateRoutine_C47A:
JSR ProcessObjectStateRoutine_D1CE ; CPU:$C47A PRG:047A 20 CE D1
LDA $78 ; CPU:$C47D PRG:047D A5 78
BEQ CorePathLoop_C46E ; CPU:$C47F PRG:047F F0 ED
CMP #$22 ; CPU:$C481 PRG:0481 C9 22
BCS CorePathLoop_C4B3 ; CPU:$C483 PRG:0483 B0 2E
CMP #$0B ; CPU:$C485 PRG:0485 C9 0B
BEQ CorePathLoop_C432 ; CPU:$C487 PRG:0487 F0 A9
BCS CorePathLoop_C421 ; CPU:$C489 PRG:0489 B0 96
CMP #$01 ; CPU:$C48B PRG:048B C9 01
BNE CorePathLoop_C438 ; CPU:$C48D PRG:048D D0 A9
DEC $78 ; CPU:$C48F PRG:048F C6 78
LDA #$02 ; CPU:$C491 PRG:0491 A9 02
STA $8A ; CPU:$C493 PRG:0493 85 8A
LDA #$00 ; CPU:$C495 PRG:0495 A9 00
STA $76 ; CPU:$C497 PRG:0497 85 76
STA $D0 ; CPU:$C499 PRG:0499 85 D0
STA $D1 ; CPU:$C49B PRG:049B 85 D1
LDA $90 ; CPU:$C49D PRG:049D A5 90
BNE UpdatePlayerStateOnNonZero_C4A3 ; CPU:$C49F PRG:049F D0 02
INC $80 ; CPU:$C4A1 PRG:04A1 E6 80
UpdatePlayerStateOnNonZero_C4A3:
LDA $91 ; CPU:$C4A3 PRG:04A3 A5 91
BNE CorePathOnNonZero_C4A9 ; CPU:$C4A5 PRG:04A5 D0 02
INC $81 ; CPU:$C4A7 PRG:04A7 E6 81
CorePathOnNonZero_C4A9:
LDA #$87 ; CPU:$C4A9 PRG:04A9 A9 87
LDX #$C0 ; CPU:$C4AB PRG:04AB A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$C4AD PRG:04AD 20 7D F7
JMP ProcessObjectStateDispatch_DD48 ; CPU:$C4B0 PRG:04B0 4C 48 DD
CorePathLoop_C4B3:
LDA #$21 ; CPU:$C4B3 PRG:04B3 A9 21
LDX $AF ; CPU:$C4B5 PRG:04B5 A6 AF
BEQ CorePathOnZero_C4BF ; CPU:$C4B7 PRG:04B7 F0 06
LDA #$FF ; CPU:$C4B9 PRG:04B9 A9 FF
STA $55 ; CPU:$C4BB PRG:04BB 85 55
LDA #$17 ; CPU:$C4BD PRG:04BD A9 17
CorePathOnZero_C4BF:
STA $78 ; CPU:$C4BF PRG:04BF 85 78
LDA #$F0 ; CPU:$C4C1 PRG:04C1 A9 F0
CorePathLoop_C4C3:
TAY ; CPU:$C4C3 PRG:04C3 A8
LDA #$01 ; CPU:$C4C4 PRG:04C4 A9 01
STA $03F0,Y ; CPU:$C4C6 PRG:04C6 99 F0 03
TYA ; CPU:$C4C9 PRG:04C9 98
SEC ; CPU:$C4CA PRG:04CA 38
SBC #$10 ; CPU:$C4CB PRG:04CB E9 10
BNE CorePathLoop_C4C3 ; CPU:$C4CD PRG:04CD D0 F4
LDA #$F0 ; CPU:$C4CF PRG:04CF A9 F0
CorePathLoop_C4D1:
TAY ; CPU:$C4D1 PRG:04D1 A8
LDA #$00 ; CPU:$C4D2 PRG:04D2 A9 00
STA $0600,Y ; CPU:$C4D4 PRG:04D4 99 00 06
LDX $05F0,Y ; CPU:$C4D7 PRG:04D7 BE F0 05
BNE CorePathOnNonZero_C4E1 ; CPU:$C4DA PRG:04DA D0 05
LDA #$01 ; CPU:$C4DC PRG:04DC A9 01
STA $05F0,Y ; CPU:$C4DE PRG:04DE 99 F0 05
CorePathOnNonZero_C4E1:
TYA ; CPU:$C4E1 PRG:04E1 98
SEC ; CPU:$C4E2 PRG:04E2 38
SBC #$20 ; CPU:$C4E3 PRG:04E3 E9 20
CMP #$F0 ; CPU:$C4E5 PRG:04E5 C9 F0
BNE CorePathLoop_C4D1 ; CPU:$C4E7 PRG:04E7 D0 E8
LDA #$80 ; CPU:$C4E9 PRG:04E9 A9 80
CorePathLoop_C4EB:
TAY ; CPU:$C4EB PRG:04EB A8
LDA #$00 ; CPU:$C4EC PRG:04EC A9 00
STA $0470,Y ; CPU:$C4EE PRG:04EE 99 70 04
TYA ; CPU:$C4F1 PRG:04F1 98
SEC ; CPU:$C4F2 PRG:04F2 38
SBC #$20 ; CPU:$C4F3 PRG:04F3 E9 20
BNE CorePathLoop_C4EB ; CPU:$C4F5 PRG:04F5 D0 F4
LDA #$40 ; CPU:$C4F7 PRG:04F7 A9 40
STA $FB ; CPU:$C4F9 PRG:04F9 85 FB
JSR RunGameTaskRoutine_C7F3 ; CPU:$C4FB PRG:04FB 20 F3 C7
LDA #$83 ; CPU:$C4FE PRG:04FE A9 83
JSR ProcessResourceStateRoutine_F31A ; CPU:$C500 PRG:0500 20 1A F3
RTS ; CPU:$C503 PRG:0503 60
;------------------------------------------------------------
; UpdatePlayerStateRoutine_C504
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdatePlayerStateRoutine_C504:
LDA $90 ; CPU:$C504 PRG:0504 A5 90
CMP #$01 ; CPU:$C506 PRG:0506 C9 01
BNE CorePathOnNonZero_C51A ; CPU:$C508 PRG:0508 D0 10
LDA $91 ; CPU:$C50A PRG:050A A5 91
CMP #$01 ; CPU:$C50C PRG:050C C9 01
BNE CorePathOnNonZero_C51A ; CPU:$C50E PRG:050E D0 0A
LDA #$01 ; CPU:$C510 PRG:0510 A9 01
STA $AF ; CPU:$C512 PRG:0512 85 AF
LDA #$23 ; CPU:$C514 PRG:0514 A9 23
STA $78 ; CPU:$C516 PRG:0516 85 78
BNE CorePathLoop_C4B3 ; CPU:$C518 PRG:0518 D0 99
CorePathOnNonZero_C51A:
RTS ; CPU:$C51A PRG:051A 60
.byte $12, $F5, $F6, $1C, $0B, $18, $17, $1E, $1C, $24, $24, $02, $00, $00, $00, $AD ; CPU:$C51B PRG:051B 0B
.byte $29, $2B, $1D, $19, $0E, $1B, $0F, $0E, $0C, $1D, $24, $03, $00, $00, $00, $AD ; CPU:$C52B PRG:052B 0B
RunGameTaskDispatch_C53B:
LDA $3F ; CPU:$C53B PRG:053B A5 3F
BNE CorePathOnNonZero_C581 ; CPU:$C53D PRG:053D D0 42
LDA #$01 ; CPU:$C53F PRG:053F A9 01
STA $0F ; CPU:$C541 PRG:0541 85 0F
LDA #$2A ; CPU:$C543 PRG:0543 A9 2A
LDX #$EE ; CPU:$C545 PRG:0545 A2 EE
UpdatePlayerStateLoop_C547:
STX $00 ; CPU:$C547 PRG:0547 86 00
STA $01 ; CPU:$C549 PRG:0549 85 01
LDX $0F ; CPU:$C54B PRG:054B A6 0F
LDA $90,X ; CPU:$C54D PRG:054D B5 90
CMP #$01 ; CPU:$C54F PRG:054F C9 01
BEQ CorePathOnZero_C56B ; CPU:$C551 PRG:0551 F0 18
LDA #$2D ; CPU:$C553 PRG:0553 A9 2D
STA $02 ; CPU:$C555 PRG:0555 85 02
LDA #$C5 ; CPU:$C557 PRG:0557 A9 C5
STA $03 ; CPU:$C559 PRG:0559 85 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$C55B PRG:055B 20 A1 F3
LDA $0F ; CPU:$C55E PRG:055E A5 0F
ORA #$80 ; CPU:$C560 PRG:0560 09 80
STA $01 ; CPU:$C562 PRG:0562 85 01
LDA #$30 ; CPU:$C564 PRG:0564 A9 30
STA $00 ; CPU:$C566 PRG:0566 85 00
JSR ProcessResourceStateRoutine_F40C ; CPU:$C568 PRG:0568 20 0C F4
CorePathOnZero_C56B:
LDA #$29 ; CPU:$C56B PRG:056B A9 29
LDX #$2E ; CPU:$C56D PRG:056D A2 2E
DEC $0F ; CPU:$C56F PRG:056F C6 0F
BPL UpdatePlayerStateLoop_C547 ; CPU:$C571 PRG:0571 10 D4
JSR RunGameTaskRoutine_C7EF ; CPU:$C573 PRG:0573 20 EF C7
LDA #$02 ; CPU:$C576 PRG:0576 A9 02
STA $FE ; CPU:$C578 PRG:0578 85 FE
JSR RunGameTaskRoutine_C809 ; CPU:$C57A PRG:057A 20 09 C8
INC $AC ; CPU:$C57D PRG:057D E6 AC
LDA #$18 ; CPU:$C57F PRG:057F A9 18
CorePathOnNonZero_C581:
JMP RunGameTaskDispatch_C7EA ; CPU:$C581 PRG:0581 4C EA C7
CorePathLoop_C584:
LDA $A1 ; CPU:$C584 PRG:0584 A5 A1
BNE CorePathContinue_C5C5 ; CPU:$C586 PRG:0586 D0 3D
LDA $2E ; CPU:$C588 PRG:0588 A5 2E
BNE CorePathOnNonZero_C590 ; CPU:$C58A PRG:058A D0 04
LDA $2F ; CPU:$C58C PRG:058C A5 2F
BEQ CorePathContinue_C5C5 ; CPU:$C58E PRG:058E F0 35
CorePathOnNonZero_C590:
LDA #$01 ; CPU:$C590 PRG:0590 A9 01
STA $0F ; CPU:$C592 PRG:0592 85 0F
UpdatePlayerStateLoop_C594:
LDA #$10 ; CPU:$C594 PRG:0594 A9 10
STA $00 ; CPU:$C596 PRG:0596 85 00
LDX $0F ; CPU:$C598 PRG:0598 A6 0F
LDA $90,X ; CPU:$C59A PRG:059A B5 90
CMP #$01 ; CPU:$C59C PRG:059C C9 01
BEQ CorePathOnZero_C5A5 ; CPU:$C59E PRG:059E F0 05
STX $01 ; CPU:$C5A0 PRG:05A0 86 01
JSR ProcessResourceStateRoutine_F40C ; CPU:$C5A2 PRG:05A2 20 0C F4
CorePathOnZero_C5A5:
DEC $0F ; CPU:$C5A5 PRG:05A5 C6 0F
BPL UpdatePlayerStateLoop_C594 ; CPU:$C5A7 PRG:05A7 10 EB
JSR RunGameTaskRoutine_C7EF ; CPU:$C5A9 PRG:05A9 20 EF C7
LDA #$10 ; CPU:$C5AC PRG:05AC A9 10
STA $00 ; CPU:$C5AE PRG:05AE 85 00
LDA #$02 ; CPU:$C5B0 PRG:05B0 A9 02
STA $01 ; CPU:$C5B2 PRG:05B2 85 01
JSR ProcessResourceStateRoutine_F408 ; CPU:$C5B4 PRG:05B4 20 08 F4
LDA $2F ; CPU:$C5B7 PRG:05B7 A5 2F
AND #$F0 ; CPU:$C5B9 PRG:05B9 29 F0
STA $2F ; CPU:$C5BB PRG:05BB 85 2F
LDA #$82 ; CPU:$C5BD PRG:05BD A9 82
JSR ProcessResourceStateRoutine_F31A ; CPU:$C5BF PRG:05BF 20 1A F3
JMP RunGameTaskRoutine_C809 ; CPU:$C5C2 PRG:05C2 4C 09 C8
CorePathContinue_C5C5:
JMP RunGameTaskDispatch_C7E5 ; CPU:$C5C5 PRG:05C5 4C E5 C7
CorePathLoop_C5C8:
JMP RunGameTaskDispatch_C53B ; CPU:$C5C8 PRG:05C8 4C 3B C5
CorePathLoop_C5CB:
LDA $8F ; CPU:$C5CB PRG:05CB A5 8F
BNE CorePathLoop_C5C8 ; CPU:$C5CD PRG:05CD D0 F9
LDA #$7B ; CPU:$C5CF PRG:05CF A9 7B
LDX #$C1 ; CPU:$C5D1 PRG:05D1 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$C5D3 PRG:05D3 20 7D F7
LDA #$BA ; CPU:$C5D6 PRG:05D6 A9 BA
STA $04A1 ; CPU:$C5D8 PRG:05D8 8D A1 04
LDX $4C ; CPU:$C5DB PRG:05DB A6 4C
BNE CorePathOnNonZero_C5E4 ; CPU:$C5DD PRG:05DD D0 05
LDX #$01 ; CPU:$C5DF PRG:05DF A2 01
STX $04A0 ; CPU:$C5E1 PRG:05E1 8E A0 04
CorePathOnNonZero_C5E4:
JSR RunGameTaskRoutine_C81A ; CPU:$C5E4 PRG:05E4 20 1A C8
LDA #$20 ; CPU:$C5E7 PRG:05E7 A9 20
JMP RunGameTaskDispatch_C7EA ; CPU:$C5E9 PRG:05E9 4C EA C7
UpdatePlayerStateDispatch_C5EC:
LDA $AF ; CPU:$C5EC PRG:05EC A5 AF
BEQ CorePathLoop_C584 ; CPU:$C5EE PRG:05EE F0 94
LDA #$90 ; CPU:$C5F0 PRG:05F0 A9 90
RunGameTaskDispatch_C5F2:
STA $51 ; CPU:$C5F2 PRG:05F2 85 51
INC $AC ; CPU:$C5F4 PRG:05F4 E6 AC
RTS ; CPU:$C5F6 PRG:05F6 60
RunGameTaskDispatch_C5F7:
LDA $D6 ; CPU:$C5F7 PRG:05F7 A5 D6
BNE CorePathOnNonZero_C5FF ; CPU:$C5F9 PRG:05F9 D0 04
LDA $D7 ; CPU:$C5FB PRG:05FB A5 D7
BEQ CorePathOnZero_C61E ; CPU:$C5FD PRG:05FD F0 1F
CorePathOnNonZero_C5FF:
LDX #$01 ; CPU:$C5FF PRG:05FF A2 01
CorePathLoop_C601:
STX $0F ; CPU:$C601 PRG:0601 86 0F
LDA $D6,X ; CPU:$C603 PRG:0603 B5 D6
BEQ CorePathOnZero_C60E ; CPU:$C605 PRG:0605 F0 07
DEC $D6,X ; CPU:$C607 PRG:0607 D6 D6
LDA #$05 ; CPU:$C609 PRG:0609 A9 05
JSR RunGameTaskRoutine_C830 ; CPU:$C60B PRG:060B 20 30 C8
CorePathOnZero_C60E:
LDX $0F ; CPU:$C60E PRG:060E A6 0F
DEX ; CPU:$C610 PRG:0610 CA
BPL CorePathLoop_C601 ; CPU:$C611 PRG:0611 10 EE
JSR RunGameTaskRoutine_C7EF ; CPU:$C613 PRG:0613 20 EF C7
JSR RunGameTaskRoutine_C824 ; CPU:$C616 PRG:0616 20 24 C8
LDA #$18 ; CPU:$C619 PRG:0619 A9 18
JMP RunGameTaskDispatch_C80B ; CPU:$C61B PRG:061B 4C 0B C8
CorePathOnZero_C61E:
JMP RunGameTaskDispatch_C7E5 ; CPU:$C61E PRG:061E 4C E5 C7
RunGameTaskDispatch_C621:
LDA $AF ; CPU:$C621 PRG:0621 A5 AF
BEQ CorePathLoop_C5CB ; CPU:$C623 PRG:0623 F0 A6
JSR RunGameTaskRoutine_C809 ; CPU:$C625 PRG:0625 20 09 C8
LDA #$FF ; CPU:$C628 PRG:0628 A9 FF
JMP RunGameTaskDispatch_C5F2 ; CPU:$C62A PRG:062A 4C F2 C5
RunGameTaskDispatch_C62D:
LDA #$82 ; CPU:$C62D PRG:062D A9 82
JSR ProcessResourceStateRoutine_F31A ; CPU:$C62F PRG:062F 20 1A F3
LDA #$6A ; CPU:$C632 PRG:0632 A9 6A
LDX #$C1 ; CPU:$C634 PRG:0634 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$C636 PRG:0636 20 7D F7
LDA #$A0 ; CPU:$C639 PRG:0639 A9 A0
STA $0441 ; CPU:$C63B PRG:063B 8D 41 04
LDA #$01 ; CPU:$C63E PRG:063E A9 01
STA $0449 ; CPU:$C640 PRG:0640 8D 49 04
LDA #$C0 ; CPU:$C643 PRG:0643 A9 C0
STA $044B ; CPU:$C645 PRG:0645 8D 4B 04
LDX #$00 ; CPU:$C648 PRG:0648 A2 00
JSR ProcessObjectStateRoutine_D44A ; CPU:$C64A PRG:064A 20 4A D4
LDX $4C ; CPU:$C64D PRG:064D A6 4C
BEQ CorePathOnZero_C682 ; CPU:$C64F PRG:064F F0 31
JSR ProcessObjectStateRoutine_D44A ; CPU:$C651 PRG:0651 20 4A D4
CorePathLoop_C654:
LDX #$00 ; CPU:$C654 PRG:0654 A2 00
LDA $4C ; CPU:$C656 PRG:0656 A5 4C
BEQ CorePathOnZero_C670 ; CPU:$C658 PRG:0658 F0 16
LDA $D5 ; CPU:$C65A PRG:065A A5 D5
BMI CorePathLoop_C66A ; CPU:$C65C PRG:065C 30 0C
SEC ; CPU:$C65E PRG:065E 38
LDY $D4 ; CPU:$C65F PRG:065F A4 D4
BMI CorePathOnNegative_C667 ; CPU:$C661 PRG:0661 30 04
CMP $D4 ; CPU:$C663 PRG:0663 C5 D4
BEQ CorePathLoop_C66B ; CPU:$C665 PRG:0665 F0 04
CorePathOnNegative_C667:
INX ; CPU:$C667 PRG:0667 E8
BCC CorePathLoop_C66B ; CPU:$C668 PRG:0668 90 01
CorePathLoop_C66A:
INX ; CPU:$C66A PRG:066A E8
CorePathLoop_C66B:
STX $AE ; CPU:$C66B PRG:066B 86 AE
JMP RunGameTaskDispatch_C7E8 ; CPU:$C66D PRG:066D 4C E8 C7
CorePathOnZero_C670:
LDA $2E ; CPU:$C670 PRG:0670 A5 2E
CMP $A8 ; CPU:$C672 PRG:0672 C5 A8
BCS CorePathLoop_C66A ; CPU:$C674 PRG:0674 B0 F4
BCC CorePathLoop_C66B ; CPU:$C676 PRG:0676 90 F3
CorePathLoop_C678:
LDA $AF ; CPU:$C678 PRG:0678 A5 AF
BEQ CorePathOnZero_C67F ; CPU:$C67A PRG:067A F0 03
JMP RunGameTaskRoutine_C3E4 ; CPU:$C67C PRG:067C 4C E4 C3
CorePathOnZero_C67F:
JMP RunGameTaskDispatch_C5F7 ; CPU:$C67F PRG:067F 4C F7 C5
CorePathOnZero_C682:
LDA #$01 ; CPU:$C682 PRG:0682 A9 01
STA $0440 ; CPU:$C684 PRG:0684 8D 40 04
BNE CorePathLoop_C654 ; CPU:$C687 PRG:0687 D0 CB
CorePathLoop_C689:
LDA #$00 ; CPU:$C689 PRG:0689 A9 00
LDX $0405 ; CPU:$C68B PRG:068B AE 05 04
BNE CorePathOnNonZero_C6A2 ; CPU:$C68E PRG:068E D0 12
LDA $54 ; CPU:$C690 PRG:0690 A5 54
BNE CorePathOnNonZero_C6A8 ; CPU:$C692 PRG:0692 D0 14
LDA #$10 ; CPU:$C694 PRG:0694 A9 10
STA $54 ; CPU:$C696 PRG:0696 85 54
LDA #$04 ; CPU:$C698 PRG:0698 A9 04
STA $FC ; CPU:$C69A PRG:069A 85 FC
LDA $AD ; CPU:$C69C PRG:069C A5 AD
EOR #$40 ; CPU:$C69E PRG:069E 49 40
STA $AD ; CPU:$C6A0 PRG:06A0 85 AD
CorePathOnNonZero_C6A2:
STA $0408 ; CPU:$C6A2 PRG:06A2 8D 08 04
STA $0448 ; CPU:$C6A5 PRG:06A5 8D 48 04
CorePathOnNonZero_C6A8:
JSR ProcessObjectStateRoutine_D083 ; CPU:$C6A8 PRG:06A8 20 83 D0
JSR ProcessObjectStateRoutine_D0A5 ; CPU:$C6AB PRG:06AB 20 A5 D0
JSR UpdateObjectBuffer_D0C8 ; CPU:$C6AE PRG:06AE 20 C8 D0
JSR ObjectPath_D1D6 ; CPU:$C6B1 PRG:06B1 20 D6 D1
RTS ; CPU:$C6B4 PRG:06B4 60
CorePathLoop_C6B5:
JMP UpdatePlayerStateDispatch_C5EC ; CPU:$C6B5 PRG:06B5 4C EC C5
CorePathLoop_C6B8:
JMP RunGameTaskDispatch_C621 ; CPU:$C6B8 PRG:06B8 4C 21 C6
CorePathLoop_C6BB:
JMP RunGameTaskDispatch_C62D ; CPU:$C6BB PRG:06BB 4C 2D C6
;------------------------------------------------------------
; RunGameTaskRoutine_C6BE
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C6BE:
LDA $51 ; CPU:$C6BE PRG:06BE A5 51
BNE CorePathLoop_C689 ; CPU:$C6C0 PRG:06C0 D0 C7
LDX $AC ; CPU:$C6C2 PRG:06C2 A6 AC
BEQ CorePathLoop_C6BB ; CPU:$C6C4 PRG:06C4 F0 F5
DEX ; CPU:$C6C6 PRG:06C6 CA
BEQ CorePathLoop_C6B5 ; CPU:$C6C7 PRG:06C7 F0 EC
DEX ; CPU:$C6C9 PRG:06C9 CA
BEQ CorePathLoop_C6B8 ; CPU:$C6CA PRG:06CA F0 EC
DEX ; CPU:$C6CC PRG:06CC CA
BEQ CorePathLoop_C678 ; CPU:$C6CD PRG:06CD F0 A9
DEX ; CPU:$C6CF PRG:06CF CA
BEQ CorePathOnZero_C740 ; CPU:$C6D0 PRG:06D0 F0 6E
DEX ; CPU:$C6D2 PRG:06D2 CA
BEQ CorePathOnZero_C73A ; CPU:$C6D3 PRG:06D3 F0 65
DEX ; CPU:$C6D5 PRG:06D5 CA
BEQ CorePathOnZero_C73D ; CPU:$C6D6 PRG:06D6 F0 65
LDA #$00 ; CPU:$C6D8 PRG:06D8 A9 00
LDX $87 ; CPU:$C6DA PRG:06DA A6 87
INX ; CPU:$C6DC PRG:06DC E8
STX $87 ; CPU:$C6DD PRG:06DD 86 87
CPX #$05 ; CPU:$C6DF PRG:06DF E0 05
BNE CorePathOnNonZero_C6E5 ; CPU:$C6E1 PRG:06E1 D0 02
LDA #$01 ; CPU:$C6E3 PRG:06E3 A9 01
CorePathOnNonZero_C6E5:
STA $8F ; CPU:$C6E5 PRG:06E5 85 8F
CPX #$06 ; CPU:$C6E7 PRG:06E7 E0 06
BNE CorePathOnNonZero_C703 ; CPU:$C6E9 PRG:06E9 D0 18
LDX #$01 ; CPU:$C6EB PRG:06EB A2 01
STX $87 ; CPU:$C6ED PRG:06ED 86 87
LDA $88 ; CPU:$C6EF PRG:06EF A5 88
INC $88 ; CPU:$C6F1 PRG:06F1 E6 88
CMP #$03 ; CPU:$C6F3 PRG:06F3 C9 03
BNE CorePathOnNonZero_C703 ; CPU:$C6F5 PRG:06F5 D0 0C
STX $8C ; CPU:$C6F7 PRG:06F7 86 8C
STX $84 ; CPU:$C6F9 PRG:06F9 86 84
LDA #$00 ; CPU:$C6FB PRG:06FB A9 00
STA $82 ; CPU:$C6FD PRG:06FD 85 82
STA $83 ; CPU:$C6FF PRG:06FF 85 83
STA $88 ; CPU:$C701 PRG:0701 85 88
CorePathOnNonZero_C703:
LDA $87 ; CPU:$C703 PRG:0703 A5 87
ASL A ; CPU:$C705 PRG:0705 0A
ASL A ; CPU:$C706 PRG:0706 0A
ORA $88 ; CPU:$C707 PRG:0707 05 88
STA $89 ; CPU:$C709 PRG:0709 85 89
LDX $8C ; CPU:$C70B PRG:070B A6 8C
LDA $8F ; CPU:$C70D PRG:070D A5 8F
BEQ UpdateGameStateOnZero_C713 ; CPU:$C70F PRG:070F F0 02
LDX #$00 ; CPU:$C711 PRG:0711 A2 00
UpdateGameStateOnZero_C713:
STX $8E ; CPU:$C713 PRG:0713 86 8E
LDA #$02 ; CPU:$C715 PRG:0715 A9 02
STA $8B ; CPU:$C717 PRG:0717 85 8B
DEC $84 ; CPU:$C719 PRG:0719 C6 84
BPL CorePathContinue_C72E ; CPU:$C71B PRG:071B 10 11
LDA #$02 ; CPU:$C71D PRG:071D A9 02
STA $84 ; CPU:$C71F PRG:071F 85 84
LDA $82 ; CPU:$C721 PRG:0721 A5 82
CMP #$07 ; CPU:$C723 PRG:0723 C9 07
BEQ CorePathContinue_C72E ; CPU:$C725 PRG:0725 F0 07
INC $82 ; CPU:$C727 PRG:0727 E6 82
LDA $82 ; CPU:$C729 PRG:0729 A5 82
LSR A ; CPU:$C72B PRG:072B 4A
STA $83 ; CPU:$C72C PRG:072C 85 83
CorePathContinue_C72E:
LDA #$01 ; CPU:$C72E PRG:072E A9 01
STA $00 ; CPU:$C730 PRG:0730 85 00
LDA #$03 ; CPU:$C732 PRG:0732 A9 03
STA $01 ; CPU:$C734 PRG:0734 85 01
JSR ProcessResourceStateRoutine_F40C ; CPU:$C736 PRG:0736 20 0C F4
RTS ; CPU:$C739 PRG:0739 60
CorePathOnZero_C73A:
JMP RunGameTaskDispatch_C772 ; CPU:$C73A PRG:073A 4C 72 C7
CorePathOnZero_C73D:
JMP RunGameTaskDispatch_C7AD ; CPU:$C73D PRG:073D 4C AD C7
CorePathOnZero_C740:
LDA #$01 ; CPU:$C740 PRG:0740 A9 01
STA $0480 ; CPU:$C742 PRG:0742 8D 80 04
STA $04A0 ; CPU:$C745 PRG:0745 8D A0 04
LDA #$46 ; CPU:$C748 PRG:0748 A9 46
STA $00 ; CPU:$C74A PRG:074A 85 00
LDA #$29 ; CPU:$C74C PRG:074C A9 29
STA $01 ; CPU:$C74E PRG:074E 85 01
LDA #$1B ; CPU:$C750 PRG:0750 A9 1B
STA $02 ; CPU:$C752 PRG:0752 85 02
LDA #$C5 ; CPU:$C754 PRG:0754 A9 C5
STA $03 ; CPU:$C756 PRG:0756 85 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$C758 PRG:0758 20 A1 F3
LDX $4C ; CPU:$C75B PRG:075B A6 4C
BEQ CorePathOnZero_C76A ; CPU:$C75D PRG:075D F0 0B
LDA #$06 ; CPU:$C75F PRG:075F A9 06
STA $00 ; CPU:$C761 PRG:0761 85 00
LDA #$2B ; CPU:$C763 PRG:0763 A9 2B
STA $01 ; CPU:$C765 PRG:0765 85 01
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$C767 PRG:0767 20 A1 F3
CorePathOnZero_C76A:
JSR RunGameTaskRoutine_C81A ; CPU:$C76A PRG:076A 20 1A C8
LDA #$20 ; CPU:$C76D PRG:076D A9 20
JMP RunGameTaskDispatch_C7EA ; CPU:$C76F PRG:076F 4C EA C7
RunGameTaskDispatch_C772:
LDA $D4 ; CPU:$C772 PRG:0772 A5 D4
BNE CorePathOnNonZero_C77A ; CPU:$C774 PRG:0774 D0 04
LDA $D5 ; CPU:$C776 PRG:0776 A5 D5
BEQ RunGameTaskDispatch_C7E5 ; CPU:$C778 PRG:0778 F0 6B
CorePathOnNonZero_C77A:
LDX #$01 ; CPU:$C77A PRG:077A A2 01
CorePathLoop_C77C:
STX $0F ; CPU:$C77C PRG:077C 86 0F
LDA $D4,X ; CPU:$C77E PRG:077E B5 D4
BEQ RunGameTaskDispatch_C78B ; CPU:$C780 PRG:0780 F0 09
BMI CorePathOnNegative_C79B ; CPU:$C782 PRG:0782 30 17
DEC $D4,X ; CPU:$C784 PRG:0784 D6 D4
LDA #$01 ; CPU:$C786 PRG:0786 A9 01
JSR RunGameTaskRoutine_C830 ; CPU:$C788 PRG:0788 20 30 C8
RunGameTaskDispatch_C78B:
LDX $0F ; CPU:$C78B PRG:078B A6 0F
DEX ; CPU:$C78D PRG:078D CA
BPL CorePathLoop_C77C ; CPU:$C78E PRG:078E 10 EC
JSR RunGameTaskRoutine_C7EF ; CPU:$C790 PRG:0790 20 EF C7
JSR RunGameTaskRoutine_C824 ; CPU:$C793 PRG:0793 20 24 C8
LDA #$05 ; CPU:$C796 PRG:0796 A9 05
JMP RunGameTaskDispatch_C80B ; CPU:$C798 PRG:0798 4C 0B C8
CorePathOnNegative_C79B:
INC $D4,X ; CPU:$C79B PRG:079B F6 D4
LDA #$01 ; CPU:$C79D PRG:079D A9 01
STA $00 ; CPU:$C79F PRG:079F 85 00
INX ; CPU:$C7A1 PRG:07A1 E8
INX ; CPU:$C7A2 PRG:07A2 E8
INX ; CPU:$C7A3 PRG:07A3 E8
INX ; CPU:$C7A4 PRG:07A4 E8
STX $01 ; CPU:$C7A5 PRG:07A5 86 01
JSR ProcessResourceStateRoutine_F408 ; CPU:$C7A7 PRG:07A7 20 08 F4
JMP RunGameTaskDispatch_C78B ; CPU:$C7AA PRG:07AA 4C 8B C7
RunGameTaskDispatch_C7AD:
LDX $AE ; CPU:$C7AD PRG:07AD A6 AE
BEQ CorePathOnZero_C7DD ; CPU:$C7AF PRG:07AF F0 2C
DEX ; CPU:$C7B1 PRG:07B1 CA
LDA $FFF8,X ; CPU:$C7B2 PRG:07B2 BD F8 FF
STA $00 ; CPU:$C7B5 PRG:07B5 85 00
LDA $C52B,X ; CPU:$C7B7 PRG:07B7 BD 2B C5
STA $01 ; CPU:$C7BA PRG:07BA 85 01
LDA #$1E ; CPU:$C7BC PRG:07BC A9 1E
STA $02 ; CPU:$C7BE PRG:07BE 85 02
LDA #$C5 ; CPU:$C7C0 PRG:07C0 A9 C5
STA $03 ; CPU:$C7C2 PRG:07C2 85 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$C7C4 PRG:07C4 20 A1 F3
DEC $AE ; CPU:$C7C7 PRG:07C7 C6 AE
LDA $AE ; CPU:$C7C9 PRG:07C9 A5 AE
ORA #$08 ; CPU:$C7CB PRG:07CB 09 08
STA $01 ; CPU:$C7CD PRG:07CD 85 01
LDA #$20 ; CPU:$C7CF PRG:07CF A9 20
STA $00 ; CPU:$C7D1 PRG:07D1 85 00
JSR ProcessResourceStateRoutine_F40C ; CPU:$C7D3 PRG:07D3 20 0C F4
JSR RunGameTaskRoutine_C7EF ; CPU:$C7D6 PRG:07D6 20 EF C7
LDA #$02 ; CPU:$C7D9 PRG:07D9 A9 02
STA $FE ; CPU:$C7DB PRG:07DB 85 FE
CorePathOnZero_C7DD:
JSR RunGameTaskRoutine_C809 ; CPU:$C7DD PRG:07DD 20 09 C8
LDA #$FF ; CPU:$C7E0 PRG:07E0 A9 FF
JMP RunGameTaskDispatch_C7EA ; CPU:$C7E2 PRG:07E2 4C EA C7
RunGameTaskDispatch_C7E5:
JSR RunGameTaskRoutine_C816 ; CPU:$C7E5 PRG:07E5 20 16 C8
RunGameTaskDispatch_C7E8:
LDA #$20 ; CPU:$C7E8 PRG:07E8 A9 20
RunGameTaskDispatch_C7EA:
STA $51 ; CPU:$C7EA PRG:07EA 85 51
INC $AC ; CPU:$C7EC PRG:07EC E6 AC
RTS ; CPU:$C7EE PRG:07EE 60
;------------------------------------------------------------
; RunGameTaskRoutine_C7EF
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C7EF:
LDA #$01 ; CPU:$C7EF PRG:07EF A9 01
STA $FE ; CPU:$C7F1 PRG:07F1 85 FE
;------------------------------------------------------------
; RunGameTaskRoutine_C7F3
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C7F3:
LDA #$F9 ; CPU:$C7F3 PRG:07F3 A9 F9
STA $00 ; CPU:$C7F5 PRG:07F5 85 00
JSR ProcessResourceStateRoutine_F500 ; CPU:$C7F7 PRG:07F7 20 00 F5
LDA #$0F ; CPU:$C7FA PRG:07FA A9 0F
JSR ProcessResourceStateRoutine_F31A ; CPU:$C7FC PRG:07FC 20 1A F3
LDX $4C ; CPU:$C7FF PRG:07FF A6 4C
BEQ CorePathOnZero_C808 ; CPU:$C801 PRG:0801 F0 05
LDA #$81 ; CPU:$C803 PRG:0803 A9 81
JSR ProcessResourceStateRoutine_F31A ; CPU:$C805 PRG:0805 20 1A F3
CorePathOnZero_C808:
RTS ; CPU:$C808 PRG:0808 60
;------------------------------------------------------------
; RunGameTaskRoutine_C809
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C809:
LDA #$04 ; CPU:$C809 PRG:0809 A9 04
RunGameTaskDispatch_C80B:
STA $51 ; CPU:$C80B PRG:080B 85 51
LDA #$01 ; CPU:$C80D PRG:080D A9 01
CorePathLoop_C80F:
STA $0405 ; CPU:$C80F PRG:080F 8D 05 04
STA $0445 ; CPU:$C812 PRG:0812 8D 45 04
RTS ; CPU:$C815 PRG:0815 60
;------------------------------------------------------------
; RunGameTaskRoutine_C816
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C816:
LDA #$00 ; CPU:$C816 PRG:0816 A9 00
BEQ CorePathLoop_C80F ; CPU:$C818 PRG:0818 F0 F5
;------------------------------------------------------------
; RunGameTaskRoutine_C81A
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C81A:
LDY #$07 ; CPU:$C81A PRG:081A A0 07
LDA #$00 ; CPU:$C81C PRG:081C A9 00
CorePathLoop_C81E:
STA a:$0034,Y ; CPU:$C81E PRG:081E 99 34 00
DEY ; CPU:$C821 PRG:0821 88
BPL CorePathLoop_C81E ; CPU:$C822 PRG:0822 10 FA
;------------------------------------------------------------
; RunGameTaskRoutine_C824
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C824:
LDA #$48 ; CPU:$C824 PRG:0824 A9 48
LDX $4C ; CPU:$C826 PRG:0826 A6 4C
BEQ CorePathOnZero_C82C ; CPU:$C828 PRG:0828 F0 02
LDA #$45 ; CPU:$C82A PRG:082A A9 45
CorePathOnZero_C82C:
JSR ProcessResourceStateRoutine_F31A ; CPU:$C82C PRG:082C 20 1A F3
RTS ; CPU:$C82F PRG:082F 60
;------------------------------------------------------------
; RunGameTaskRoutine_C830
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C830:
PHA ; CPU:$C830 PRG:0830 48
INX ; CPU:$C831 PRG:0831 E8
INX ; CPU:$C832 PRG:0832 E8
INX ; CPU:$C833 PRG:0833 E8
INX ; CPU:$C834 PRG:0834 E8
STX $01 ; CPU:$C835 PRG:0835 86 01
LDA #$01 ; CPU:$C837 PRG:0837 A9 01
STA $00 ; CPU:$C839 PRG:0839 85 00
JSR ProcessResourceStateRoutine_F40C ; CPU:$C83B PRG:083B 20 0C F4
PLA ; CPU:$C83E PRG:083E 68
STA $00 ; CPU:$C83F PRG:083F 85 00
LDA #$08 ; CPU:$C841 PRG:0841 A9 08
ORA $0F ; CPU:$C843 PRG:0843 05 0F
STA $01 ; CPU:$C845 PRG:0845 85 01
JSR ProcessResourceStateRoutine_F40C ; CPU:$C847 PRG:0847 20 0C F4
RTS ; CPU:$C84A PRG:084A 60
;------------------------------------------------------------
; RunGameTaskRoutine_C84B
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C84B:
LDA #$05 ; CPU:$C84B PRG:084B A9 05
STA $01 ; CPU:$C84D PRG:084D 85 01
LDY #$13 ; CPU:$C84F PRG:084F A0 13
CorePathLoop_C851:
TYA ; CPU:$C851 PRG:0851 98
AND #$FC ; CPU:$C852 PRG:0852 29 FC
STA $0720,Y ; CPU:$C854 PRG:0854 99 20 07
DEY ; CPU:$C857 PRG:0857 88
BPL CorePathLoop_C851 ; CPU:$C858 PRG:0858 10 F7
LDA #$20 ; CPU:$C85A PRG:085A A9 20
STA $04 ; CPU:$C85C PRG:085C 85 04
LDA #$07 ; CPU:$C85E PRG:085E A9 07
STA $05 ; CPU:$C860 PRG:0860 85 05
CorePathLoop_C862:
LDA $10 ; CPU:$C862 PRG:0862 A5 10
AND #$03 ; CPU:$C864 PRG:0864 29 03
LDY #$03 ; CPU:$C866 PRG:0866 A0 03
ORA ($04),Y ; CPU:$C868 PRG:0868 11 04
CorePathLoop_C86A:
STA ($04),Y ; CPU:$C86A PRG:086A 91 04
DEY ; CPU:$C86C PRG:086C 88
BPL CorePathLoop_C86A ; CPU:$C86D PRG:086D 10 FB
LDX #$02 ; CPU:$C86F PRG:086F A2 02
STX $03 ; CPU:$C871 PRG:0871 86 03
CorePathLoop_C873:
LDY $14 ; CPU:$C873 PRG:0873 A4 14
CorePathLoop_C875:
JSR EnginePath_F58D ; CPU:$C875 PRG:0875 20 8D F5
DEY ; CPU:$C878 PRG:0878 88
BNE CorePathLoop_C875 ; CPU:$C879 PRG:0879 D0 FA
LDA $11 ; CPU:$C87B PRG:087B A5 11
AND #$03 ; CPU:$C87D PRG:087D 29 03
STA $02 ; CPU:$C87F PRG:087F 85 02
LDY #$03 ; CPU:$C881 PRG:0881 A0 03
LDA ($04),Y ; CPU:$C883 PRG:0883 B1 04
AND #$FC ; CPU:$C885 PRG:0885 29 FC
ORA $02 ; CPU:$C887 PRG:0887 05 02
CorePathLoop_C889:
CMP ($04),Y ; CPU:$C889 PRG:0889 D1 04
BEQ CorePathLoop_C873 ; CPU:$C88B PRG:088B F0 E6
DEY ; CPU:$C88D PRG:088D 88
BPL CorePathLoop_C889 ; CPU:$C88E PRG:088E 10 F9
LDY $03 ; CPU:$C890 PRG:0890 A4 03
STA ($04),Y ; CPU:$C892 PRG:0892 91 04
DEC $03 ; CPU:$C894 PRG:0894 C6 03
BPL CorePathLoop_C873 ; CPU:$C896 PRG:0896 10 DB
CLC ; CPU:$C898 PRG:0898 18
LDA #$04 ; CPU:$C899 PRG:0899 A9 04
ADC $04 ; CPU:$C89B PRG:089B 65 04
STA $04 ; CPU:$C89D PRG:089D 85 04
LDA #$00 ; CPU:$C89F PRG:089F A9 00
ADC $05 ; CPU:$C8A1 PRG:08A1 65 05
STA $05 ; CPU:$C8A3 PRG:08A3 85 05
DEC $01 ; CPU:$C8A5 PRG:08A5 C6 01
BNE CorePathLoop_C862 ; CPU:$C8A7 PRG:08A7 D0 B9
RTS ; CPU:$C8A9 PRG:08A9 60
;------------------------------------------------------------
; RunGameTaskRoutine_C8AA
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C8AA:
LDA $85 ; CPU:$C8AA PRG:08AA A5 85
ASL A ; CPU:$C8AC PRG:08AC 0A
TAX ; CPU:$C8AD PRG:08AD AA
LDA $C008,X ; CPU:$C8AE PRG:08AE BD 08 C0
STA $04 ; CPU:$C8B1 PRG:08B1 85 04
LDA $C009,X ; CPU:$C8B3 PRG:08B3 BD 09 C0
STA $05 ; CPU:$C8B6 PRG:08B6 85 05
RTS ; CPU:$C8B8 PRG:08B8 60
;------------------------------------------------------------
; RunGameTaskRoutine_C8B9
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C8B9:
LDY #$10 ; CPU:$C8B9 PRG:08B9 A0 10
LDX $83 ; CPU:$C8BB PRG:08BB A6 83
LDA $C0D1,X ; CPU:$C8BD PRG:08BD BD D1 C0
STA $0F ; CPU:$C8C0 PRG:08C0 85 0F
LDA #$80 ; CPU:$C8C2 PRG:08C2 A9 80
STA $00 ; CPU:$C8C4 PRG:08C4 85 00
LDA #$04 ; CPU:$C8C6 PRG:08C6 A9 04
STA $01 ; CPU:$C8C8 PRG:08C8 85 01
CorePathLoop_C8CA:
LDA #$01 ; CPU:$C8CA PRG:08CA A9 01
STA ($00),Y ; CPU:$C8CC PRG:08CC 91 00
LDX #$00 ; CPU:$C8CE PRG:08CE A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$C8D0 PRG:08D0 20 D3 CB
BNE CorePathLoop_C8CA ; CPU:$C8D3 PRG:08D3 D0 F5
RTS ; CPU:$C8D5 PRG:08D5 60
;------------------------------------------------------------
; RunGameTaskRoutine_C8D6
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C8D6:
JSR RunGameTaskRoutine_C463 ; CPU:$C8D6 PRG:08D6 20 63 C4
LDY #$0F ; CPU:$C8D9 PRG:08D9 A0 0F
LDA $4C ; CPU:$C8DB PRG:08DB A5 4C
BNE CorePathLoop_C8E1 ; CPU:$C8DD PRG:08DD D0 02
LDY #$07 ; CPU:$C8DF PRG:08DF A0 07
CorePathLoop_C8E1:
LDA $C0A1,Y ; CPU:$C8E1 PRG:08E1 B9 A1 C0
STA $02E0,Y ; CPU:$C8E4 PRG:08E4 99 E0 02
DEY ; CPU:$C8E7 PRG:08E7 88
BPL CorePathLoop_C8E1 ; CPU:$C8E8 PRG:08E8 10 F7
RTS ; CPU:$C8EA PRG:08EA 60
.byte $1C, $34, $4C, $64, $94, $AC, $C4, $DC, $20, $38, $50, $68, $80, $98, $B0, $C8 ; CPU:$C8EB PRG:08EB 0B
;------------------------------------------------------------
; RunGameTaskRoutine_C8FB
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_C8FB:
LDA #$07 ; CPU:$C8FB PRG:08FB A9 07
STA $0E ; CPU:$C8FD PRG:08FD 85 0E
LDA #$00 ; CPU:$C8FF PRG:08FF A9 00
STA $04 ; CPU:$C901 PRG:0901 85 04
LDA #$06 ; CPU:$C903 PRG:0903 A9 06
STA $05 ; CPU:$C905 PRG:0905 85 05
CorePathLoop_C907:
LDA $16 ; CPU:$C907 PRG:0907 A5 16
AND #$07 ; CPU:$C909 PRG:0909 29 07
TAX ; CPU:$C90B PRG:090B AA
LDA $C8EB,X ; CPU:$C90C PRG:090C BD EB C8
STA $01 ; CPU:$C90F PRG:090F 85 01
LDA $17 ; CPU:$C911 PRG:0911 A5 17
AND #$07 ; CPU:$C913 PRG:0913 29 07
TAX ; CPU:$C915 PRG:0915 AA
LDA $C8F3,X ; CPU:$C916 PRG:0916 BD F3 C8
STA $00 ; CPU:$C919 PRG:0919 85 00
JSR UpdateObjectBufferRoutine_E0DF ; CPU:$C91B PRG:091B 20 DF E0
LDA #$00 ; CPU:$C91E PRG:091E A9 00
JSR ProcessObjectStateRoutine_E0B2 ; CPU:$C920 PRG:0920 20 B2 E0
JSR ObjectPath_E113 ; CPU:$C923 PRG:0923 20 13 E1
LDA #$00 ; CPU:$C926 PRG:0926 A9 00
JSR ProcessObjectStateRoutine_E0B2 ; CPU:$C928 PRG:0928 20 B2 E0
CMP #$24 ; CPU:$C92B PRG:092B C9 24
BEQ CorePathContinue_C941 ; CPU:$C92D PRG:092D F0 12
CMP #$4E ; CPU:$C92F PRG:092F C9 4E
BCS CorePathLoop_C937 ; CPU:$C931 PRG:0931 B0 04
CMP #$49 ; CPU:$C933 PRG:0933 C9 49
BCS CorePathContinue_C941 ; CPU:$C935 PRG:0935 B0 0A
CorePathLoop_C937:
LDX $10 ; CPU:$C937 PRG:0937 A6 10
CorePathLoop_C939:
JSR EnginePath_F58D ; CPU:$C939 PRG:0939 20 8D F5
DEX ; CPU:$C93C PRG:093C CA
BNE CorePathLoop_C939 ; CPU:$C93D PRG:093D D0 FA
BEQ CorePathLoop_C907 ; CPU:$C93F PRG:093F F0 C6
CorePathContinue_C941:
LDA #$07 ; CPU:$C941 PRG:0941 A9 07
STA $0F ; CPU:$C943 PRG:0943 85 0F
LDA #$00 ; CPU:$C945 PRG:0945 A9 00
STA $06 ; CPU:$C947 PRG:0947 85 06
LDA #$06 ; CPU:$C949 PRG:0949 A9 06
STA $07 ; CPU:$C94B PRG:094B 85 07
CorePathLoop_C94D:
LDY #$01 ; CPU:$C94D PRG:094D A0 01
LDA ($06),Y ; CPU:$C94F PRG:094F B1 06
CMP $00 ; CPU:$C951 PRG:0951 C5 00
BNE CorePathOnNonZero_C95D ; CPU:$C953 PRG:0953 D0 08
LDY #$03 ; CPU:$C955 PRG:0955 A0 03
LDA ($06),Y ; CPU:$C957 PRG:0957 B1 06
CMP $01 ; CPU:$C959 PRG:0959 C5 01
BEQ CorePathLoop_C937 ; CPU:$C95B PRG:095B F0 DA
CorePathOnNonZero_C95D:
LDX #$06 ; CPU:$C95D PRG:095D A2 06
JSR RunGameTaskRoutine_CBD3 ; CPU:$C95F PRG:095F 20 D3 CB
BPL CorePathLoop_C94D ; CPU:$C962 PRG:0962 10 E9
LDY #$01 ; CPU:$C964 PRG:0964 A0 01
LDA #$00 ; CPU:$C966 PRG:0966 A9 00
LDX $8F ; CPU:$C968 PRG:0968 A6 8F
BNE CorePathContinue_C974 ; CPU:$C96A PRG:096A D0 08
LDX $11 ; CPU:$C96C PRG:096C A6 11
CPX #$3C ; CPU:$C96E PRG:096E E0 3C
BCS CorePathContinue_C974 ; CPU:$C970 PRG:0970 B0 02
LDA WorkPtr0Lo ; CPU:$C972 PRG:0972 A5 00
CorePathContinue_C974:
STA ($04),Y ; CPU:$C974 PRG:0974 91 04
LDA ($04),Y ; CPU:$C976 PRG:0976 B1 04
BEQ CorePathContinue_C986 ; CPU:$C978 PRG:0978 F0 0C
LDX $12 ; CPU:$C97A PRG:097A A6 12
CPX #$40 ; CPU:$C97C PRG:097C E0 40
BCS CorePathContinue_C986 ; CPU:$C97E PRG:097E B0 06
LDY #$10 ; CPU:$C980 PRG:0980 A0 10
LDA #$01 ; CPU:$C982 PRG:0982 A9 01
STA ($04),Y ; CPU:$C984 PRG:0984 91 04
CorePathContinue_C986:
LDY #$03 ; CPU:$C986 PRG:0986 A0 03
LDA WorkPtr0Hi ; CPU:$C988 PRG:0988 A5 01
STA ($04),Y ; CPU:$C98A PRG:098A 91 04
LDX #$04 ; CPU:$C98C PRG:098C A2 04
JSR RunGameTaskRoutine_CBD3 ; CPU:$C98E PRG:098E 20 D3 CB
DEC $0E ; CPU:$C991 PRG:0991 C6 0E
BPL CorePathLoop_C937 ; CPU:$C993 PRG:0993 10 A2
RTS ; CPU:$C995 PRG:0995 60
;------------------------------------------------------------
; UpdateGameStateRoutine_C996
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateGameStateRoutine_C996:
LDA $8B ; CPU:$C996 PRG:0996 A5 8B
BNE UpdateGameStateOnNonZero_C99B ; CPU:$C998 PRG:0998 D0 01
RTS ; CPU:$C99A PRG:099A 60
UpdateGameStateOnNonZero_C99B:
DEC $8B ; CPU:$C99B PRG:099B C6 8B
BEQ CorePathOnZero_C9DA ; CPU:$C99D PRG:099D F0 3B
LDA #$24 ; CPU:$C99F PRG:099F A9 24
STA $00 ; CPU:$C9A1 PRG:09A1 85 00
LDA #$01 ; CPU:$C9A3 PRG:09A3 A9 01
STA $01 ; CPU:$C9A5 PRG:09A5 85 01
JSR ProcessResourceStateRoutine_F257 ; CPU:$C9A7 PRG:09A7 20 57 F2
LDA #$03 ; CPU:$C9AA PRG:09AA A9 03
STA $01 ; CPU:$C9AC PRG:09AC 85 01
JSR ProcessResourceStateRoutine_F257 ; CPU:$C9AE PRG:09AE 20 57 F2
LDY #$1C ; CPU:$C9B1 PRG:09B1 A0 1C
LDA $4C ; CPU:$C9B3 PRG:09B3 A5 4C
BEQ UpdateGameStateOnZero_C9B8 ; CPU:$C9B5 PRG:09B5 F0 01
INY ; CPU:$C9B7 PRG:09B7 C8
UpdateGameStateOnZero_C9B8:
STY $85 ; CPU:$C9B8 PRG:09B8 84 85
JSR RunGameTaskRoutine_CB8C ; CPU:$C9BA PRG:09BA 20 8C CB
LDA #$1B ; CPU:$C9BD PRG:09BD A9 1B
LDX #$14 ; CPU:$C9BF PRG:09BF A2 14
LDY $8A ; CPU:$C9C1 PRG:09C1 A4 8A
BEQ CorePathOnZero_C9D3 ; CPU:$C9C3 PRG:09C3 F0 0E
LDA $87 ; CPU:$C9C5 PRG:09C5 A5 87
CLC ; CPU:$C9C7 PRG:09C7 18
ADC #$15 ; CPU:$C9C8 PRG:09C8 69 15
CMP #$1A ; CPU:$C9CA PRG:09CA C9 1A
BEQ CorePathOnZero_C9D3 ; CPU:$C9CC PRG:09CC F0 05
LDY $89 ; CPU:$C9CE PRG:09CE A4 89
LDX $0720,Y ; CPU:$C9D0 PRG:09D0 BE 20 07
CorePathOnZero_C9D3:
STA $85 ; CPU:$C9D3 PRG:09D3 85 85
STX $86 ; CPU:$C9D5 PRG:09D5 86 86
JMP RunGameTaskDispatch_CB87 ; CPU:$C9D7 PRG:09D7 4C 87 CB
CorePathOnZero_C9DA:
JSR RunGameTaskRoutine_CB8C ; CPU:$C9DA PRG:09DA 20 8C CB
LDA $86 ; CPU:$C9DD PRG:09DD A5 86
ASL A ; CPU:$C9DF PRG:09DF 0A
TAX ; CPU:$C9E0 PRG:09E0 AA
LDA $C008,X ; CPU:$C9E1 PRG:09E1 BD 08 C0
STA $00 ; CPU:$C9E4 PRG:09E4 85 00
LDA $C009,X ; CPU:$C9E6 PRG:09E6 BD 09 C0
STA $01 ; CPU:$C9E9 PRG:09E9 85 01
JSR ObjectPath_DF2F ; CPU:$C9EB PRG:09EB 20 2F DF
LDA $85 ; CPU:$C9EE PRG:09EE A5 85
CMP #$1B ; CPU:$C9F0 PRG:09F0 C9 1B
BEQ CorePathOnZero_CA09 ; CPU:$C9F2 PRG:09F2 F0 15
JSR ProcessObjectStateRoutine_D211 ; CPU:$C9F4 PRG:09F4 20 11 D2
JSR ProcessObjectStateRoutine_D211 ; CPU:$C9F7 PRG:09F7 20 11 D2
JSR ProcessObjectStateRoutine_D211 ; CPU:$C9FA PRG:09FA 20 11 D2
JSR ProcessObjectStateRoutine_D211 ; CPU:$C9FD PRG:09FD 20 11 D2
JSR ResourceAndLevelData ; CPU:$CA00 PRG:0A00 20 0B F2
JSR ObjectPath_DE15 ; CPU:$CA03 PRG:0A03 20 15 DE
JSR UpdateObjectBuffer_DF5E ; CPU:$CA06 PRG:0A06 20 5E DF
CorePathOnZero_CA09:
LDY #$06 ; CPU:$CA09 PRG:0A09 A0 06
LDX #$04 ; CPU:$CA0B PRG:0A0B A2 04
JSR RunGameTaskRoutine_CBA6 ; CPU:$CA0D PRG:0A0D 20 A6 CB
LDY #$02 ; CPU:$CA10 PRG:0A10 A0 02
LDX #$01 ; CPU:$CA12 PRG:0A12 A2 01
LDA #$F4 ; CPU:$CA14 PRG:0A14 A9 F4
JSR RunGameTaskRoutine_CBA8 ; CPU:$CA16 PRG:0A16 20 A8 CB
LDY #$50 ; CPU:$CA19 PRG:0A19 A0 50
LDA #$00 ; CPU:$CA1B PRG:0A1B A9 00
CorePathLoop_CA1D:
STA a:$009F,Y ; CPU:$CA1D PRG:0A1D 99 9F 00
DEY ; CPU:$CA20 PRG:0A20 88
BNE CorePathLoop_CA1D ; CPU:$CA21 PRG:0A21 D0 FA
LDY #$28 ; CPU:$CA23 PRG:0A23 A0 28
UpdateGameStateLoop_CA25:
STA a:$0053,Y ; CPU:$CA25 PRG:0A25 99 53 00
DEY ; CPU:$CA28 PRG:0A28 88
BNE UpdateGameStateLoop_CA25 ; CPU:$CA29 PRG:0A29 D0 FA
LDA $40 ; CPU:$CA2B PRG:0A2B A5 40
ORA #$02 ; CPU:$CA2D PRG:0A2D 09 02
STA $40 ; CPU:$CA2F PRG:0A2F 85 40
LDA #$EF ; CPU:$CA31 PRG:0A31 A9 EF
STA $43 ; CPU:$CA33 PRG:0A33 85 43
LDA $8A ; CPU:$CA35 PRG:0A35 A5 8A
BNE CorePathOnNonZero_CA4D ; CPU:$CA37 PRG:0A37 D0 14
LDA #$90 ; CPU:$CA39 PRG:0A39 A9 90
LDX #$C0 ; CPU:$CA3B PRG:0A3B A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$CA3D PRG:0A3D 20 7D F7
LDA #$0F ; CPU:$CA40 PRG:0A40 A9 0F
JSR ProcessResourceStateRoutine_F31A ; CPU:$CA42 PRG:0A42 20 1A F3
LDA #$81 ; CPU:$CA45 PRG:0A45 A9 81
JSR ProcessResourceStateRoutine_F31A ; CPU:$CA47 PRG:0A47 20 1A F3
JMP RunGameTaskDispatch_CB87 ; CPU:$CA4A PRG:0A4A 4C 87 CB
CorePathOnNonZero_CA4D:
LDY $86 ; CPU:$CA4D PRG:0A4D A4 86
LDA $C044,Y ; CPU:$CA4F PRG:0A4F B9 44 C0
STA $3F ; CPU:$CA52 PRG:0A52 85 3F
LDA #$FA ; CPU:$CA54 PRG:0A54 A9 FA
LDX #$C0 ; CPU:$CA56 PRG:0A56 A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$CA58 PRG:0A58 20 7D F7
LDA #$E5 ; CPU:$CA5B PRG:0A5B A9 E5
LDX #$C0 ; CPU:$CA5D PRG:0A5D A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$CA5F PRG:0A5F 20 7D F7
LDA #$F2 ; CPU:$CA62 PRG:0A62 A9 F2
STA $0437 ; CPU:$CA64 PRG:0A64 8D 37 04
STA $0477 ; CPU:$CA67 PRG:0A67 8D 77 04
LDA #$01 ; CPU:$CA6A PRG:0A6A A9 01
STA $0449 ; CPU:$CA6C PRG:0A6C 8D 49 04
STA $0469 ; CPU:$CA6F PRG:0A6F 8D 69 04
STA $0479 ; CPU:$CA72 PRG:0A72 8D 79 04
LDA #$D8 ; CPU:$CA75 PRG:0A75 A9 D8
STA $043B ; CPU:$CA77 PRG:0A77 8D 3B 04
LDA #$14 ; CPU:$CA7A PRG:0A7A A9 14
STA $044B ; CPU:$CA7C PRG:0A7C 8D 4B 04
LDA #$24 ; CPU:$CA7F PRG:0A7F A9 24
STA $046B ; CPU:$CA81 PRG:0A81 8D 6B 04
LDA #$DC ; CPU:$CA84 PRG:0A84 A9 DC
STA $047B ; CPU:$CA86 PRG:0A86 8D 7B 04
LDA #$0B ; CPU:$CA89 PRG:0A89 A9 0B
LDX #$C1 ; CPU:$CA8B PRG:0A8B A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CA8D PRG:0A8D 20 7D F7
LDA #$70 ; CPU:$CA90 PRG:0A90 A9 70
STA $052B ; CPU:$CA92 PRG:0A92 8D 2B 05
LDA #$78 ; CPU:$CA95 PRG:0A95 A9 78
STA $054B ; CPU:$CA97 PRG:0A97 8D 4B 05
LDA #$80 ; CPU:$CA9A PRG:0A9A A9 80
STA $056B ; CPU:$CA9C PRG:0A9C 8D 6B 05
LDA #$88 ; CPU:$CA9F PRG:0A9F A9 88
STA $058B ; CPU:$CAA1 PRG:0AA1 8D 8B 05
LDA #$90 ; CPU:$CAA4 PRG:0AA4 A9 90
STA $05AB ; CPU:$CAA6 PRG:0AA6 8D AB 05
LDA #$98 ; CPU:$CAA9 PRG:0AA9 A9 98
STA $05CB ; CPU:$CAAB PRG:0AAB 8D CB 05
LDA #$A0 ; CPU:$CAAE PRG:0AAE A9 A0
STA $05EB ; CPU:$CAB0 PRG:0AB0 8D EB 05
LDA #$21 ; CPU:$CAB3 PRG:0AB3 A9 21
LDX #$C1 ; CPU:$CAB5 PRG:0AB5 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CAB7 PRG:0AB7 20 7D F7
LDA #$38 ; CPU:$CABA PRG:0ABA A9 38
STA $04AB ; CPU:$CABC PRG:0ABC 8D AB 04
LDA #$48 ; CPU:$CABF PRG:0ABF A9 48
STA $04CB ; CPU:$CAC1 PRG:0AC1 8D CB 04
LDA #$58 ; CPU:$CAC4 PRG:0AC4 A9 58
STA $04EB ; CPU:$CAC6 PRG:0AC6 8D EB 04
LDA #$42 ; CPU:$CAC9 PRG:0AC9 A9 42
LDX #$C1 ; CPU:$CACB PRG:0ACB A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CACD PRG:0ACD 20 7D F7
LDX #$05 ; CPU:$CAD0 PRG:0AD0 A2 05
LDY #$07 ; CPU:$CAD2 PRG:0AD2 A0 07
CorePathLoop_CAD4:
TYA ; CPU:$CAD4 PRG:0AD4 98
STA $0600,X ; CPU:$CAD5 PRG:0AD5 9D 00 06
TXA ; CPU:$CAD8 PRG:0AD8 8A
CLC ; CPU:$CAD9 PRG:0AD9 18
ADC #$20 ; CPU:$CADA PRG:0ADA 69 20
TAX ; CPU:$CADC PRG:0ADC AA
DEY ; CPU:$CADD PRG:0ADD 88
BNE CorePathLoop_CAD4 ; CPU:$CADE PRG:0ADE D0 F4
LDA #$01 ; CPU:$CAE0 PRG:0AE0 A9 01
STA $0629 ; CPU:$CAE2 PRG:0AE2 8D 29 06
STA $0649 ; CPU:$CAE5 PRG:0AE5 8D 49 06
STA $06E9 ; CPU:$CAE8 PRG:0AE8 8D E9 06
JSR RunGameTaskRoutine_C8FB ; CPU:$CAEB PRG:0AEB 20 FB C8
LDA #$58 ; CPU:$CAEE PRG:0AEE A9 58
LDX #$C1 ; CPU:$CAF0 PRG:0AF0 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CAF2 PRG:0AF2 20 7D F7
LDA #$C8 ; CPU:$CAF5 PRG:0AF5 A9 C8
STA $03DB ; CPU:$CAF7 PRG:0AF7 8D DB 03
LDA #$D0 ; CPU:$CAFA PRG:0AFA A9 D0
STA $03EB ; CPU:$CAFC PRG:0AFC 8D EB 03
LDA #$37 ; CPU:$CAFF PRG:0AFF A9 37
LDX #$C1 ; CPU:$CB01 PRG:0B01 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CB03 PRG:0B03 20 7D F7
LDA #$01 ; CPU:$CB06 PRG:0B06 A9 01
STA $8A ; CPU:$CB08 PRG:0B08 85 8A
LDA #$02 ; CPU:$CB0A PRG:0B0A A9 02
LDY $8F ; CPU:$CB0C PRG:0B0C A4 8F
BNE UpdateGameStateOnNonZero_CB15 ; CPU:$CB0E PRG:0B0E D0 05
LDA #$08 ; CPU:$CB10 PRG:0B10 A9 08
SEC ; CPU:$CB12 PRG:0B12 38
SBC $83 ; CPU:$CB13 PRG:0B13 E5 83
UpdateGameStateOnNonZero_CB15:
STA $2E ; CPU:$CB15 PRG:0B15 85 2E
SEC ; CPU:$CB17 PRG:0B17 38
SBC #$03 ; CPU:$CB18 PRG:0B18 E9 03
STA $A8 ; CPU:$CB1A PRG:0B1A 85 A8
LDA #$00 ; CPU:$CB1C PRG:0B1C A9 00
STA $2F ; CPU:$CB1E PRG:0B1E 85 2F
STA $2C ; CPU:$CB20 PRG:0B20 85 2C
LDA #$8A ; CPU:$CB22 PRG:0B22 A9 8A
LDX #$C1 ; CPU:$CB24 PRG:0B24 A2 C1
JSR ProcessResourceStateRoutine_F77D ; CPU:$CB26 PRG:0B26 20 7D F7
LDA #$59 ; CPU:$CB29 PRG:0B29 A9 59
LDX #$C0 ; CPU:$CB2B PRG:0B2B A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$CB2D PRG:0B2D 20 7D F7
LDA #$26 ; CPU:$CB30 PRG:0B30 A9 26
LDY $8F ; CPU:$CB32 PRG:0B32 A4 8F
BEQ UpdatePlayerStateOnZero_CB3F ; CPU:$CB34 PRG:0B34 F0 09
LDA #$7E ; CPU:$CB36 PRG:0B36 A9 7E
LDX #$C0 ; CPU:$CB38 PRG:0B38 A2 C0
JSR ProcessResourceStateRoutine_F77D ; CPU:$CB3A PRG:0B3A 20 7D F7
LDA #$28 ; CPU:$CB3D PRG:0B3D A9 28
UpdatePlayerStateOnZero_CB3F:
JSR ProcessResourceStateRoutine_F31A ; CPU:$CB3F PRG:0B3F 20 1A F3
LDX #$00 ; CPU:$CB42 PRG:0B42 A2 00
JSR ProcessObjectStateRoutine_D42C ; CPU:$CB44 PRG:0B44 20 2C D4
LDX $4C ; CPU:$CB47 PRG:0B47 A6 4C
JSR ProcessObjectStateRoutine_D42C ; CPU:$CB49 PRG:0B49 20 2C D4
LDX #$11 ; CPU:$CB4C PRG:0B4C A2 11
LDA $90 ; CPU:$CB4E PRG:0B4E A5 90
CMP #$01 ; CPU:$CB50 PRG:0B50 C9 01
BEQ UpdatePlayerStateOnZero_CB56 ; CPU:$CB52 PRG:0B52 F0 02
STX $90 ; CPU:$CB54 PRG:0B54 86 90
UpdatePlayerStateOnZero_CB56:
LDA $91 ; CPU:$CB56 PRG:0B56 A5 91
CMP #$01 ; CPU:$CB58 PRG:0B58 C9 01
BEQ UpdateGameStateOnZero_CB5E ; CPU:$CB5A PRG:0B5A F0 02
STX $91 ; CPU:$CB5C PRG:0B5C 86 91
UpdateGameStateOnZero_CB5E:
JSR RunGameTaskRoutine_C8D6 ; CPU:$CB5E PRG:0B5E 20 D6 C8
JSR RunGameTaskRoutine_C8B9 ; CPU:$CB61 PRG:0B61 20 B9 C8
LDA #$08 ; CPU:$CB64 PRG:0B64 A9 08
STA $0495 ; CPU:$CB66 PRG:0B66 8D 95 04
LDA #$18 ; CPU:$CB69 PRG:0B69 A9 18
STA $04B5 ; CPU:$CB6B PRG:0B6B 8D B5 04
LDA #$28 ; CPU:$CB6E PRG:0B6E A9 28
STA $04D5 ; CPU:$CB70 PRG:0B70 8D D5 04
LDA #$38 ; CPU:$CB73 PRG:0B73 A9 38
STA $04F5 ; CPU:$CB75 PRG:0B75 8D F5 04
LDA #$02 ; CPU:$CB78 PRG:0B78 A9 02
STA $FB ; CPU:$CB7A PRG:0B7A 85 FB
JSR UpdateGameStateRoutine_C3BC ; CPU:$CB7C PRG:0B7C 20 BC C3
LDA $8D ; CPU:$CB7F PRG:0B7F A5 8D
BNE CorePathOnNonZero_CB85 ; CPU:$CB81 PRG:0B81 D0 02
LDA #$21 ; CPU:$CB83 PRG:0B83 A9 21
CorePathOnNonZero_CB85:
STA $92 ; CPU:$CB85 PRG:0B85 85 92
RunGameTaskDispatch_CB87:
PLA ; CPU:$CB87 PRG:0B87 68
PLA ; CPU:$CB88 PRG:0B88 68
JMP NMIReadPPUStatus_C234 ; CPU:$CB89 PRG:0B89 4C 34 C2
;------------------------------------------------------------
; RunGameTaskRoutine_CB8C
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CB8C:
JSR RunGameTaskRoutine_C8AA ; CPU:$CB8C PRG:0B8C 20 AA C8
LDY #$01 ; CPU:$CB8F PRG:0B8F A0 01
LDA ($04),Y ; CPU:$CB91 PRG:0B91 B1 04
CLC ; CPU:$CB93 PRG:0B93 18
ADC $04 ; CPU:$CB94 PRG:0B94 65 04
STA $00 ; CPU:$CB96 PRG:0B96 85 00
LDA #$00 ; CPU:$CB98 PRG:0B98 A9 00
ADC $05 ; CPU:$CB9A PRG:0B9A 65 05
STA $01 ; CPU:$CB9C PRG:0B9C 85 01
JSR ProcessResourceStateDispatch_F2EA ; CPU:$CB9E PRG:0B9E 20 EA F2
INY ; CPU:$CBA1 PRG:0BA1 C8
JSR ObjectPath_DF2F ; CPU:$CBA2 PRG:0BA2 20 2F DF
RTS ; CPU:$CBA5 PRG:0BA5 60
;------------------------------------------------------------
; RunGameTaskRoutine_CBA6
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CBA6:
LDA #$00 ; CPU:$CBA6 PRG:0BA6 A9 00
;------------------------------------------------------------
; RunGameTaskRoutine_CBA8
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CBA8:
STY $01 ; CPU:$CBA8 PRG:0BA8 84 01
LDY #$00 ; CPU:$CBAA PRG:0BAA A0 00
STY $00 ; CPU:$CBAC PRG:0BAC 84 00
CorePathLoop_CBAE:
STA ($00),Y ; CPU:$CBAE PRG:0BAE 91 00
DEY ; CPU:$CBB0 PRG:0BB0 88
BNE CorePathLoop_CBAE ; CPU:$CBB1 PRG:0BB1 D0 FB
DEC $01 ; CPU:$CBB3 PRG:0BB3 C6 01
DEX ; CPU:$CBB5 PRG:0BB5 CA
BNE CorePathLoop_CBAE ; CPU:$CBB6 PRG:0BB6 D0 F6
RTS ; CPU:$CBB8 PRG:0BB8 60
;------------------------------------------------------------
; RunGameTaskRoutine_CBB9
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CBB9:
LDA #$00 ; CPU:$CBB9 PRG:0BB9 A9 00
STA $08 ; CPU:$CBBB PRG:0BBB 85 08
LDA #$04 ; CPU:$CBBD PRG:0BBD A9 04
STA $09 ; CPU:$CBBF PRG:0BBF 85 09
LDA #$00 ; CPU:$CBC1 PRG:0BC1 A9 00
STA $0A ; CPU:$CBC3 PRG:0BC3 85 0A
RTS ; CPU:$CBC5 PRG:0BC5 60
;------------------------------------------------------------
; RunGameTaskRoutine_CBC6
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CBC6:
LDA #$40 ; CPU:$CBC6 PRG:0BC6 A9 40
STA $08 ; CPU:$CBC8 PRG:0BC8 85 08
LDA #$04 ; CPU:$CBCA PRG:0BCA A9 04
STA $09 ; CPU:$CBCC PRG:0BCC 85 09
LDA #$01 ; CPU:$CBCE PRG:0BCE A9 01
STA $0A ; CPU:$CBD0 PRG:0BD0 85 0A
RTS ; CPU:$CBD2 PRG:0BD2 60
;------------------------------------------------------------
; RunGameTaskRoutine_CBD3
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
RunGameTaskRoutine_CBD3:
CLC ; CPU:$CBD3 PRG:0BD3 18
LDA #$20 ; CPU:$CBD4 PRG:0BD4 A9 20
ADC $00,X ; CPU:$CBD6 PRG:0BD6 75 00
STA $00,X ; CPU:$CBD8 PRG:0BD8 95 00
LDA #$00 ; CPU:$CBDA PRG:0BDA A9 00
ADC $01,X ; CPU:$CBDC PRG:0BDC 75 01
STA $01,X ; CPU:$CBDE PRG:0BDE 95 01
DEC $0F ; CPU:$CBE0 PRG:0BE0 C6 0F
RTS ; CPU:$CBE2 PRG:0BE2 60
;------------------------------------------------------------
; ProcessCurrentObjectRoutine_CBE3
;
; Global:
; First-pass core-game entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Game state, object pointers, and frame state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessCurrentObjectRoutine_CBE3:
LDY #$10 ; CPU:$CBE3 PRG:0BE3 A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$CBE5 PRG:0BE5 B1 08
STA $06 ; CPU:$CBE7 PRG:0BE7 85 06
LDA $06 ; CPU:$CBE9 PRG:0BE9 A5 06
BPL CorePathOnPositive_CBFA ; CPU:$CBEB PRG:0BEB 10 0D
LDX $0A ; CPU:$CBED PRG:0BED A6 0A
LDA #$00 ; CPU:$CBEF PRG:0BEF A9 00
STA $90,X ; CPU:$CBF1 PRG:0BF1 95 90
JSR UpdateObjectBufferRoutine_E468 ; CPU:$CBF3 PRG:0BF3 20 68 E4
JSR ReadObjectRecordRoutine_E539 ; CPU:$CBF6 PRG:0BF6 20 39 E5
RTS ; CPU:$CBF9 PRG:0BF9 60
CorePathOnPositive_CBFA:
CMP #$30 ; CPU:$CBFA PRG:0BFA C9 30
BCS CorePathOnCarry_CC23 ; CPU:$CBFC PRG:0BFC B0 25
JSR ReadObjectRecordRoutine_E06A ; CPU:$CBFE PRG:0BFE 20 6A E0
LDA $0A ; CPU:$CC01 PRG:0C01 A5 0A
JSR ReadObjectRecordRoutine_E5AA ; CPU:$CC03 PRG:0C03 20 AA E5
BCS CorePathContinue_CC10 ; CPU:$CC06 PRG:0C06 B0 08
JSR ProcessObjectStateRoutine_E17F ; CPU:$CC08 PRG:0C08 20 7F E1
BCC CorePathContinue_CC10 ; CPU:$CC0B PRG:0C0B 90 03
JSR ProcessObjectStateRoutine_E1BF ; CPU:$CC0D PRG:0C0D 20 BF E1
CorePathContinue_CC10:
JSR PrepareObjectMovementContext ; CPU:$CC10 PRG:0C10 20 A8 CC
JSR ReadObjectRecordRoutine_E351 ; CPU:$CC13 PRG:0C13 20 51 E3
BCC CorePathOnNoCarry_CC22 ; CPU:$CC16 PRG:0C16 90 0A
JSR UpdateObjectRecordRoutine_E3A7 ; CPU:$CC18 PRG:0C18 20 A7 E3
LDA #$04 ; CPU:$CC1B PRG:0C1B A9 04
STA $FC ; CPU:$CC1D PRG:0C1D 85 FC
RunGameTaskDispatch_CC1F:
JSR PrepareObjectMovementContext ; CPU:$CC1F PRG:0C1F 20 A8 CC
CorePathOnNoCarry_CC22:
RTS ; CPU:$CC22 PRG:0C22 60
CorePathOnCarry_CC23:
JSR ProcessObjectStateRoutine_E28F ; CPU:$CC23 PRG:0C23 20 8F E2
JSR ReadObjectRecordRoutine_E06A ; CPU:$CC26 PRG:0C26 20 6A E0
JMP RunGameTaskDispatch_CC1F ; CPU:$CC29 PRG:0C29 4C 1F CC
.byte $00, $00, $02, $02, $00, $00, $00, $00, $02, $02, $02, $02, $00, $80, $40, $00 ; CPU:$CC2C PRG:0C2C 0B
.byte $00, $40, $80, $C0 ; CPU:$CC3C PRG:0C3C 0B
;------------------------------------------------------------
; Movement tables and object-engine setup
; CPU $CC40-$CCB7
; PRG $0C40-$0CB7
;------------------------------------------------------------
MovementTables:
.byte $00, $80, $40, $C0, $80, $00, $00, $40, $00, $80, $40, $00, $00, $40, $80, $C0 ; CPU:$CC40 PRG:0C40 0B
.byte $00, $80, $40, $C0, $C0, $40, $80, $C0, $00, $00, $00, $00, $04, $04, $04, $04 ; CPU:$CC50 PRG:0C50 0B
.byte $10, $F8, $10, $F8, $00, $08, $F8, $F8, $00, $00, $00, $00, $0F, $F9, $0F, $F9 ; CPU:$CC60 PRG:0C60 0B
.byte $04, $04, $04, $04, $F8, $F8, $00, $08, $00, $00, $00, $00, $00, $00, $00, $00 ; CPU:$CC70 PRG:0C70 0B
.byte $01, $01, $01, $01, $F8, $10, $04, $04, $F8, $F8, $10, $10, $04, $04, $04, $04 ; CPU:$CC80 PRG:0C80 0B
.byte $00, $08, $10, $10, $04, $04, $F8, $10, $04, $04, $04, $04, $10, $10, $F8, $F8 ; CPU:$CC90 PRG:0C90 0B
.byte $10, $10, $00, $08, $04, $05, $08, $09 ; CPU:$CCA0 PRG:0CA0 0B
;------------------------------------------------------------
; PrepareObjectMovementContext
;
; Global:
; Prepares an index and object-state selector before falling
; through into ObjectEngineCodeAndTables at CPU $CCB8.
;
; Parameters:
; $06 supplies a two-bit selector.
;
; Returns:
; X = $03 normally, or $0C when the selector is at least two.
; Y = $10.
; $00 = $06 & $03.
;------------------------------------------------------------
PrepareObjectMovementContext:
LDX #$03 ; CPU:$CCA8 PRG:0CA8 A2 03
LDA $06 ; CPU:$CCAA PRG:0CAA A5 06
AND #$03 ; CPU:$CCAC PRG:0CAC 29 03
STA $00 ; CPU:$CCAE PRG:0CAE 85 00
CMP #$02 ; CPU:$CCB0 PRG:0CB0 C9 02
BCC @SetObjectFieldOffset ; CPU:$CCB2 PRG:0CB2 90 02
LDX #$0C ; CPU:$CCB4 PRG:0CB4 A2 0C
@SetObjectFieldOffset:
LDY #$10 ; CPU:$CCB6 PRG:0CB6 A0 10
; Falls through to ObjectEngineCodeAndTables at CPU $CCB8.
;------------------------------------------------------------
; Object engine code with embedded lookup tables
; CPU $CCB8-$E77F
; PRG $0CB8-$277F
;
; Pass 1 recursively traced from verified entry roots in this region.
; Direct branches, jumps, and subroutine calls are decoded.
; Bytes not reached by that trace remain explicit .byte data.
;------------------------------------------------------------
;------------------------------------------------------------
; ObjectEngineCodeAndTables
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectEngineCodeAndTables:
LDA (CurrentObjectPtrLo),Y ; CPU:$CCB8 PRG:0CB8 B1 08
BMI ObjectPathContinue_CCCC ; CPU:$CCBA PRG:0CBA 30 10
LDY #$1B ; CPU:$CCBC PRG:0CBC A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$CCBE PRG:0CBE B1 08
CMP #$50 ; CPU:$CCC0 PRG:0CC0 C9 50
BCS ObjectPathContinue_CCE9 ; CPU:$CCC2 PRG:0CC2 B0 25
CMP #$40 ; CPU:$CCC4 PRG:0CC4 C9 40
BCS ObjectPathContinue_CCCC ; CPU:$CCC6 PRG:0CC6 B0 04
CMP #$30 ; CPU:$CCC8 PRG:0CC8 C9 30
BCS ObjectPathOnCarry_CCEF ; CPU:$CCCA PRG:0CCA B0 23
ObjectPathContinue_CCCC:
TXA ; CPU:$CCCC PRG:0CCC 8A
LDY $0A ; CPU:$CCCD PRG:0CCD A4 0A
AND a:$0046,Y ; CPU:$CCCF PRG:0CCF 39 46 00
BEQ ObjectPathContinue_CCE9 ; CPU:$CCD2 PRG:0CD2 F0 15
JSR ProcessObjectStateRoutine_CD54 ; CPU:$CCD4 PRG:0CD4 20 54 CD
STX $07 ; CPU:$CCD7 PRG:0CD7 86 07
ObjectPathLoop_CCD9:
JSR UpdateObjectRecordRoutine_CCF7 ; CPU:$CCD9 PRG:0CD9 20 F7 CC
LDA #$00 ; CPU:$CCDC PRG:0CDC A9 00
UpdateObjectRecordLoop_CCDE:
LDY #$20 ; CPU:$CCDE PRG:0CDE A0 20
STA (CurrentObjectPtrLo),Y ; CPU:$CCE0 PRG:0CE0 91 08
JSR UpdateObjectRecordRoutine_CD1E ; CPU:$CCE2 PRG:0CE2 20 1E CD
JSR UpdateObjectRecordRoutine_CD45 ; CPU:$CCE5 PRG:0CE5 20 45 CD
RTS ; CPU:$CCE8 PRG:0CE8 60
ObjectPathContinue_CCE9:
LDX $00 ; CPU:$CCE9 PRG:0CE9 A6 00
LDA #$01 ; CPU:$CCEB PRG:0CEB A9 01
BNE UpdateObjectRecordLoop_CCDE ; CPU:$CCED PRG:0CED D0 EF
ObjectPathOnCarry_CCEF:
AND #$03 ; CPU:$CCEF PRG:0CEF 29 03
CLC ; CPU:$CCF1 PRG:0CF1 18
ADC #$0C ; CPU:$CCF2 PRG:0CF2 69 0C
TAX ; CPU:$CCF4 PRG:0CF4 AA
BNE ObjectPathLoop_CCD9 ; CPU:$CCF5 PRG:0CF5 D0 E2
;------------------------------------------------------------
; UpdateObjectRecordRoutine_CCF7
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_CCF7:
CLC ; CPU:$CCF7 PRG:0CF7 18
LDY #$01 ; CPU:$CCF8 PRG:0CF8 A0 01
LDA $CC58,X ; CPU:$CCFA PRG:0CFA BD 58 CC
ADC (CurrentObjectPtrLo),Y ; CPU:$CCFD PRG:0CFD 71 08
LDY #$21 ; CPU:$CCFF PRG:0CFF A0 21
STA (CurrentObjectPtrLo),Y ; CPU:$CD01 PRG:0D01 91 08
CLC ; CPU:$CD03 PRG:0D03 18
LDY #$03 ; CPU:$CD04 PRG:0D04 A0 03
LDA $CC68,X ; CPU:$CD06 PRG:0D06 BD 68 CC
ADC (CurrentObjectPtrLo),Y ; CPU:$CD09 PRG:0D09 71 08
LDY #$23 ; CPU:$CD0B PRG:0D0B A0 23
STA (CurrentObjectPtrLo),Y ; CPU:$CD0D PRG:0D0D 91 08
LDY #$25 ; CPU:$CD0F PRG:0D0F A0 25
LDA $CC78,X ; CPU:$CD11 PRG:0D11 BD 78 CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD14 PRG:0D14 91 08
LDY #$28 ; CPU:$CD16 PRG:0D16 A0 28
LDA $CC38,X ; CPU:$CD18 PRG:0D18 BD 38 CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD1B PRG:0D1B 91 08
RTS ; CPU:$CD1D PRG:0D1D 60
;------------------------------------------------------------
; UpdateObjectRecordRoutine_CD1E
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_CD1E:
CLC ; CPU:$CD1E PRG:0D1E 18
LDY #$01 ; CPU:$CD1F PRG:0D1F A0 01
LDA $CC84,X ; CPU:$CD21 PRG:0D21 BD 84 CC
ADC (CurrentObjectPtrLo),Y ; CPU:$CD24 PRG:0D24 71 08
LDY #$31 ; CPU:$CD26 PRG:0D26 A0 31
STA (CurrentObjectPtrLo),Y ; CPU:$CD28 PRG:0D28 91 08
CLC ; CPU:$CD2A PRG:0D2A 18
LDY #$03 ; CPU:$CD2B PRG:0D2B A0 03
LDA $CC94,X ; CPU:$CD2D PRG:0D2D BD 94 CC
ADC (CurrentObjectPtrLo),Y ; CPU:$CD30 PRG:0D30 71 08
LDY #$33 ; CPU:$CD32 PRG:0D32 A0 33
STA (CurrentObjectPtrLo),Y ; CPU:$CD34 PRG:0D34 91 08
LDY #$35 ; CPU:$CD36 PRG:0D36 A0 35
LDA $CC2C,X ; CPU:$CD38 PRG:0D38 BD 2C CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD3B PRG:0D3B 91 08
LDY #$38 ; CPU:$CD3D PRG:0D3D A0 38
LDA $CC48,X ; CPU:$CD3F PRG:0D3F BD 48 CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD42 PRG:0D42 91 08
RTS ; CPU:$CD44 PRG:0D44 60
;------------------------------------------------------------
; UpdateObjectRecordRoutine_CD45
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_CD45:
LDY #$05 ; CPU:$CD45 PRG:0D45 A0 05
LDA $CC2C,X ; CPU:$CD47 PRG:0D47 BD 2C CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD4A PRG:0D4A 91 08
LDY #$08 ; CPU:$CD4C PRG:0D4C A0 08
LDA $CC38,X ; CPU:$CD4E PRG:0D4E BD 38 CC
STA (CurrentObjectPtrLo),Y ; CPU:$CD51 PRG:0D51 91 08
RTS ; CPU:$CD53 PRG:0D53 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_CD54
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_CD54:
LDX #$00 ; CPU:$CD54 PRG:0D54 A2 00
CMP #$04 ; CPU:$CD56 PRG:0D56 C9 04
BCC ObjectPathOnNoCarry_CD5C ; CPU:$CD58 PRG:0D58 90 02
LDX #$03 ; CPU:$CD5A PRG:0D5A A2 03
ObjectPathOnNoCarry_CD5C:
CPX $00 ; CPU:$CD5C PRG:0D5C E4 00
BEQ ObjectPathOnZero_CD62 ; CPU:$CD5E PRG:0D5E F0 02
ORA #$10 ; CPU:$CD60 PRG:0D60 09 10
ObjectPathOnZero_CD62:
LDY #$FF ; CPU:$CD62 PRG:0D62 A0 FF
ObjectPathLoop_CD64:
LSR A ; CPU:$CD64 PRG:0D64 4A
INY ; CPU:$CD65 PRG:0D65 C8
BCC ObjectPathLoop_CD64 ; CPU:$CD66 PRG:0D66 90 FC
LDX $CCA4,Y ; CPU:$CD68 PRG:0D68 BE A4 CC
TAY ; CPU:$CD6B PRG:0D6B A8
BEQ ObjectPathOnZero_CD70 ; CPU:$CD6C PRG:0D6C F0 02
INX ; CPU:$CD6E PRG:0D6E E8
INX ; CPU:$CD6F PRG:0D6F E8
ObjectPathOnZero_CD70:
RTS ; CPU:$CD70 PRG:0D70 60
.byte $21, $24, $24, $12, $24, $24, $71, $74, $CD, $CD ; CPU:$CD71 PRG:0D71 0B
;------------------------------------------------------------
; ReadObjectRecord_CD7B
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecord_CD7B:
LDX $0A ; CPU:$CD7B PRG:0D7B A6 0A
LDA $5A,X ; CPU:$CD7D PRG:0D7D B5 5A
BNE ObjectPathContinue_CDCD ; CPU:$CD7F PRG:0D7F D0 4C
CLC ; CPU:$CD81 PRG:0D81 18
LDY #$01 ; CPU:$CD82 PRG:0D82 A0 01
LDA #$06 ; CPU:$CD84 PRG:0D84 A9 06
ADC (CurrentObjectPtrLo),Y ; CPU:$CD86 PRG:0D86 71 08
STA $00 ; CPU:$CD88 PRG:0D88 85 00
CLC ; CPU:$CD8A PRG:0D8A 18
LDY #$03 ; CPU:$CD8B PRG:0D8B A0 03
LDA #$06 ; CPU:$CD8D PRG:0D8D A9 06
ADC (CurrentObjectPtrLo),Y ; CPU:$CD8F PRG:0D8F 71 08
STA $01 ; CPU:$CD91 PRG:0D91 85 01
JSR UpdateObjectBufferRoutine_E0DF ; CPU:$CD93 PRG:0D93 20 DF E0
LDA $0A ; CPU:$CD96 PRG:0D96 A5 0A
CLC ; CPU:$CD98 PRG:0D98 18
ADC #$04 ; CPU:$CD99 PRG:0D99 69 04
JSR ProcessObjectStateRoutine_E0B2 ; CPU:$CD9B PRG:0D9B 20 B2 E0
BCS ObjectPathContinue_CDCD ; CPU:$CD9E PRG:0D9E B0 2D
LDY #$00 ; CPU:$CDA0 PRG:0DA0 A0 00
LDX #$80 ; CPU:$CDA2 PRG:0DA2 A2 80
CMP #$FB ; CPU:$CDA4 PRG:0DA4 C9 FB
BEQ ObjectPathContinue_CDCE ; CPU:$CDA6 PRG:0DA6 F0 26
INY ; CPU:$CDA8 PRG:0DA8 C8
CMP #$FA ; CPU:$CDA9 PRG:0DA9 C9 FA
BEQ ObjectPathContinue_CDCE ; CPU:$CDAB PRG:0DAB F0 21
DEY ; CPU:$CDAD PRG:0DAD 88
LDX #$00 ; CPU:$CDAE PRG:0DAE A2 00
CMP #$D2 ; CPU:$CDB0 PRG:0DB0 C9 D2
BCS ObjectPathOnCarry_CDBE ; CPU:$CDB2 PRG:0DB2 B0 0A
CMP #$D0 ; CPU:$CDB4 PRG:0DB4 C9 D0
BCS ObjectPathContinue_CDCE ; CPU:$CDB6 PRG:0DB6 B0 16
INY ; CPU:$CDB8 PRG:0DB8 C8
CMP #$CE ; CPU:$CDB9 PRG:0DB9 C9 CE
BCS ObjectPathContinue_CDCE ; CPU:$CDBB PRG:0DBB B0 11
DEY ; CPU:$CDBD PRG:0DBD 88
ObjectPathOnCarry_CDBE:
LDX #$04 ; CPU:$CDBE PRG:0DBE A2 04
CMP #$F9 ; CPU:$CDC0 PRG:0DC0 C9 F9
BCS ObjectPathContinue_CDCD ; CPU:$CDC2 PRG:0DC2 B0 09
CMP #$F7 ; CPU:$CDC4 PRG:0DC4 C9 F7
BCS ObjectPathContinue_CDCE ; CPU:$CDC6 PRG:0DC6 B0 06
INY ; CPU:$CDC8 PRG:0DC8 C8
CMP #$F5 ; CPU:$CDC9 PRG:0DC9 C9 F5
BCS ObjectPathContinue_CDCE ; CPU:$CDCB PRG:0DCB B0 01
ObjectPathContinue_CDCD:
RTS ; CPU:$CDCD PRG:0DCD 60
ObjectPathContinue_CDCE:
STY $0D ; CPU:$CDCE PRG:0DCE 84 0D
STX $0E ; CPU:$CDD0 PRG:0DD0 86 0E
LDX $0A ; CPU:$CDD2 PRG:0DD2 A6 0A
LDA #$08 ; CPU:$CDD4 PRG:0DD4 A9 08
STA $5A,X ; CPU:$CDD6 PRG:0DD6 95 5A
LDX #$01 ; CPU:$CDD8 PRG:0DD8 A2 01
LDA $8F ; CPU:$CDDA PRG:0DDA A5 8F
BNE UpdateObjectBufferContinue_CDE4 ; CPU:$CDDC PRG:0DDC D0 06
LDA $0E ; CPU:$CDDE PRG:0DDE A5 0E
BPL UpdateObjectBufferContinue_CDE4 ; CPU:$CDE0 PRG:0DE0 10 02
LDX #$28 ; CPU:$CDE2 PRG:0DE2 A2 28
UpdateObjectBufferContinue_CDE4:
STX $07 ; CPU:$CDE4 PRG:0DE4 86 07
JSR ProcessObjectStateRoutine_CE50 ; CPU:$CDE6 PRG:0DE6 20 50 CE
BCS ObjectPathContinue_CE33 ; CPU:$CDE9 PRG:0DE9 B0 48
LDA WorkPtr1Lo ; CPU:$CDEB PRG:0DEB A5 02
STA $01 ; CPU:$CDED PRG:0DED 85 01
LDA $03 ; CPU:$CDEF PRG:0DEF A5 03
STA $00 ; CPU:$CDF1 PRG:0DF1 85 00
LDY $0D ; CPU:$CDF3 PRG:0DF3 A4 0D
LDA $CD77,Y ; CPU:$CDF5 PRG:0DF5 B9 77 CD
STA $02 ; CPU:$CDF8 PRG:0DF8 85 02
LDA $CD79,Y ; CPU:$CDFA PRG:0DFA B9 79 CD
STA $03 ; CPU:$CDFD PRG:0DFD 85 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$CDFF PRG:0DFF 20 A1 F3
LDA #$80 ; CPU:$CE02 PRG:0E02 A9 80
STA $FF ; CPU:$CE04 PRG:0E04 85 FF
LDX $0A ; CPU:$CE06 PRG:0E06 A6 0A
LDA #$01 ; CPU:$CE08 PRG:0E08 A9 01
STA $00 ; CPU:$CE0A PRG:0E0A 85 00
LDA $0E ; CPU:$CE0C PRG:0E0C A5 0E
CMP #$04 ; CPU:$CE0E PRG:0E0E C9 04
BEQ ObjectPathOnZero_CE34 ; CPU:$CE10 PRG:0E10 F0 22
INC $D4,X ; CPU:$CE12 PRG:0E12 F6 D4
LDA #$06 ; CPU:$CE14 PRG:0E14 A9 06
STA $01 ; CPU:$CE16 PRG:0E16 85 01
JSR ProcessResourceStateRoutine_F408 ; CPU:$CE18 PRG:0E18 20 08 F4
LDA $3F ; CPU:$CE1B PRG:0E1B A5 3F
BNE ProcessObjectStateDispatch_CE2A ; CPU:$CE1D PRG:0E1D D0 0B
LDA $8D ; CPU:$CE1F PRG:0E1F A5 8D
BEQ ObjectPathOnZero_CE26 ; CPU:$CE21 PRG:0E21 F0 03
JMP RunGameTaskRoutine_C3E4 ; CPU:$CE23 PRG:0E23 4C E4 C3
ObjectPathOnZero_CE26:
LDA #$23 ; CPU:$CE26 PRG:0E26 A9 23
STA $78 ; CPU:$CE28 PRG:0E28 85 78
ProcessObjectStateDispatch_CE2A:
LDA $8F ; CPU:$CE2A PRG:0E2A A5 8F
BNE ObjectPathContinue_CE33 ; CPU:$CE2C PRG:0E2C D0 05
LDA #$68 ; CPU:$CE2E PRG:0E2E A9 68
JSR ProcessResourceStateRoutine_F31A ; CPU:$CE30 PRG:0E30 20 1A F3
ObjectPathContinue_CE33:
RTS ; CPU:$CE33 PRG:0E33 60
ObjectPathOnZero_CE34:
LDA $8E ; CPU:$CE34 PRG:0E34 A5 8E
BEQ ObjectPathOnZero_CE41 ; CPU:$CE36 PRG:0E36 F0 09
DEC $D4,X ; CPU:$CE38 PRG:0E38 D6 D4
LDA #$06 ; CPU:$CE3A PRG:0E3A A9 06
STA $01 ; CPU:$CE3C PRG:0E3C 85 01
JSR ProcessResourceStateRoutine_F40C ; CPU:$CE3E PRG:0E3E 20 0C F4
ObjectPathOnZero_CE41:
JMP ProcessObjectStateDispatch_CE2A ; CPU:$CE41 PRG:0E41 4C 2A CE
.byte $21, $00, $00, $10, $08, $12, $00, $00, $08, $10, $40, $80 ; CPU:$CE44 PRG:0E44 0B
;------------------------------------------------------------
; ProcessObjectStateRoutine_CE50
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_CE50:
LDA #$00 ; CPU:$CE50 PRG:0E50 A9 00
STA $04 ; CPU:$CE52 PRG:0E52 85 04
STA $0B ; CPU:$CE54 PRG:0E54 85 0B
LDA #$05 ; CPU:$CE56 PRG:0E56 A9 05
STA $05 ; CPU:$CE58 PRG:0E58 85 05
STA $0C ; CPU:$CE5A PRG:0E5A 85 0C
LDA #$07 ; CPU:$CE5C PRG:0E5C A9 07
STA $0F ; CPU:$CE5E PRG:0E5E 85 0F
ObjectPathLoop_CE60:
LDY #$10 ; CPU:$CE60 PRG:0E60 A0 10
LDA ($04),Y ; CPU:$CE62 PRG:0E62 B1 04
BEQ ObjectPathOnZero_CE6F ; CPU:$CE64 PRG:0E64 F0 09
LDX #$04 ; CPU:$CE66 PRG:0E66 A2 04
JSR RunGameTaskRoutine_CBD3 ; CPU:$CE68 PRG:0E68 20 D3 CB
BPL ObjectPathLoop_CE60 ; CPU:$CE6B PRG:0E6B 10 F3
ObjectPathLoop_CE6D:
SEC ; CPU:$CE6D PRG:0E6D 38
RTS ; CPU:$CE6E PRG:0E6E 60
ObjectPathOnZero_CE6F:
LDA WorkPtr1Lo ; CPU:$CE6F PRG:0E6F A5 02
BEQ ObjectPathOnZero_CE9D ; CPU:$CE71 PRG:0E71 F0 2A
JSR UpdateObjectBufferRoutine_E0F9 ; CPU:$CE73 PRG:0E73 20 F9 E0
LDA #$07 ; CPU:$CE76 PRG:0E76 A9 07
STA $0F ; CPU:$CE78 PRG:0E78 85 0F
ObjectPathLoop_CE7A:
LDY #$10 ; CPU:$CE7A PRG:0E7A A0 10
LDA ($0B),Y ; CPU:$CE7C PRG:0E7C B1 0B
BEQ ObjectPathContinue_CE96 ; CPU:$CE7E PRG:0E7E F0 16
LDY #$12 ; CPU:$CE80 PRG:0E80 A0 12
LDA ($0B),Y ; CPU:$CE82 PRG:0E82 B1 0B
BEQ ObjectPathContinue_CE96 ; CPU:$CE84 PRG:0E84 F0 10
LDY #$01 ; CPU:$CE86 PRG:0E86 A0 01
LDA ($0B),Y ; CPU:$CE88 PRG:0E88 B1 0B
CMP $00 ; CPU:$CE8A PRG:0E8A C5 00
BNE ObjectPathContinue_CE96 ; CPU:$CE8C PRG:0E8C D0 08
LDY #$03 ; CPU:$CE8E PRG:0E8E A0 03
LDA ($0B),Y ; CPU:$CE90 PRG:0E90 B1 0B
CMP $01 ; CPU:$CE92 PRG:0E92 C5 01
BEQ ObjectPathLoop_CE6D ; CPU:$CE94 PRG:0E94 F0 D7
ObjectPathContinue_CE96:
LDX #$0B ; CPU:$CE96 PRG:0E96 A2 0B
JSR RunGameTaskRoutine_CBD3 ; CPU:$CE98 PRG:0E98 20 D3 CB
BPL ObjectPathLoop_CE7A ; CPU:$CE9B PRG:0E9B 10 DD
ObjectPathOnZero_CE9D:
LDY #$00 ; CPU:$CE9D PRG:0E9D A0 00
LDA #$00 ; CPU:$CE9F PRG:0E9F A9 00
STA ($04),Y ; CPU:$CEA1 PRG:0EA1 91 04
INY ; CPU:$CEA3 PRG:0EA3 C8
LDA WorkPtr0Lo ; CPU:$CEA4 PRG:0EA4 A5 00
STA ($04),Y ; CPU:$CEA6 PRG:0EA6 91 04
INY ; CPU:$CEA8 PRG:0EA8 C8
LDA #$00 ; CPU:$CEA9 PRG:0EA9 A9 00
STA ($04),Y ; CPU:$CEAB PRG:0EAB 91 04
INY ; CPU:$CEAD PRG:0EAD C8
LDA WorkPtr0Hi ; CPU:$CEAE PRG:0EAE A5 01
STA ($04),Y ; CPU:$CEB0 PRG:0EB0 91 04
INY ; CPU:$CEB2 PRG:0EB2 C8
LDA #$00 ; CPU:$CEB3 PRG:0EB3 A9 00
STA ($04),Y ; CPU:$CEB5 PRG:0EB5 91 04
LDY #$14 ; CPU:$CEB7 PRG:0EB7 A0 14
LDA $0E ; CPU:$CEB9 PRG:0EB9 A5 0E
STA ($04),Y ; CPU:$CEBB PRG:0EBB 91 04
AND #$0F ; CPU:$CEBD PRG:0EBD 29 0F
LDX #$00 ; CPU:$CEBF PRG:0EBF A2 00
LDY $0D ; CPU:$CEC1 PRG:0EC1 A4 0D
BEQ ObjectPathOnZero_CECA ; CPU:$CEC3 PRG:0EC3 F0 05
CLC ; CPU:$CEC5 PRG:0EC5 18
ADC #$0A ; CPU:$CEC6 PRG:0EC6 69 0A
LDX #$05 ; CPU:$CEC8 PRG:0EC8 A2 05
ObjectPathOnZero_CECA:
LDY #$05 ; CPU:$CECA PRG:0ECA A0 05
STA ($04),Y ; CPU:$CECC PRG:0ECC 91 04
LDY #$0A ; CPU:$CECE PRG:0ECE A0 0A
LDA $CE44,X ; CPU:$CED0 PRG:0ED0 BD 44 CE
STA ($04),Y ; CPU:$CED3 PRG:0ED3 91 04
LDY #$0C ; CPU:$CED5 PRG:0ED5 A0 0C
ObjectPathLoop_CED7:
INX ; CPU:$CED7 PRG:0ED7 E8
LDA $CE44,X ; CPU:$CED8 PRG:0ED8 BD 44 CE
STA ($04),Y ; CPU:$CEDB PRG:0EDB 91 04
INY ; CPU:$CEDD PRG:0EDD C8
CPY #$10 ; CPU:$CEDE PRG:0EDE C0 10
BNE ObjectPathLoop_CED7 ; CPU:$CEE0 PRG:0EE0 D0 F5
LDY #$10 ; CPU:$CEE2 PRG:0EE2 A0 10
LDA $08 ; CPU:$CEE4 PRG:0EE4 A5 08
STA $00 ; CPU:$CEE6 PRG:0EE6 85 00
LDA $09 ; CPU:$CEE8 PRG:0EE8 A5 09
STA $01 ; CPU:$CEEA PRG:0EEA 85 01
JSR ProcessObjectStateRoutine_D94D ; CPU:$CEEC PRG:0EEC 20 4D D9
ORA #$10 ; CPU:$CEEF PRG:0EEF 09 10
STA ($04),Y ; CPU:$CEF1 PRG:0EF1 91 04
AND #$01 ; CPU:$CEF3 PRG:0EF3 29 01
BEQ ObjectPathContinue_CF02 ; CPU:$CEF5 PRG:0EF5 F0 0B
LDA #$00 ; CPU:$CEF7 PRG:0EF7 A9 00
LDY $02 ; CPU:$CEF9 PRG:0EF9 A4 02
BNE ObjectPathContinue_CF02 ; CPU:$CEFB PRG:0EFB D0 05
LDY $0D ; CPU:$CEFD PRG:0EFD A4 0D
LDA $CE4E,Y ; CPU:$CEFF PRG:0EFF B9 4E CE
ObjectPathContinue_CF02:
LDY #$08 ; CPU:$CF02 PRG:0F02 A0 08
STA ($04),Y ; CPU:$CF04 PRG:0F04 91 04
LDY #$11 ; CPU:$CF06 PRG:0F06 A0 11
LDA $07 ; CPU:$CF08 PRG:0F08 A5 07
STA ($04),Y ; CPU:$CF0A PRG:0F0A 91 04
LDA WorkPtr1Lo ; CPU:$CF0C PRG:0F0C A5 02
BEQ ObjectPathContinue_CF1E ; CPU:$CF0E PRG:0F0E F0 0E
LDA #$0D ; CPU:$CF10 PRG:0F10 A9 0D
LDX $8E ; CPU:$CF12 PRG:0F12 A6 8E
BNE ObjectPathContinue_CF1E ; CPU:$CF14 PRG:0F14 D0 08
LDX $0E ; CPU:$CF16 PRG:0F16 A6 0E
CPX #$04 ; CPU:$CF18 PRG:0F18 E0 04
BNE ObjectPathContinue_CF1E ; CPU:$CF1A PRG:0F1A D0 02
LDA #$09 ; CPU:$CF1C PRG:0F1C A9 09
ObjectPathContinue_CF1E:
INY ; CPU:$CF1E PRG:0F1E C8
STA ($04),Y ; CPU:$CF1F PRG:0F1F 91 04
INY ; CPU:$CF21 PRG:0F21 C8
LDA #$02 ; CPU:$CF22 PRG:0F22 A9 02
STA ($04),Y ; CPU:$CF24 PRG:0F24 91 04
CLC ; CPU:$CF26 PRG:0F26 18
RTS ; CPU:$CF27 PRG:0F27 60
.byte $21, $D0, $D1, $12, $CE, $CF, $21, $F7, $F8, $12, $F5, $F6, $02, $FD, $02, $FD ; CPU:$CF28 PRG:0F28 0B
.byte $60, $A0, $60, $A0 ; CPU:$CF38 PRG:0F38 0B
ReadObjectRecordDispatch_CF3C:
LDY #$01 ; CPU:$CF3C PRG:0F3C A0 01
LDA (CurrentObjectPtrLo),Y ; CPU:$CF3E PRG:0F3E B1 08
STA WorkPtr0Lo ; CPU:$CF40 PRG:0F40 85 00
LDY #$03 ; CPU:$CF42 PRG:0F42 A0 03
LDA (CurrentObjectPtrLo),Y ; CPU:$CF44 PRG:0F44 B1 08
STA WorkPtr0Hi ; CPU:$CF46 PRG:0F46 85 01
JSR UpdateObjectBufferRoutine_E0DF ; CPU:$CF48 PRG:0F48 20 DF E0
LDY #$05 ; CPU:$CF4B PRG:0F4B A0 05
LDA (CurrentObjectPtrLo),Y ; CPU:$CF4D PRG:0F4D B1 08
LDX #$28 ; CPU:$CF4F PRG:0F4F A2 28
LDY #$CF ; CPU:$CF51 PRG:0F51 A0 CF
CMP #$00 ; CPU:$CF53 PRG:0F53 C9 00
BEQ UpdateObjectRecordOnZero_CF6B ; CPU:$CF55 PRG:0F55 F0 14
LDX #$2B ; CPU:$CF57 PRG:0F57 A2 2B
LDY #$CF ; CPU:$CF59 PRG:0F59 A0 CF
CMP #$0A ; CPU:$CF5B PRG:0F5B C9 0A
BEQ UpdateObjectRecordOnZero_CF6B ; CPU:$CF5D PRG:0F5D F0 0C
LDX #$2E ; CPU:$CF5F PRG:0F5F A2 2E
LDY #$CF ; CPU:$CF61 PRG:0F61 A0 CF
CMP #$04 ; CPU:$CF63 PRG:0F63 C9 04
BEQ UpdateObjectRecordOnZero_CF6B ; CPU:$CF65 PRG:0F65 F0 04
LDX #$31 ; CPU:$CF67 PRG:0F67 A2 31
LDY #$CF ; CPU:$CF69 PRG:0F69 A0 CF
UpdateObjectRecordOnZero_CF6B:
LDA WorkPtr1Lo ; CPU:$CF6B PRG:0F6B A5 02
STA WorkPtr0Hi ; CPU:$CF6D PRG:0F6D 85 01
LDA WorkPtr1Hi ; CPU:$CF6F PRG:0F6F A5 03
STA WorkPtr0Lo ; CPU:$CF71 PRG:0F71 85 00
STX WorkPtr1Lo ; CPU:$CF73 PRG:0F73 86 02
STY WorkPtr1Hi ; CPU:$CF75 PRG:0F75 84 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$CF77 PRG:0F77 20 A1 F3
LDY #$05 ; CPU:$CF7A PRG:0F7A A0 05
LDA (CurrentObjectPtrLo),Y ; CPU:$CF7C PRG:0F7C B1 08
CMP #$05 ; CPU:$CF7E PRG:0F7E C9 05
LDA #$14 ; CPU:$CF80 PRG:0F80 A9 14
STA (CurrentObjectPtrLo),Y ; CPU:$CF82 PRG:0F82 91 08
BCS UpdateObjectRecordOnCarry_CF96 ; CPU:$CF84 PRG:0F84 B0 10
LDY #$01 ; CPU:$CF86 PRG:0F86 A0 01
LDA (CurrentObjectPtrLo),Y ; CPU:$CF88 PRG:0F88 B1 08
ADC #$04 ; CPU:$CF8A PRG:0F8A 69 04
STA (CurrentObjectPtrLo),Y ; CPU:$CF8C PRG:0F8C 91 08
LDY #$03 ; CPU:$CF8E PRG:0F8E A0 03
LDA (CurrentObjectPtrLo),Y ; CPU:$CF90 PRG:0F90 B1 08
SBC #$03 ; CPU:$CF92 PRG:0F92 E9 03
STA (CurrentObjectPtrLo),Y ; CPU:$CF94 PRG:0F94 91 08
UpdateObjectRecordOnCarry_CF96:
LDY #$0A ; CPU:$CF96 PRG:0F96 A0 0A
LDA #$12 ; CPU:$CF98 PRG:0F98 A9 12
STA (CurrentObjectPtrLo),Y ; CPU:$CF9A PRG:0F9A 91 08
BNE UpdateObjectRecordLoop_CFAD ; CPU:$CF9C PRG:0F9C D0 0F
ObjectPathLoop_CF9E:
JMP ReadObjectRecordDispatch_CF3C ; CPU:$CF9E PRG:0F9E 4C 3C CF
;------------------------------------------------------------
; ObjectPath_CFA1
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_CFA1:
LDA #$00 ; CPU:$CFA1 PRG:0FA1 A9 00
STA CurrentObjectPtrLo ; CPU:$CFA3 PRG:0FA3 85 08
LDA #$05 ; CPU:$CFA5 PRG:0FA5 A9 05
STA CurrentObjectPtrHi ; CPU:$CFA7 PRG:0FA7 85 09
LDA #$07 ; CPU:$CFA9 PRG:0FA9 A9 07
STA LoopCounter ; CPU:$CFAB PRG:0FAB 85 0F
UpdateObjectRecordLoop_CFAD:
LDY #$10 ; CPU:$CFAD PRG:0FAD A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$CFAF PRG:0FAF B1 08
BEQ ProcessObjectStateDispatch_CFFA ; CPU:$CFB1 PRG:0FB1 F0 47
STA WorkPtr0Lo ; CPU:$CFB3 PRG:0FB3 85 00
LDY #$12 ; CPU:$CFB5 PRG:0FB5 A0 12
LDA (CurrentObjectPtrLo),Y ; CPU:$CFB7 PRG:0FB7 B1 08
BEQ UpdateObjectRecordOnZero_D004 ; CPU:$CFB9 PRG:0FB9 F0 49
INY ; CPU:$CFBB PRG:0FBB C8
LDA (CurrentObjectPtrLo),Y ; CPU:$CFBC PRG:0FBC B1 08
SEC ; CPU:$CFBE PRG:0FBE 38
SBC #$01 ; CPU:$CFBF PRG:0FBF E9 01
STA (CurrentObjectPtrLo),Y ; CPU:$CFC1 PRG:0FC1 91 08
BNE ProcessObjectStateDispatch_CFFA ; CPU:$CFC3 PRG:0FC3 D0 35
LDA #$03 ; CPU:$CFC5 PRG:0FC5 A9 03
STA (CurrentObjectPtrLo),Y ; CPU:$CFC7 PRG:0FC7 91 08
DEY ; CPU:$CFC9 PRG:0FC9 88
LDA (CurrentObjectPtrLo),Y ; CPU:$CFCA PRG:0FCA B1 08
SEC ; CPU:$CFCC PRG:0FCC 38
SBC #$01 ; CPU:$CFCD PRG:0FCD E9 01
STA (CurrentObjectPtrLo),Y ; CPU:$CFCF PRG:0FCF 91 08
BEQ ObjectPathLoop_CF9E ; CPU:$CFD1 PRG:0FD1 F0 CB
LDA WorkPtr0Lo ; CPU:$CFD3 PRG:0FD3 A5 00
AND #$01 ; CPU:$CFD5 PRG:0FD5 29 01
BNE ReadObjectRecordOnNonZero_CFDB ; CPU:$CFD7 PRG:0FD7 D0 02
LDA #$FF ; CPU:$CFD9 PRG:0FD9 A9 FF
ReadObjectRecordOnNonZero_CFDB:
LDX #$07 ; CPU:$CFDB PRG:0FDB A2 07
LDY #$05 ; CPU:$CFDD PRG:0FDD A0 05
CLC ; CPU:$CFDF PRG:0FDF 18
ADC (CurrentObjectPtrLo),Y ; CPU:$CFE0 PRG:0FE0 71 08
BMI UpdateObjectRecordContinue_CFF7 ; CPU:$CFE2 PRG:0FE2 30 13
LDX #$00 ; CPU:$CFE4 PRG:0FE4 A2 00
CMP #$08 ; CPU:$CFE6 PRG:0FE6 C9 08
BEQ UpdateObjectRecordContinue_CFF7 ; CPU:$CFE8 PRG:0FE8 F0 0D
LDX #$11 ; CPU:$CFEA PRG:0FEA A2 11
CMP #$09 ; CPU:$CFEC PRG:0FEC C9 09
BEQ UpdateObjectRecordContinue_CFF7 ; CPU:$CFEE PRG:0FEE F0 07
LDX #$0A ; CPU:$CFF0 PRG:0FF0 A2 0A
CMP #$12 ; CPU:$CFF2 PRG:0FF2 C9 12
BEQ UpdateObjectRecordContinue_CFF7 ; CPU:$CFF4 PRG:0FF4 F0 01
TAX ; CPU:$CFF6 PRG:0FF6 AA
UpdateObjectRecordContinue_CFF7:
TXA ; CPU:$CFF7 PRG:0FF7 8A
STA (CurrentObjectPtrLo),Y ; CPU:$CFF8 PRG:0FF8 91 08
ProcessObjectStateDispatch_CFFA:
LDX #$08 ; CPU:$CFFA PRG:0FFA A2 08
JSR RunGameTaskRoutine_CBD3 ; CPU:$CFFC PRG:0FFC 20 D3 CB
BPL UpdateObjectRecordLoop_CFAD ; CPU:$CFFF PRG:0FFF 10 AC
DEC $A5 ; CPU:$D001 PRG:1001 C6 A5
RTS ; CPU:$D003 PRG:1003 60
UpdateObjectRecordOnZero_D004:
DEY ; CPU:$D004 PRG:1004 88
LDA (CurrentObjectPtrLo),Y ; CPU:$D005 PRG:1005 B1 08
SEC ; CPU:$D007 PRG:1007 38
SBC #$01 ; CPU:$D008 PRG:1008 E9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D00A PRG:100A 91 08
BEQ UpdateObjectRecordOnZero_D052 ; CPU:$D00C PRG:100C F0 44
CMP #$23 ; CPU:$D00E PRG:100E C9 23
BCS UpdateObjectRecordOnCarry_D01A ; CPU:$D010 PRG:1010 B0 08
LDY #$05 ; CPU:$D012 PRG:1012 A0 05
LDA (CurrentObjectPtrLo),Y ; CPU:$D014 PRG:1014 B1 08
CMP #$14 ; CPU:$D016 PRG:1016 C9 14
BCS ProcessObjectStateDispatch_D04F ; CPU:$D018 PRG:1018 B0 35
UpdateObjectRecordOnCarry_D01A:
LDA WorkPtr0Lo ; CPU:$D01A PRG:101A A5 00
AND #$03 ; CPU:$D01C PRG:101C 29 03
TAX ; CPU:$D01E PRG:101E AA
LDY $E17B,X ; CPU:$D01F PRG:101F BC 7B E1
INY ; CPU:$D022 PRG:1022 C8
CLC ; CPU:$D023 PRG:1023 18
LDA $CF38,X ; CPU:$D024 PRG:1024 BD 38 CF
ADC (CurrentObjectPtrLo),Y ; CPU:$D027 PRG:1027 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$D029 PRG:1029 91 08
DEY ; CPU:$D02B PRG:102B 88
LDA $CF34,X ; CPU:$D02C PRG:102C BD 34 CF
ADC (CurrentObjectPtrLo),Y ; CPU:$D02F PRG:102F 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$D031 PRG:1031 91 08
LDY #$05 ; CPU:$D033 PRG:1033 A0 05
LDA (CurrentObjectPtrLo),Y ; CPU:$D035 PRG:1035 B1 08
CMP #$14 ; CPU:$D037 PRG:1037 C9 14
BCS ProcessObjectStateDispatch_D04F ; CPU:$D039 PRG:1039 B0 14
LDX #$08 ; CPU:$D03B PRG:103B A2 08
LDA WorkPtr0Lo ; CPU:$D03D PRG:103D A5 00
AND #$02 ; CPU:$D03F PRG:103F 29 02
BNE ObjectPathOnNonZero_D045 ; CPU:$D041 PRG:1041 D0 02
LDX #$12 ; CPU:$D043 PRG:1043 A2 12
ObjectPathOnNonZero_D045:
LDA $A5 ; CPU:$D045 PRG:1045 A5 A5
AND #$01 ; CPU:$D047 PRG:1047 29 01
BEQ UpdateObjectRecordOnZero_D04C ; CPU:$D049 PRG:1049 F0 01
INX ; CPU:$D04B PRG:104B E8
UpdateObjectRecordOnZero_D04C:
TXA ; CPU:$D04C PRG:104C 8A
STA (CurrentObjectPtrLo),Y ; CPU:$D04D PRG:104D 91 08
ProcessObjectStateDispatch_D04F:
JMP ProcessObjectStateDispatch_CFFA ; CPU:$D04F PRG:104F 4C FA CF
UpdateObjectRecordOnZero_D052:
DEY ; CPU:$D052 PRG:1052 88
STA (CurrentObjectPtrLo),Y ; CPU:$D053 PRG:1053 91 08
LDY #$00 ; CPU:$D055 PRG:1055 A0 00
LDA #$01 ; CPU:$D057 PRG:1057 A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D059 PRG:1059 91 08
LDY #$05 ; CPU:$D05B PRG:105B A0 05
LDA (CurrentObjectPtrLo),Y ; CPU:$D05D PRG:105D B1 08
CMP #$14 ; CPU:$D05F PRG:105F C9 14
BCS ProcessObjectStateDispatch_D04F ; CPU:$D061 PRG:1061 B0 EC
LDY #$15 ; CPU:$D063 PRG:1063 A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D065 PRG:1065 B1 08
TAX ; CPU:$D067 PRG:1067 AA
DEC $DA,X ; CPU:$D068 PRG:1068 D6 DA
JMP ProcessObjectStateDispatch_D04F ; CPU:$D06A PRG:106A 4C 4F D0
;------------------------------------------------------------
; ObjectPath_D06D
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D06D:
LDA #$20 ; CPU:$D06D PRG:106D A9 20
STA $00 ; CPU:$D06F PRG:106F 85 00
LDA #$04 ; CPU:$D071 PRG:1071 A9 04
STA $01 ; CPU:$D073 PRG:1073 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D075 PRG:1075 20 01 F6
LDA #$30 ; CPU:$D078 PRG:1078 A9 30
STA $00 ; CPU:$D07A PRG:107A 85 00
LDA #$04 ; CPU:$D07C PRG:107C A9 04
STA $01 ; CPU:$D07E PRG:107E 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D080 PRG:1080 20 01 F6
;------------------------------------------------------------
; ProcessObjectStateRoutine_D083
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D083:
LDA #$00 ; CPU:$D083 PRG:1083 A9 00
STA $00 ; CPU:$D085 PRG:1085 85 00
LDA #$04 ; CPU:$D087 PRG:1087 A9 04
STA $01 ; CPU:$D089 PRG:1089 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D08B PRG:108B 20 01 F6
RTS ; CPU:$D08E PRG:108E 60
;------------------------------------------------------------
; ObjectPath_D08F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D08F:
LDA #$60 ; CPU:$D08F PRG:108F A9 60
STA $00 ; CPU:$D091 PRG:1091 85 00
LDA #$04 ; CPU:$D093 PRG:1093 A9 04
STA $01 ; CPU:$D095 PRG:1095 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D097 PRG:1097 20 01 F6
LDA #$70 ; CPU:$D09A PRG:109A A9 70
STA $00 ; CPU:$D09C PRG:109C 85 00
LDA #$04 ; CPU:$D09E PRG:109E A9 04
STA $01 ; CPU:$D0A0 PRG:10A0 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D0A2 PRG:10A2 20 01 F6
;------------------------------------------------------------
; ProcessObjectStateRoutine_D0A5
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D0A5:
LDA #$40 ; CPU:$D0A5 PRG:10A5 A9 40
STA $00 ; CPU:$D0A7 PRG:10A7 85 00
LDA #$04 ; CPU:$D0A9 PRG:10A9 A9 04
STA $01 ; CPU:$D0AB PRG:10AB 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D0AD PRG:10AD 20 01 F6
RTS ; CPU:$D0B0 PRG:10B0 60
;------------------------------------------------------------
; ObjectPath_D0B1
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D0B1:
LDA #$00 ; CPU:$D0B1 PRG:10B1 A9 00
STA $00 ; CPU:$D0B3 PRG:10B3 85 00
LDA #$05 ; CPU:$D0B5 PRG:10B5 A9 05
STA $01 ; CPU:$D0B7 PRG:10B7 85 01
LDA #$07 ; CPU:$D0B9 PRG:10B9 A9 07
STA $0F ; CPU:$D0BB PRG:10BB 85 0F
ObjectPathLoop_D0BD:
JSR ProcessResourceStateRoutine_F601 ; CPU:$D0BD PRG:10BD 20 01 F6
LDX #$00 ; CPU:$D0C0 PRG:10C0 A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D0C2 PRG:10C2 20 D3 CB
BPL ObjectPathLoop_D0BD ; CPU:$D0C5 PRG:10C5 10 F6
RTS ; CPU:$D0C7 PRG:10C7 60
;------------------------------------------------------------
; UpdateObjectBuffer_D0C8
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_D0C8:
LDA #$80 ; CPU:$D0C8 PRG:10C8 A9 80
STA $00 ; CPU:$D0CA PRG:10CA 85 00
LDA #$04 ; CPU:$D0CC PRG:10CC A9 04
STA $01 ; CPU:$D0CE PRG:10CE 85 01
LDA #$03 ; CPU:$D0D0 PRG:10D0 A9 03
STA $0F ; CPU:$D0D2 PRG:10D2 85 0F
ObjectPathLoop_D0D4:
JSR ProcessResourceStateRoutine_F601 ; CPU:$D0D4 PRG:10D4 20 01 F6
LDX #$00 ; CPU:$D0D7 PRG:10D7 A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D0D9 PRG:10D9 20 D3 CB
BPL ObjectPathLoop_D0D4 ; CPU:$D0DC PRG:10DC 10 F6
RTS ; CPU:$D0DE PRG:10DE 60
;------------------------------------------------------------
; ObjectPath_D0DF
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D0DF:
LDA #$00 ; CPU:$D0DF PRG:10DF A9 00
STA $00 ; CPU:$D0E1 PRG:10E1 85 00
LDA #$06 ; CPU:$D0E3 PRG:10E3 A9 06
STA $01 ; CPU:$D0E5 PRG:10E5 85 01
LDA #$07 ; CPU:$D0E7 PRG:10E7 A9 07
STA $0F ; CPU:$D0E9 PRG:10E9 85 0F
ObjectPathLoop_D0EB:
JSR ProcessResourceStateRoutine_F601 ; CPU:$D0EB PRG:10EB 20 01 F6
LDX #$00 ; CPU:$D0EE PRG:10EE A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D0F0 PRG:10F0 20 D3 CB
BPL ObjectPathLoop_D0EB ; CPU:$D0F3 PRG:10F3 10 F6
RTS ; CPU:$D0F5 PRG:10F5 60
;------------------------------------------------------------
; UpdateObjectBuffer_D0F6
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_D0F6:
LDA #$C0 ; CPU:$D0F6 PRG:10F6 A9 C0
STA $00 ; CPU:$D0F8 PRG:10F8 85 00
LDA #$03 ; CPU:$D0FA PRG:10FA A9 03
STA $01 ; CPU:$D0FC PRG:10FC 85 01
LDA #$02 ; CPU:$D0FE PRG:10FE A9 02
STA $0F ; CPU:$D100 PRG:1100 85 0F
ObjectPathLoop_D102:
JSR ProcessResourceStateRoutine_F601 ; CPU:$D102 PRG:1102 20 01 F6
JSR ProcessObjectStateRoutine_DDB2 ; CPU:$D105 PRG:1105 20 B2 DD
DEC $0F ; CPU:$D108 PRG:1108 C6 0F
BPL ObjectPathLoop_D102 ; CPU:$D10A PRG:110A 10 F6
RTS ; CPU:$D10C PRG:110C 60
.byte $02, $03, $07, $0E, $0F, $11, $0A, $0B, $0B, $0C, $11, $0D, $0E, $0F, $0F, $10 ; CPU:$D10D PRG:110D 0B
.byte $0D ; CPU:$D11D PRG:111D 0B
;------------------------------------------------------------
; ReadObjectRecord_D11E
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecord_D11E:
LDY #$10 ; CPU:$D11E PRG:111E A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D120 PRG:1120 B1 08
STA $06 ; CPU:$D122 PRG:1122 85 06
BMI ObjectPathContinue_D132 ; CPU:$D124 PRG:1124 30 0C
LDY #$1B ; CPU:$D126 PRG:1126 A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$D128 PRG:1128 B1 08
CMP #$10 ; CPU:$D12A PRG:112A C9 10
BCC ObjectPathContinue_D132 ; CPU:$D12C PRG:112C 90 04
CMP #$40 ; CPU:$D12E PRG:112E C9 40
BCC ObjectPathOnNoCarry_D14F ; CPU:$D130 PRG:1130 90 1D
ObjectPathContinue_D132:
LDA $54 ; CPU:$D132 PRG:1132 A5 54
BNE UpdateObjectRecordOnNonZero_D13A ; CPU:$D134 PRG:1134 D0 04
LDA #$09 ; CPU:$D136 PRG:1136 A9 09
STA $54 ; CPU:$D138 PRG:1138 85 54
UpdateObjectRecordOnNonZero_D13A:
CMP #$05 ; CPU:$D13A PRG:113A C9 05
BCC ObjectPathOnNoCarry_D14E ; CPU:$D13C PRG:113C 90 10
LDY #$35 ; CPU:$D13E PRG:113E A0 35
LDA #$01 ; CPU:$D140 PRG:1140 A9 01
EOR (CurrentObjectPtrLo),Y ; CPU:$D142 PRG:1142 51 08
STA (CurrentObjectPtrLo),Y ; CPU:$D144 PRG:1144 91 08
LDY #$05 ; CPU:$D146 PRG:1146 A0 05
LDA #$01 ; CPU:$D148 PRG:1148 A9 01
EOR (CurrentObjectPtrLo),Y ; CPU:$D14A PRG:114A 51 08
STA (CurrentObjectPtrLo),Y ; CPU:$D14C PRG:114C 91 08
ObjectPathOnNoCarry_D14E:
RTS ; CPU:$D14E PRG:114E 60
ObjectPathOnNoCarry_D14F:
LDX #$00 ; CPU:$D14F PRG:114F A2 00
LDY $0A ; CPU:$D151 PRG:1151 A4 0A
LDA a:$0058,Y ; CPU:$D153 PRG:1153 B9 58 00
LDY #$04 ; CPU:$D156 PRG:1156 A0 04
ObjectPathLoop_D158:
CMP $D10D,Y ; CPU:$D158 PRG:1158 D9 0D D1
BCS ObjectPathOnCarry_D161 ; CPU:$D15B PRG:115B B0 04
INX ; CPU:$D15D PRG:115D E8
DEY ; CPU:$D15E PRG:115E 88
BPL ObjectPathLoop_D158 ; CPU:$D15F PRG:115F 10 F7
ObjectPathOnCarry_D161:
LDA $06 ; CPU:$D161 PRG:1161 A5 06
AND #$03 ; CPU:$D163 PRG:1163 29 03
CMP #$02 ; CPU:$D165 PRG:1165 C9 02
TXA ; CPU:$D167 PRG:1167 8A
BCC UpdateObjectRecordOnNoCarry_D16D ; CPU:$D168 PRG:1168 90 03
CLC ; CPU:$D16A PRG:116A 18
ADC #$06 ; CPU:$D16B PRG:116B 69 06
UpdateObjectRecordOnNoCarry_D16D:
TAX ; CPU:$D16D PRG:116D AA
CLC ; CPU:$D16E PRG:116E 18
ADC #$06 ; CPU:$D16F PRG:116F 69 06
LDY #$05 ; CPU:$D171 PRG:1171 A0 05
STA (CurrentObjectPtrLo),Y ; CPU:$D173 PRG:1173 91 08
LDA $D112,X ; CPU:$D175 PRG:1175 BD 12 D1
LDY #$25 ; CPU:$D178 PRG:1178 A0 25
STA (CurrentObjectPtrLo),Y ; CPU:$D17A PRG:117A 91 08
SEC ; CPU:$D17C PRG:117C 38
SBC #$04 ; CPU:$D17D PRG:117D E9 04
LDY #$35 ; CPU:$D17F PRG:117F A0 35
STA (CurrentObjectPtrLo),Y ; CPU:$D181 PRG:1181 91 08
RTS ; CPU:$D183 PRG:1183 60
.byte $27, $16, $27, $1A, $27, $26, $27, $2A, $27, $17, $17, $17, $25, $05, $05, $25 ; CPU:$D184 PRG:1184 0B
.byte $2A, $0A, $0A, $2A, $21, $01, $01, $21, $23, $03, $03, $23, $27, $07, $07, $27 ; CPU:$D194 PRG:1194 0B
.byte $25, $05, $05, $25, $21, $11, $11, $11, $21, $0F ; CPU:$D1A4 PRG:11A4 0B
;------------------------------------------------------------
; UpdateObjectBufferRoutine_D1AE
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_D1AE:
STX $00 ; CPU:$D1AE PRG:11AE 86 00
LDX #$3F ; CPU:$D1B0 PRG:11B0 A2 3F
STX $01 ; CPU:$D1B2 PRG:11B2 86 01
TYA ; CPU:$D1B4 PRG:11B4 98
ASL A ; CPU:$D1B5 PRG:11B5 0A
TAY ; CPU:$D1B6 PRG:11B6 A8
LDA $D184,Y ; CPU:$D1B7 PRG:11B7 B9 84 D1
STA $EE ; CPU:$D1BA PRG:11BA 85 EE
INY ; CPU:$D1BC PRG:11BC C8
LDA $D184,Y ; CPU:$D1BD PRG:11BD B9 84 D1
STA $EF ; CPU:$D1C0 PRG:11C0 85 EF
LDA #$EB ; CPU:$D1C2 PRG:11C2 A9 EB
STA $02 ; CPU:$D1C4 PRG:11C4 85 02
LDA #$00 ; CPU:$D1C6 PRG:11C6 A9 00
STA $03 ; CPU:$D1C8 PRG:11C8 85 03
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$D1CA PRG:11CA 20 A1 F3
RTS ; CPU:$D1CD PRG:11CD 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_D1CE
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D1CE:
LDA $87 ; CPU:$D1CE PRG:11CE A5 87
ASL A ; CPU:$D1D0 PRG:11D0 0A
CLC ; CPU:$D1D1 PRG:11D1 18
ADC #$06 ; CPU:$D1D2 PRG:11D2 69 06
TAY ; CPU:$D1D4 PRG:11D4 A8
RTS ; CPU:$D1D5 PRG:11D5 60
;------------------------------------------------------------
; ObjectPath_D1D6
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D1D6:
LDA $62 ; CPU:$D1D6 PRG:11D6 A5 62
BNE ObjectPathOnNonZero_D1F4 ; CPU:$D1D8 PRG:11D8 D0 1A
LDA #$06 ; CPU:$D1DA PRG:11DA A9 06
STA $62 ; CPU:$D1DC PRG:11DC 85 62
LDY #$04 ; CPU:$D1DE PRG:11DE A0 04
LDA $8F ; CPU:$D1E0 PRG:11E0 A5 8F
BEQ ObjectPathOnZero_D1E6 ; CPU:$D1E2 PRG:11E2 F0 02
LDY #$12 ; CPU:$D1E4 PRG:11E4 A0 12
ObjectPathOnZero_D1E6:
LDA #$01 ; CPU:$D1E6 PRG:11E6 A9 01
EOR $A2 ; CPU:$D1E8 PRG:11E8 45 A2
STA $A2 ; CPU:$D1EA PRG:11EA 85 A2
BEQ ObjectPathOnZero_D1EF ; CPU:$D1EC PRG:11EC F0 01
INY ; CPU:$D1EE PRG:11EE C8
ObjectPathOnZero_D1EF:
LDX #$04 ; CPU:$D1EF PRG:11EF A2 04
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$D1F1 PRG:11F1 20 AE D1
ObjectPathOnNonZero_D1F4:
RTS ; CPU:$D1F4 PRG:11F4 60
.byte $22, $5C, $5D, $5E, $5F, $22, $58, $59, $5A, $5B, $22, $54, $55, $56, $57, $22 ; CPU:$D1F5 PRG:11F5 0B
.byte $50, $51, $52, $53 ; CPU:$D205 PRG:1205 0B
;------------------------------------------------------------
; ObjectPath_D209
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D209:
LDA $57 ; CPU:$D209 PRG:1209 A5 57
BNE ObjectPathContinue_D254 ; CPU:$D20B PRG:120B D0 47
LDA #$02 ; CPU:$D20D PRG:120D A9 02
STA $57 ; CPU:$D20F PRG:120F 85 57
;------------------------------------------------------------
; ProcessObjectStateRoutine_D211
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D211:
LDA $A3 ; CPU:$D211 PRG:1211 A5 A3
LDY $A4 ; CPU:$D213 PRG:1213 A4 A4
CPY #$FF ; CPU:$D215 PRG:1215 C0 FF
BNE UpdateObjectBufferOnNonZero_D222 ; CPU:$D217 PRG:1217 D0 09
SEC ; CPU:$D219 PRG:1219 38
SBC #$05 ; CPU:$D21A PRG:121A E9 05
BPL ObjectPathOnPositive_D220 ; CPU:$D21C PRG:121C 10 02
LDA #$0F ; CPU:$D21E PRG:121E A9 0F
ObjectPathOnPositive_D220:
STA $A3 ; CPU:$D220 PRG:1220 85 A3
UpdateObjectBufferOnNonZero_D222:
CLC ; CPU:$D222 PRG:1222 18
ADC #$F5 ; CPU:$D223 PRG:1223 69 F5
STA $02 ; CPU:$D225 PRG:1225 85 02
LDA #$00 ; CPU:$D227 PRG:1227 A9 00
ADC #$D1 ; CPU:$D229 PRG:1229 69 D1
STA $03 ; CPU:$D22B PRG:122B 85 03
JSR RunGameTaskRoutine_C8AA ; CPU:$D22D PRG:122D 20 AA C8
INC $A4 ; CPU:$D230 PRG:1230 E6 A4
INC $A4 ; CPU:$D232 PRG:1232 E6 A4
LDA $A4 ; CPU:$D234 PRG:1234 A5 A4
BMI ObjectPathOnNegative_D23A ; CPU:$D236 PRG:1236 30 02
LDA #$F9 ; CPU:$D238 PRG:1238 A9 F9
ObjectPathOnNegative_D23A:
STA $A4 ; CPU:$D23A PRG:123A 85 A4
LDY #$00 ; CPU:$D23C PRG:123C A0 00
CLC ; CPU:$D23E PRG:123E 18
ADC ($04),Y ; CPU:$D23F PRG:123F 71 04
TAY ; CPU:$D241 PRG:1241 A8
CMP #$01 ; CPU:$D242 PRG:1242 C9 01
BEQ ObjectPathContinue_D254 ; CPU:$D244 PRG:1244 F0 0E
BMI ObjectPathContinue_D254 ; CPU:$D246 PRG:1246 30 0C
LDA ($04),Y ; CPU:$D248 PRG:1248 B1 04
STA $00 ; CPU:$D24A PRG:124A 85 00
DEY ; CPU:$D24C PRG:124C 88
LDA ($04),Y ; CPU:$D24D PRG:124D B1 04
STA $01 ; CPU:$D24F PRG:124F 85 01
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$D251 PRG:1251 20 A1 F3
ObjectPathContinue_D254:
RTS ; CPU:$D254 PRG:1254 60
.byte $02, $03, $00, $00, $00, $00, $00, $01, $10, $14 ; CPU:$D255 PRG:1255 0B
ObjectPathLoop_D25F:
LDY $0A ; CPU:$D25F PRG:125F A4 0A
LDX $D25D,Y ; CPU:$D261 PRG:1261 BE 5D D2
LDA $63 ; CPU:$D264 PRG:1264 A5 63
BEQ ObjectPathOnZero_D277 ; CPU:$D266 PRG:1266 F0 0F
CMP #$08 ; CPU:$D268 PRG:1268 C9 08
BEQ ObjectPathOnZero_D272 ; CPU:$D26A PRG:126A F0 06
INY ; CPU:$D26C PRG:126C C8
INY ; CPU:$D26D PRG:126D C8
CMP #$01 ; CPU:$D26E PRG:126E C9 01
BNE ObjectPathLoop_D275 ; CPU:$D270 PRG:1270 D0 03
ObjectPathOnZero_D272:
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$D272 PRG:1272 20 AE D1
ObjectPathLoop_D275:
SEC ; CPU:$D275 PRG:1275 38
RTS ; CPU:$D276 PRG:1276 60
ObjectPathOnZero_D277:
LDA #$10 ; CPU:$D277 PRG:1277 A9 10
STA $63 ; CPU:$D279 PRG:1279 85 63
BNE ObjectPathLoop_D275 ; CPU:$D27B PRG:127B D0 F8
;------------------------------------------------------------
; UpdateObjectRecord_D27D
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecord_D27D:
LDA $78 ; CPU:$D27D PRG:127D A5 78
BNE ObjectPathLoop_D275 ; CPU:$D27F PRG:127F D0 F4
LDX $0A ; CPU:$D281 PRG:1281 A6 0A
LDA $D0,X ; CPU:$D283 PRG:1283 B5 D0
BEQ ObjectPathOnZero_D2CE ; CPU:$D285 PRG:1285 F0 47
CMP #$02 ; CPU:$D287 PRG:1287 C9 02
BEQ ObjectPathOnZero_D2D0 ; CPU:$D289 PRG:1289 F0 45
LDA $46,X ; CPU:$D28B PRG:128B B5 46
AND #$0F ; CPU:$D28D PRG:128D 29 0F
BEQ ObjectPathLoop_D25F ; CPU:$D28F PRG:128F F0 CE
DEC $D0,X ; CPU:$D291 PRG:1291 D6 D0
TAX ; CPU:$D293 PRG:1293 AA
LDA $D254,X ; CPU:$D294 PRG:1294 BD 54 D2
LDY #$10 ; CPU:$D297 PRG:1297 A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$D299 PRG:1299 91 08
PHA ; CPU:$D29B PRG:129B 48
TAX ; CPU:$D29C PRG:129C AA
LDY $E16F,X ; CPU:$D29D PRG:129D BC 6F E1
LDX $82 ; CPU:$D2A0 PRG:12A0 A6 82
LDA $C0DD,X ; CPU:$D2A2 PRG:12A2 BD DD C0
STA (CurrentObjectPtrLo),Y ; CPU:$D2A5 PRG:12A5 91 08
DEY ; CPU:$D2A7 PRG:12A7 88
LDA $C0D5,X ; CPU:$D2A8 PRG:12A8 BD D5 C0
STA (CurrentObjectPtrLo),Y ; CPU:$D2AB PRG:12AB 91 08
PLA ; CPU:$D2AD PRG:12AD 68
AND #$01 ; CPU:$D2AE PRG:12AE 29 01
BEQ UpdateObjectRecordOnZero_D2B5 ; CPU:$D2B0 PRG:12B0 F0 03
JSR UpdateObjectRecordRoutine_E325 ; CPU:$D2B2 PRG:12B2 20 25 E3
UpdateObjectRecordOnZero_D2B5:
LDY #$30 ; CPU:$D2B5 PRG:12B5 A0 30
LDA #$00 ; CPU:$D2B7 PRG:12B7 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D2B9 PRG:12B9 91 08
LDY $0A ; CPU:$D2BB PRG:12BB A4 0A
LDX $D25D,Y ; CPU:$D2BD PRG:12BD BE 5D D2
LDA a:$0075,Y ; CPU:$D2C0 PRG:12C0 B9 75 00
BEQ ObjectPathOnZero_D2C7 ; CPU:$D2C3 PRG:12C3 F0 02
INY ; CPU:$D2C5 PRG:12C5 C8
INY ; CPU:$D2C6 PRG:12C6 C8
ObjectPathOnZero_D2C7:
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$D2C7 PRG:12C7 20 AE D1
LDA #$04 ; CPU:$D2CA PRG:12CA A9 04
STA $FF ; CPU:$D2CC PRG:12CC 85 FF
ObjectPathOnZero_D2CE:
CLC ; CPU:$D2CE PRG:12CE 18
RTS ; CPU:$D2CF PRG:12CF 60
ObjectPathOnZero_D2D0:
DEC $D0,X ; CPU:$D2D0 PRG:12D0 D6 D0
JSR RunGameTaskRoutine_C8AA ; CPU:$D2D2 PRG:12D2 20 AA C8
LDY #$00 ; CPU:$D2D5 PRG:12D5 A0 00
LDA ($04),Y ; CPU:$D2D7 PRG:12D7 B1 04
TAY ; CPU:$D2D9 PRG:12D9 A8
LDX $0A ; CPU:$D2DA PRG:12DA A6 0A
BEQ UpdateObjectRecordOnZero_D2E0 ; CPU:$D2DC PRG:12DC F0 02
INY ; CPU:$D2DE PRG:12DE C8
INY ; CPU:$D2DF PRG:12DF C8
UpdateObjectRecordOnZero_D2E0:
LDA ($04),Y ; CPU:$D2E0 PRG:12E0 B1 04
STA $00 ; CPU:$D2E2 PRG:12E2 85 00
INY ; CPU:$D2E4 PRG:12E4 C8
LDA ($04),Y ; CPU:$D2E5 PRG:12E5 B1 04
STA $01 ; CPU:$D2E7 PRG:12E7 85 01
LDY #$00 ; CPU:$D2E9 PRG:12E9 A0 00
LDA #$00 ; CPU:$D2EB PRG:12EB A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D2ED PRG:12ED 91 08
INY ; CPU:$D2EF PRG:12EF C8
LDA WorkPtr0Lo ; CPU:$D2F0 PRG:12F0 A5 00
STA (CurrentObjectPtrLo),Y ; CPU:$D2F2 PRG:12F2 91 08
INY ; CPU:$D2F4 PRG:12F4 C8
LDA #$00 ; CPU:$D2F5 PRG:12F5 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D2F7 PRG:12F7 91 08
INY ; CPU:$D2F9 PRG:12F9 C8
LDA WorkPtr0Hi ; CPU:$D2FA PRG:12FA A5 01
STA (CurrentObjectPtrLo),Y ; CPU:$D2FC PRG:12FC 91 08
INY ; CPU:$D2FE PRG:12FE C8
LDA #$00 ; CPU:$D2FF PRG:12FF A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D301 PRG:1301 91 08
LDA #$16 ; CPU:$D303 PRG:1303 A9 16
CPX #$00 ; CPU:$D305 PRG:1305 E0 00
BEQ UpdateObjectRecordOnZero_D30B ; CPU:$D307 PRG:1307 F0 02
LDA #$17 ; CPU:$D309 PRG:1309 A9 17
UpdateObjectRecordOnZero_D30B:
INY ; CPU:$D30B PRG:130B C8
STA (CurrentObjectPtrLo),Y ; CPU:$D30C PRG:130C 91 08
LDY #$10 ; CPU:$D30E PRG:130E A0 10
LDA #$00 ; CPU:$D310 PRG:1310 A9 00
UpdateObjectRecordLoop_D312:
STA (CurrentObjectPtrLo),Y ; CPU:$D312 PRG:1312 91 08
INY ; CPU:$D314 PRG:1314 C8
CPY #$1E ; CPU:$D315 PRG:1315 C0 1E
BNE UpdateObjectRecordLoop_D312 ; CPU:$D317 PRG:1317 D0 F9
LDY #$08 ; CPU:$D319 PRG:1319 A0 08
STA (CurrentObjectPtrLo),Y ; CPU:$D31B PRG:131B 91 08
SEC ; CPU:$D31D PRG:131D 38
RTS ; CPU:$D31E PRG:131E 60
.byte $10, $D0, $12, $13, $14, $15, $17, $18, $19, $1A, $1B, $17 ; CPU:$D31F PRG:131F 0B
ObjectPathLoop_D32B:
LDA #$00 ; CPU:$D32B PRG:132B A9 00
STA $90,X ; CPU:$D32D PRG:132D 95 90
ObjectPathLoop_D32F:
CLC ; CPU:$D32F PRG:132F 18
RTS ; CPU:$D330 PRG:1330 60
ReadObjectRecordLoop_D331:
LDA $78 ; CPU:$D331 PRG:1331 A5 78
BNE ObjectPathLoop_D32B ; CPU:$D333 PRG:1333 D0 F6
LDY #$10 ; CPU:$D335 PRG:1335 A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D337 PRG:1337 B1 08
BMI ObjectPathLoop_D32F ; CPU:$D339 PRG:1339 30 F4
AND #$0F ; CPU:$D33B PRG:133B 29 0F
TAX ; CPU:$D33D PRG:133D AA
JSR UpdateObjectRecordRoutine_E335 ; CPU:$D33E PRG:133E 20 35 E3
BCC ObjectPathLoop_D32F ; CPU:$D341 PRG:1341 90 EC
LDX $0A ; CPU:$D343 PRG:1343 A6 0A
DEC $90,X ; CPU:$D345 PRG:1345 D6 90
LDA #$00 ; CPU:$D347 PRG:1347 A9 00
BEQ UpdateObjectRecordOnZero_D36E ; CPU:$D349 PRG:1349 F0 23
ObjectPathLoop_D34B:
JMP UpdateObjectRecordDispatch_D401 ; CPU:$D34B PRG:134B 4C 01 D4
;------------------------------------------------------------
; ObjectPath_D34E
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D34E:
LDX $0A ; CPU:$D34E PRG:134E A6 0A
LDA $90,X ; CPU:$D350 PRG:1350 B5 90
BEQ ObjectPathLoop_D32F ; CPU:$D352 PRG:1352 F0 DB
CMP #$01 ; CPU:$D354 PRG:1354 C9 01
BEQ ObjectPathOnZero_D382 ; CPU:$D356 PRG:1356 F0 2A
CMP #$10 ; CPU:$D358 PRG:1358 C9 10
BEQ UpdateObjectBufferOnZero_D384 ; CPU:$D35A PRG:135A F0 28
CMP #$11 ; CPU:$D35C PRG:135C C9 11
BEQ UpdateObjectBufferOnZero_D3AF ; CPU:$D35E PRG:135E F0 4F
CMP #$12 ; CPU:$D360 PRG:1360 C9 12
BEQ ObjectPathLoop_D34B ; CPU:$D362 PRG:1362 F0 E7
CMP #$13 ; CPU:$D364 PRG:1364 C9 13
BEQ ReadObjectRecordLoop_D331 ; CPU:$D366 PRG:1366 F0 C9
LDA #$12 ; CPU:$D368 PRG:1368 A9 12
STA $90,X ; CPU:$D36A PRG:136A 95 90
LDA #$05 ; CPU:$D36C PRG:136C A9 05
UpdateObjectRecordOnZero_D36E:
STA $D2,X ; CPU:$D36E PRG:136E 95 D2
LDA #$08 ; CPU:$D370 PRG:1370 A9 08
STA $5C,X ; CPU:$D372 PRG:1372 95 5C
LDY #$20 ; CPU:$D374 PRG:1374 A0 20
LDA #$01 ; CPU:$D376 PRG:1376 A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D378 PRG:1378 91 08
LDY #$30 ; CPU:$D37A PRG:137A A0 30
STA (CurrentObjectPtrLo),Y ; CPU:$D37C PRG:137C 91 08
LDA #$02 ; CPU:$D37E PRG:137E A9 02
STA $FF ; CPU:$D380 PRG:1380 85 FF
ObjectPathOnZero_D382:
SEC ; CPU:$D382 PRG:1382 38
RTS ; CPU:$D383 PRG:1383 60
UpdateObjectBufferOnZero_D384:
LDA $72,X ; CPU:$D384 PRG:1384 B5 72
BNE UpdateObjectBufferOnNonZero_D396 ; CPU:$D386 PRG:1386 D0 0E
STA $90,X ; CPU:$D388 PRG:1388 95 90
INC $90,X ; CPU:$D38A PRG:138A F6 90
LDA #$01 ; CPU:$D38C PRG:138C A9 01
STA $03F0 ; CPU:$D38E PRG:138E 8D F0 03
JSR RunGameTaskRoutine_C8D6 ; CPU:$D391 PRG:1391 20 D6 C8
SEC ; CPU:$D394 PRG:1394 38
RTS ; CPU:$D395 PRG:1395 60
UpdateObjectBufferOnNonZero_D396:
LDA $03F1 ; CPU:$D396 PRG:1396 AD F1 03
CMP #$1A ; CPU:$D399 PRG:1399 C9 1A
BCC UpdateObjectBufferOnNoCarry_D3A2 ; CPU:$D39B PRG:139B 90 05
SBC #$02 ; CPU:$D39D PRG:139D E9 02
STA $03F1 ; CPU:$D39F PRG:139F 8D F1 03
UpdateObjectBufferOnNoCarry_D3A2:
LDA #$F0 ; CPU:$D3A2 PRG:13A2 A9 F0
STA $00 ; CPU:$D3A4 PRG:13A4 85 00
LDA #$03 ; CPU:$D3A6 PRG:13A6 A9 03
STA $01 ; CPU:$D3A8 PRG:13A8 85 01
JSR ProcessResourceStateRoutine_F601 ; CPU:$D3AA PRG:13AA 20 01 F6
SEC ; CPU:$D3AD PRG:13AD 38
RTS ; CPU:$D3AE PRG:13AE 60
UpdateObjectBufferOnZero_D3AF:
LDA $5C,X ; CPU:$D3AF PRG:13AF B5 5C
BNE ObjectPathContinue_D3DA ; CPU:$D3B1 PRG:13B1 D0 27
DEC $80,X ; CPU:$D3B3 PRG:13B3 D6 80
BPL ObjectPathOnPositive_D3E0 ; CPU:$D3B5 PRG:13B5 10 29
STA $80,X ; CPU:$D3B7 PRG:13B7 95 80
LDA $03F0 ; CPU:$D3B9 PRG:13B9 AD F0 03
BEQ ObjectPathContinue_D3DA ; CPU:$D3BC PRG:13BC F0 1C
LDA $8D ; CPU:$D3BE PRG:13BE A5 8D
BNE ObjectPathOnNonZero_D3DC ; CPU:$D3C0 PRG:13C0 D0 1A
STA $03F0 ; CPU:$D3C2 PRG:13C2 8D F0 03
LDA #$EF ; CPU:$D3C5 PRG:13C5 A9 EF
STA $03F1 ; CPU:$D3C7 PRG:13C7 8D F1 03
LDA $D31F,X ; CPU:$D3CA PRG:13CA BD 1F D3
STA $03F3 ; CPU:$D3CD PRG:13CD 8D F3 03
LDA #$01 ; CPU:$D3D0 PRG:13D0 A9 01
STA $FF ; CPU:$D3D2 PRG:13D2 85 FF
LDA #$14 ; CPU:$D3D4 PRG:13D4 A9 14
STA $72,X ; CPU:$D3D6 PRG:13D6 95 72
DEC $90,X ; CPU:$D3D8 PRG:13D8 D6 90
ObjectPathContinue_D3DA:
SEC ; CPU:$D3DA PRG:13DA 38
RTS ; CPU:$D3DB PRG:13DB 60
ObjectPathOnNonZero_D3DC:
STA $90,X ; CPU:$D3DC PRG:13DC 95 90
SEC ; CPU:$D3DE PRG:13DE 38
RTS ; CPU:$D3DF PRG:13DF 60
ObjectPathOnPositive_D3E0:
STA $90,X ; CPU:$D3E0 PRG:13E0 95 90
LDA #$02 ; CPU:$D3E2 PRG:13E2 A9 02
STA $D0,X ; CPU:$D3E4 PRG:13E4 95 D0
JSR ProcessObjectStateRoutine_D42C ; CPU:$D3E6 PRG:13E6 20 2C D4
LDA $A0 ; CPU:$D3E9 PRG:13E9 A5 A0
BEQ ObjectPathOnZero_D3FF ; CPU:$D3EB PRG:13EB F0 12
LDA #$00 ; CPU:$D3ED PRG:13ED A9 00
STA $A0 ; CPU:$D3EF PRG:13EF 85 A0
STA $2F ; CPU:$D3F1 PRG:13F1 85 2F
LDA #$04 ; CPU:$D3F3 PRG:13F3 A9 04
STA $2E ; CPU:$D3F5 PRG:13F5 85 2E
LDA #$82 ; CPU:$D3F7 PRG:13F7 A9 82
JSR ProcessResourceStateRoutine_F31A ; CPU:$D3F9 PRG:13F9 20 1A F3
JSR UpdateGameStateRoutine_C402 ; CPU:$D3FC PRG:13FC 20 02 C4
ObjectPathOnZero_D3FF:
SEC ; CPU:$D3FF PRG:13FF 38
RTS ; CPU:$D400 PRG:1400 60
UpdateObjectRecordDispatch_D401:
LDA $5C,X ; CPU:$D401 PRG:1401 B5 5C
BNE ObjectPathOnNonZero_D418 ; CPU:$D403 PRG:1403 D0 13
LDY $D2,X ; CPU:$D405 PRG:1405 B4 D2
LDA $D321,Y ; CPU:$D407 PRG:1407 B9 21 D3
LDY #$05 ; CPU:$D40A PRG:140A A0 05
STA (CurrentObjectPtrLo),Y ; CPU:$D40C PRG:140C 91 08
CMP #$17 ; CPU:$D40E PRG:140E C9 17
BEQ UpdateObjectRecordOnZero_D41A ; CPU:$D410 PRG:1410 F0 08
INC $D2,X ; CPU:$D412 PRG:1412 F6 D2
LDA #$08 ; CPU:$D414 PRG:1414 A9 08
ObjectPathLoop_D416:
STA $5C,X ; CPU:$D416 PRG:1416 95 5C
ObjectPathOnNonZero_D418:
SEC ; CPU:$D418 PRG:1418 38
RTS ; CPU:$D419 PRG:1419 60
UpdateObjectRecordOnZero_D41A:
DEC $90,X ; CPU:$D41A PRG:141A D6 90
LDY #$00 ; CPU:$D41C PRG:141C A0 00
LDA #$01 ; CPU:$D41E PRG:141E A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D420 PRG:1420 91 08
LDA #$80 ; CPU:$D422 PRG:1422 A9 80
LDY $80,X ; CPU:$D424 PRG:1424 B4 80
BNE ObjectPathLoop_D416 ; CPU:$D426 PRG:1426 D0 EE
LDA #$10 ; CPU:$D428 PRG:1428 A9 10
BNE ObjectPathLoop_D416 ; CPU:$D42A PRG:142A D0 EA
;------------------------------------------------------------
; ProcessObjectStateRoutine_D42C
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D42C:
LDY #$20 ; CPU:$D42C PRG:142C A0 20
LDA #$43 ; CPU:$D42E PRG:142E A9 43
CPX #$00 ; CPU:$D430 PRG:1430 E0 00
BEQ UpdateObjectBufferLoop_D436 ; CPU:$D432 PRG:1432 F0 02
LDA #$5A ; CPU:$D434 PRG:1434 A9 5A
UpdateObjectBufferLoop_D436:
STA $00 ; CPU:$D436 PRG:1436 85 00
STY $01 ; CPU:$D438 PRG:1438 84 01
LDA #$E7 ; CPU:$D43A PRG:143A A9 E7
STA $02 ; CPU:$D43C PRG:143C 85 02
LDA #$00 ; CPU:$D43E PRG:143E A9 00
STA $03 ; CPU:$D440 PRG:1440 85 03
LDA $80,X ; CPU:$D442 PRG:1442 B5 80
STA $E9 ; CPU:$D444 PRG:1444 85 E9
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$D446 PRG:1446 20 A1 F3
RTS ; CPU:$D449 PRG:1449 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_D44A
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D44A:
LDY #$28 ; CPU:$D44A PRG:144A A0 28
LDA #$E9 ; CPU:$D44C PRG:144C A9 E9
CPX #$00 ; CPU:$D44E PRG:144E E0 00
BEQ UpdateObjectBufferLoop_D436 ; CPU:$D450 PRG:1450 F0 E4
LDY #$2A ; CPU:$D452 PRG:1452 A0 2A
LDA #$A9 ; CPU:$D454 PRG:1454 A9 A9
BNE UpdateObjectBufferLoop_D436 ; CPU:$D456 PRG:1456 D0 DE
CLC ; CPU:$D458 PRG:1458 18
BMI ObjectPathOnNegative_D4A3 ; CPU:$D459 PRG:1459 30 48
RTS ; CPU:$D45B PRG:145B 60
.byte $78, $90, $A8, $C0, $D8, $20, $38, $50, $68, $80, $98, $B0, $C8, $C8, $0A, $18 ; CPU:$D45C PRG:145C 0B
.byte $08, $08, $10, $04, $01, $03, $19, $1A, $01, $03 ; CPU:$D46C PRG:146C 0B
ObjectPathLoop_D476:
SBC #$03 ; CPU:$D476 PRG:1476 E9 03
CMP #$F0 ; CPU:$D478 PRG:1478 C9 F0
BCC ObjectPathOnNoCarry_D47E ; CPU:$D47A PRG:147A 90 02
LDA #$F0 ; CPU:$D47C PRG:147C A9 F0
ObjectPathOnNoCarry_D47E:
JMP UpdateObjectRecordDispatch_D49E ; CPU:$D47E PRG:147E 4C 9E D4
ReadObjectRecordDispatch_D481:
CMP #$F0 ; CPU:$D481 PRG:1481 C9 F0
BCS ReadObjectRecordOnCarry_D4D5 ; CPU:$D483 PRG:1483 B0 50
CMP #$90 ; CPU:$D485 PRG:1485 C9 90
AND #$0F ; CPU:$D487 PRG:1487 29 0F
STA $06 ; CPU:$D489 PRG:1489 85 06
BCS UpdateObjectRecordOnCarry_D4DE ; CPU:$D48B PRG:148B B0 51
LSR A ; CPU:$D48D PRG:148D 4A
TAX ; CPU:$D48E PRG:148E AA
LDY $D474,X ; CPU:$D48F PRG:148F BC 74 D4
LDA (CurrentObjectPtrLo),Y ; CPU:$D492 PRG:1492 B1 08
BCS ObjectPathLoop_D476 ; CPU:$D494 PRG:1494 B0 E0
ADC #$03 ; CPU:$D496 PRG:1496 69 03
CMP #$F1 ; CPU:$D498 PRG:1498 C9 F1
BCC UpdateObjectRecordDispatch_D49E ; CPU:$D49A PRG:149A 90 02
LDA #$00 ; CPU:$D49C PRG:149C A9 00
UpdateObjectRecordDispatch_D49E:
STA (CurrentObjectPtrLo),Y ; CPU:$D49E PRG:149E 91 08
LDA $0F ; CPU:$D4A0 PRG:14A0 A5 0F
CLC ; CPU:$D4A2 PRG:14A2 18
ObjectPathOnNegative_D4A3:
ADC #$06 ; CPU:$D4A3 PRG:14A3 69 06
JSR ReadObjectRecordRoutine_E5AA ; CPU:$D4A5 PRG:14A5 20 AA E5
LDY #$10 ; CPU:$D4A8 PRG:14A8 A0 10
BCS UpdateObjectRecordContinue_D4CB ; CPU:$D4AA PRG:14AA B0 1F
CMP #$24 ; CPU:$D4AC PRG:14AC C9 24
BEQ UpdateObjectRecordContinue_D4CB ; CPU:$D4AE PRG:14AE F0 1B
CMP #$FF ; CPU:$D4B0 PRG:14B0 C9 FF
BEQ UpdateObjectRecordOnZero_D4B8 ; CPU:$D4B2 PRG:14B2 F0 04
CMP #$4A ; CPU:$D4B4 PRG:14B4 C9 4A
BCS UpdateObjectRecordContinue_D4CB ; CPU:$D4B6 PRG:14B6 B0 13
UpdateObjectRecordOnZero_D4B8:
LDA #$01 ; CPU:$D4B8 PRG:14B8 A9 01
STA $FC ; CPU:$D4BA PRG:14BA 85 FC
LDA #$94 ; CPU:$D4BC PRG:14BC A9 94
STA (CurrentObjectPtrLo),Y ; CPU:$D4BE PRG:14BE 91 08
LDY #$15 ; CPU:$D4C0 PRG:14C0 A0 15
LDA #$02 ; CPU:$D4C2 PRG:14C2 A9 02
STA (CurrentObjectPtrLo),Y ; CPU:$D4C4 PRG:14C4 91 08
ObjectPathLoop_D4C6:
LDA #$20 ; CPU:$D4C6 PRG:14C6 A9 20
JMP ProcessObjectStateDispatch_D783 ; CPU:$D4C8 PRG:14C8 4C 83 D7
UpdateObjectRecordContinue_D4CB:
LDA (CurrentObjectPtrLo),Y ; CPU:$D4CB PRG:14CB B1 08
AND #$03 ; CPU:$D4CD PRG:14CD 29 03
ORA #$40 ; CPU:$D4CF PRG:14CF 09 40
STA (CurrentObjectPtrLo),Y ; CPU:$D4D1 PRG:14D1 91 08
BNE ObjectPathLoop_D4C6 ; CPU:$D4D3 PRG:14D3 D0 F1
ReadObjectRecordOnCarry_D4D5:
LDY #$15 ; CPU:$D4D5 PRG:14D5 A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D4D7 PRG:14D7 B1 08
BNE ObjectPathOnNonZero_D4F9 ; CPU:$D4D9 PRG:14D9 D0 1E
JMP UpdateObjectRecordDispatch_D57E ; CPU:$D4DB PRG:14DB 4C 7E D5
UpdateObjectRecordOnCarry_D4DE:
LDY #$15 ; CPU:$D4DE PRG:14DE A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D4E0 PRG:14E0 B1 08
BNE ObjectPathOnNonZero_D4F9 ; CPU:$D4E2 PRG:14E2 D0 15
LDA #$01 ; CPU:$D4E4 PRG:14E4 A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D4E6 PRG:14E6 91 08
LDA $06 ; CPU:$D4E8 PRG:14E8 A5 06
CMP #$09 ; CPU:$D4EA PRG:14EA C9 09
BCS UpdateObjectRecordOnCarry_D4FC ; CPU:$D4EC PRG:14EC B0 0E
LDY #$05 ; CPU:$D4EE PRG:14EE A0 05
STA (CurrentObjectPtrLo),Y ; CPU:$D4F0 PRG:14F0 91 08
CLC ; CPU:$D4F2 PRG:14F2 18
ADC #$91 ; CPU:$D4F3 PRG:14F3 69 91
LDY #$10 ; CPU:$D4F5 PRG:14F5 A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$D4F7 PRG:14F7 91 08
ObjectPathOnNonZero_D4F9:
JMP ProcessObjectStateDispatch_D67A ; CPU:$D4F9 PRG:14F9 4C 7A D6
UpdateObjectRecordOnCarry_D4FC:
LDX $82 ; CPU:$D4FC PRG:14FC A6 82
LDA $C0C9,X ; CPU:$D4FE PRG:14FE BD C9 C0
STA (CurrentObjectPtrLo),Y ; CPU:$D501 PRG:1501 91 08
LDY #$10 ; CPU:$D503 PRG:1503 A0 10
LDA #$01 ; CPU:$D505 PRG:1505 A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D507 PRG:1507 91 08
LDY #$00 ; CPU:$D509 PRG:1509 A0 00
STA (CurrentObjectPtrLo),Y ; CPU:$D50B PRG:150B 91 08
INY ; CPU:$D50D PRG:150D C8
LDA (CurrentObjectPtrLo),Y ; CPU:$D50E PRG:150E B1 08
STA $04 ; CPU:$D510 PRG:1510 85 04
LDY #$03 ; CPU:$D512 PRG:1512 A0 03
LDA (CurrentObjectPtrLo),Y ; CPU:$D514 PRG:1514 B1 08
STA $05 ; CPU:$D516 PRG:1516 85 05
LDX #$01 ; CPU:$D518 PRG:1518 A2 01
JSR UpdateObjectBufferRoutine_DD5B ; CPU:$D51A PRG:151A 20 5B DD
LDY #$1B ; CPU:$D51D PRG:151D A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$D51F PRG:151F B1 08
TAX ; CPU:$D521 PRG:1521 AA
INC $D6,X ; CPU:$D522 PRG:1522 F6 D6
JMP ProcessObjectStateDispatch_D67A ; CPU:$D524 PRG:1524 4C 7A D6
UpdateObjectRecordDispatch_D527:
LDX $82 ; CPU:$D527 PRG:1527 A6 82
LDA $C0C1,X ; CPU:$D529 PRG:1529 BD C1 C0
SBC #$05 ; CPU:$D52C PRG:152C E9 05
LDY #$15 ; CPU:$D52E PRG:152E A0 15
CMP (CurrentObjectPtrLo),Y ; CPU:$D530 PRG:1530 D1 08
BCC ObjectPathOnNoCarry_D54C ; CPU:$D532 PRG:1532 90 18
LDA (CurrentObjectPtrLo),Y ; CPU:$D534 PRG:1534 B1 08
BNE ObjectPathOnNonZero_D546 ; CPU:$D536 PRG:1536 D0 0E
LDA #$10 ; CPU:$D538 PRG:1538 A9 10
STA (CurrentObjectPtrLo),Y ; CPU:$D53A PRG:153A 91 08
LDY #$10 ; CPU:$D53C PRG:153C A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D53E PRG:153E B1 08
AND #$03 ; CPU:$D540 PRG:1540 29 03
ORA #$30 ; CPU:$D542 PRG:1542 09 30
STA (CurrentObjectPtrLo),Y ; CPU:$D544 PRG:1544 91 08
ObjectPathOnNonZero_D546:
LDA #$04 ; CPU:$D546 PRG:1546 A9 04
UpdateObjectRecordLoop_D548:
LDY #$05 ; CPU:$D548 PRG:1548 A0 05
STA (CurrentObjectPtrLo),Y ; CPU:$D54A PRG:154A 91 08
ObjectPathOnNoCarry_D54C:
LDA #$30 ; CPU:$D54C PRG:154C A9 30
JMP ProcessObjectStateDispatch_D783 ; CPU:$D54E PRG:154E 4C 83 D7
.byte $A9, $10, $91, $08 ; CPU:$D551 PRG:1551 0B
UpdateObjectRecordDispatch_D555:
AND #$03 ; CPU:$D555 PRG:1555 29 03
ORA #$50 ; CPU:$D557 PRG:1557 09 50
STA (CurrentObjectPtrLo),Y ; CPU:$D559 PRG:1559 91 08
LDY #$15 ; CPU:$D55B PRG:155B A0 15
LDX $82 ; CPU:$D55D PRG:155D A6 82
LDA $C0C1,X ; CPU:$D55F PRG:155F BD C1 C0
STA (CurrentObjectPtrLo),Y ; CPU:$D562 PRG:1562 91 08
INY ; CPU:$D564 PRG:1564 C8
LDA #$00 ; CPU:$D565 PRG:1565 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D567 PRG:1567 91 08
LDY #$08 ; CPU:$D569 PRG:1569 A0 08
STA (CurrentObjectPtrLo),Y ; CPU:$D56B PRG:156B 91 08
LDA #$02 ; CPU:$D56D PRG:156D A9 02
STA $FC ; CPU:$D56F PRG:156F 85 FC
LDY #$09 ; CPU:$D571 PRG:1571 A0 09
LDA (CurrentObjectPtrLo),Y ; CPU:$D573 PRG:1573 B1 08
AND #$F0 ; CPU:$D575 PRG:1575 29 F0
ORA #$03 ; CPU:$D577 PRG:1577 09 03
STA (CurrentObjectPtrLo),Y ; CPU:$D579 PRG:1579 91 08
JMP ProcessObjectStateDispatch_D67A ; CPU:$D57B PRG:157B 4C 7A D6
UpdateObjectRecordDispatch_D57E:
LDY #$15 ; CPU:$D57E PRG:157E A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D580 PRG:1580 B1 08
BNE UpdateObjectRecordOnNonZero_D595 ; CPU:$D582 PRG:1582 D0 11
LDA #$30 ; CPU:$D584 PRG:1584 A9 30
STA (CurrentObjectPtrLo),Y ; CPU:$D586 PRG:1586 91 08
LDY #$10 ; CPU:$D588 PRG:1588 A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D58A PRG:158A B1 08
AND #$03 ; CPU:$D58C PRG:158C 29 03
ORA #$10 ; CPU:$D58E PRG:158E 09 10
STA (CurrentObjectPtrLo),Y ; CPU:$D590 PRG:1590 91 08
JMP ReadObjectRecordDispatch_D777 ; CPU:$D592 PRG:1592 4C 77 D7
UpdateObjectRecordOnNonZero_D595:
LDY #$09 ; CPU:$D595 PRG:1595 A0 09
LDA (CurrentObjectPtrLo),Y ; CPU:$D597 PRG:1597 B1 08
AND #$F0 ; CPU:$D599 PRG:1599 29 F0
ORA #$02 ; CPU:$D59B PRG:159B 09 02
STA (CurrentObjectPtrLo),Y ; CPU:$D59D PRG:159D 91 08
ProcessObjectStateDispatch_D59F:
LDA #$04 ; CPU:$D59F PRG:159F A9 04
BNE UpdateObjectRecordLoop_D548 ; CPU:$D5A1 PRG:15A1 D0 A5
UpdateObjectRecordDispatch_D5A3:
STA $06 ; CPU:$D5A3 PRG:15A3 85 06
LDY #$17 ; CPU:$D5A5 PRG:15A5 A0 17
LDA (CurrentObjectPtrLo),Y ; CPU:$D5A7 PRG:15A7 B1 08
BNE ObjectPathContinue_D5CC ; CPU:$D5A9 PRG:15A9 D0 21
LDY #$15 ; CPU:$D5AB PRG:15AB A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D5AD PRG:15AD B1 08
BEQ ObjectPathContinue_D5CC ; CPU:$D5AF PRG:15AF F0 1B
INY ; CPU:$D5B1 PRG:15B1 C8
LDA (CurrentObjectPtrLo),Y ; CPU:$D5B2 PRG:15B2 B1 08
BNE ObjectPathOnNonZero_D5C9 ; CPU:$D5B4 PRG:15B4 D0 13
LDA #$04 ; CPU:$D5B6 PRG:15B6 A9 04
STA (CurrentObjectPtrLo),Y ; CPU:$D5B8 PRG:15B8 91 08
LDY #$10 ; CPU:$D5BA PRG:15BA A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D5BC PRG:15BC B1 08
CLC ; CPU:$D5BE PRG:15BE 18
ADC #$01 ; CPU:$D5BF PRG:15BF 69 01
CMP #$24 ; CPU:$D5C1 PRG:15C1 C9 24
BNE UpdateObjectRecordOnNonZero_D5C7 ; CPU:$D5C3 PRG:15C3 D0 02
LDA #$20 ; CPU:$D5C5 PRG:15C5 A9 20
UpdateObjectRecordOnNonZero_D5C7:
STA (CurrentObjectPtrLo),Y ; CPU:$D5C7 PRG:15C7 91 08
ObjectPathOnNonZero_D5C9:
JMP ReadObjectRecordDispatch_D777 ; CPU:$D5C9 PRG:15C9 4C 77 D7
ObjectPathContinue_D5CC:
LDX #$00 ; CPU:$D5CC PRG:15CC A2 00
LDA $06 ; CPU:$D5CE PRG:15CE A5 06
AND #$02 ; CPU:$D5D0 PRG:15D0 29 02
BNE ReadObjectRecordOnNonZero_D5D5 ; CPU:$D5D2 PRG:15D2 D0 01
INX ; CPU:$D5D4 PRG:15D4 E8
ReadObjectRecordOnNonZero_D5D5:
EOR #$13 ; CPU:$D5D5 PRG:15D5 49 13
PHA ; CPU:$D5D7 PRG:15D7 48
LDY $D470,X ; CPU:$D5D8 PRG:15D8 BC 70 D4
LDA (CurrentObjectPtrLo),Y ; CPU:$D5DB PRG:15DB B1 08
LDY $D472,X ; CPU:$D5DD PRG:15DD BC 72 D4
LDX #$80 ; CPU:$D5E0 PRG:15E0 A2 80
SEC ; CPU:$D5E2 PRG:15E2 38
SBC (CurrentObjectPtrLo),Y ; CPU:$D5E3 PRG:15E3 F1 08
STA $00 ; CPU:$D5E5 PRG:15E5 85 00
BEQ ObjectPathOnZero_D5F8 ; CPU:$D5E7 PRG:15E7 F0 0F
BCS ObjectPathOnCarry_D5F6 ; CPU:$D5E9 PRG:15E9 B0 0B
PLA ; CPU:$D5EB PRG:15EB 68
AND #$12 ; CPU:$D5EC PRG:15EC 29 12
PHA ; CPU:$D5EE PRG:15EE 48
SEC ; CPU:$D5EF PRG:15EF 38
LDA #$00 ; CPU:$D5F0 PRG:15F0 A9 00
SBC $00 ; CPU:$D5F2 PRG:15F2 E5 00
STA $00 ; CPU:$D5F4 PRG:15F4 85 00
ObjectPathOnCarry_D5F6:
LDX #$20 ; CPU:$D5F6 PRG:15F6 A2 20
ObjectPathOnZero_D5F8:
PLA ; CPU:$D5F8 PRG:15F8 68
CPX $11 ; CPU:$D5F9 PRG:15F9 E4 11
BCC UpdateObjectRecordOnNoCarry_D5FF ; CPU:$D5FB PRG:15FB 90 02
EOR #$01 ; CPU:$D5FD PRG:15FD 49 01
UpdateObjectRecordOnNoCarry_D5FF:
LDY #$10 ; CPU:$D5FF PRG:15FF A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$D601 PRG:1601 91 08
LDX #$01 ; CPU:$D603 PRG:1603 A2 01
LDA $82 ; CPU:$D605 PRG:1605 A5 82
CMP #$03 ; CPU:$D607 PRG:1607 C9 03
BCC UpdateObjectRecordOnNoCarry_D60C ; CPU:$D609 PRG:1609 90 01
INX ; CPU:$D60B PRG:160B E8
UpdateObjectRecordOnNoCarry_D60C:
TXA ; CPU:$D60C PRG:160C 8A
LDY #$18 ; CPU:$D60D PRG:160D A0 18
STA (CurrentObjectPtrLo),Y ; CPU:$D60F PRG:160F 91 08
LDY #$00 ; CPU:$D611 PRG:1611 A0 00
STY $01 ; CPU:$D613 PRG:1613 84 01
ObjectPathLoop_D615:
SEC ; CPU:$D615 PRG:1615 38
LDA WorkPtr0Hi ; CPU:$D616 PRG:1616 A5 01
SBC $C0BD,X ; CPU:$D618 PRG:1618 FD BD C0
STA $01 ; CPU:$D61B PRG:161B 85 01
LDA WorkPtr0Lo ; CPU:$D61D PRG:161D A5 00
SBC $C0B5,X ; CPU:$D61F PRG:161F FD B5 C0
STA $00 ; CPU:$D622 PRG:1622 85 00
INY ; CPU:$D624 PRG:1624 C8
BCS ObjectPathLoop_D615 ; CPU:$D625 PRG:1625 B0 EE
TYA ; CPU:$D627 PRG:1627 98
LDY #$00 ; CPU:$D628 PRG:1628 A0 00
UpdateObjectRecordLoop_D62A:
SEC ; CPU:$D62A PRG:162A 38
SBC #$06 ; CPU:$D62B PRG:162B E9 06
INY ; CPU:$D62D PRG:162D C8
BCS UpdateObjectRecordLoop_D62A ; CPU:$D62E PRG:162E B0 FA
TYA ; CPU:$D630 PRG:1630 98
LDY #$15 ; CPU:$D631 PRG:1631 A0 15
STA (CurrentObjectPtrLo),Y ; CPU:$D633 PRG:1633 91 08
INY ; CPU:$D635 PRG:1635 C8
LDA #$00 ; CPU:$D636 PRG:1636 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D638 PRG:1638 91 08
INY ; CPU:$D63A PRG:163A C8
STA (CurrentObjectPtrLo),Y ; CPU:$D63B PRG:163B 91 08
JMP ReadObjectRecordDispatch_D777 ; CPU:$D63D PRG:163D 4C 77 D7
ObjectPathLoop_D640:
JMP UpdateObjectRecordDispatch_D5A3 ; CPU:$D640 PRG:1640 4C A3 D5
ObjectPathLoop_D643:
JMP ReadObjectRecordDispatch_D481 ; CPU:$D643 PRG:1643 4C 81 D4
ObjectPathLoop_D646:
JMP UpdateObjectRecordDispatch_D57E ; CPU:$D646 PRG:1646 4C 7E D5
ObjectPathLoop_D649:
JMP UpdateObjectBufferDispatch_D73B ; CPU:$D649 PRG:1649 4C 3B D7
ObjectPathLoop_D64C:
JMP UpdateObjectRecordDispatch_D555 ; CPU:$D64C PRG:164C 4C 55 D5
;------------------------------------------------------------
; UpdateObjectBuffer_D64F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_D64F:
LDA #$03 ; CPU:$D64F PRG:164F A9 03
STA $0F ; CPU:$D651 PRG:1651 85 0F
LDA #$80 ; CPU:$D653 PRG:1653 A9 80
STA $08 ; CPU:$D655 PRG:1655 85 08
LDA #$04 ; CPU:$D657 PRG:1657 A9 04
STA $09 ; CPU:$D659 PRG:1659 85 09
ReadObjectRecordLoop_D65B:
LDY #$10 ; CPU:$D65B PRG:165B A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D65D PRG:165D B1 08
BEQ ProcessObjectStateDispatch_D67A ; CPU:$D65F PRG:165F F0 19
BMI ObjectPathLoop_D643 ; CPU:$D661 PRG:1661 30 E0
CMP #$01 ; CPU:$D663 PRG:1663 C9 01
BEQ ReadObjectRecordOnZero_D6A9 ; CPU:$D665 PRG:1665 F0 42
CMP #$20 ; CPU:$D667 PRG:1667 C9 20
BCC ObjectPathLoop_D649 ; CPU:$D669 PRG:1669 90 DE
CMP #$30 ; CPU:$D66B PRG:166B C9 30
BCC ObjectPathLoop_D640 ; CPU:$D66D PRG:166D 90 D1
CMP #$40 ; CPU:$D66F PRG:166F C9 40
BCC ObjectPathLoop_D646 ; CPU:$D671 PRG:1671 90 D3
CMP #$50 ; CPU:$D673 PRG:1673 C9 50
BCC ObjectPathLoop_D64C ; CPU:$D675 PRG:1675 90 D5
JMP UpdateObjectRecordDispatch_D527 ; CPU:$D677 PRG:1677 4C 27 D5
ProcessObjectStateDispatch_D67A:
LDX $5E ; CPU:$D67A PRG:167A A6 5E
BNE UpdateObjectRecordContinue_D68E ; CPU:$D67C PRG:167C D0 10
LDY #$15 ; CPU:$D67E PRG:167E A0 15
UpdateObjectRecordLoop_D680:
LDA (CurrentObjectPtrLo),Y ; CPU:$D680 PRG:1680 B1 08
BEQ UpdateObjectRecordContinue_D68E ; CPU:$D682 PRG:1682 F0 0A
SEC ; CPU:$D684 PRG:1684 38
SBC #$01 ; CPU:$D685 PRG:1685 E9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D687 PRG:1687 91 08
INY ; CPU:$D689 PRG:1689 C8
CPY #$17 ; CPU:$D68A PRG:168A C0 17
BCC UpdateObjectRecordLoop_D680 ; CPU:$D68C PRG:168C 90 F2
UpdateObjectRecordContinue_D68E:
LDY #$1C ; CPU:$D68E PRG:168E A0 1C
LDA (CurrentObjectPtrLo),Y ; CPU:$D690 PRG:1690 B1 08
BEQ ObjectPathOnZero_D699 ; CPU:$D692 PRG:1692 F0 05
SEC ; CPU:$D694 PRG:1694 38
SBC #$01 ; CPU:$D695 PRG:1695 E9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D697 PRG:1697 91 08
ObjectPathOnZero_D699:
LDX #$08 ; CPU:$D699 PRG:1699 A2 08
JSR RunGameTaskRoutine_CBD3 ; CPU:$D69B PRG:169B 20 D3 CB
BPL ReadObjectRecordLoop_D65B ; CPU:$D69E PRG:169E 10 BB
LDX $5E ; CPU:$D6A0 PRG:16A0 A6 5E
BNE ObjectPathOnNonZero_D6A8 ; CPU:$D6A2 PRG:16A2 D0 04
LDX #$05 ; CPU:$D6A4 PRG:16A4 A2 05
STX $5E ; CPU:$D6A6 PRG:16A6 86 5E
ObjectPathOnNonZero_D6A8:
RTS ; CPU:$D6A8 PRG:16A8 60
ReadObjectRecordOnZero_D6A9:
LDY #$15 ; CPU:$D6A9 PRG:16A9 A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D6AB PRG:16AB B1 08
BNE ProcessObjectStateDispatch_D67A ; CPU:$D6AD PRG:16AD D0 CB
JSR RunGameTaskRoutine_C8AA ; CPU:$D6AF PRG:16AF 20 AA C8
LDY #$00 ; CPU:$D6B2 PRG:16B2 A0 00
LDA ($04),Y ; CPU:$D6B4 PRG:16B4 B1 04
LSR A ; CPU:$D6B6 PRG:16B6 4A
TAX ; CPU:$D6B7 PRG:16B7 AA
DEX ; CPU:$D6B8 PRG:16B8 CA
BEQ ProcessObjectStateDispatch_D67A ; CPU:$D6B9 PRG:16B9 F0 BF
LDA $A6 ; CPU:$D6BB PRG:16BB A5 A6
BNE UpdateObjectBufferOnNonZero_D6C0 ; CPU:$D6BD PRG:16BD D0 01
TXA ; CPU:$D6BF PRG:16BF 8A
UpdateObjectBufferOnNonZero_D6C0:
STA $A6 ; CPU:$D6C0 PRG:16C0 85 A6
DEC $A6 ; CPU:$D6C2 PRG:16C2 C6 A6
ASL A ; CPU:$D6C4 PRG:16C4 0A
TAY ; CPU:$D6C5 PRG:16C5 A8
LDA ($04),Y ; CPU:$D6C6 PRG:16C6 B1 04
STA $02 ; CPU:$D6C8 PRG:16C8 85 02
INY ; CPU:$D6CA PRG:16CA C8
LDA ($04),Y ; CPU:$D6CB PRG:16CB B1 04
STA $03 ; CPU:$D6CD PRG:16CD 85 03
JSR UpdateObjectBufferRoutine_E0F9 ; CPU:$D6CF PRG:16CF 20 F9 E0
LDY #$05 ; CPU:$D6D2 PRG:16D2 A0 05
LDA #$00 ; CPU:$D6D4 PRG:16D4 A9 00
UpdateObjectRecordLoop_D6D6:
STA (CurrentObjectPtrLo),Y ; CPU:$D6D6 PRG:16D6 91 08
DEY ; CPU:$D6D8 PRG:16D8 88
BPL UpdateObjectRecordLoop_D6D6 ; CPU:$D6D9 PRG:16D9 10 FB
LDY #$09 ; CPU:$D6DB PRG:16DB A0 09
LDA #$02 ; CPU:$D6DD PRG:16DD A9 02
STA (CurrentObjectPtrLo),Y ; CPU:$D6DF PRG:16DF 91 08
LDY #$01 ; CPU:$D6E1 PRG:16E1 A0 01
LDA WorkPtr0Lo ; CPU:$D6E3 PRG:16E3 A5 00
STA (CurrentObjectPtrLo),Y ; CPU:$D6E5 PRG:16E5 91 08
LDY #$03 ; CPU:$D6E7 PRG:16E7 A0 03
LDA WorkPtr0Hi ; CPU:$D6E9 PRG:16E9 A5 01
STA (CurrentObjectPtrLo),Y ; CPU:$D6EB PRG:16EB 91 08
LDY #$10 ; CPU:$D6ED PRG:16ED A0 10
LDA $15 ; CPU:$D6EF PRG:16EF A5 15
AND #$03 ; CPU:$D6F1 PRG:16F1 29 03
ORA #$30 ; CPU:$D6F3 PRG:16F3 09 30
STA (CurrentObjectPtrLo),Y ; CPU:$D6F5 PRG:16F5 91 08
LDY #$15 ; CPU:$D6F7 PRG:16F7 A0 15
LDA #$0C ; CPU:$D6F9 PRG:16F9 A9 0C
STA (CurrentObjectPtrLo),Y ; CPU:$D6FB PRG:16FB 91 08
INY ; CPU:$D6FD PRG:16FD C8
LDA #$00 ; CPU:$D6FE PRG:16FE A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D700 PRG:1700 91 08
INY ; CPU:$D702 PRG:1702 C8
STA (CurrentObjectPtrLo),Y ; CPU:$D703 PRG:1703 91 08
INY ; CPU:$D705 PRG:1705 C8
LDA #$01 ; CPU:$D706 PRG:1706 A9 01
STA (CurrentObjectPtrLo),Y ; CPU:$D708 PRG:1708 91 08
LDA #$03 ; CPU:$D70A PRG:170A A9 03
STA $02 ; CPU:$D70C PRG:170C 85 02
LDA #$80 ; CPU:$D70E PRG:170E A9 80
STA $00 ; CPU:$D710 PRG:1710 85 00
LDA #$04 ; CPU:$D712 PRG:1712 A9 04
STA $01 ; CPU:$D714 PRG:1714 85 01
ObjectPathLoop_D716:
LDY #$10 ; CPU:$D716 PRG:1716 A0 10
LDA ($00),Y ; CPU:$D718 PRG:1718 B1 00
CMP #$01 ; CPU:$D71A PRG:171A C9 01
BNE ObjectPathContinue_D72A ; CPU:$D71C PRG:171C D0 0C
LDY #$15 ; CPU:$D71E PRG:171E A0 15
LDA ($00),Y ; CPU:$D720 PRG:1720 B1 00
CMP #$20 ; CPU:$D722 PRG:1722 C9 20
BCS ObjectPathContinue_D72A ; CPU:$D724 PRG:1724 B0 04
LDA #$20 ; CPU:$D726 PRG:1726 A9 20
STA ($00),Y ; CPU:$D728 PRG:1728 91 00
ObjectPathContinue_D72A:
LDX #$00 ; CPU:$D72A PRG:172A A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D72C PRG:172C 20 D3 CB
DEC $02 ; CPU:$D72F PRG:172F C6 02
BPL ObjectPathLoop_D716 ; CPU:$D731 PRG:1731 10 E3
JMP ProcessObjectStateDispatch_D59F ; CPU:$D733 PRG:1733 4C 9F D5
ObjectPathLoop_D736:
INY ; CPU:$D736 PRG:1736 C8
LDA #$01 ; CPU:$D737 PRG:1737 A9 01
BNE UpdateObjectRecordOnNonZero_D775 ; CPU:$D739 PRG:1739 D0 3A
UpdateObjectBufferDispatch_D73B:
AND #$03 ; CPU:$D73B PRG:173B 29 03
STA $06 ; CPU:$D73D PRG:173D 85 06
LDA $0F ; CPU:$D73F PRG:173F A5 0F
CLC ; CPU:$D741 PRG:1741 18
ADC #$06 ; CPU:$D742 PRG:1742 69 06
JSR ReadObjectRecordRoutine_E5AA ; CPU:$D744 PRG:1744 20 AA E5
BCS ReadObjectRecordContinue_D7A4 ; CPU:$D747 PRG:1747 B0 5B
CMP #$24 ; CPU:$D749 PRG:1749 C9 24
BEQ ReadObjectRecordContinue_D7A4 ; CPU:$D74B PRG:174B F0 57
CMP #$4E ; CPU:$D74D PRG:174D C9 4E
BCS ObjectPathOnCarry_D755 ; CPU:$D74F PRG:174F B0 04
CMP #$4A ; CPU:$D751 PRG:1751 C9 4A
BCS ReadObjectRecordContinue_D7A4 ; CPU:$D753 PRG:1753 B0 4F
ObjectPathOnCarry_D755:
CMP #$60 ; CPU:$D755 PRG:1755 C9 60
BCS ObjectPathOnCarry_D75D ; CPU:$D757 PRG:1757 B0 04
CMP #$50 ; CPU:$D759 PRG:1759 C9 50
BCS ReadObjectRecordContinue_D7A4 ; CPU:$D75B PRG:175B B0 47
ObjectPathOnCarry_D75D:
CMP #$FD ; CPU:$D75D PRG:175D C9 FD
BCS UpdateObjectRecordOnCarry_D765 ; CPU:$D75F PRG:175F B0 04
CMP #$F9 ; CPU:$D761 PRG:1761 C9 F9
BCS ReadObjectRecordContinue_D7A4 ; CPU:$D763 PRG:1763 B0 3F
UpdateObjectRecordOnCarry_D765:
LDA #$11 ; CPU:$D765 PRG:1765 A9 11
EOR $06 ; CPU:$D767 PRG:1767 45 06
LDY #$10 ; CPU:$D769 PRG:1769 A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$D76B PRG:176B 91 08
LDY #$16 ; CPU:$D76D PRG:176D A0 16
LDA (CurrentObjectPtrLo),Y ; CPU:$D76F PRG:176F B1 08
BNE ObjectPathLoop_D736 ; CPU:$D771 PRG:1771 D0 C3
LDA #$18 ; CPU:$D773 PRG:1773 A9 18
UpdateObjectRecordOnNonZero_D775:
STA (CurrentObjectPtrLo),Y ; CPU:$D775 PRG:1775 91 08
ReadObjectRecordDispatch_D777:
LDY #$10 ; CPU:$D777 PRG:1777 A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$D779 PRG:1779 B1 08
PHA ; CPU:$D77B PRG:177B 48
AND #$03 ; CPU:$D77C PRG:177C 29 03
TAX ; CPU:$D77E PRG:177E AA
JSR UpdateObjectRecordRoutine_CD45 ; CPU:$D77F PRG:177F 20 45 CD
PLA ; CPU:$D782 PRG:1782 68
ProcessObjectStateDispatch_D783:
AND #$F0 ; CPU:$D783 PRG:1783 29 F0
LSR A ; CPU:$D785 PRG:1785 4A
LSR A ; CPU:$D786 PRG:1786 4A
LSR A ; CPU:$D787 PRG:1787 4A
LSR A ; CPU:$D788 PRG:1788 4A
TAX ; CPU:$D789 PRG:1789 AA
DEX ; CPU:$D78A PRG:178A CA
LDA $5F,X ; CPU:$D78B PRG:178B B5 5F
BNE UpdateObjectRecordOnNonZero_D794 ; CPU:$D78D PRG:178D D0 05
LDA $D46A,X ; CPU:$D78F PRG:178F BD 6A D4
STA $5F,X ; CPU:$D792 PRG:1792 95 5F
UpdateObjectRecordOnNonZero_D794:
CMP $D46D,X ; CPU:$D794 PRG:1794 DD 6D D4
BCC ObjectPathOnNoCarry_D7A1 ; CPU:$D797 PRG:1797 90 08
LDY #$05 ; CPU:$D799 PRG:1799 A0 05
LDA #$01 ; CPU:$D79B PRG:179B A9 01
EOR (CurrentObjectPtrLo),Y ; CPU:$D79D PRG:179D 51 08
STA (CurrentObjectPtrLo),Y ; CPU:$D79F PRG:179F 91 08
ObjectPathOnNoCarry_D7A1:
JMP ProcessObjectStateDispatch_D67A ; CPU:$D7A1 PRG:17A1 4C 7A D6
ReadObjectRecordContinue_D7A4:
LDY #$15 ; CPU:$D7A4 PRG:17A4 A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$D7A6 PRG:17A6 B1 08
BEQ UpdateObjectRecordContinue_D814 ; CPU:$D7A8 PRG:17A8 F0 6A
LDY #$17 ; CPU:$D7AA PRG:17AA A0 17
LDA (CurrentObjectPtrLo),Y ; CPU:$D7AC PRG:17AC B1 08
BNE UpdateObjectRecordContinue_D814 ; CPU:$D7AE PRG:17AE D0 64
LDA $06 ; CPU:$D7B0 PRG:17B0 A5 06
LDX #$01 ; CPU:$D7B2 PRG:17B2 A2 01
CMP #$02 ; CPU:$D7B4 PRG:17B4 C9 02
BCC TestObjectFieldOnNoCarry_D7B9 ; CPU:$D7B6 PRG:17B6 90 01
DEX ; CPU:$D7B8 PRG:17B8 CA
TestObjectFieldOnNoCarry_D7B9:
LDY $D470,X ; CPU:$D7B9 PRG:17B9 BC 70 D4
LDA (CurrentObjectPtrLo),Y ; CPU:$D7BC PRG:17BC B1 08
LDY $D472,X ; CPU:$D7BE PRG:17BE BC 72 D4
CMP (CurrentObjectPtrLo),Y ; CPU:$D7C1 PRG:17C1 D1 08
BNE ReadObjectRecordLoop_D80D ; CPU:$D7C3 PRG:17C3 D0 48
TXA ; CPU:$D7C5 PRG:17C5 8A
EOR #$01 ; CPU:$D7C6 PRG:17C6 49 01
TAX ; CPU:$D7C8 PRG:17C8 AA
LDY $D470,X ; CPU:$D7C9 PRG:17C9 BC 70 D4
LDA (CurrentObjectPtrLo),Y ; CPU:$D7CC PRG:17CC B1 08
LDY $D472,X ; CPU:$D7CE PRG:17CE BC 72 D4
CMP (CurrentObjectPtrLo),Y ; CPU:$D7D1 PRG:17D1 D1 08
LDA $06 ; CPU:$D7D3 PRG:17D3 A5 06
AND #$01 ; CPU:$D7D5 PRG:17D5 29 01
BCS ObjectPathOnCarry_D807 ; CPU:$D7D7 PRG:17D7 B0 2E
BEQ ObjectPathOnZero_D809 ; CPU:$D7D9 PRG:17D9 F0 2E
ObjectPathLoop_D7DB:
LDA #$00 ; CPU:$D7DB PRG:17DB A9 00
ProcessObjectStateDispatch_D7DD:
TAX ; CPU:$D7DD PRG:17DD AA
LDA $06 ; CPU:$D7DE PRG:17DE A5 06
LDY #$02 ; CPU:$D7E0 PRG:17E0 A0 02
CMP #$02 ; CPU:$D7E2 PRG:17E2 C9 02
BCC ObjectPathOnNoCarry_D7E8 ; CPU:$D7E4 PRG:17E4 90 02
LDY #$04 ; CPU:$D7E6 PRG:17E6 A0 04
ObjectPathOnNoCarry_D7E8:
AND #$01 ; CPU:$D7E8 PRG:17E8 29 01
BNE UpdateObjectRecordOnNonZero_D7F0 ; CPU:$D7EA PRG:17EA D0 04
INX ; CPU:$D7EC PRG:17EC E8
INX ; CPU:$D7ED PRG:17ED E8
INX ; CPU:$D7EE PRG:17EE E8
INX ; CPU:$D7EF PRG:17EF E8
UpdateObjectRecordOnNonZero_D7F0:
LDA $77 ; CPU:$D7F0 PRG:17F0 A5 77
BNE ObjectPathOnNonZero_D804 ; CPU:$D7F2 PRG:17F2 D0 10
CLC ; CPU:$D7F4 PRG:17F4 18
LDA $C0B9,X ; CPU:$D7F5 PRG:17F5 BD B9 C0
ADC (CurrentObjectPtrLo),Y ; CPU:$D7F8 PRG:17F8 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$D7FA PRG:17FA 91 08
DEY ; CPU:$D7FC PRG:17FC 88
LDA $C0B1,X ; CPU:$D7FD PRG:17FD BD B1 C0
ADC (CurrentObjectPtrLo),Y ; CPU:$D800 PRG:1800 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$D802 PRG:1802 91 08
ObjectPathOnNonZero_D804:
JMP ReadObjectRecordDispatch_D777 ; CPU:$D804 PRG:1804 4C 77 D7
ObjectPathOnCarry_D807:
BEQ ObjectPathLoop_D7DB ; CPU:$D807 PRG:1807 F0 D2
ObjectPathOnZero_D809:
LDA #$03 ; CPU:$D809 PRG:1809 A9 03
BNE ProcessObjectStateDispatch_D7DD ; CPU:$D80B PRG:180B D0 D0
ReadObjectRecordLoop_D80D:
LDY #$18 ; CPU:$D80D PRG:180D A0 18
LDA (CurrentObjectPtrLo),Y ; CPU:$D80F PRG:180F B1 08
JMP ProcessObjectStateDispatch_D7DD ; CPU:$D811 PRG:1811 4C DD D7
UpdateObjectRecordContinue_D814:
LDY #$18 ; CPU:$D814 PRG:1814 A0 18
LDA #$00 ; CPU:$D816 PRG:1816 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$D818 PRG:1818 91 08
LDY #$03 ; CPU:$D81A PRG:181A A0 03
LDX #$08 ; CPU:$D81C PRG:181C A2 08
LDA $06 ; CPU:$D81E PRG:181E A5 06
CMP #$02 ; CPU:$D820 PRG:1820 C9 02
BCS ReadObjectRecordOnCarry_D828 ; CPU:$D822 PRG:1822 B0 04
LDY #$01 ; CPU:$D824 PRG:1824 A0 01
LDX #$11 ; CPU:$D826 PRG:1826 A2 11
ReadObjectRecordOnCarry_D828:
LDA (CurrentObjectPtrLo),Y ; CPU:$D828 PRG:1828 B1 08
INY ; CPU:$D82A PRG:182A C8
STY $00 ; CPU:$D82B PRG:182B 84 00
LDY #$09 ; CPU:$D82D PRG:182D A0 09
ObjectPathLoop_D82F:
CMP $D458,X ; CPU:$D82F PRG:182F DD 58 D4
BEQ ObjectPathOnZero_D83A ; CPU:$D832 PRG:1832 F0 06
DEX ; CPU:$D834 PRG:1834 CA
DEY ; CPU:$D835 PRG:1835 88
BNE ObjectPathLoop_D82F ; CPU:$D836 PRG:1836 D0 F7
BEQ ReadObjectRecordLoop_D80D ; CPU:$D838 PRG:1838 F0 D3
ObjectPathOnZero_D83A:
LDA $15 ; CPU:$D83A PRG:183A A5 15
CMP #$20 ; CPU:$D83C PRG:183C C9 20
BCC UpdateObjectRecordOnNoCarry_D842 ; CPU:$D83E PRG:183E 90 02
LDA #$00 ; CPU:$D840 PRG:1840 A9 00
UpdateObjectRecordOnNoCarry_D842:
LDY #$15 ; CPU:$D842 PRG:1842 A0 15
STA (CurrentObjectPtrLo),Y ; CPU:$D844 PRG:1844 91 08
INY ; CPU:$D846 PRG:1846 C8
LDA #$04 ; CPU:$D847 PRG:1847 A9 04
STA (CurrentObjectPtrLo),Y ; CPU:$D849 PRG:1849 91 08
LDY #$10 ; CPU:$D84B PRG:184B A0 10
LDA $06 ; CPU:$D84D PRG:184D A5 06
ORA #$20 ; CPU:$D84F PRG:184F 09 20
STA (CurrentObjectPtrLo),Y ; CPU:$D851 PRG:1851 91 08
JMP ReadObjectRecordDispatch_D777 ; CPU:$D853 PRG:1853 4C 77 D7
;------------------------------------------------------------
; ObjectPath_D856
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D856:
LDA #$07 ; CPU:$D856 PRG:1856 A9 07
STA $0E ; CPU:$D858 PRG:1858 85 0E
LDA #$00 ; CPU:$D85A PRG:185A A9 00
STA $00 ; CPU:$D85C PRG:185C 85 00
LDA #$05 ; CPU:$D85E PRG:185E A9 05
STA $01 ; CPU:$D860 PRG:1860 85 01
UpdateObjectBufferLoop_D862:
LDA #$03 ; CPU:$D862 PRG:1862 A9 03
STA $0F ; CPU:$D864 PRG:1864 85 0F
LDA #$80 ; CPU:$D866 PRG:1866 A9 80
STA $02 ; CPU:$D868 PRG:1868 85 02
LDA #$04 ; CPU:$D86A PRG:186A A9 04
STA $03 ; CPU:$D86C PRG:186C 85 03
ObjectPathLoop_D86E:
LDY #$10 ; CPU:$D86E PRG:186E A0 10
LDA ($00),Y ; CPU:$D870 PRG:1870 B1 00
BEQ ObjectPathContinue_D8A5 ; CPU:$D872 PRG:1872 F0 31
LDY #$05 ; CPU:$D874 PRG:1874 A0 05
LDA ($00),Y ; CPU:$D876 PRG:1876 B1 00
CMP #$08 ; CPU:$D878 PRG:1878 C9 08
BEQ ObjectPathOnZero_D888 ; CPU:$D87A PRG:187A F0 0C
CMP #$09 ; CPU:$D87C PRG:187C C9 09
BEQ ObjectPathOnZero_D888 ; CPU:$D87E PRG:187E F0 08
CMP #$12 ; CPU:$D880 PRG:1880 C9 12
BEQ ObjectPathOnZero_D888 ; CPU:$D882 PRG:1882 F0 04
CMP #$13 ; CPU:$D884 PRG:1884 C9 13
BNE ObjectPathContinue_D8A5 ; CPU:$D886 PRG:1886 D0 1D
ObjectPathOnZero_D888:
LDY #$10 ; CPU:$D888 PRG:1888 A0 10
LDA ($02),Y ; CPU:$D88A PRG:188A B1 02
CMP #$02 ; CPU:$D88C PRG:188C C9 02
BCC ObjectPathContinue_D8A5 ; CPU:$D88E PRG:188E 90 15
BPL UpdateObjectBufferOnPositive_D896 ; CPU:$D890 PRG:1890 10 04
CMP #$F0 ; CPU:$D892 PRG:1892 C9 F0
BCC ObjectPathContinue_D8A5 ; CPU:$D894 PRG:1894 90 0F
UpdateObjectBufferOnPositive_D896:
JSR ProcessResourceStateRoutine_F71C ; CPU:$D896 PRG:1896 20 1C F7
BCC ObjectPathContinue_D8A5 ; CPU:$D899 PRG:1899 90 0A
LDY #$10 ; CPU:$D89B PRG:189B A0 10
LDA ($02),Y ; CPU:$D89D PRG:189D B1 02
AND #$03 ; CPU:$D89F PRG:189F 29 03
ORA #$40 ; CPU:$D8A1 PRG:18A1 09 40
STA ($02),Y ; CPU:$D8A3 PRG:18A3 91 02
ObjectPathContinue_D8A5:
LDX #$02 ; CPU:$D8A5 PRG:18A5 A2 02
JSR RunGameTaskRoutine_CBD3 ; CPU:$D8A7 PRG:18A7 20 D3 CB
BPL ObjectPathLoop_D86E ; CPU:$D8AA PRG:18AA 10 C2
LDX #$00 ; CPU:$D8AC PRG:18AC A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D8AE PRG:18AE 20 D3 CB
DEC $0E ; CPU:$D8B1 PRG:18B1 C6 0E
BPL UpdateObjectBufferLoop_D862 ; CPU:$D8B3 PRG:18B3 10 AD
RTS ; CPU:$D8B5 PRG:18B5 60
.byte $00, $02, $01, $03 ; CPU:$D8B6 PRG:18B6 0B
;------------------------------------------------------------
; ObjectPath_D8BA
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D8BA:
LDA #$01 ; CPU:$D8BA PRG:18BA A9 01
STA $0E ; CPU:$D8BC PRG:18BC 85 0E
LDA #$40 ; CPU:$D8BE PRG:18BE A9 40
STA $00 ; CPU:$D8C0 PRG:18C0 85 00
LDA #$04 ; CPU:$D8C2 PRG:18C2 A9 04
STA $01 ; CPU:$D8C4 PRG:18C4 85 01
UpdateObjectBufferLoop_D8C6:
LDA #$03 ; CPU:$D8C6 PRG:18C6 A9 03
STA $0F ; CPU:$D8C8 PRG:18C8 85 0F
LDA #$80 ; CPU:$D8CA PRG:18CA A9 80
STA $02 ; CPU:$D8CC PRG:18CC 85 02
LDA #$04 ; CPU:$D8CE PRG:18CE A9 04
STA $03 ; CPU:$D8D0 PRG:18D0 85 03
ObjectPathLoop_D8D2:
JSR ProcessObjectStateRoutine_D970 ; CPU:$D8D2 PRG:18D2 20 70 D9
BNE ProcessObjectStateDispatch_D904 ; CPU:$D8D5 PRG:18D5 D0 2D
LDY #$10 ; CPU:$D8D7 PRG:18D7 A0 10
LDA ($02),Y ; CPU:$D8D9 PRG:18D9 B1 02
BPL ObjectPathOnPositive_D8E1 ; CPU:$D8DB PRG:18DB 10 04
CMP #$F0 ; CPU:$D8DD PRG:18DD C9 F0
BCC ProcessObjectStateDispatch_D904 ; CPU:$D8DF PRG:18DF 90 23
ObjectPathOnPositive_D8E1:
CMP #$02 ; CPU:$D8E1 PRG:18E1 C9 02
BCC ProcessObjectStateDispatch_D904 ; CPU:$D8E3 PRG:18E3 90 1F
JSR ProcessResourceStateRoutine_F71C ; CPU:$D8E5 PRG:18E5 20 1C F7
BCC ProcessObjectStateDispatch_D904 ; CPU:$D8E8 PRG:18E8 90 1A
LDY #$10 ; CPU:$D8EA PRG:18EA A0 10
LDA ($02),Y ; CPU:$D8EC PRG:18EC B1 02
CMP #$30 ; CPU:$D8EE PRG:18EE C9 30
BCS ObjectPathOnCarry_D928 ; CPU:$D8F0 PRG:18F0 B0 36
UpdateObjectBufferLoop_D8F2:
LDA #$23 ; CPU:$D8F2 PRG:18F2 A9 23
STA $90,X ; CPU:$D8F4 PRG:18F4 95 90
LDA ($02),Y ; CPU:$D8F6 PRG:18F6 B1 02
AND #$03 ; CPU:$D8F8 PRG:18F8 29 03
ORA #$F0 ; CPU:$D8FA PRG:18FA 09 F0
STA ($02),Y ; CPU:$D8FC PRG:18FC 91 02
LDY #$15 ; CPU:$D8FE PRG:18FE A0 15
LDA #$08 ; CPU:$D900 PRG:1900 A9 08
STA ($02),Y ; CPU:$D902 PRG:1902 91 02
ProcessObjectStateDispatch_D904:
LDX #$02 ; CPU:$D904 PRG:1904 A2 02
JSR RunGameTaskRoutine_CBD3 ; CPU:$D906 PRG:1906 20 D3 CB
BPL ObjectPathLoop_D8D2 ; CPU:$D909 PRG:1909 10 C7
LDA #$00 ; CPU:$D90B PRG:190B A9 00
STA $00 ; CPU:$D90D PRG:190D 85 00
LDA #$04 ; CPU:$D90F PRG:190F A9 04
STA $01 ; CPU:$D911 PRG:1911 85 01
DEC $0E ; CPU:$D913 PRG:1913 C6 0E
BPL UpdateObjectBufferLoop_D8C6 ; CPU:$D915 PRG:1915 10 AF
RTS ; CPU:$D917 PRG:1917 60
UpdateObjectBufferLoop_D918:
LDA ($02),Y ; CPU:$D918 PRG:1918 B1 02
AND #$03 ; CPU:$D91A PRG:191A 29 03
ORA #$30 ; CPU:$D91C PRG:191C 09 30
STA ($02),Y ; CPU:$D91E PRG:191E 91 02
LDY #$15 ; CPU:$D920 PRG:1920 A0 15
LDA #$14 ; CPU:$D922 PRG:1922 A9 14
STA ($02),Y ; CPU:$D924 PRG:1924 91 02
BNE ProcessObjectStateDispatch_D904 ; CPU:$D926 PRG:1926 D0 DC
ObjectPathOnCarry_D928:
CMP #$40 ; CPU:$D928 PRG:1928 C9 40
BCC UpdateObjectBufferLoop_D918 ; CPU:$D92A PRG:192A 90 EC
CMP #$F0 ; CPU:$D92C PRG:192C C9 F0
BCS UpdateObjectBufferLoop_D8F2 ; CPU:$D92E PRG:192E B0 C2
JSR ProcessObjectStateRoutine_D94D ; CPU:$D930 PRG:1930 20 4D D9
TAX ; CPU:$D933 PRG:1933 AA
EOR ($02),Y ; CPU:$D934 PRG:1934 51 02
AND #$02 ; CPU:$D936 PRG:1936 29 02
BEQ UpdateObjectBufferOnZero_D93D ; CPU:$D938 PRG:1938 F0 03
LDA ($02),Y ; CPU:$D93A PRG:193A B1 02
TAX ; CPU:$D93C PRG:193C AA
UpdateObjectBufferOnZero_D93D:
TXA ; CPU:$D93D PRG:193D 8A
AND #$03 ; CPU:$D93E PRG:193E 29 03
ORA #$80 ; CPU:$D940 PRG:1940 09 80
STA ($02),Y ; CPU:$D942 PRG:1942 91 02
LDY #$1B ; CPU:$D944 PRG:1944 A0 1B
LDA $0E ; CPU:$D946 PRG:1946 A5 0E
STA ($02),Y ; CPU:$D948 PRG:1948 91 02
JMP ProcessObjectStateDispatch_D904 ; CPU:$D94A PRG:194A 4C 04 D9
;------------------------------------------------------------
; ProcessObjectStateRoutine_D94D
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D94D:
LDA ($00),Y ; CPU:$D94D PRG:194D B1 00
BPL ObjectPathContinue_D96D ; CPU:$D94F PRG:194F 10 1C
CMP #$81 ; CPU:$D951 PRG:1951 C9 81
PHP ; CPU:$D953 PRG:1953 08
LDA #$08 ; CPU:$D954 PRG:1954 A9 08
BCC ObjectPathOnNoCarry_D95A ; CPU:$D956 PRG:1956 90 02
LDA #$38 ; CPU:$D958 PRG:1958 A9 38
ObjectPathOnNoCarry_D95A:
LDY #$1B ; CPU:$D95A PRG:195A A0 1B
CLC ; CPU:$D95C PRG:195C 18
ADC ($00),Y ; CPU:$D95D PRG:195D 71 00
ROL A ; CPU:$D95F PRG:195F 2A
ROL A ; CPU:$D960 PRG:1960 2A
ROL A ; CPU:$D961 PRG:1961 2A
AND #$03 ; CPU:$D962 PRG:1962 29 03
TAX ; CPU:$D964 PRG:1964 AA
LDA $D8B6,X ; CPU:$D965 PRG:1965 BD B6 D8
PLP ; CPU:$D968 PRG:1968 28
BCC ObjectPathContinue_D96D ; CPU:$D969 PRG:1969 90 02
EOR #$01 ; CPU:$D96B PRG:196B 49 01
ObjectPathContinue_D96D:
LDY #$10 ; CPU:$D96D PRG:196D A0 10
RTS ; CPU:$D96F PRG:196F 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_D970
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D970:
LDX $0E ; CPU:$D970 PRG:1970 A6 0E
LDA $90,X ; CPU:$D972 PRG:1972 B5 90
BNE ObjectPathOnNonZero_D978 ; CPU:$D974 PRG:1974 D0 02
LDA $D0,X ; CPU:$D976 PRG:1976 B5 D0
ObjectPathOnNonZero_D978:
RTS ; CPU:$D978 PRG:1978 60
.byte $03, $FD ; CPU:$D979 PRG:1979 0B
;------------------------------------------------------------
; ObjectPath_D97B
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_D97B:
LDA #$02 ; CPU:$D97B PRG:197B A9 02
STA $0E ; CPU:$D97D PRG:197D 85 0E
LDA #$80 ; CPU:$D97F PRG:197F A9 80
STA $00 ; CPU:$D981 PRG:1981 85 00
LDA #$04 ; CPU:$D983 PRG:1983 A9 04
STA $01 ; CPU:$D985 PRG:1985 85 01
UpdateObjectBufferLoop_D987:
LDA $0E ; CPU:$D987 PRG:1987 A5 0E
STA $0F ; CPU:$D989 PRG:1989 85 0F
CLC ; CPU:$D98B PRG:198B 18
LDA #$20 ; CPU:$D98C PRG:198C A9 20
ADC $00 ; CPU:$D98E PRG:198E 65 00
STA $02 ; CPU:$D990 PRG:1990 85 02
LDA #$00 ; CPU:$D992 PRG:1992 A9 00
ADC $01 ; CPU:$D994 PRG:1994 65 01
STA $03 ; CPU:$D996 PRG:1996 85 03
ObjectPathLoop_D998:
JSR ProcessResourceStateRoutine_F71C ; CPU:$D998 PRG:1998 20 1C F7
BCC ObjectPathOnNoCarry_D9A0 ; CPU:$D99B PRG:199B 90 03
JSR ProcessObjectStateRoutine_D9B1 ; CPU:$D99D PRG:199D 20 B1 D9
ObjectPathOnNoCarry_D9A0:
LDX #$02 ; CPU:$D9A0 PRG:19A0 A2 02
JSR RunGameTaskRoutine_CBD3 ; CPU:$D9A2 PRG:19A2 20 D3 CB
BPL ObjectPathLoop_D998 ; CPU:$D9A5 PRG:19A5 10 F1
LDX #$00 ; CPU:$D9A7 PRG:19A7 A2 00
JSR RunGameTaskRoutine_CBD3 ; CPU:$D9A9 PRG:19A9 20 D3 CB
DEC $0E ; CPU:$D9AC PRG:19AC C6 0E
BPL UpdateObjectBufferLoop_D987 ; CPU:$D9AE PRG:19AE 10 D7
RTS ; CPU:$D9B0 PRG:19B0 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_D9B1
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_D9B1:
LDY #$10 ; CPU:$D9B1 PRG:19B1 A0 10
LDA ($00),Y ; CPU:$D9B3 PRG:19B3 B1 00
CMP #$20 ; CPU:$D9B5 PRG:19B5 C9 20
BCS ObjectPathContinue_D9DE ; CPU:$D9B7 PRG:19B7 B0 25
LDA ($02),Y ; CPU:$D9B9 PRG:19B9 B1 02
CMP #$20 ; CPU:$D9BB PRG:19BB C9 20
BCS ObjectPathOnCarry_D9CB ; CPU:$D9BD PRG:19BD B0 0C
EOR ($00),Y ; CPU:$D9BF PRG:19BF 51 00
AND #$02 ; CPU:$D9C1 PRG:19C1 29 02
BNE ObjectPathOnNonZero_D9CF ; CPU:$D9C3 PRG:19C3 D0 0A
LDY #$1C ; CPU:$D9C5 PRG:19C5 A0 1C
LDA ($00),Y ; CPU:$D9C7 PRG:19C7 B1 00
BNE ObjectPathContinue_D9DE ; CPU:$D9C9 PRG:19C9 D0 13
ObjectPathOnCarry_D9CB:
JSR UpdateObjectBufferRoutine_D9E2 ; CPU:$D9CB PRG:19CB 20 E2 D9
RTS ; CPU:$D9CE PRG:19CE 60
ObjectPathOnNonZero_D9CF:
JSR UpdateObjectBufferRoutine_D9E2 ; CPU:$D9CF PRG:19CF 20 E2 D9
JSR ProcessResourceStateRoutine_F71C ; CPU:$D9D2 PRG:19D2 20 1C F7
BCC ObjectPathOnNoCarry_D9E1 ; CPU:$D9D5 PRG:19D5 90 0A
JSR UpdateObjectBufferRoutine_D9E2 ; CPU:$D9D7 PRG:19D7 20 E2 D9
LDA #$00 ; CPU:$D9DA PRG:19DA A9 00
STA ($00),Y ; CPU:$D9DC PRG:19DC 91 00
ObjectPathContinue_D9DE:
JSR UpdateObjectBufferRoutine_DA04 ; CPU:$D9DE PRG:19DE 20 04 DA
ObjectPathOnNoCarry_D9E1:
RTS ; CPU:$D9E1 PRG:19E1 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_D9E2
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_D9E2:
LDY #$10 ; CPU:$D9E2 PRG:19E2 A0 10
LDA ($00),Y ; CPU:$D9E4 PRG:19E4 B1 00
EOR #$01 ; CPU:$D9E6 PRG:19E6 49 01
STA ($00),Y ; CPU:$D9E8 PRG:19E8 91 00
LDY #$01 ; CPU:$D9EA PRG:19EA A0 01
CMP #$12 ; CPU:$D9EC PRG:19EC C9 12
BCC ObjectPathOnNoCarry_D9F2 ; CPU:$D9EE PRG:19EE 90 02
LDY #$03 ; CPU:$D9F0 PRG:19F0 A0 03
ObjectPathOnNoCarry_D9F2:
AND #$01 ; CPU:$D9F2 PRG:19F2 29 01
TAX ; CPU:$D9F4 PRG:19F4 AA
LDA $D979,X ; CPU:$D9F5 PRG:19F5 BD 79 D9
CLC ; CPU:$D9F8 PRG:19F8 18
ADC ($00),Y ; CPU:$D9F9 PRG:19F9 71 00
STA ($00),Y ; CPU:$D9FB PRG:19FB 91 00
LDY #$1C ; CPU:$D9FD PRG:19FD A0 1C
LDA #$05 ; CPU:$D9FF PRG:19FF A9 05
STA ($00),Y ; CPU:$DA01 PRG:1A01 91 00
RTS ; CPU:$DA03 PRG:1A03 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_DA04
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_DA04:
LDY #$10 ; CPU:$DA04 PRG:1A04 A0 10
LDA ($02),Y ; CPU:$DA06 PRG:1A06 B1 02
EOR #$01 ; CPU:$DA08 PRG:1A08 49 01
STA ($02),Y ; CPU:$DA0A PRG:1A0A 91 02
LDY #$01 ; CPU:$DA0C PRG:1A0C A0 01
CMP #$12 ; CPU:$DA0E PRG:1A0E C9 12
BCC ObjectPathOnNoCarry_DA14 ; CPU:$DA10 PRG:1A10 90 02
LDY #$03 ; CPU:$DA12 PRG:1A12 A0 03
ObjectPathOnNoCarry_DA14:
AND #$01 ; CPU:$DA14 PRG:1A14 29 01
TAX ; CPU:$DA16 PRG:1A16 AA
LDA $D979,X ; CPU:$DA17 PRG:1A17 BD 79 D9
CLC ; CPU:$DA1A PRG:1A1A 18
ADC ($02),Y ; CPU:$DA1B PRG:1A1B 71 02
STA ($02),Y ; CPU:$DA1D PRG:1A1D 91 02
LDY #$1C ; CPU:$DA1F PRG:1A1F A0 1C
LDA #$05 ; CPU:$DA21 PRG:1A21 A9 05
STA ($02),Y ; CPU:$DA23 PRG:1A23 91 02
RTS ; CPU:$DA25 PRG:1A25 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_DA26
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_DA26:
LDA $77 ; CPU:$DA26 PRG:1A26 A5 77
BNE ObjectPathContinue_DA8A ; CPU:$DA28 PRG:1A28 D0 60
LDA $64 ; CPU:$DA2A PRG:1A2A A5 64
BNE ObjectPathContinue_DA8A ; CPU:$DA2C PRG:1A2C D0 5C
LDA $2E ; CPU:$DA2E PRG:1A2E A5 2E
BNE ObjectPathOnNonZero_DA36 ; CPU:$DA30 PRG:1A30 D0 04
LDA $2F ; CPU:$DA32 PRG:1A32 A5 2F
BEQ ObjectPathContinue_DA8A ; CPU:$DA34 PRG:1A34 F0 54
ObjectPathOnNonZero_DA36:
LDX #$07 ; CPU:$DA36 PRG:1A36 A2 07
LDA $4C ; CPU:$DA38 PRG:1A38 A5 4C
BEQ ObjectPathOnZero_DA3E ; CPU:$DA3A PRG:1A3A F0 02
LDX #$06 ; CPU:$DA3C PRG:1A3C A2 06
ObjectPathOnZero_DA3E:
STX $64 ; CPU:$DA3E PRG:1A3E 86 64
LDA #$01 ; CPU:$DA40 PRG:1A40 A9 01
STA $00 ; CPU:$DA42 PRG:1A42 85 00
LDA #$02 ; CPU:$DA44 PRG:1A44 A9 02
STA $01 ; CPU:$DA46 PRG:1A46 85 01
JSR ProcessResourceStateRoutine_F408 ; CPU:$DA48 PRG:1A48 20 08 F4
LDA $2F ; CPU:$DA4B PRG:1A4B A5 2F
BNE ObjectPathLoop_DA85 ; CPU:$DA4D PRG:1A4D D0 36
LDA $2E ; CPU:$DA4F PRG:1A4F A5 2E
BEQ ObjectPathOnZero_DA65 ; CPU:$DA51 PRG:1A51 F0 12
CMP #$02 ; CPU:$DA53 PRG:1A53 C9 02
BNE ObjectPathLoop_DA85 ; CPU:$DA55 PRG:1A55 D0 2E
LDA #$01 ; CPU:$DA57 PRG:1A57 A9 01
STA $64 ; CPU:$DA59 PRG:1A59 85 64
LDA $8F ; CPU:$DA5B PRG:1A5B A5 8F
BNE ObjectPathLoop_DA85 ; CPU:$DA5D PRG:1A5D D0 26
LDA #$08 ; CPU:$DA5F PRG:1A5F A9 08
STA $FB ; CPU:$DA61 PRG:1A61 85 FB
BNE ObjectPathLoop_DA85 ; CPU:$DA63 PRG:1A63 D0 20
ObjectPathOnZero_DA65:
LDA $8F ; CPU:$DA65 PRG:1A65 A5 8F
BNE ObjectPathOnNonZero_DA8B ; CPU:$DA67 PRG:1A67 D0 22
LDA #$01 ; CPU:$DA69 PRG:1A69 A9 01
STA $A1 ; CPU:$DA6B PRG:1A6B 85 A1
STA $A0 ; CPU:$DA6D PRG:1A6D 85 A0
LDA #$23 ; CPU:$DA6F PRG:1A6F A9 23
LDX $90 ; CPU:$DA71 PRG:1A71 A6 90
CPX #$01 ; CPU:$DA73 PRG:1A73 E0 01
BCS ObjectPathOnCarry_DA79 ; CPU:$DA75 PRG:1A75 B0 02
STA $90 ; CPU:$DA77 PRG:1A77 85 90
ObjectPathOnCarry_DA79:
LDX $91 ; CPU:$DA79 PRG:1A79 A6 91
CPX #$01 ; CPU:$DA7B PRG:1A7B E0 01
BCS ObjectPathOnCarry_DA81 ; CPU:$DA7D PRG:1A7D B0 02
STA $91 ; CPU:$DA7F PRG:1A7F 85 91
ObjectPathOnCarry_DA81:
LDA #$80 ; CPU:$DA81 PRG:1A81 A9 80
STA $FB ; CPU:$DA83 PRG:1A83 85 FB
ObjectPathLoop_DA85:
LDA #$82 ; CPU:$DA85 PRG:1A85 A9 82
JSR ProcessResourceStateRoutine_F31A ; CPU:$DA87 PRG:1A87 20 1A F3
ObjectPathContinue_DA8A:
RTS ; CPU:$DA8A PRG:1A8A 60
ObjectPathOnNonZero_DA8B:
LDA #$23 ; CPU:$DA8B PRG:1A8B A9 23
STA $78 ; CPU:$DA8D PRG:1A8D 85 78
BNE ObjectPathLoop_DA85 ; CPU:$DA8F PRG:1A8F D0 F4
;------------------------------------------------------------
; ObjectPath_DA91
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DA91:
LDA $0401 ; CPU:$DA91 PRG:1A91 AD 01 04
LDY $0403 ; CPU:$DA94 PRG:1A94 AC 03 04
LDX $D0 ; CPU:$DA97 PRG:1A97 A6 D0
BEQ ObjectPathOnZero_DA9F ; CPU:$DA99 PRG:1A99 F0 04
LDA $11 ; CPU:$DA9B PRG:1A9B A5 11
LDY $12 ; CPU:$DA9D PRG:1A9D A4 12
ObjectPathOnZero_DA9F:
STA $0499 ; CPU:$DA9F PRG:1A9F 8D 99 04
STY $049A ; CPU:$DAA2 PRG:1AA2 8C 9A 04
STA $04D9 ; CPU:$DAA5 PRG:1AA5 8D D9 04
STY $04DA ; CPU:$DAA8 PRG:1AA8 8C DA 04
LDX $4C ; CPU:$DAAB PRG:1AAB A6 4C
BEQ ObjectPathOnZero_DAB5 ; CPU:$DAAD PRG:1AAD F0 06
LDA $0441 ; CPU:$DAAF PRG:1AAF AD 41 04
LDY $0443 ; CPU:$DAB2 PRG:1AB2 AC 43 04
ObjectPathOnZero_DAB5:
LDX $D1 ; CPU:$DAB5 PRG:1AB5 A6 D1
BEQ ObjectPathOnZero_DABD ; CPU:$DAB7 PRG:1AB7 F0 04
LDA $13 ; CPU:$DAB9 PRG:1AB9 A5 13
LDY $14 ; CPU:$DABB PRG:1ABB A4 14
ObjectPathOnZero_DABD:
STA $04B9 ; CPU:$DABD PRG:1ABD 8D B9 04
STY $04BA ; CPU:$DAC0 PRG:1AC0 8C BA 04
STA $04F9 ; CPU:$DAC3 PRG:1AC3 8D F9 04
STY $04FA ; CPU:$DAC6 PRG:1AC6 8C FA 04
RTS ; CPU:$DAC9 PRG:1AC9 60
.byte $0C, $FC, $00, $00, $00, $00, $0C, $FC, $00, $F0, $00, $08, $08, $00, $F0, $00 ; CPU:$DACA PRG:1ACA 0B
;------------------------------------------------------------
; ReadObjectRecord_DADA
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecord_DADA:
LDX $0A ; CPU:$DADA PRG:1ADA A6 0A
LDA $46,X ; CPU:$DADC PRG:1ADC B5 46
AND #$C0 ; CPU:$DADE PRG:1ADE 29 C0
BEQ ObjectPathContinue_DB27 ; CPU:$DAE0 PRG:1AE0 F0 45
LDA $DA,X ; CPU:$DAE2 PRG:1AE2 B5 DA
CMP #$02 ; CPU:$DAE4 PRG:1AE4 C9 02
BEQ ObjectPathContinue_DB27 ; CPU:$DAE6 PRG:1AE6 F0 3F
LDA #$20 ; CPU:$DAE8 PRG:1AE8 A9 20
STA $07 ; CPU:$DAEA PRG:1AEA 85 07
LSR A ; CPU:$DAEC PRG:1AEC 4A
STA $6C,X ; CPU:$DAED PRG:1AED 95 6C
LDA $06 ; CPU:$DAEF PRG:1AEF A5 06
BMI ObjectPathOnNegative_DB28 ; CPU:$DAF1 PRG:1AF1 30 35
AND #$03 ; CPU:$DAF3 PRG:1AF3 29 03
TAX ; CPU:$DAF5 PRG:1AF5 AA
LSR A ; CPU:$DAF6 PRG:1AF6 4A
EOR #$01 ; CPU:$DAF7 PRG:1AF7 49 01
STA $0D ; CPU:$DAF9 PRG:1AF9 85 0D
LDY #$01 ; CPU:$DAFB PRG:1AFB A0 01
LDA $DACA,X ; CPU:$DAFD PRG:1AFD BD CA DA
CLC ; CPU:$DB00 PRG:1B00 18
ADC (CurrentObjectPtrLo),Y ; CPU:$DB01 PRG:1B01 71 08
STA $00 ; CPU:$DB03 PRG:1B03 85 00
LDY #$03 ; CPU:$DB05 PRG:1B05 A0 03
LDA $DACE,X ; CPU:$DB07 PRG:1B07 BD CE DA
ReadObjectRecordLoop_DB0A:
CLC ; CPU:$DB0A PRG:1B0A 18
ADC (CurrentObjectPtrLo),Y ; CPU:$DB0B PRG:1B0B 71 08
STA $01 ; CPU:$DB0D PRG:1B0D 85 01
LDA #$00 ; CPU:$DB0F PRG:1B0F A9 00
STA $02 ; CPU:$DB11 PRG:1B11 85 02
STA $0E ; CPU:$DB13 PRG:1B13 85 0E
JSR ProcessObjectStateRoutine_CE50 ; CPU:$DB15 PRG:1B15 20 50 CE
BCS ObjectPathContinue_DB27 ; CPU:$DB18 PRG:1B18 B0 0D
LDX $0A ; CPU:$DB1A PRG:1B1A A6 0A
INC $DA,X ; CPU:$DB1C PRG:1B1C F6 DA
LDY #$15 ; CPU:$DB1E PRG:1B1E A0 15
TXA ; CPU:$DB20 PRG:1B20 8A
STA ($04),Y ; CPU:$DB21 PRG:1B21 91 04
LDA #$40 ; CPU:$DB23 PRG:1B23 A9 40
STA $FF ; CPU:$DB25 PRG:1B25 85 FF
ObjectPathContinue_DB27:
RTS ; CPU:$DB27 PRG:1B27 60
ObjectPathOnNegative_DB28:
CMP #$81 ; CPU:$DB28 PRG:1B28 C9 81
LDA #$08 ; CPU:$DB2A PRG:1B2A A9 08
BCC ReadObjectRecordOnNoCarry_DB30 ; CPU:$DB2C PRG:1B2C 90 02
LDA #$38 ; CPU:$DB2E PRG:1B2E A9 38
ReadObjectRecordOnNoCarry_DB30:
LDY #$1B ; CPU:$DB30 PRG:1B30 A0 1B
CLC ; CPU:$DB32 PRG:1B32 18
ADC (CurrentObjectPtrLo),Y ; CPU:$DB33 PRG:1B33 71 08
ROL A ; CPU:$DB35 PRG:1B35 2A
ROL A ; CPU:$DB36 PRG:1B36 2A
ROL A ; CPU:$DB37 PRG:1B37 2A
AND #$03 ; CPU:$DB38 PRG:1B38 29 03
TAX ; CPU:$DB3A PRG:1B3A AA
AND #$01 ; CPU:$DB3B PRG:1B3B 29 01
EOR #$01 ; CPU:$DB3D PRG:1B3D 49 01
STA $0D ; CPU:$DB3F PRG:1B3F 85 0D
LDY #$21 ; CPU:$DB41 PRG:1B41 A0 21
CLC ; CPU:$DB43 PRG:1B43 18
LDA $DAD2,X ; CPU:$DB44 PRG:1B44 BD D2 DA
ADC (CurrentObjectPtrLo),Y ; CPU:$DB47 PRG:1B47 71 08
STA $00 ; CPU:$DB49 PRG:1B49 85 00
LDA $DAD6,X ; CPU:$DB4B PRG:1B4B BD D6 DA
LDY #$23 ; CPU:$DB4E PRG:1B4E A0 23
BNE ReadObjectRecordLoop_DB0A ; CPU:$DB50 PRG:1B50 D0 B8
;------------------------------------------------------------
; UpdateObjectBuffer_DB52
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_DB52:
LDA $67 ; CPU:$DB52 PRG:1B52 A5 67
BNE ObjectPathContinue_DBC3 ; CPU:$DB54 PRG:1B54 D0 6D
LDA $90 ; CPU:$DB56 PRG:1B56 A5 90
BNE ObjectPathContinue_DBC3 ; CPU:$DB58 PRG:1B58 D0 69
LDA $91 ; CPU:$DB5A PRG:1B5A A5 91
BNE ObjectPathContinue_DBC3 ; CPU:$DB5C PRG:1B5C D0 65
LDA $D0 ; CPU:$DB5E PRG:1B5E A5 D0
BNE ObjectPathContinue_DBC3 ; CPU:$DB60 PRG:1B60 D0 61
LDA $D1 ; CPU:$DB62 PRG:1B62 A5 D1
BNE ObjectPathContinue_DBC3 ; CPU:$DB64 PRG:1B64 D0 5D
LDA #$00 ; CPU:$DB66 PRG:1B66 A9 00
STA $00 ; CPU:$DB68 PRG:1B68 85 00
LDA #$04 ; CPU:$DB6A PRG:1B6A A9 04
STA $01 ; CPU:$DB6C PRG:1B6C 85 01
LDA #$40 ; CPU:$DB6E PRG:1B6E A9 40
STA $02 ; CPU:$DB70 PRG:1B70 85 02
LDA #$04 ; CPU:$DB72 PRG:1B72 A9 04
STA $03 ; CPU:$DB74 PRG:1B74 85 03
JSR ProcessResourceStateRoutine_F71C ; CPU:$DB76 PRG:1B76 20 1C F7
BCC ObjectPathContinue_DBC3 ; CPU:$DB79 PRG:1B79 90 48
JSR ProcessObjectStateRoutine_DB8A ; CPU:$DB7B PRG:1B7B 20 8A DB
LDA #$40 ; CPU:$DB7E PRG:1B7E A9 40
STA $00 ; CPU:$DB80 PRG:1B80 85 00
LDA #$04 ; CPU:$DB82 PRG:1B82 A9 04
STA $01 ; CPU:$DB84 PRG:1B84 85 01
LDA #$08 ; CPU:$DB86 PRG:1B86 A9 08
STA $FF ; CPU:$DB88 PRG:1B88 85 FF
;------------------------------------------------------------
; ProcessObjectStateRoutine_DB8A
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_DB8A:
LDY #$10 ; CPU:$DB8A PRG:1B8A A0 10
LDA ($00),Y ; CPU:$DB8C PRG:1B8C B1 00
BMI UpdateObjectBufferOnNegative_DBA7 ; CPU:$DB8E PRG:1B8E 30 17
CMP #$04 ; CPU:$DB90 PRG:1B90 C9 04
BCS ObjectPathContinue_DBC3 ; CPU:$DB92 PRG:1B92 B0 2F
TAX ; CPU:$DB94 PRG:1B94 AA
LDY $E16F,X ; CPU:$DB95 PRG:1B95 BC 6F E1
SEC ; CPU:$DB98 PRG:1B98 38
LDA #$00 ; CPU:$DB99 PRG:1B99 A9 00
SBC ($00),Y ; CPU:$DB9B PRG:1B9B F1 00
STA ($00),Y ; CPU:$DB9D PRG:1B9D 91 00
DEY ; CPU:$DB9F PRG:1B9F 88
LDA #$00 ; CPU:$DBA0 PRG:1BA0 A9 00
SBC ($00),Y ; CPU:$DBA2 PRG:1BA2 F1 00
STA ($00),Y ; CPU:$DBA4 PRG:1BA4 91 00
TXA ; CPU:$DBA6 PRG:1BA6 8A
UpdateObjectBufferOnNegative_DBA7:
LDY #$18 ; CPU:$DBA7 PRG:1BA7 A0 18
STY $67 ; CPU:$DBA9 PRG:1BA9 84 67
EOR #$01 ; CPU:$DBAB PRG:1BAB 49 01
LDY #$10 ; CPU:$DBAD PRG:1BAD A0 10
STA ($00),Y ; CPU:$DBAF PRG:1BAF 91 00
LDA #$0A ; CPU:$DBB1 PRG:1BB1 A9 0A
STA $56 ; CPU:$DBB3 PRG:1BB3 85 56
LDY #$02 ; CPU:$DBB5 PRG:1BB5 A0 02
LDX #$10 ; CPU:$DBB7 PRG:1BB7 A2 10
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DBB9 PRG:1BB9 20 AE D1
LDY #$03 ; CPU:$DBBC PRG:1BBC A0 03
LDX #$14 ; CPU:$DBBE PRG:1BBE A2 14
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DBC0 PRG:1BC0 20 AE D1
ObjectPathContinue_DBC3:
RTS ; CPU:$DBC3 PRG:1BC3 60
.byte $A8, $B0, $B8 ; CPU:$DBC4 PRG:1BC4 0B
;------------------------------------------------------------
; UpdateObjectBuffer_DBC7
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_DBC7:
LDA #$07 ; CPU:$DBC7 PRG:1BC7 A9 07
STA $0F ; CPU:$DBC9 PRG:1BC9 85 0F
LDA #$00 ; CPU:$DBCB PRG:1BCB A9 00
STA $02 ; CPU:$DBCD PRG:1BCD 85 02
LDA #$06 ; CPU:$DBCF PRG:1BCF A9 06
STA $03 ; CPU:$DBD1 PRG:1BD1 85 03
ObjectPathLoop_DBD3:
LDY #$10 ; CPU:$DBD3 PRG:1BD3 A0 10
LDA ($02),Y ; CPU:$DBD5 PRG:1BD5 B1 02
TAX ; CPU:$DBD7 PRG:1BD7 AA
BEQ ObjectPathLoop_DC36 ; CPU:$DBD8 PRG:1BD8 F0 5C
DEX ; CPU:$DBDA PRG:1BDA CA
TXA ; CPU:$DBDB PRG:1BDB 8A
STA ($02),Y ; CPU:$DBDC PRG:1BDC 91 02
LDY #$00 ; CPU:$DBDE PRG:1BDE A0 00
LDA ($02),Y ; CPU:$DBE0 PRG:1BE0 B1 02
BMI ObjectPathOnNegative_DC3E ; CPU:$DBE2 PRG:1BE2 30 5A
LDY #$05 ; CPU:$DBE4 PRG:1BE4 A0 05
LDA #$08 ; CPU:$DBE6 PRG:1BE6 A9 08
CPX #$1C ; CPU:$DBE8 PRG:1BE8 E0 1C
BEQ ObjectPathOnZero_DC34 ; CPU:$DBEA PRG:1BEA F0 48
LDA #$09 ; CPU:$DBEC PRG:1BEC A9 09
CPX #$14 ; CPU:$DBEE PRG:1BEE E0 14
BEQ ObjectPathOnZero_DC34 ; CPU:$DBF0 PRG:1BF0 F0 42
LDA #$01 ; CPU:$DBF2 PRG:1BF2 A9 01
CPX #$01 ; CPU:$DBF4 PRG:1BF4 E0 01
BEQ ObjectPathLoop_DC2E ; CPU:$DBF6 PRG:1BF6 F0 36
CPX #$00 ; CPU:$DBF8 PRG:1BF8 E0 00
BNE ObjectPathLoop_DC36 ; CPU:$DBFA PRG:1BFA D0 3A
LDY #$01 ; CPU:$DBFC PRG:1BFC A0 01
LDA ($02),Y ; CPU:$DBFE PRG:1BFE B1 02
SEC ; CPU:$DC00 PRG:1C00 38
SBC #$04 ; CPU:$DC01 PRG:1C01 E9 04
STA $04 ; CPU:$DC03 PRG:1C03 85 04
LDY #$03 ; CPU:$DC05 PRG:1C05 A0 03
LDA ($02),Y ; CPU:$DC07 PRG:1C07 B1 02
SEC ; CPU:$DC09 PRG:1C09 38
SBC #$04 ; CPU:$DC0A PRG:1C0A E9 04
STA $05 ; CPU:$DC0C PRG:1C0C 85 05
LDY #$11 ; CPU:$DC0E PRG:1C0E A0 11
LDA ($02),Y ; CPU:$DC10 PRG:1C10 B1 02
TAX ; CPU:$DC12 PRG:1C12 AA
BEQ ObjectPathOnZero_DC18 ; CPU:$DC13 PRG:1C13 F0 03
JSR UpdateObjectBufferRoutine_DD5B ; CPU:$DC15 PRG:1C15 20 5B DD
ObjectPathOnZero_DC18:
LDY #$0B ; CPU:$DC18 PRG:1C18 A0 0B
LDA ($02),Y ; CPU:$DC1A PRG:1C1A B1 02
LDX #$03 ; CPU:$DC1C PRG:1C1C A2 03
ObjectPathLoop_DC1E:
DEX ; CPU:$DC1E PRG:1C1E CA
CMP $DBC4,X ; CPU:$DC1F PRG:1C1F DD C4 DB
BNE ObjectPathLoop_DC1E ; CPU:$DC22 PRG:1C22 D0 FA
LDA #$00 ; CPU:$DC24 PRG:1C24 A9 00
STA $A9,X ; CPU:$DC26 PRG:1C26 95 A9
LDY #$01 ; CPU:$DC28 PRG:1C28 A0 01
STA ($02),Y ; CPU:$DC2A PRG:1C2A 91 02
LDA #$80 ; CPU:$DC2C PRG:1C2C A9 80
ObjectPathLoop_DC2E:
LDX #$10 ; CPU:$DC2E PRG:1C2E A2 10
STX $FF ; CPU:$DC30 PRG:1C30 86 FF
LDY #$00 ; CPU:$DC32 PRG:1C32 A0 00
ObjectPathOnZero_DC34:
STA ($02),Y ; CPU:$DC34 PRG:1C34 91 02
ObjectPathLoop_DC36:
LDX #$02 ; CPU:$DC36 PRG:1C36 A2 02
JSR RunGameTaskRoutine_CBD3 ; CPU:$DC38 PRG:1C38 20 D3 CB
BPL ObjectPathLoop_DBD3 ; CPU:$DC3B PRG:1C3B 10 96
RTS ; CPU:$DC3D PRG:1C3D 60
ObjectPathOnNegative_DC3E:
CPX #$00 ; CPU:$DC3E PRG:1C3E E0 00
BNE ObjectPathLoop_DC36 ; CPU:$DC40 PRG:1C40 D0 F4
LDX #$03 ; CPU:$DC42 PRG:1C42 A2 03
ObjectPathLoop_DC44:
DEX ; CPU:$DC44 PRG:1C44 CA
BMI ObjectPathLoop_DC36 ; CPU:$DC45 PRG:1C45 30 EF
LDA $A9,X ; CPU:$DC47 PRG:1C47 B5 A9
BNE ObjectPathLoop_DC44 ; CPU:$DC49 PRG:1C49 D0 F9
LDY #$0B ; CPU:$DC4B PRG:1C4B A0 0B
LDA $DBC4,X ; CPU:$DC4D PRG:1C4D BD C4 DB
STA ($02),Y ; CPU:$DC50 PRG:1C50 91 02
LDA #$01 ; CPU:$DC52 PRG:1C52 A9 01
STA $A9,X ; CPU:$DC54 PRG:1C54 95 A9
LDA #$00 ; CPU:$DC56 PRG:1C56 A9 00
BEQ ObjectPathLoop_DC2E ; CPU:$DC58 PRG:1C58 F0 D4
;------------------------------------------------------------
; ObjectPath_DC5A
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DC5A:
LDA #$01 ; CPU:$DC5A PRG:1C5A A9 01
STA $0E ; CPU:$DC5C PRG:1C5C 85 0E
LDA #$40 ; CPU:$DC5E PRG:1C5E A9 40
STA $00 ; CPU:$DC60 PRG:1C60 85 00
LDA #$04 ; CPU:$DC62 PRG:1C62 A9 04
STA $01 ; CPU:$DC64 PRG:1C64 85 01
UpdateObjectBufferLoop_DC66:
LDA #$07 ; CPU:$DC66 PRG:1C66 A9 07
STA $0F ; CPU:$DC68 PRG:1C68 85 0F
LDA #$00 ; CPU:$DC6A PRG:1C6A A9 00
STA $02 ; CPU:$DC6C PRG:1C6C 85 02
LDA #$06 ; CPU:$DC6E PRG:1C6E A9 06
STA $03 ; CPU:$DC70 PRG:1C70 85 03
ObjectPathLoop_DC72:
JSR ProcessObjectStateRoutine_D970 ; CPU:$DC72 PRG:1C72 20 70 D9
BNE ObjectPathLoop_DC8A ; CPU:$DC75 PRG:1C75 D0 13
LDY #$00 ; CPU:$DC77 PRG:1C77 A0 00
LDA ($02),Y ; CPU:$DC79 PRG:1C79 B1 02
BMI ObjectPathOnNegative_DC9E ; CPU:$DC7B PRG:1C7B 30 21
BNE ObjectPathLoop_DC8A ; CPU:$DC7D PRG:1C7D D0 0B
JSR ProcessResourceStateRoutine_F71C ; CPU:$DC7F PRG:1C7F 20 1C F7
BCC ObjectPathLoop_DC8A ; CPU:$DC82 PRG:1C82 90 06
LDY #$10 ; CPU:$DC84 PRG:1C84 A0 10
LDA ($02),Y ; CPU:$DC86 PRG:1C86 B1 02
BEQ UpdateObjectBufferOnZero_DCBB ; CPU:$DC88 PRG:1C88 F0 31
ObjectPathLoop_DC8A:
LDX #$02 ; CPU:$DC8A PRG:1C8A A2 02
JSR RunGameTaskRoutine_CBD3 ; CPU:$DC8C PRG:1C8C 20 D3 CB
BPL ObjectPathLoop_DC72 ; CPU:$DC8F PRG:1C8F 10 E1
LDA #$00 ; CPU:$DC91 PRG:1C91 A9 00
STA $00 ; CPU:$DC93 PRG:1C93 85 00
LDA #$04 ; CPU:$DC95 PRG:1C95 A9 04
STA $01 ; CPU:$DC97 PRG:1C97 85 01
DEC $0E ; CPU:$DC99 PRG:1C99 C6 0E
BPL UpdateObjectBufferLoop_DC66 ; CPU:$DC9B PRG:1C9B 10 C9
RTS ; CPU:$DC9D PRG:1C9D 60
ObjectPathOnNegative_DC9E:
INY ; CPU:$DC9E PRG:1C9E C8
LDA ($02),Y ; CPU:$DC9F PRG:1C9F B1 02
BEQ ObjectPathLoop_DC8A ; CPU:$DCA1 PRG:1CA1 F0 E7
DEY ; CPU:$DCA3 PRG:1CA3 88
LDA #$00 ; CPU:$DCA4 PRG:1CA4 A9 00
STA ($02),Y ; CPU:$DCA6 PRG:1CA6 91 02
JSR ProcessResourceStateRoutine_F71C ; CPU:$DCA8 PRG:1CA8 20 1C F7
LDY #$00 ; CPU:$DCAB PRG:1CAB A0 00
LDA #$80 ; CPU:$DCAD PRG:1CAD A9 80
STA ($02),Y ; CPU:$DCAF PRG:1CAF 91 02
BCC ObjectPathLoop_DC8A ; CPU:$DCB1 PRG:1CB1 90 D7
LDA #$04 ; CPU:$DCB3 PRG:1CB3 A9 04
LDY #$10 ; CPU:$DCB5 PRG:1CB5 A0 10
STA ($02),Y ; CPU:$DCB7 PRG:1CB7 91 02
BNE ObjectPathLoop_DC8A ; CPU:$DCB9 PRG:1CB9 D0 CF
UpdateObjectBufferOnZero_DCBB:
LDY #$10 ; CPU:$DCBB PRG:1CBB A0 10
LDA #$28 ; CPU:$DCBD PRG:1CBD A9 28
STA ($02),Y ; CPU:$DCBF PRG:1CBF 91 02
LDY #$05 ; CPU:$DCC1 PRG:1CC1 A0 05
LDA ($02),Y ; CPU:$DCC3 PRG:1CC3 B1 02
TAX ; CPU:$DCC5 PRG:1CC5 AA
BEQ ObjectPathOnZero_DCEA ; CPU:$DCC6 PRG:1CC6 F0 22
DEX ; CPU:$DCC8 PRG:1CC8 CA
BEQ ObjectPathOnZero_DD08 ; CPU:$DCC9 PRG:1CC9 F0 3D
LDA #$03 ; CPU:$DCCB PRG:1CCB A9 03
LDY #$15 ; CPU:$DCCD PRG:1CCD A0 15
DEX ; CPU:$DCCF PRG:1CCF CA
BEQ ObjectPathOnZero_DCD6 ; CPU:$DCD0 PRG:1CD0 F0 04
LDA #$02 ; CPU:$DCD2 PRG:1CD2 A9 02
LDY #$08 ; CPU:$DCD4 PRG:1CD4 A0 08
ObjectPathOnZero_DCD6:
STY $00 ; CPU:$DCD6 PRG:1CD6 84 00
LDY #$11 ; CPU:$DCD8 PRG:1CD8 A0 11
STA ($02),Y ; CPU:$DCDA PRG:1CDA 91 02
LDA $8D ; CPU:$DCDC PRG:1CDC A5 8D
BNE ObjectPathOnNonZero_DCE9 ; CPU:$DCDE PRG:1CDE D0 09
LDA $0E ; CPU:$DCE0 PRG:1CE0 A5 0E
ORA #$08 ; CPU:$DCE2 PRG:1CE2 09 08
STA $01 ; CPU:$DCE4 PRG:1CE4 85 01
JSR ProcessResourceStateRoutine_F40C ; CPU:$DCE6 PRG:1CE6 20 0C F4
ObjectPathOnNonZero_DCE9:
RTS ; CPU:$DCE9 PRG:1CE9 60
ObjectPathOnZero_DCEA:
JSR ProcessObjectStateRoutine_D1CE ; CPU:$DCEA PRG:1CEA 20 CE D1
INY ; CPU:$DCED PRG:1CED C8
LDX #$08 ; CPU:$DCEE PRG:1CEE A2 08
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DCF0 PRG:1CF0 20 AE D1
LDA $0E ; CPU:$DCF3 PRG:1CF3 A5 0E
EOR #$01 ; CPU:$DCF5 PRG:1CF5 49 01
TAY ; CPU:$DCF7 PRG:1CF7 A8
LDA #$30 ; CPU:$DCF8 PRG:1CF8 A9 30
STA a:$0075,Y ; CPU:$DCFA PRG:1CFA 99 75 00
STA $77 ; CPU:$DCFD PRG:1CFD 85 77
LDX $D25D,Y ; CPU:$DCFF PRG:1CFF BE 5D D2
INY ; CPU:$DD02 PRG:1D02 C8
INY ; CPU:$DD03 PRG:1D03 C8
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD04 PRG:1D04 20 AE D1
RTS ; CPU:$DD07 PRG:1D07 60
ObjectPathOnZero_DD08:
LDX $0E ; CPU:$DD08 PRG:1D08 A6 0E
INC $80,X ; CPU:$DD0A PRG:1D0A F6 80
JSR ProcessObjectStateRoutine_D42C ; CPU:$DD0C PRG:1D0C 20 2C D4
RTS ; CPU:$DD0F PRG:1D0F 60
;------------------------------------------------------------
; ObjectPath_DD10
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DD10:
LDA $77 ; CPU:$DD10 PRG:1D10 A5 77
CMP #$01 ; CPU:$DD12 PRG:1D12 C9 01
BNE ObjectPathOnNonZero_DD20 ; CPU:$DD14 PRG:1D14 D0 0A
DEC $77 ; CPU:$DD16 PRG:1D16 C6 77
JSR ProcessObjectStateRoutine_D1CE ; CPU:$DD18 PRG:1D18 20 CE D1
LDX #$08 ; CPU:$DD1B PRG:1D1B A2 08
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD1D PRG:1D1D 20 AE D1
ObjectPathOnNonZero_DD20:
LDA $75 ; CPU:$DD20 PRG:1D20 A5 75
CMP #$01 ; CPU:$DD22 PRG:1D22 C9 01
BNE ObjectPathOnNonZero_DD2F ; CPU:$DD24 PRG:1D24 D0 09
DEC $75 ; CPU:$DD26 PRG:1D26 C6 75
LDY #$00 ; CPU:$DD28 PRG:1D28 A0 00
LDX #$10 ; CPU:$DD2A PRG:1D2A A2 10
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD2C PRG:1D2C 20 AE D1
ObjectPathOnNonZero_DD2F:
LDA $76 ; CPU:$DD2F PRG:1D2F A5 76
CMP #$01 ; CPU:$DD31 PRG:1D31 C9 01
BNE ObjectPathOnNonZero_DD3E ; CPU:$DD33 PRG:1D33 D0 09
DEC $76 ; CPU:$DD35 PRG:1D35 C6 76
LDY #$01 ; CPU:$DD37 PRG:1D37 A0 01
LDX #$14 ; CPU:$DD39 PRG:1D39 A2 14
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD3B PRG:1D3B 20 AE D1
ObjectPathOnNonZero_DD3E:
LDA $56 ; CPU:$DD3E PRG:1D3E A5 56
CMP #$01 ; CPU:$DD40 PRG:1D40 C9 01
BNE ObjectPathOnNonZero_DD5A ; CPU:$DD42 PRG:1D42 D0 16
LDA $75 ; CPU:$DD44 PRG:1D44 A5 75
BNE ObjectPathOnNonZero_DD4F ; CPU:$DD46 PRG:1D46 D0 07
;------------------------------------------------------------
; ProcessObjectStateDispatch_DD48
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateDispatch_DD48:
LDY #$00 ; CPU:$DD48 PRG:1D48 A0 00
LDX #$10 ; CPU:$DD4A PRG:1D4A A2 10
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD4C PRG:1D4C 20 AE D1
ObjectPathOnNonZero_DD4F:
LDA $76 ; CPU:$DD4F PRG:1D4F A5 76
BNE ObjectPathOnNonZero_DD5A ; CPU:$DD51 PRG:1D51 D0 07
LDY #$01 ; CPU:$DD53 PRG:1D53 A0 01
LDX #$14 ; CPU:$DD55 PRG:1D55 A2 14
JSR UpdateObjectBufferRoutine_D1AE ; CPU:$DD57 PRG:1D57 20 AE D1
ObjectPathOnNonZero_DD5A:
RTS ; CPU:$DD5A PRG:1D5A 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_DD5B
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_DD5B:
STX $06 ; CPU:$DD5B PRG:1D5B 86 06
LDA #$B0 ; CPU:$DD5D PRG:1D5D A9 B0
STA $00 ; CPU:$DD5F PRG:1D5F 85 00
LDA #$03 ; CPU:$DD61 PRG:1D61 A9 03
STA $01 ; CPU:$DD63 PRG:1D63 85 01
LDX #$03 ; CPU:$DD65 PRG:1D65 A2 03
UpdateObjectBufferLoop_DD67:
JSR ProcessObjectStateRoutine_DDB2 ; CPU:$DD67 PRG:1D67 20 B2 DD
BMI ObjectPathOnNegative_DD8E ; CPU:$DD6A PRG:1D6A 30 22
LDY #$00 ; CPU:$DD6C PRG:1D6C A0 00
LDA ($00),Y ; CPU:$DD6E PRG:1D6E B1 00
BEQ UpdateObjectBufferLoop_DD67 ; CPU:$DD70 PRG:1D70 F0 F5
LDA #$00 ; CPU:$DD72 PRG:1D72 A9 00
STA ($00),Y ; CPU:$DD74 PRG:1D74 91 00
LDA $04 ; CPU:$DD76 PRG:1D76 A5 04
LDY #$01 ; CPU:$DD78 PRG:1D78 A0 01
STA ($00),Y ; CPU:$DD7A PRG:1D7A 91 00
LDA $05 ; CPU:$DD7C PRG:1D7C A5 05
LDY #$03 ; CPU:$DD7E PRG:1D7E A0 03
STA ($00),Y ; CPU:$DD80 PRG:1D80 91 00
LDA $06 ; CPU:$DD82 PRG:1D82 A5 06
LDY #$05 ; CPU:$DD84 PRG:1D84 A0 05
STA ($00),Y ; CPU:$DD86 PRG:1D86 91 00
LDA #$20 ; CPU:$DD88 PRG:1D88 A9 20
LDY #$0C ; CPU:$DD8A PRG:1D8A A0 0C
STA ($00),Y ; CPU:$DD8C PRG:1D8C 91 00
ObjectPathOnNegative_DD8E:
RTS ; CPU:$DD8E PRG:1D8E 60
;------------------------------------------------------------
; UpdateObjectBuffer_DD8F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_DD8F:
LDA #$C0 ; CPU:$DD8F PRG:1D8F A9 C0
STA $00 ; CPU:$DD91 PRG:1D91 85 00
LDA #$03 ; CPU:$DD93 PRG:1D93 A9 03
STA $01 ; CPU:$DD95 PRG:1D95 85 01
LDX #$02 ; CPU:$DD97 PRG:1D97 A2 02
ObjectPathLoop_DD99:
LDY #$0C ; CPU:$DD99 PRG:1D99 A0 0C
LDA ($00),Y ; CPU:$DD9B PRG:1D9B B1 00
BEQ ObjectPathContinue_DDAC ; CPU:$DD9D PRG:1D9D F0 0D
SEC ; CPU:$DD9F PRG:1D9F 38
SBC #$01 ; CPU:$DDA0 PRG:1DA0 E9 01
STA ($00),Y ; CPU:$DDA2 PRG:1DA2 91 00
BNE ObjectPathContinue_DDAC ; CPU:$DDA4 PRG:1DA4 D0 06
LDY #$00 ; CPU:$DDA6 PRG:1DA6 A0 00
LDA #$01 ; CPU:$DDA8 PRG:1DA8 A9 01
STA ($00),Y ; CPU:$DDAA PRG:1DAA 91 00
ObjectPathContinue_DDAC:
JSR ProcessObjectStateRoutine_DDB2 ; CPU:$DDAC PRG:1DAC 20 B2 DD
BPL ObjectPathLoop_DD99 ; CPU:$DDAF PRG:1DAF 10 E8
RTS ; CPU:$DDB1 PRG:1DB1 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_DDB2
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_DDB2:
CLC ; CPU:$DDB2 PRG:1DB2 18
LDA #$10 ; CPU:$DDB3 PRG:1DB3 A9 10
ADC $00 ; CPU:$DDB5 PRG:1DB5 65 00
STA $00 ; CPU:$DDB7 PRG:1DB7 85 00
LDA #$00 ; CPU:$DDB9 PRG:1DB9 A9 00
ADC $01 ; CPU:$DDBB PRG:1DBB 65 01
STA $01 ; CPU:$DDBD PRG:1DBD 85 01
DEX ; CPU:$DDBF PRG:1DBF CA
RTS ; CPU:$DDC0 PRG:1DC0 60
;------------------------------------------------------------
; ObjectPath_DDC1
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DDC1:
LDA $8D ; CPU:$DDC1 PRG:1DC1 A5 8D
BEQ ObjectPathOnZero_DDF8 ; CPU:$DDC3 PRG:1DC3 F0 33
LDX #$01 ; CPU:$DDC5 PRG:1DC5 A2 01
ObjectPathLoop_DDC7:
LDA $70,X ; CPU:$DDC7 PRG:1DC7 B5 70
BNE ObjectPathOnNonZero_DDE3 ; CPU:$DDC9 PRG:1DC9 D0 18
LDA $10,X ; CPU:$DDCB PRG:1DCB B5 10
AND #$07 ; CPU:$DDCD PRG:1DCD 29 07
ORA #$02 ; CPU:$DDCF PRG:1DCF 09 02
STA $70,X ; CPU:$DDD1 PRG:1DD1 95 70
LDA $12,X ; CPU:$DDD3 PRG:1DD3 B5 12
AND #$0F ; CPU:$DDD5 PRG:1DD5 29 0F
TAY ; CPU:$DDD7 PRG:1DD7 A8
LDA #$00 ; CPU:$DDD8 PRG:1DD8 A9 00
SEC ; CPU:$DDDA PRG:1DDA 38
ObjectPathLoop_DDDB:
ROL A ; CPU:$DDDB PRG:1DDB 2A
DEY ; CPU:$DDDC PRG:1DDC 88
BNE ObjectPathLoop_DDDB ; CPU:$DDDD PRG:1DDD D0 FC
AND #$0F ; CPU:$DDDF PRG:1DDF 29 0F
STA $D8,X ; CPU:$DDE1 PRG:1DE1 95 D8
ObjectPathOnNonZero_DDE3:
LDA $44,X ; CPU:$DDE3 PRG:1DE3 B5 44
AND #$30 ; CPU:$DDE5 PRG:1DE5 29 30
ORA $D8,X ; CPU:$DDE7 PRG:1DE7 15 D8
STA $44,X ; CPU:$DDE9 PRG:1DE9 95 44
LDY $14,X ; CPU:$DDEB PRG:1DEB B4 14
CPY #$08 ; CPU:$DDED PRG:1DED C0 08
BCS ObjectPathOnCarry_DDF3 ; CPU:$DDEF PRG:1DEF B0 02
ORA #$80 ; CPU:$DDF1 PRG:1DF1 09 80
ObjectPathOnCarry_DDF3:
STA $46,X ; CPU:$DDF3 PRG:1DF3 95 46
DEX ; CPU:$DDF5 PRG:1DF5 CA
BPL ObjectPathLoop_DDC7 ; CPU:$DDF6 PRG:1DF6 10 CF
ObjectPathOnZero_DDF8:
RTS ; CPU:$DDF8 PRG:1DF8 60
.byte $28, $28, $20, $23, $00, $1F, $00, $A0, $00, $FF, $00, $FF, $01, $FF, $20, $E0 ; CPU:$DDF9 PRG:1DF9 0B
.byte $20, $20, $01, $01, $1E, $1E, $20, $20, $20, $20, $1E, $1E ; CPU:$DE09 PRG:1E09 0B
;------------------------------------------------------------
; ObjectPath_DE15
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DE15:
LDX #$03 ; CPU:$DE15 PRG:1E15 A2 03
ObjectPathLoop_DE17:
LDA $DE0D,X ; CPU:$DE17 PRG:1E17 BD 0D DE
STA $04 ; CPU:$DE1A PRG:1E1A 85 04
LDA $DDFD,X ; CPU:$DE1C PRG:1E1C BD FD DD
STA $00 ; CPU:$DE1F PRG:1E1F 85 00
LDA $DDF9,X ; CPU:$DE21 PRG:1E21 BD F9 DD
STA $01 ; CPU:$DE24 PRG:1E24 85 01
UpdateObjectBufferLoop_DE26:
LDY $DE11,X ; CPU:$DE26 PRG:1E26 BC 11 DE
LDA WorkPtr0Lo ; CPU:$DE29 PRG:1E29 A5 00
STA $02 ; CPU:$DE2B PRG:1E2B 85 02
LDA WorkPtr0Hi ; CPU:$DE2D PRG:1E2D A5 01
STA $03 ; CPU:$DE2F PRG:1E2F 85 03
ObjectPathLoop_DE31:
JSR UpdateObjectBufferRoutine_DE81 ; CPU:$DE31 PRG:1E31 20 81 DE
CMP #$4E ; CPU:$DE34 PRG:1E34 C9 4E
BEQ UpdateObjectBufferOnZero_DE3C ; CPU:$DE36 PRG:1E36 F0 04
CMP #$24 ; CPU:$DE38 PRG:1E38 C9 24
BNE ObjectPathOnNonZero_DE4D ; CPU:$DE3A PRG:1E3A D0 11
UpdateObjectBufferOnZero_DE3C:
PHA ; CPU:$DE3C PRG:1E3C 48
LDA $03 ; CPU:$DE3D PRG:1E3D A5 03
STA PPUADDR ; CPU:$DE3F PRG:1E3F 8D 06 20
LDA WorkPtr1Lo ; CPU:$DE42 PRG:1E42 A5 02
STA PPUADDR ; CPU:$DE44 PRG:1E44 8D 06 20
LDA #$FF ; CPU:$DE47 PRG:1E47 A9 FF
STA PPUDATA ; CPU:$DE49 PRG:1E49 8D 07 20
PLA ; CPU:$DE4C PRG:1E4C 68
ObjectPathOnNonZero_DE4D:
CMP #$4E ; CPU:$DE4D PRG:1E4D C9 4E
BCS UpdateObjectBufferOnCarry_DE55 ; CPU:$DE4F PRG:1E4F B0 04
CMP #$30 ; CPU:$DE51 PRG:1E51 C9 30
BCS ObjectPathOnCarry_DE6B ; CPU:$DE53 PRG:1E53 B0 16
UpdateObjectBufferOnCarry_DE55:
CMP #$B9 ; CPU:$DE55 PRG:1E55 C9 B9
BCS ObjectPathOnCarry_DE6B ; CPU:$DE57 PRG:1E57 B0 12
CLC ; CPU:$DE59 PRG:1E59 18
LDA $DE05,X ; CPU:$DE5A PRG:1E5A BD 05 DE
ADC $02 ; CPU:$DE5D PRG:1E5D 65 02
STA $02 ; CPU:$DE5F PRG:1E5F 85 02
LDA $DE01,X ; CPU:$DE61 PRG:1E61 BD 01 DE
ADC $03 ; CPU:$DE64 PRG:1E64 65 03
STA $03 ; CPU:$DE66 PRG:1E66 85 03
DEY ; CPU:$DE68 PRG:1E68 88
BNE ObjectPathLoop_DE31 ; CPU:$DE69 PRG:1E69 D0 C6
ObjectPathOnCarry_DE6B:
CLC ; CPU:$DE6B PRG:1E6B 18
LDA $DE09,X ; CPU:$DE6C PRG:1E6C BD 09 DE
ADC $00 ; CPU:$DE6F PRG:1E6F 65 00
STA $00 ; CPU:$DE71 PRG:1E71 85 00
LDA #$00 ; CPU:$DE73 PRG:1E73 A9 00
ADC $01 ; CPU:$DE75 PRG:1E75 65 01
STA $01 ; CPU:$DE77 PRG:1E77 85 01
DEC $04 ; CPU:$DE79 PRG:1E79 C6 04
BNE UpdateObjectBufferLoop_DE26 ; CPU:$DE7B PRG:1E7B D0 A9
DEX ; CPU:$DE7D PRG:1E7D CA
BPL ObjectPathLoop_DE17 ; CPU:$DE7E PRG:1E7E 10 97
RTS ; CPU:$DE80 PRG:1E80 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_DE81
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_DE81:
LDA PPUSTATUS ; CPU:$DE81 PRG:1E81 AD 02 20
LDA $03 ; CPU:$DE84 PRG:1E84 A5 03
STA PPUADDR ; CPU:$DE86 PRG:1E86 8D 06 20
LDA WorkPtr1Lo ; CPU:$DE89 PRG:1E89 A5 02
;------------------------------------------------------------
; ProcessObjectStateRoutine_DE8B
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_DE8B:
STA PPUADDR ; CPU:$DE8B PRG:1E8B 8D 06 20
LDA PPUDATA ; CPU:$DE8E PRG:1E8E AD 07 20
LDA PPUDATA ; CPU:$DE91 PRG:1E91 AD 07 20
RTS ; CPU:$DE94 PRG:1E94 60
.byte $30, $35, $31, $4A, $3A, $3E, $4C, $3F, $33, $4B, $34, $38, $4D, $40, $3D, $41 ; CPU:$DE95 PRG:1E95 0B
.byte $37, $35, $3B, $3C, $3A, $49, $48, $36, $45, $47, $46, $38, $42, $43, $3D, $44 ; CPU:$DEA5 PRG:1EA5 0B
.byte $4E, $FA, $FA, $4E, $6E, $86, $86, $6F, $FC, $FC, $FC, $FC, $4F, $F9, $F9, $4F ; CPU:$DEB5 PRG:1EB5 0B
.byte $4E, $FB, $FB, $4E, $60, $7C, $7C, $61, $FC, $FC, $FC, $FC, $4F, $F9, $F9, $4F ; CPU:$DEC5 PRG:1EC5 0B
ObjectPathLoop_DED5:
AND #$F0 ; CPU:$DED5 PRG:1ED5 29 F0
PHA ; CPU:$DED7 PRG:1ED7 48
CMP #$C0 ; CPU:$DED8 PRG:1ED8 C9 C0
LDA $40 ; CPU:$DEDA PRG:1EDA A5 40
AND #$FB ; CPU:$DEDC PRG:1EDC 29 FB
BCC UpdateObjectBufferOnNoCarry_DEE2 ; CPU:$DEDE PRG:1EDE 90 02
ORA #$04 ; CPU:$DEE0 PRG:1EE0 09 04
UpdateObjectBufferOnNoCarry_DEE2:
STA $2000 ; CPU:$DEE2 PRG:1EE2 8D 00 20
STA $40 ; CPU:$DEE5 PRG:1EE5 85 40
LDA ($00),Y ; CPU:$DEE7 PRG:1EE7 B1 00
AND #$0F ; CPU:$DEE9 PRG:1EE9 29 0F
ORA #$20 ; CPU:$DEEB PRG:1EEB 09 20
STA PPUADDR ; CPU:$DEED PRG:1EED 8D 06 20
STA $03 ; CPU:$DEF0 PRG:1EF0 85 03
INY ; CPU:$DEF2 PRG:1EF2 C8
LDA ($00),Y ; CPU:$DEF3 PRG:1EF3 B1 00
STA PPUADDR ; CPU:$DEF5 PRG:1EF5 8D 06 20
STA $02 ; CPU:$DEF8 PRG:1EF8 85 02
PLA ; CPU:$DEFA PRG:1EFA 68
LSR A ; CPU:$DEFB PRG:1EFB 4A
LSR A ; CPU:$DEFC PRG:1EFC 4A
TAY ; CPU:$DEFD PRG:1EFD A8
LDA $DE95,Y ; CPU:$DEFE PRG:1EFE B9 95 DE
STA PPUDATA ; CPU:$DF01 PRG:1F01 8D 07 20
INY ; CPU:$DF04 PRG:1F04 C8
LDA $DE95,Y ; CPU:$DF05 PRG:1F05 B9 95 DE
STA PPUDATA ; CPU:$DF08 PRG:1F08 8D 07 20
CPY #$20 ; CPU:$DF0B PRG:1F0B C0 20
BCS ObjectPathOnCarry_DF1F ; CPU:$DF0D PRG:1F0D B0 10
CLC ; CPU:$DF0F PRG:1F0F 18
LDA #$20 ; CPU:$DF10 PRG:1F10 A9 20
ADC $02 ; CPU:$DF12 PRG:1F12 65 02
TAX ; CPU:$DF14 PRG:1F14 AA
LDA #$00 ; CPU:$DF15 PRG:1F15 A9 00
ADC $03 ; CPU:$DF17 PRG:1F17 65 03
STA PPUADDR ; CPU:$DF19 PRG:1F19 8D 06 20
STX PPUADDR ; CPU:$DF1C PRG:1F1C 8E 06 20
ObjectPathOnCarry_DF1F:
INY ; CPU:$DF1F PRG:1F1F C8
LDA $DE95,Y ; CPU:$DF20 PRG:1F20 B9 95 DE
STA PPUDATA ; CPU:$DF23 PRG:1F23 8D 07 20
INY ; CPU:$DF26 PRG:1F26 C8
LDA $DE95,Y ; CPU:$DF27 PRG:1F27 B9 95 DE
STA PPUDATA ; CPU:$DF2A PRG:1F2A 8D 07 20
LDY #$02 ; CPU:$DF2D PRG:1F2D A0 02
;------------------------------------------------------------
; ObjectPath_DF2F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_DF2F:
LDX PPUSTATUS ; CPU:$DF2F PRG:1F2F AE 02 20
TYA ; CPU:$DF32 PRG:1F32 98
CLC ; CPU:$DF33 PRG:1F33 18
ADC $00 ; CPU:$DF34 PRG:1F34 65 00
STA $00 ; CPU:$DF36 PRG:1F36 85 00
LDA #$00 ; CPU:$DF38 PRG:1F38 A9 00
ADC $01 ; CPU:$DF3A PRG:1F3A 65 01
STA $01 ; CPU:$DF3C PRG:1F3C 85 01
LDY #$00 ; CPU:$DF3E PRG:1F3E A0 00
LDA ($00),Y ; CPU:$DF40 PRG:1F40 B1 00
CMP #$FF ; CPU:$DF42 PRG:1F42 C9 FF
BNE ObjectPathLoop_DED5 ; CPU:$DF44 PRG:1F44 D0 8F
RTS ; CPU:$DF46 PRG:1F46 60
.byte $00, $02, $40, $42, $FC, $F3, $CF, $3F, $01, $04, $10, $40 ; CPU:$DF47 PRG:1F47 0B
ObjectPathLoop_DF53:
LDA $42 ; CPU:$DF53 PRG:1F53 A5 42
STA PPUSCROLL ; CPU:$DF55 PRG:1F55 8D 05 20
LDA $43 ; CPU:$DF58 PRG:1F58 A5 43
STA PPUSCROLL ; CPU:$DF5A PRG:1F5A 8D 05 20
RTS ; CPU:$DF5D PRG:1F5D 60
;------------------------------------------------------------
; UpdateObjectBuffer_DF5E
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_DF5E:
LDA #$1F ; CPU:$DF5E PRG:1F5E A9 1F
STA $03 ; CPU:$DF60 PRG:1F60 85 03
LDA #$FF ; CPU:$DF62 PRG:1F62 A9 FF
STA $02 ; CPU:$DF64 PRG:1F64 85 02
UpdateObjectBufferDispatch_DF66:
CLC ; CPU:$DF66 PRG:1F66 18
LDA #$01 ; CPU:$DF67 PRG:1F67 A9 01
ADC $02 ; CPU:$DF69 PRG:1F69 65 02
STA $02 ; CPU:$DF6B PRG:1F6B 85 02
LDA #$00 ; CPU:$DF6D PRG:1F6D A9 00
ADC $03 ; CPU:$DF6F PRG:1F6F 65 03
STA $03 ; CPU:$DF71 PRG:1F71 85 03
CMP #$23 ; CPU:$DF73 PRG:1F73 C9 23
BNE ObjectPathOnNonZero_DF7D ; CPU:$DF75 PRG:1F75 D0 06
LDA WorkPtr1Lo ; CPU:$DF77 PRG:1F77 A5 02
CMP #$C0 ; CPU:$DF79 PRG:1F79 C9 C0
BEQ ObjectPathLoop_DF53 ; CPU:$DF7B PRG:1F7B F0 D6
ObjectPathOnNonZero_DF7D:
JSR UpdateObjectBufferRoutine_DE81 ; CPU:$DF7D PRG:1F7D 20 81 DE
LDY #$00 ; CPU:$DF80 PRG:1F80 A0 00
CMP #$4E ; CPU:$DF82 PRG:1F82 C9 4E
BEQ UpdateObjectBufferContinue_DFAC ; CPU:$DF84 PRG:1F84 F0 26
CMP #$FA ; CPU:$DF86 PRG:1F86 C9 FA
BEQ UpdateObjectBufferContinue_DFAC ; CPU:$DF88 PRG:1F88 F0 22
CMP #$FB ; CPU:$DF8A PRG:1F8A C9 FB
BEQ UpdateObjectBufferContinue_DFAC ; CPU:$DF8C PRG:1F8C F0 1E
INY ; CPU:$DF8E PRG:1F8E C8
CMP #$24 ; CPU:$DF8F PRG:1F8F C9 24
BEQ UpdateObjectBufferDispatch_DF66 ; CPU:$DF91 PRG:1F91 F0 D3
CMP #$4E ; CPU:$DF93 PRG:1F93 C9 4E
BCC UpdateObjectBufferContinue_DFAC ; CPU:$DF95 PRG:1F95 90 15
CMP #$FF ; CPU:$DF97 PRG:1F97 C9 FF
BEQ UpdateObjectBufferContinue_DFAC ; CPU:$DF99 PRG:1F99 F0 11
CMP #$CC ; CPU:$DF9B PRG:1F9B C9 CC
BCS ObjectPathOnCarry_DFA3 ; CPU:$DF9D PRG:1F9D B0 04
CMP #$AB ; CPU:$DF9F PRG:1F9F C9 AB
BCS UpdateObjectBufferContinue_DFAC ; CPU:$DFA1 PRG:1FA1 B0 09
ObjectPathOnCarry_DFA3:
INY ; CPU:$DFA3 PRG:1FA3 C8
CMP #$60 ; CPU:$DFA4 PRG:1FA4 C9 60
BCS UpdateObjectBufferDispatch_DF66 ; CPU:$DFA6 PRG:1FA6 B0 BE
CMP #$50 ; CPU:$DFA8 PRG:1FA8 C9 50
BCC UpdateObjectBufferDispatch_DF66 ; CPU:$DFAA PRG:1FAA 90 BA
UpdateObjectBufferContinue_DFAC:
LDA WorkPtr1Lo ; CPU:$DFAC PRG:1FAC A5 02
AND #$1C ; CPU:$DFAE PRG:1FAE 29 1C
LSR A ; CPU:$DFB0 PRG:1FB0 4A
LSR A ; CPU:$DFB1 PRG:1FB1 4A
STA $00 ; CPU:$DFB2 PRG:1FB2 85 00
LDA WorkPtr1Lo ; CPU:$DFB4 PRG:1FB4 A5 02
ASL A ; CPU:$DFB6 PRG:1FB6 0A
LDA $03 ; CPU:$DFB7 PRG:1FB7 A5 03
AND #$03 ; CPU:$DFB9 PRG:1FB9 29 03
ROL A ; CPU:$DFBB PRG:1FBB 2A
ASL A ; CPU:$DFBC PRG:1FBC 0A
ASL A ; CPU:$DFBD PRG:1FBD 0A
ASL A ; CPU:$DFBE PRG:1FBE 0A
CLC ; CPU:$DFBF PRG:1FBF 18
ADC $00 ; CPU:$DFC0 PRG:1FC0 65 00
CLC ; CPU:$DFC2 PRG:1FC2 18
ADC #$C0 ; CPU:$DFC3 PRG:1FC3 69 C0
STA $00 ; CPU:$DFC5 PRG:1FC5 85 00
LDA #$23 ; CPU:$DFC7 PRG:1FC7 A9 23
STA $01 ; CPU:$DFC9 PRG:1FC9 85 01
LDA WorkPtr1Lo ; CPU:$DFCB PRG:1FCB A5 02
AND #$42 ; CPU:$DFCD PRG:1FCD 29 42
LDX #$FF ; CPU:$DFCF PRG:1FCF A2 FF
ObjectPathLoop_DFD1:
INX ; CPU:$DFD1 PRG:1FD1 E8
CMP $DF47,X ; CPU:$DFD2 PRG:1FD2 DD 47 DF
BNE ObjectPathLoop_DFD1 ; CPU:$DFD5 PRG:1FD5 D0 FA
LDA $DF4F,X ; CPU:$DFD7 PRG:1FD7 BD 4F DF
CPY #$00 ; CPU:$DFDA PRG:1FDA C0 00
BEQ ObjectPathOnZero_DFE6 ; CPU:$DFDC PRG:1FDC F0 08
ASL A ; CPU:$DFDE PRG:1FDE 0A
CPY #$01 ; CPU:$DFDF PRG:1FDF C0 01
BEQ ObjectPathOnZero_DFE6 ; CPU:$DFE1 PRG:1FE1 F0 03
ORA $DF4F,X ; CPU:$DFE3 PRG:1FE3 1D 4F DF
ObjectPathOnZero_DFE6:
STA $04 ; CPU:$DFE6 PRG:1FE6 85 04
LDY $01 ; CPU:$DFE8 PRG:1FE8 A4 01
STY PPUADDR ; CPU:$DFEA PRG:1FEA 8C 06 20
LDA WorkPtr0Lo ; CPU:$DFED PRG:1FED A5 00
JSR ProcessObjectStateRoutine_DE8B ; CPU:$DFEF PRG:1FEF 20 8B DE
AND $DF4B,X ; CPU:$DFF2 PRG:1FF2 3D 4B DF
ORA $04 ; CPU:$DFF5 PRG:1FF5 05 04
STY PPUADDR ; CPU:$DFF7 PRG:1FF7 8C 06 20
LDY $00 ; CPU:$DFFA PRG:1FFA A4 00
STY PPUADDR ; CPU:$DFFC PRG:1FFC 8C 06 20
STA PPUDATA ; CPU:$DFFF PRG:1FFF 8D 07 20
JMP UpdateObjectBufferDispatch_DF66 ; CPU:$E002 PRG:2002 4C 66 DF
.byte $00, $00, $01, $01, $01, $01, $02, $02, $02, $03, $03, $03, $03, $04, $04, $04 ; CPU:$E005 PRG:2005 0B
.byte $05, $05, $05, $05, $06, $06, $06, $06, $07, $07, $07, $07, $08, $08, $08, $08 ; CPU:$E015 PRG:2015 0B
.byte $08, $09, $09, $09, $09, $09, $0A, $0A, $0A, $0A, $0A, $0A, $0B, $0B, $0B, $0B ; CPU:$E025 PRG:2025 0B
.byte $0B, $0B, $0B, $0B, $0B, $0C, $0C, $0C, $0C, $0C, $0C, $0C, $0C, $0C, $0C, $0C ; CPU:$E035 PRG:2035 0B
;------------------------------------------------------------
; ProcessObjectStateRoutine_E045
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E045:
LDX #$00 ; CPU:$E045 PRG:2045 A2 00
CMP #$80 ; CPU:$E047 PRG:2047 C9 80
BCC ObjectPathOnNoCarry_E04F ; CPU:$E049 PRG:2049 90 04
SBC #$80 ; CPU:$E04B PRG:204B E9 80
LDX #$01 ; CPU:$E04D PRG:204D A2 01
ObjectPathOnNoCarry_E04F:
CMP #$40 ; CPU:$E04F PRG:204F C9 40
BCC ObjectPathOnNoCarry_E059 ; CPU:$E051 PRG:2051 90 06
STA $00 ; CPU:$E053 PRG:2053 85 00
LDA #$7F ; CPU:$E055 PRG:2055 A9 7F
SBC $00 ; CPU:$E057 PRG:2057 E5 00
ObjectPathOnNoCarry_E059:
TAY ; CPU:$E059 PRG:2059 A8
LDA $E005,Y ; CPU:$E05A PRG:205A B9 05 E0
STA $00 ; CPU:$E05D PRG:205D 85 00
DEX ; CPU:$E05F PRG:205F CA
BNE ObjectPathOnNonZero_E069 ; CPU:$E060 PRG:2060 D0 07
SEC ; CPU:$E062 PRG:2062 38
LDA #$00 ; CPU:$E063 PRG:2063 A9 00
SBC $00 ; CPU:$E065 PRG:2065 E5 00
STA $00 ; CPU:$E067 PRG:2067 85 00
ObjectPathOnNonZero_E069:
RTS ; CPU:$E069 PRG:2069 60
;------------------------------------------------------------
; ReadObjectRecordRoutine_E06A
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E06A:
LDA $56 ; CPU:$E06A PRG:206A A5 56
BNE ObjectPathContinue_E09B ; CPU:$E06C PRG:206C D0 2D
LDX $0A ; CPU:$E06E PRG:206E A6 0A
LDA $75,X ; CPU:$E070 PRG:2070 B5 75
BNE ObjectPathContinue_E09B ; CPU:$E072 PRG:2072 D0 27
LDY #$1B ; CPU:$E074 PRG:2074 A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$E076 PRG:2076 B1 08
CMP #$30 ; CPU:$E078 PRG:2078 C9 30
BCC UpdateObjectRecordOnNoCarry_E080 ; CPU:$E07A PRG:207A 90 04
CMP #$40 ; CPU:$E07C PRG:207C C9 40
BCC ObjectPathContinue_E09B ; CPU:$E07E PRG:207E 90 1B
UpdateObjectRecordOnNoCarry_E080:
LDA $06 ; CPU:$E080 PRG:2080 A5 06
AND #$02 ; CPU:$E082 PRG:2082 29 02
BEQ UpdateObjectRecordOnZero_E09C ; CPU:$E084 PRG:2084 F0 16
CLC ; CPU:$E086 PRG:2086 18
LDY #$14 ; CPU:$E087 PRG:2087 A0 14
LDA (CurrentObjectPtrLo),Y ; CPU:$E089 PRG:2089 B1 08
LDY #$04 ; CPU:$E08B PRG:208B A0 04
ADC (CurrentObjectPtrLo),Y ; CPU:$E08D PRG:208D 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E08F PRG:208F 91 08
LDY #$13 ; CPU:$E091 PRG:2091 A0 13
LDA (CurrentObjectPtrLo),Y ; CPU:$E093 PRG:2093 B1 08
LDY #$03 ; CPU:$E095 PRG:2095 A0 03
ADC (CurrentObjectPtrLo),Y ; CPU:$E097 PRG:2097 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E099 PRG:2099 91 08
ObjectPathContinue_E09B:
RTS ; CPU:$E09B PRG:209B 60
UpdateObjectRecordOnZero_E09C:
CLC ; CPU:$E09C PRG:209C 18
LDY #$12 ; CPU:$E09D PRG:209D A0 12
LDA (CurrentObjectPtrLo),Y ; CPU:$E09F PRG:209F B1 08
LDY #$02 ; CPU:$E0A1 PRG:20A1 A0 02
ADC (CurrentObjectPtrLo),Y ; CPU:$E0A3 PRG:20A3 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E0A5 PRG:20A5 91 08
LDY #$11 ; CPU:$E0A7 PRG:20A7 A0 11
LDA (CurrentObjectPtrLo),Y ; CPU:$E0A9 PRG:20A9 B1 08
LDY #$01 ; CPU:$E0AB PRG:20AB A0 01
ADC (CurrentObjectPtrLo),Y ; CPU:$E0AD PRG:20AD 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E0AF PRG:20AF 91 08
RTS ; CPU:$E0B1 PRG:20B1 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E0B2
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E0B2:
TAX ; CPU:$E0B2 PRG:20B2 AA
LDA #$FD ; CPU:$E0B3 PRG:20B3 A9 FD
ObjectPathLoop_E0B5:
CLC ; CPU:$E0B5 PRG:20B5 18
ADC #$03 ; CPU:$E0B6 PRG:20B6 69 03
DEX ; CPU:$E0B8 PRG:20B8 CA
BPL ObjectPathLoop_E0B5 ; CPU:$E0B9 PRG:20B9 10 FA
TAX ; CPU:$E0BB PRG:20BB AA
TAY ; CPU:$E0BC PRG:20BC A8
LDA a:$00B2,X ; CPU:$E0BD PRG:20BD BD B2 00
CMP $02 ; CPU:$E0C0 PRG:20C0 C5 02
BNE UpdateObjectBufferOnNonZero_E0D2 ; CPU:$E0C2 PRG:20C2 D0 0E
INX ; CPU:$E0C4 PRG:20C4 E8
LDA a:$00B2,X ; CPU:$E0C5 PRG:20C5 BD B2 00
CMP $03 ; CPU:$E0C8 PRG:20C8 C5 03
BNE UpdateObjectBufferOnNonZero_E0D2 ; CPU:$E0CA PRG:20CA D0 06
INX ; CPU:$E0CC PRG:20CC E8
LDA a:$00B2,X ; CPU:$E0CD PRG:20CD BD B2 00
CLC ; CPU:$E0D0 PRG:20D0 18
RTS ; CPU:$E0D1 PRG:20D1 60
UpdateObjectBufferOnNonZero_E0D2:
LDA WorkPtr1Lo ; CPU:$E0D2 PRG:20D2 A5 02
STA a:$00B2,Y ; CPU:$E0D4 PRG:20D4 99 B2 00
INY ; CPU:$E0D7 PRG:20D7 C8
LDA $03 ; CPU:$E0D8 PRG:20D8 A5 03
STA a:$00B2,Y ; CPU:$E0DA PRG:20DA 99 B2 00
SEC ; CPU:$E0DD PRG:20DD 38
RTS ; CPU:$E0DE PRG:20DE 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_E0DF
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_E0DF:
LDA #$08 ; CPU:$E0DF PRG:20DF A9 08
STA $02 ; CPU:$E0E1 PRG:20E1 85 02
LDA WorkPtr0Lo ; CPU:$E0E3 PRG:20E3 A5 00
ASL A ; CPU:$E0E5 PRG:20E5 0A
ROL $02 ; CPU:$E0E6 PRG:20E6 26 02
ASL A ; CPU:$E0E8 PRG:20E8 0A
ROL $02 ; CPU:$E0E9 PRG:20E9 26 02
AND #$E0 ; CPU:$E0EB PRG:20EB 29 E0
STA $03 ; CPU:$E0ED PRG:20ED 85 03
LDA WorkPtr0Hi ; CPU:$E0EF PRG:20EF A5 01
LSR A ; CPU:$E0F1 PRG:20F1 4A
LSR A ; CPU:$E0F2 PRG:20F2 4A
LSR A ; CPU:$E0F3 PRG:20F3 4A
ORA $03 ; CPU:$E0F4 PRG:20F4 05 03
STA $03 ; CPU:$E0F6 PRG:20F6 85 03
RTS ; CPU:$E0F8 PRG:20F8 60
;------------------------------------------------------------
; UpdateObjectBufferRoutine_E0F9
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_E0F9:
LDA $03 ; CPU:$E0F9 PRG:20F9 A5 03
ASL A ; CPU:$E0FB PRG:20FB 0A
ASL A ; CPU:$E0FC PRG:20FC 0A
ASL A ; CPU:$E0FD PRG:20FD 0A
STA $01 ; CPU:$E0FE PRG:20FE 85 01
LDA $03 ; CPU:$E100 PRG:2100 A5 03
STA $00 ; CPU:$E102 PRG:2102 85 00
LDA WorkPtr1Lo ; CPU:$E104 PRG:2104 A5 02
LSR A ; CPU:$E106 PRG:2106 4A
ROR $00 ; CPU:$E107 PRG:2107 66 00
LSR A ; CPU:$E109 PRG:2109 4A
ROR $00 ; CPU:$E10A PRG:210A 66 00
LDA #$F8 ; CPU:$E10C PRG:210C A9 F8
AND $00 ; CPU:$E10E PRG:210E 25 00
STA $00 ; CPU:$E110 PRG:2110 85 00
RTS ; CPU:$E112 PRG:2112 60
;------------------------------------------------------------
; ObjectPath_E113
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ObjectPath_E113:
LDA PPUSTATUS ; CPU:$E113 PRG:2113 AD 02 20
LDX #$00 ; CPU:$E116 PRG:2116 A2 00
ObjectPathLoop_E118:
LDA a:$00B2,X ; CPU:$E118 PRG:2118 BD B2 00
STA PPUADDR ; CPU:$E11B PRG:211B 8D 06 20
INX ; CPU:$E11E PRG:211E E8
LDA a:$00B2,X ; CPU:$E11F PRG:211F BD B2 00
STA PPUADDR ; CPU:$E122 PRG:2122 8D 06 20
INX ; CPU:$E125 PRG:2125 E8
LDA PPUDATA ; CPU:$E126 PRG:2126 AD 07 20
LDA PPUDATA ; CPU:$E129 PRG:2129 AD 07 20
STA a:$00B2,X ; CPU:$E12C PRG:212C 9D B2 00
INX ; CPU:$E12F PRG:212F E8
CPX #$1E ; CPU:$E130 PRG:2130 E0 1E
BNE ObjectPathLoop_E118 ; CPU:$E132 PRG:2132 D0 E4
LDA $42 ; CPU:$E134 PRG:2134 A5 42
STA PPUSCROLL ; CPU:$E136 PRG:2136 8D 05 20
LDA $43 ; CPU:$E139 PRG:2139 A5 43
STA PPUSCROLL ; CPU:$E13B PRG:213B 8D 05 20
RTS ; CPU:$E13E PRG:213E 60
;------------------------------------------------------------
; ReadObjectRecordRoutine_E13F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E13F:
LDY #$10 ; CPU:$E13F PRG:213F A0 10
LDA (CurrentObjectPtrLo),Y ; CPU:$E141 PRG:2141 B1 08
LDY #$21 ; CPU:$E143 PRG:2143 A0 21
CMP #$00 ; CPU:$E145 PRG:2145 C9 00
BEQ ReadObjectRecordOnZero_E15D ; CPU:$E147 PRG:2147 F0 14
CMP #$01 ; CPU:$E149 PRG:2149 C9 01
BEQ ReadObjectRecordOnZero_E153 ; CPU:$E14B PRG:214B F0 06
LDY #$23 ; CPU:$E14D PRG:214D A0 23
CMP #$02 ; CPU:$E14F PRG:214F C9 02
BEQ ReadObjectRecordOnZero_E15D ; CPU:$E151 PRG:2151 F0 0A
ReadObjectRecordOnZero_E153:
LDA (CurrentObjectPtrLo),Y ; CPU:$E153 PRG:2153 B1 08
AND #$07 ; CPU:$E155 PRG:2155 29 07
CMP #$07 ; CPU:$E157 PRG:2157 C9 07
BCS ObjectPathOnCarry_E165 ; CPU:$E159 PRG:2159 B0 0A
ObjectPathLoop_E15B:
CLC ; CPU:$E15B PRG:215B 18
RTS ; CPU:$E15C PRG:215C 60
ReadObjectRecordOnZero_E15D:
LDA (CurrentObjectPtrLo),Y ; CPU:$E15D PRG:215D B1 08
AND #$07 ; CPU:$E15F PRG:215F 29 07
CMP #$01 ; CPU:$E161 PRG:2161 C9 01
BCS ObjectPathLoop_E15B ; CPU:$E163 PRG:2163 B0 F6
ObjectPathOnCarry_E165:
SEC ; CPU:$E165 PRG:2165 38
RTS ; CPU:$E166 PRG:2166 60
.byte $01, $19, $03, $1A, $19, $01, $1A, $03, $12, $12, $14, $14, $11, $11, $13, $13 ; CPU:$E167 PRG:2167 0B
.byte $19, $19, $1A, $1A, $01, $01, $03, $03 ; CPU:$E177 PRG:2177 0B
;------------------------------------------------------------
; ProcessObjectStateRoutine_E17F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E17F:
LDX #$08 ; CPU:$E17F PRG:217F A2 08
LDY #$41 ; CPU:$E181 PRG:2181 A0 41
CMP #$F9 ; CPU:$E183 PRG:2183 C9 F9
BEQ ObjectPathContinue_E1BB ; CPU:$E185 PRG:2185 F0 34
LDX #$20 ; CPU:$E187 PRG:2187 A2 20
CMP #$93 ; CPU:$E189 PRG:2189 C9 93
BCS ObjectPathOnCarry_E191 ; CPU:$E18B PRG:218B B0 04
CMP #$7C ; CPU:$E18D PRG:218D C9 7C
BCS ObjectPathContinue_E1BB ; CPU:$E18F PRG:218F B0 2A
ObjectPathOnCarry_E191:
LDY #$31 ; CPU:$E191 PRG:2191 A0 31
CMP #$24 ; CPU:$E193 PRG:2193 C9 24
BEQ ObjectPathOnZero_E1A7 ; CPU:$E195 PRG:2195 F0 10
CMP #$4A ; CPU:$E197 PRG:2197 C9 4A
BCC ObjectPathContinue_E1BB ; CPU:$E199 PRG:2199 90 20
CMP #$C4 ; CPU:$E19B PRG:219B C9 C4
BCS ObjectPathOnCarry_E1A3 ; CPU:$E19D PRG:219D B0 04
CMP #$B9 ; CPU:$E19F PRG:219F C9 B9
BCS ObjectPathContinue_E1BB ; CPU:$E1A1 PRG:21A1 B0 18
ObjectPathOnCarry_E1A3:
CMP #$FF ; CPU:$E1A3 PRG:21A3 C9 FF
BEQ ObjectPathContinue_E1BB ; CPU:$E1A5 PRG:21A5 F0 14
ObjectPathOnZero_E1A7:
LDY #$80 ; CPU:$E1A7 PRG:21A7 A0 80
CMP #$60 ; CPU:$E1A9 PRG:21A9 C9 60
BCS ObjectPathContinue_E1B9 ; CPU:$E1AB PRG:21AB B0 0C
CMP #$50 ; CPU:$E1AD PRG:21AD C9 50
BCC ObjectPathContinue_E1B9 ; CPU:$E1AF PRG:21AF 90 08
LDX $0A ; CPU:$E1B1 PRG:21B1 A6 0A
LDA $90,X ; CPU:$E1B3 PRG:21B3 B5 90
CMP #$13 ; CPU:$E1B5 PRG:21B5 C9 13
BNE ObjectPathOnNonZero_E1BD ; CPU:$E1B7 PRG:21B7 D0 04
ObjectPathContinue_E1B9:
CLC ; CPU:$E1B9 PRG:21B9 18
RTS ; CPU:$E1BA PRG:21BA 60
ObjectPathContinue_E1BB:
STX $FF ; CPU:$E1BB PRG:21BB 86 FF
ObjectPathOnNonZero_E1BD:
SEC ; CPU:$E1BD PRG:21BD 38
RTS ; CPU:$E1BE PRG:21BE 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E1BF
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E1BF:
TYA ; CPU:$E1BF PRG:21BF 98
BPL UpdateObjectRecordOnPositive_E1CF ; CPU:$E1C0 PRG:21C0 10 0D
JSR ReadObjectRecordRoutine_E262 ; CPU:$E1C2 PRG:21C2 20 62 E2
JSR UpdateObjectRecordRoutine_E229 ; CPU:$E1C5 PRG:21C5 20 29 E2
LDX $0A ; CPU:$E1C8 PRG:21C8 A6 0A
LDA #$13 ; CPU:$E1CA PRG:21CA A9 13
STA $90,X ; CPU:$E1CC PRG:21CC 95 90
RTS ; CPU:$E1CE PRG:21CE 60
UpdateObjectRecordOnPositive_E1CF:
EOR $06 ; CPU:$E1CF PRG:21CF 45 06
LDY #$1B ; CPU:$E1D1 PRG:21D1 A0 1B
STA (CurrentObjectPtrLo),Y ; CPU:$E1D3 PRG:21D3 91 08
STA $00 ; CPU:$E1D5 PRG:21D5 85 00
JSR ReadObjectRecordRoutine_E262 ; CPU:$E1D7 PRG:21D7 20 62 E2
LDA WorkPtr0Lo ; CPU:$E1DA PRG:21DA A5 00
CMP #$40 ; CPU:$E1DC PRG:21DC C9 40
BMI ObjectPathOnNegative_E1E8 ; CPU:$E1DE PRG:21DE 30 08
LSR $04 ; CPU:$E1E0 PRG:21E0 46 04
ROR $05 ; CPU:$E1E2 PRG:21E2 66 05
LSR $04 ; CPU:$E1E4 PRG:21E4 46 04
ROR $05 ; CPU:$E1E6 PRG:21E6 66 05
ObjectPathOnNegative_E1E8:
LSR $04 ; CPU:$E1E8 PRG:21E8 46 04
ROR $05 ; CPU:$E1EA PRG:21EA 66 05
LSR $04 ; CPU:$E1EC PRG:21EC 46 04
ROR $05 ; CPU:$E1EE PRG:21EE 66 05
LSR $04 ; CPU:$E1F0 PRG:21F0 46 04
ROR $05 ; CPU:$E1F2 PRG:21F2 66 05
LDA $06 ; CPU:$E1F4 PRG:21F4 A5 06
AND #$01 ; CPU:$E1F6 PRG:21F6 29 01
BNE UpdateObjectRecordOnNonZero_E1FD ; CPU:$E1F8 PRG:21F8 D0 03
JSR ProcessObjectStateRoutine_E281 ; CPU:$E1FA PRG:21FA 20 81 E2
UpdateObjectRecordOnNonZero_E1FD:
LDY #$18 ; CPU:$E1FD PRG:21FD A0 18
LDA $05 ; CPU:$E1FF PRG:21FF A5 05
STA (CurrentObjectPtrLo),Y ; CPU:$E201 PRG:2201 91 08
DEY ; CPU:$E203 PRG:2203 88
LDA $04 ; CPU:$E204 PRG:2204 A5 04
STA (CurrentObjectPtrLo),Y ; CPU:$E206 PRG:2206 91 08
JSR UpdateObjectRecordRoutine_E229 ; CPU:$E208 PRG:2208 20 29 E2
LDA $06 ; CPU:$E20B PRG:220B A5 06
ORA #$70 ; CPU:$E20D PRG:220D 09 70
LDY #$10 ; CPU:$E20F PRG:220F A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$E211 PRG:2211 91 08
LDA WorkPtr0Lo ; CPU:$E213 PRG:2213 A5 00
CMP #$40 ; CPU:$E215 PRG:2215 C9 40
BCC ObjectPathOnNoCarry_E21D ; CPU:$E217 PRG:2217 90 04
JSR ProcessObjectStateRoutine_E69A ; CPU:$E219 PRG:2219 20 9A E6
RTS ; CPU:$E21C PRG:221C 60
ObjectPathOnNoCarry_E21D:
LDY $0A ; CPU:$E21D PRG:221D A4 0A
LDA #$10 ; CPU:$E21F PRG:221F A9 10
STA a:$0058,Y ; CPU:$E221 PRG:2221 99 58 00
RTS ; CPU:$E224 PRG:2224 60
.byte $F8, $00, $10, $18 ; CPU:$E225 PRG:2225 0B
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E229
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E229:
LDY #$01 ; CPU:$E229 PRG:2229 A0 01
LDA (CurrentObjectPtrLo),Y ; CPU:$E22B PRG:222B B1 08
LDY #$19 ; CPU:$E22D PRG:222D A0 19
STA (CurrentObjectPtrLo),Y ; CPU:$E22F PRG:222F 91 08
LDY #$03 ; CPU:$E231 PRG:2231 A0 03
LDA (CurrentObjectPtrLo),Y ; CPU:$E233 PRG:2233 B1 08
LDY #$1A ; CPU:$E235 PRG:2235 A0 1A
STA (CurrentObjectPtrLo),Y ; CPU:$E237 PRG:2237 91 08
LDX $06 ; CPU:$E239 PRG:2239 A6 06
LDY $E17B,X ; CPU:$E23B PRG:223B BC 7B E1
LDX #$00 ; CPU:$E23E PRG:223E A2 00
LDA (CurrentObjectPtrLo),Y ; CPU:$E240 PRG:2240 B1 08
AND #$0F ; CPU:$E242 PRG:2242 29 0F
CMP #$08 ; CPU:$E244 PRG:2244 C9 08
BCC ObjectPathOnNoCarry_E249 ; CPU:$E246 PRG:2246 90 01
INX ; CPU:$E248 PRG:2248 E8
ObjectPathOnNoCarry_E249:
LDA $06 ; CPU:$E249 PRG:2249 A5 06
AND #$01 ; CPU:$E24B PRG:224B 29 01
BNE UpdateObjectRecordOnNonZero_E251 ; CPU:$E24D PRG:224D D0 02
INX ; CPU:$E24F PRG:224F E8
INX ; CPU:$E250 PRG:2250 E8
UpdateObjectRecordOnNonZero_E251:
LDA (CurrentObjectPtrLo),Y ; CPU:$E251 PRG:2251 B1 08
AND #$F0 ; CPU:$E253 PRG:2253 29 F0
CLC ; CPU:$E255 PRG:2255 18
ADC $E225,X ; CPU:$E256 PRG:2256 7D 25 E2
TAX ; CPU:$E259 PRG:2259 AA
LDA $E177,Y ; CPU:$E25A PRG:225A B9 77 E1
TAY ; CPU:$E25D PRG:225D A8
TXA ; CPU:$E25E PRG:225E 8A
STA (CurrentObjectPtrLo),Y ; CPU:$E25F PRG:225F 91 08
RTS ; CPU:$E261 PRG:2261 60
;------------------------------------------------------------
; ReadObjectRecordRoutine_E262
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E262:
LDX $06 ; CPU:$E262 PRG:2262 A6 06
LDY $E16F,X ; CPU:$E264 PRG:2264 BC 6F E1
LDA (CurrentObjectPtrLo),Y ; CPU:$E267 PRG:2267 B1 08
STA $05 ; CPU:$E269 PRG:2269 85 05
DEY ; CPU:$E26B PRG:226B 88
LDA (CurrentObjectPtrLo),Y ; CPU:$E26C PRG:226C B1 08
STA $04 ; CPU:$E26E PRG:226E 85 04
BPL UpdateObjectRecordOnPositive_E275 ; CPU:$E270 PRG:2270 10 03
JSR ProcessObjectStateRoutine_E281 ; CPU:$E272 PRG:2272 20 81 E2
UpdateObjectRecordOnPositive_E275:
LDY #$16 ; CPU:$E275 PRG:2275 A0 16
LDA $05 ; CPU:$E277 PRG:2277 A5 05
STA (CurrentObjectPtrLo),Y ; CPU:$E279 PRG:2279 91 08
DEY ; CPU:$E27B PRG:227B 88
LDA $04 ; CPU:$E27C PRG:227C A5 04
STA (CurrentObjectPtrLo),Y ; CPU:$E27E PRG:227E 91 08
RTS ; CPU:$E280 PRG:2280 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E281
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E281:
SEC ; CPU:$E281 PRG:2281 38
LDA #$00 ; CPU:$E282 PRG:2282 A9 00
SBC $05 ; CPU:$E284 PRG:2284 E5 05
STA $05 ; CPU:$E286 PRG:2286 85 05
LDA #$00 ; CPU:$E288 PRG:2288 A9 00
SBC $04 ; CPU:$E28A PRG:228A E5 04
STA $04 ; CPU:$E28C PRG:228C 85 04
RTS ; CPU:$E28E PRG:228E 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E28F
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E28F:
LDA $06 ; CPU:$E28F PRG:228F A5 06
AND #$03 ; CPU:$E291 PRG:2291 29 03
TAX ; CPU:$E293 PRG:2293 AA
LDA $06 ; CPU:$E294 PRG:2294 A5 06
AND #$F0 ; CPU:$E296 PRG:2296 29 F0
CMP #$70 ; CPU:$E298 PRG:2298 C9 70
BNE ReadObjectRecordOnNonZero_E2C7 ; CPU:$E29A PRG:229A D0 2B
JSR UpdateObjectRecordRoutine_E335 ; CPU:$E29C PRG:229C 20 35 E3
BCS ObjectPathOnCarry_E2BA ; CPU:$E29F PRG:229F B0 19
JSR UpdateObjectRecordRoutine_E2E6 ; CPU:$E2A1 PRG:22A1 20 E6 E2
BMI ObjectPathOnNegative_E2B5 ; CPU:$E2A4 PRG:22A4 30 0F
LDA WorkPtr0Lo ; CPU:$E2A6 PRG:22A6 A5 00
BMI ObjectPathOnNegative_E2B9 ; CPU:$E2A8 PRG:22A8 30 0F
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E2AA
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E2AA:
LDY #$1B ; CPU:$E2AA PRG:22AA A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$E2AC PRG:22AC B1 08
LDY #$10 ; CPU:$E2AE PRG:22AE A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$E2B0 PRG:22B0 91 08
STA $06 ; CPU:$E2B2 PRG:22B2 85 06
RTS ; CPU:$E2B4 PRG:22B4 60
ObjectPathOnNegative_E2B5:
LDA WorkPtr0Lo ; CPU:$E2B5 PRG:22B5 A5 00
BMI UpdateObjectRecordRoutine_E2AA ; CPU:$E2B7 PRG:22B7 30 F1
ObjectPathOnNegative_E2B9:
RTS ; CPU:$E2B9 PRG:22B9 60
ObjectPathOnCarry_E2BA:
JSR UpdateObjectRecordRoutine_E2AA ; CPU:$E2BA PRG:22BA 20 AA E2
AND #$03 ; CPU:$E2BD PRG:22BD 29 03
TAX ; CPU:$E2BF PRG:22BF AA
LDY $E173,X ; CPU:$E2C0 PRG:22C0 BC 73 E1
JSR UpdateObjectRecordRoutine_E325 ; CPU:$E2C3 PRG:22C3 20 25 E3
RTS ; CPU:$E2C6 PRG:22C6 60
ReadObjectRecordOnNonZero_E2C7:
LDY $E16F,X ; CPU:$E2C7 PRG:22C7 BC 6F E1
LDA (CurrentObjectPtrLo),Y ; CPU:$E2CA PRG:22CA B1 08
STA $05 ; CPU:$E2CC PRG:22CC 85 05
DEY ; CPU:$E2CE PRG:22CE 88
LDA (CurrentObjectPtrLo),Y ; CPU:$E2CF PRG:22CF B1 08
STA $04 ; CPU:$E2D1 PRG:22D1 85 04
BPL ReadObjectRecordOnPositive_E2D8 ; CPU:$E2D3 PRG:22D3 10 03
JSR ProcessObjectStateRoutine_E281 ; CPU:$E2D5 PRG:22D5 20 81 E2
ReadObjectRecordOnPositive_E2D8:
LDY #$16 ; CPU:$E2D8 PRG:22D8 A0 16
SEC ; CPU:$E2DA PRG:22DA 38
LDA $05 ; CPU:$E2DB PRG:22DB A5 05
SBC (CurrentObjectPtrLo),Y ; CPU:$E2DD PRG:22DD F1 08
DEY ; CPU:$E2DF PRG:22DF 88
LDA $04 ; CPU:$E2E0 PRG:22E0 A5 04
SBC (CurrentObjectPtrLo),Y ; CPU:$E2E2 PRG:22E2 F1 08
BCC UpdateObjectRecordOnNoCarry_E301 ; CPU:$E2E4 PRG:22E4 90 1B
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E2E6
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E2E6:
LDY #$18 ; CPU:$E2E6 PRG:22E6 A0 18
LDA (CurrentObjectPtrLo),Y ; CPU:$E2E8 PRG:22E8 B1 08
CLC ; CPU:$E2EA PRG:22EA 18
LDY $E16F,X ; CPU:$E2EB PRG:22EB BC 6F E1
ADC (CurrentObjectPtrLo),Y ; CPU:$E2EE PRG:22EE 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E2F0 PRG:22F0 91 08
LDY #$17 ; CPU:$E2F2 PRG:22F2 A0 17
LDA (CurrentObjectPtrLo),Y ; CPU:$E2F4 PRG:22F4 B1 08
STA $00 ; CPU:$E2F6 PRG:22F6 85 00
LDY $E16F,X ; CPU:$E2F8 PRG:22F8 BC 6F E1
DEY ; CPU:$E2FB PRG:22FB 88
ADC (CurrentObjectPtrLo),Y ; CPU:$E2FC PRG:22FC 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E2FE PRG:22FE 91 08
RTS ; CPU:$E300 PRG:2300 60
UpdateObjectRecordOnNoCarry_E301:
LDY #$10 ; CPU:$E301 PRG:2301 A0 10
TXA ; CPU:$E303 PRG:2303 8A
STA (CurrentObjectPtrLo),Y ; CPU:$E304 PRG:2304 91 08
LDY #$1B ; CPU:$E306 PRG:2306 A0 1B
STA (CurrentObjectPtrLo),Y ; CPU:$E308 PRG:2308 91 08
AND #$01 ; CPU:$E30A PRG:230A 29 01
BEQ UpdateObjectRecordOnZero_E313 ; CPU:$E30C PRG:230C F0 05
LDY #$15 ; CPU:$E30E PRG:230E A0 15
JSR UpdateObjectRecordRoutine_E325 ; CPU:$E310 PRG:2310 20 25 E3
UpdateObjectRecordOnZero_E313:
LDY #$15 ; CPU:$E313 PRG:2313 A0 15
LDA (CurrentObjectPtrLo),Y ; CPU:$E315 PRG:2315 B1 08
PHA ; CPU:$E317 PRG:2317 48
INY ; CPU:$E318 PRG:2318 C8
LDA (CurrentObjectPtrLo),Y ; CPU:$E319 PRG:2319 B1 08
LDY $E16F,X ; CPU:$E31B PRG:231B BC 6F E1
STA (CurrentObjectPtrLo),Y ; CPU:$E31E PRG:231E 91 08
DEY ; CPU:$E320 PRG:2320 88
PLA ; CPU:$E321 PRG:2321 68
STA (CurrentObjectPtrLo),Y ; CPU:$E322 PRG:2322 91 08
RTS ; CPU:$E324 PRG:2324 60
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E325
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E325:
INY ; CPU:$E325 PRG:2325 C8
SEC ; CPU:$E326 PRG:2326 38
LDA #$00 ; CPU:$E327 PRG:2327 A9 00
SBC (CurrentObjectPtrLo),Y ; CPU:$E329 PRG:2329 F1 08
STA (CurrentObjectPtrLo),Y ; CPU:$E32B PRG:232B 91 08
DEY ; CPU:$E32D PRG:232D 88
LDA #$00 ; CPU:$E32E PRG:232E A9 00
SBC (CurrentObjectPtrLo),Y ; CPU:$E330 PRG:2330 F1 08
STA (CurrentObjectPtrLo),Y ; CPU:$E332 PRG:2332 91 08
RTS ; CPU:$E334 PRG:2334 60
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E335
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E335:
LDY $E167,X ; CPU:$E335 PRG:2335 BC 67 E1
LDA (CurrentObjectPtrLo),Y ; CPU:$E338 PRG:2338 B1 08
LDY $E16B,X ; CPU:$E33A PRG:233A BC 6B E1
CMP (CurrentObjectPtrLo),Y ; CPU:$E33D PRG:233D D1 08
BCC ObjectPathOnNoCarry_E350 ; CPU:$E33F PRG:233F 90 0F
LDY $E177,X ; CPU:$E341 PRG:2341 BC 77 E1
LDA (CurrentObjectPtrLo),Y ; CPU:$E344 PRG:2344 B1 08
LDY $E17B,X ; CPU:$E346 PRG:2346 BC 7B E1
STA (CurrentObjectPtrLo),Y ; CPU:$E349 PRG:2349 91 08
INY ; CPU:$E34B PRG:234B C8
LDA #$00 ; CPU:$E34C PRG:234C A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$E34E PRG:234E 91 08
ObjectPathOnNoCarry_E350:
RTS ; CPU:$E350 PRG:2350 60
;------------------------------------------------------------
; ReadObjectRecordRoutine_E351
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E351:
LDY #$20 ; CPU:$E351 PRG:2351 A0 20
LDA (CurrentObjectPtrLo),Y ; CPU:$E353 PRG:2353 B1 08
BNE ObjectPathLoop_E37E ; CPU:$E355 PRG:2355 D0 27
LDY #$21 ; CPU:$E357 PRG:2357 A0 21
LDA (CurrentObjectPtrLo),Y ; CPU:$E359 PRG:2359 B1 08
CLC ; CPU:$E35B PRG:235B 18
;------------------------------------------------------------
; ReadObjectRecord_E35C
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecord_E35C:
ADC #$04 ; CPU:$E35C PRG:235C 69 04
STA $00 ; CPU:$E35E PRG:235E 85 00
LDY #$23 ; CPU:$E360 PRG:2360 A0 23
LDA (CurrentObjectPtrLo),Y ; CPU:$E362 PRG:2362 B1 08
CLC ; CPU:$E364 PRG:2364 18
ADC #$04 ; CPU:$E365 PRG:2365 69 04
STA $01 ; CPU:$E367 PRG:2367 85 01
JSR UpdateObjectBufferRoutine_E0DF ; CPU:$E369 PRG:2369 20 DF E0
LDA $0A ; CPU:$E36C PRG:236C A5 0A
CLC ; CPU:$E36E PRG:236E 18
ADC #$02 ; CPU:$E36F PRG:236F 69 02
JSR ProcessObjectStateRoutine_E0B2 ; CPU:$E371 PRG:2371 20 B2 E0
BCS ObjectPathLoop_E37E ; CPU:$E374 PRG:2374 B0 08
CMP #$4E ; CPU:$E376 PRG:2376 C9 4E
BEQ ObjectPathOnZero_E380 ; CPU:$E378 PRG:2378 F0 06
CMP #$4F ; CPU:$E37A PRG:237A C9 4F
BEQ ObjectPathOnZero_E380 ; CPU:$E37C PRG:237C F0 02
ObjectPathLoop_E37E:
CLC ; CPU:$E37E PRG:237E 18
RTS ; CPU:$E37F PRG:237F 60
ObjectPathOnZero_E380:
JSR ReadObjectRecordRoutine_E13F ; CPU:$E380 PRG:2380 20 3F E1
BCS ObjectPathLoop_E37E ; CPU:$E383 PRG:2383 B0 F9
SEC ; CPU:$E385 PRG:2385 38
RTS ; CPU:$E386 PRG:2386 60
.byte $00, $00, $00, $00, $0C, $F4, $0C, $F4, $F4, $0C, $F4, $0C, $00, $00, $00, $00 ; CPU:$E387 PRG:2387 0B
.byte $80, $00, $80, $00, $40, $C0, $40, $C0, $81, $80, $80, $81, $81, $80, $80, $81 ; CPU:$E397 PRG:2397 0B
;------------------------------------------------------------
; UpdateObjectRecordRoutine_E3A7
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecordRoutine_E3A7:
JSR ReadObjectRecordRoutine_E262 ; CPU:$E3A7 PRG:23A7 20 62 E2
LDX $06 ; CPU:$E3AA PRG:23AA A6 06
LDY $E16F,X ; CPU:$E3AC PRG:23AC BC 6F E1
LDA #$00 ; CPU:$E3AF PRG:23AF A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$E3B1 PRG:23B1 91 08
DEY ; CPU:$E3B3 PRG:23B3 88
STA (CurrentObjectPtrLo),Y ; CPU:$E3B4 PRG:23B4 91 08
;------------------------------------------------------------
; UpdateObjectRecord_E3B6
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectRecord_E3B6:
LDA $07 ; CPU:$E3B6 PRG:23B6 A5 07
SEC ; CPU:$E3B8 PRG:23B8 38
SBC #$04 ; CPU:$E3B9 PRG:23B9 E9 04
TAX ; CPU:$E3BB PRG:23BB AA
LDA $E39F,X ; CPU:$E3BC PRG:23BC BD 9F E3
LDY #$10 ; CPU:$E3BF PRG:23BF A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$E3C1 PRG:23C1 91 08
LDA $E387,X ; CPU:$E3C3 PRG:23C3 BD 87 E3
LDY #$19 ; CPU:$E3C6 PRG:23C6 A0 19
STA (CurrentObjectPtrLo),Y ; CPU:$E3C8 PRG:23C8 91 08
LDA $E38F,X ; CPU:$E3CA PRG:23CA BD 8F E3
INY ; CPU:$E3CD PRG:23CD C8
STA (CurrentObjectPtrLo),Y ; CPU:$E3CE PRG:23CE 91 08
LDA $E397,X ; CPU:$E3D0 PRG:23D0 BD 97 E3
INY ; CPU:$E3D3 PRG:23D3 C8
STA (CurrentObjectPtrLo),Y ; CPU:$E3D4 PRG:23D4 91 08
LDY #$01 ; CPU:$E3D6 PRG:23D6 A0 01
LDA (CurrentObjectPtrLo),Y ; CPU:$E3D8 PRG:23D8 B1 08
LDX $06 ; CPU:$E3DA PRG:23DA A6 06
CPX #$02 ; CPU:$E3DC PRG:23DC E0 02
PHP ; CPU:$E3DE PRG:23DE 08
BCS UpdateObjectRecordOnCarry_E3E4 ; CPU:$E3DF PRG:23DF B0 03
JSR ProcessObjectStateRoutine_E405 ; CPU:$E3E1 PRG:23E1 20 05 E4
UpdateObjectRecordOnCarry_E3E4:
STA (CurrentObjectPtrLo),Y ; CPU:$E3E4 PRG:23E4 91 08
LDY #$17 ; CPU:$E3E6 PRG:23E6 A0 17
STA (CurrentObjectPtrLo),Y ; CPU:$E3E8 PRG:23E8 91 08
LDY #$03 ; CPU:$E3EA PRG:23EA A0 03
LDA (CurrentObjectPtrLo),Y ; CPU:$E3EC PRG:23EC B1 08
PLP ; CPU:$E3EE PRG:23EE 28
BCC UpdateObjectRecordOnNoCarry_E3F4 ; CPU:$E3EF PRG:23EF 90 03
JSR ProcessObjectStateRoutine_E405 ; CPU:$E3F1 PRG:23F1 20 05 E4
UpdateObjectRecordOnNoCarry_E3F4:
STA (CurrentObjectPtrLo),Y ; CPU:$E3F4 PRG:23F4 91 08
LDY #$18 ; CPU:$E3F6 PRG:23F6 A0 18
STA (CurrentObjectPtrLo),Y ; CPU:$E3F8 PRG:23F8 91 08
LDA #$00 ; CPU:$E3FA PRG:23FA A9 00
LDY #$02 ; CPU:$E3FC PRG:23FC A0 02
STA (CurrentObjectPtrLo),Y ; CPU:$E3FE PRG:23FE 91 08
LDY #$04 ; CPU:$E400 PRG:2400 A0 04
STA (CurrentObjectPtrLo),Y ; CPU:$E402 PRG:2402 91 08
RTS ; CPU:$E404 PRG:2404 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E405
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E405:
AND #$0F ; CPU:$E405 PRG:2405 29 0F
LDX #$04 ; CPU:$E407 PRG:2407 A2 04
CMP #$08 ; CPU:$E409 PRG:2409 C9 08
BCC ReadObjectRecordOnNoCarry_E40F ; CPU:$E40B PRG:240B 90 02
LDX #$0C ; CPU:$E40D PRG:240D A2 0C
ReadObjectRecordOnNoCarry_E40F:
STX $04 ; CPU:$E40F PRG:240F 86 04
LDA (CurrentObjectPtrLo),Y ; CPU:$E411 PRG:2411 B1 08
AND #$F0 ; CPU:$E413 PRG:2413 29 F0
ORA $04 ; CPU:$E415 PRG:2415 05 04
RTS ; CPU:$E417 PRG:2417 60
.byte $00, $04, $02, $04, $00, $04, $02, $04, $00, $04, $02, $04, $00, $04, $02, $04 ; CPU:$E418 PRG:2418 0B
.byte $40, $40, $40, $C0, $80, $80, $80, $00, $C0, $80, $00, $00, $00, $40, $C0, $C0 ; CPU:$E428 PRG:2428 0B
.byte $00, $03, $01, $02, $00, $03, $01, $02, $00, $02, $01, $03, $00, $02, $01, $03 ; CPU:$E438 PRG:2438 0B
.byte $F8, $F8, $04, $10, $10, $10, $04, $F8, $10, $10, $04, $F8, $F8, $F8, $04, $10 ; CPU:$E448 PRG:2448 0B
.byte $04, $FC, $F8, $FC, $04, $0C, $10, $0C, $04, $0C, $10, $0C, $04, $FC, $F8, $FC ; CPU:$E458 PRG:2458 0B
;------------------------------------------------------------
; UpdateObjectBufferRoutine_E468
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBufferRoutine_E468:
LDA #$00 ; CPU:$E468 PRG:2468 A9 00
STA $04 ; CPU:$E46A PRG:246A 85 04
STA $05 ; CPU:$E46C PRG:246C 85 05
LDX #$03 ; CPU:$E46E PRG:246E A2 03
ReadObjectRecordLoop_E470:
LDY #$16 ; CPU:$E470 PRG:2470 A0 16
LDA $05 ; CPU:$E472 PRG:2472 A5 05
CLC ; CPU:$E474 PRG:2474 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E475 PRG:2475 71 08
STA $05 ; CPU:$E477 PRG:2477 85 05
LDY #$15 ; CPU:$E479 PRG:2479 A0 15
LDA $04 ; CPU:$E47B PRG:247B A5 04
ADC (CurrentObjectPtrLo),Y ; CPU:$E47D PRG:247D 71 08
STA $04 ; CPU:$E47F PRG:247F 85 04
DEX ; CPU:$E481 PRG:2481 CA
BNE ReadObjectRecordLoop_E470 ; CPU:$E482 PRG:2482 D0 EC
LDA $06 ; CPU:$E484 PRG:2484 A5 06
CMP #$80 ; CPU:$E486 PRG:2486 C9 80
BNE ObjectPathOnNonZero_E491 ; CPU:$E488 PRG:2488 D0 07
SEC ; CPU:$E48A PRG:248A 38
LDA #$00 ; CPU:$E48B PRG:248B A9 00
SBC $04 ; CPU:$E48D PRG:248D E5 04
STA $04 ; CPU:$E48F PRG:248F 85 04
ObjectPathOnNonZero_E491:
LDA $56 ; CPU:$E491 PRG:2491 A5 56
BNE ObjectPathOnNonZero_E49B ; CPU:$E493 PRG:2493 D0 06
LDX $0A ; CPU:$E495 PRG:2495 A6 0A
LDA $75,X ; CPU:$E497 PRG:2497 B5 75
BEQ UpdateObjectRecordOnZero_E49F ; CPU:$E499 PRG:2499 F0 04
ObjectPathOnNonZero_E49B:
LDA #$00 ; CPU:$E49B PRG:249B A9 00
STA $04 ; CPU:$E49D PRG:249D 85 04
UpdateObjectRecordOnZero_E49F:
LDY #$1B ; CPU:$E49F PRG:249F A0 1B
CLC ; CPU:$E4A1 PRG:24A1 18
LDA $04 ; CPU:$E4A2 PRG:24A2 A5 04
ADC (CurrentObjectPtrLo),Y ; CPU:$E4A4 PRG:24A4 71 08
STA (CurrentObjectPtrLo),Y ; CPU:$E4A6 PRG:24A6 91 08
JSR ProcessObjectStateRoutine_E045 ; CPU:$E4A8 PRG:24A8 20 45 E0
LDY #$19 ; CPU:$E4AB PRG:24AB A0 19
LDA (CurrentObjectPtrLo),Y ; CPU:$E4AD PRG:24AD B1 08
SEC ; CPU:$E4AF PRG:24AF 38
SBC $00 ; CPU:$E4B0 PRG:24B0 E5 00
LDY #$17 ; CPU:$E4B2 PRG:24B2 A0 17
CLC ; CPU:$E4B4 PRG:24B4 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E4B5 PRG:24B5 71 08
LDY #$01 ; CPU:$E4B7 PRG:24B7 A0 01
STA (CurrentObjectPtrLo),Y ; CPU:$E4B9 PRG:24B9 91 08
LDY #$1B ; CPU:$E4BB PRG:24BB A0 1B
SEC ; CPU:$E4BD PRG:24BD 38
LDA #$40 ; CPU:$E4BE PRG:24BE A9 40
SBC (CurrentObjectPtrLo),Y ; CPU:$E4C0 PRG:24C0 F1 08
JSR ProcessObjectStateRoutine_E045 ; CPU:$E4C2 PRG:24C2 20 45 E0
LDY #$1A ; CPU:$E4C5 PRG:24C5 A0 1A
LDA (CurrentObjectPtrLo),Y ; CPU:$E4C7 PRG:24C7 B1 08
SEC ; CPU:$E4C9 PRG:24C9 38
SBC $00 ; CPU:$E4CA PRG:24CA E5 00
STA $00 ; CPU:$E4CC PRG:24CC 85 00
LDY #$18 ; CPU:$E4CE PRG:24CE A0 18
LDA (CurrentObjectPtrLo),Y ; CPU:$E4D0 PRG:24D0 B1 08
SEC ; CPU:$E4D2 PRG:24D2 38
SBC $00 ; CPU:$E4D3 PRG:24D3 E5 00
LDY #$03 ; CPU:$E4D5 PRG:24D5 A0 03
STA (CurrentObjectPtrLo),Y ; CPU:$E4D7 PRG:24D7 91 08
LDX #$07 ; CPU:$E4D9 PRG:24D9 A2 07
LDA $06 ; CPU:$E4DB PRG:24DB A5 06
CMP #$81 ; CPU:$E4DD PRG:24DD C9 81
BEQ ReadObjectRecordOnZero_E4E3 ; CPU:$E4DF PRG:24DF F0 02
LDX #$FF ; CPU:$E4E1 PRG:24E1 A2 FF
ReadObjectRecordOnZero_E4E3:
LDY #$1B ; CPU:$E4E3 PRG:24E3 A0 1B
LDA #$10 ; CPU:$E4E5 PRG:24E5 A9 10
CLC ; CPU:$E4E7 PRG:24E7 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E4E8 PRG:24E8 71 08
UpdateObjectRecordLoop_E4EA:
SEC ; CPU:$E4EA PRG:24EA 38
SBC #$20 ; CPU:$E4EB PRG:24EB E9 20
INX ; CPU:$E4ED PRG:24ED E8
BCS UpdateObjectRecordLoop_E4EA ; CPU:$E4EE PRG:24EE B0 FA
LDA $E418,X ; CPU:$E4F0 PRG:24F0 BD 18 E4
LDY #$05 ; CPU:$E4F3 PRG:24F3 A0 05
STA (CurrentObjectPtrLo),Y ; CPU:$E4F5 PRG:24F5 91 08
LDA $E428,X ; CPU:$E4F7 PRG:24F7 BD 28 E4
LDY #$08 ; CPU:$E4FA PRG:24FA A0 08
STA (CurrentObjectPtrLo),Y ; CPU:$E4FC PRG:24FC 91 08
LDY #$28 ; CPU:$E4FE PRG:24FE A0 28
STA (CurrentObjectPtrLo),Y ; CPU:$E500 PRG:2500 91 08
LDY #$38 ; CPU:$E502 PRG:2502 A0 38
STA (CurrentObjectPtrLo),Y ; CPU:$E504 PRG:2504 91 08
LDA $E438,X ; CPU:$E506 PRG:2506 BD 38 E4
LDY #$25 ; CPU:$E509 PRG:2509 A0 25
STA (CurrentObjectPtrLo),Y ; CPU:$E50B PRG:250B 91 08
LDA $E418,X ; CPU:$E50D PRG:250D BD 18 E4
LDY #$35 ; CPU:$E510 PRG:2510 A0 35
STA (CurrentObjectPtrLo),Y ; CPU:$E512 PRG:2512 91 08
LDA $E448,X ; CPU:$E514 PRG:2514 BD 48 E4
LDY #$01 ; CPU:$E517 PRG:2517 A0 01
CLC ; CPU:$E519 PRG:2519 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E51A PRG:251A 71 08
LDY #$31 ; CPU:$E51C PRG:251C A0 31
STA (CurrentObjectPtrLo),Y ; CPU:$E51E PRG:251E 91 08
LDA $E458,X ; CPU:$E520 PRG:2520 BD 58 E4
LDY #$03 ; CPU:$E523 PRG:2523 A0 03
CLC ; CPU:$E525 PRG:2525 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E526 PRG:2526 71 08
LDY #$33 ; CPU:$E528 PRG:2528 A0 33
STA (CurrentObjectPtrLo),Y ; CPU:$E52A PRG:252A 91 08
RTS ; CPU:$E52C PRG:252C 60
.byte $02, $01, $03, $00, $02, $03, $03, $01, $01, $11, $24 ; CPU:$E52D PRG:252D 0B
ObjectPathLoop_E538:
RTS ; CPU:$E538 PRG:2538 60
;------------------------------------------------------------
; ReadObjectRecordRoutine_E539
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E539:
LDX $0A ; CPU:$E539 PRG:2539 A6 0A
LDA $46,X ; CPU:$E53B PRG:253B B5 46
AND #$0F ; CPU:$E53D PRG:253D 29 0F
BNE ObjectPathLoop_E538 ; CPU:$E53F PRG:253F D0 F7
LDY #$1B ; CPU:$E541 PRG:2541 A0 1B
LDA (CurrentObjectPtrLo),Y ; CPU:$E543 PRG:2543 B1 08
LDY #$FF ; CPU:$E545 PRG:2545 A0 FF
ObjectPathLoop_E547:
INY ; CPU:$E547 PRG:2547 C8
SEC ; CPU:$E548 PRG:2548 38
SBC #$40 ; CPU:$E549 PRG:2549 E9 40
BCS ObjectPathLoop_E547 ; CPU:$E54B PRG:254B B0 FA
ADC #$40 ; CPU:$E54D PRG:254D 69 40
LDX $06 ; CPU:$E54F PRG:254F A6 06
CPX #$80 ; CPU:$E551 PRG:2551 E0 80
BEQ ObjectPathOnZero_E59C ; CPU:$E553 PRG:2553 F0 47
CMP #$1C ; CPU:$E555 PRG:2555 C9 1C
BCS ObjectPathLoop_E538 ; CPU:$E557 PRG:2557 B0 DF
INY ; CPU:$E559 PRG:2559 C8
UpdateObjectRecordLoop_E55A:
LDA $E52D,Y ; CPU:$E55A PRG:255A B9 2D E5
LDY #$10 ; CPU:$E55D PRG:255D A0 10
STA (CurrentObjectPtrLo),Y ; CPU:$E55F PRG:255F 91 08
LDY #$1B ; CPU:$E561 PRG:2561 A0 1B
STA (CurrentObjectPtrLo),Y ; CPU:$E563 PRG:2563 91 08
STA $06 ; CPU:$E565 PRG:2565 85 06
LDY #$15 ; CPU:$E567 PRG:2567 A0 15
TAX ; CPU:$E569 PRG:2569 AA
AND #$01 ; CPU:$E56A PRG:256A 29 01
BEQ UpdateObjectRecordOnZero_E571 ; CPU:$E56C PRG:256C F0 03
JSR UpdateObjectRecordRoutine_E325 ; CPU:$E56E PRG:256E 20 25 E3
UpdateObjectRecordOnZero_E571:
LDA (CurrentObjectPtrLo),Y ; CPU:$E571 PRG:2571 B1 08
STA $00 ; CPU:$E573 PRG:2573 85 00
INY ; CPU:$E575 PRG:2575 C8
LDA (CurrentObjectPtrLo),Y ; CPU:$E576 PRG:2576 B1 08
LDY $E16F,X ; CPU:$E578 PRG:2578 BC 6F E1
STA (CurrentObjectPtrLo),Y ; CPU:$E57B PRG:257B 91 08
LDA WorkPtr0Lo ; CPU:$E57D PRG:257D A5 00
DEY ; CPU:$E57F PRG:257F 88
STA (CurrentObjectPtrLo),Y ; CPU:$E580 PRG:2580 91 08
LDY $E532,X ; CPU:$E582 PRG:2582 BC 32 E5
LDA (CurrentObjectPtrLo),Y ; CPU:$E585 PRG:2585 B1 08
AND #$04 ; CPU:$E587 PRG:2587 29 04
PHP ; CPU:$E589 PRG:2589 08
LDA (CurrentObjectPtrLo),Y ; CPU:$E58A PRG:258A B1 08
PLP ; CPU:$E58C PRG:258C 28
BEQ UpdateObjectRecordOnZero_E592 ; CPU:$E58D PRG:258D F0 03
CLC ; CPU:$E58F PRG:258F 18
ADC #$04 ; CPU:$E590 PRG:2590 69 04
UpdateObjectRecordOnZero_E592:
AND #$F8 ; CPU:$E592 PRG:2592 29 F8
STA (CurrentObjectPtrLo),Y ; CPU:$E594 PRG:2594 91 08
INY ; CPU:$E596 PRG:2596 C8
LDA #$00 ; CPU:$E597 PRG:2597 A9 00
STA (CurrentObjectPtrLo),Y ; CPU:$E599 PRG:2599 91 08
ObjectPathLoop_E59B:
RTS ; CPU:$E59B PRG:259B 60
ObjectPathOnZero_E59C:
CMP #$24 ; CPU:$E59C PRG:259C C9 24
BCC ObjectPathLoop_E59B ; CPU:$E59E PRG:259E 90 FB
BCS UpdateObjectRecordLoop_E55A ; CPU:$E5A0 PRG:25A0 B0 B8
.byte $0F, $01, $04, $04, $04, $04, $0F, $01 ; CPU:$E5A2 PRG:25A2 0B
;------------------------------------------------------------
; ReadObjectRecordRoutine_E5AA
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ReadObjectRecordRoutine_E5AA:
PHA ; CPU:$E5AA PRG:25AA 48
LDA $06 ; CPU:$E5AB PRG:25AB A5 06
AND #$03 ; CPU:$E5AD PRG:25AD 29 03
TAX ; CPU:$E5AF PRG:25AF AA
LDA $E5A2,X ; CPU:$E5B0 PRG:25B0 BD A2 E5
LDY #$01 ; CPU:$E5B3 PRG:25B3 A0 01
CLC ; CPU:$E5B5 PRG:25B5 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E5B6 PRG:25B6 71 08
STA $00 ; CPU:$E5B8 PRG:25B8 85 00
LDA $E5A6,X ; CPU:$E5BA PRG:25BA BD A6 E5
LDY #$03 ; CPU:$E5BD PRG:25BD A0 03
CLC ; CPU:$E5BF PRG:25BF 18
ADC (CurrentObjectPtrLo),Y ; CPU:$E5C0 PRG:25C0 71 08
STA $01 ; CPU:$E5C2 PRG:25C2 85 01
JSR UpdateObjectBufferRoutine_E0DF ; CPU:$E5C4 PRG:25C4 20 DF E0
PLA ; CPU:$E5C7 PRG:25C7 68
JSR ProcessObjectStateRoutine_E0B2 ; CPU:$E5C8 PRG:25C8 20 B2 E0
RTS ; CPU:$E5CB PRG:25CB 60
.byte $34, $24, $24, $24, $24, $6E, $86, $86, $6F, $24, $24, $24, $24, $34, $24, $24 ; CPU:$E5CC PRG:25CC 0B
.byte $24, $24, $70, $87, $88, $71, $24, $24, $24, $24, $34, $24, $24, $24, $24, $72 ; CPU:$E5DC PRG:25DC 0B
.byte $89, $8A, $73, $24, $9F, $A0, $24, $34, $24, $24, $24, $24, $74, $8B, $8C, $75 ; CPU:$E5EC PRG:25EC 0B
.byte $A1, $A2, $A3, $A4, $34, $24, $24, $24, $24, $76, $8D, $8E, $77, $24, $24, $24 ; CPU:$E5FC PRG:25FC 0B
.byte $24, $34, $24, $A5, $A6, $24, $78, $8F, $90, $79, $24, $24, $24, $24, $34, $A7 ; CPU:$E60C PRG:260C 0B
.byte $A8, $A9, $AA, $7A, $91, $92, $7B, $24, $24, $24, $24, $43, $24, $60, $24, $24 ; CPU:$E61C PRG:261C 0B
.byte $7C, $24, $24, $7C, $24, $24, $61, $24, $43, $24, $62, $24, $24, $7D, $24, $24 ; CPU:$E62C PRG:262C 0B
.byte $7E, $24, $24, $63, $24, $43, $24, $64, $24, $24, $81, $93, $24, $82, $94, $24 ; CPU:$E63C PRG:263C 0B
.byte $65, $24, $43, $24, $66, $95, $24, $85, $96, $24, $85, $97, $24, $67, $98, $43 ; CPU:$E64C PRG:264C 0B
.byte $24, $68, $24, $24, $7F, $24, $24, $80, $24, $24, $69, $24, $43, $24, $6A, $24 ; CPU:$E65C PRG:265C 0B
.byte $99, $83, $24, $9A, $84, $24, $24, $6B, $24, $43, $9B, $6C, $24, $9C, $85, $24 ; CPU:$E66C PRG:266C 0B
.byte $9D, $85, $24, $9E, $6D, $24, $00, $0D, $00, $34, $41, $34, $00, $0D, $1A, $27 ; CPU:$E67C PRG:267C 0B
.byte $1A, $0D, $00, $34, $00, $0D, $1A, $0D, $00, $34, $41, $4E, $41, $34 ; CPU:$E68C PRG:268C 0B
;------------------------------------------------------------
; ProcessObjectStateRoutine_E69A
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E69A:
LDX #$FB ; CPU:$E69A PRG:269A A2 FB
ReadObjectRecordLoop_E69C:
INX ; CPU:$E69C PRG:269C E8
INX ; CPU:$E69D PRG:269D E8
INX ; CPU:$E69E PRG:269E E8
INX ; CPU:$E69F PRG:269F E8
INX ; CPU:$E6A0 PRG:26A0 E8
CPX #$14 ; CPU:$E6A1 PRG:26A1 E0 14
BEQ ObjectPathLoop_E6F2 ; CPU:$E6A3 PRG:26A3 F0 4D
LDA $0370,X ; CPU:$E6A5 PRG:26A5 BD 70 03
BNE ReadObjectRecordLoop_E69C ; CPU:$E6A8 PRG:26A8 D0 F2
LDA #$0C ; CPU:$E6AA PRG:26AA A9 0C
STA $0370,X ; CPU:$E6AC PRG:26AC 9D 70 03
LDY #$16 ; CPU:$E6AF PRG:26AF A0 16
LDA (CurrentObjectPtrLo),Y ; CPU:$E6B1 PRG:26B1 B1 08
STA $00 ; CPU:$E6B3 PRG:26B3 85 00
DEY ; CPU:$E6B5 PRG:26B5 88
LDA (CurrentObjectPtrLo),Y ; CPU:$E6B6 PRG:26B6 B1 08
LSR A ; CPU:$E6B8 PRG:26B8 4A
ROR $00 ; CPU:$E6B9 PRG:26B9 66 00
LSR A ; CPU:$E6BB PRG:26BB 4A
ROR $00 ; CPU:$E6BC PRG:26BC 66 00
LSR A ; CPU:$E6BE PRG:26BE 4A
ROR $00 ; CPU:$E6BF PRG:26BF 66 00
BNE ObjectPathOnNonZero_E6C5 ; CPU:$E6C1 PRG:26C1 D0 02
INC $00 ; CPU:$E6C3 PRG:26C3 E6 00
ObjectPathOnNonZero_E6C5:
SEC ; CPU:$E6C5 PRG:26C5 38
LDA #$00 ; CPU:$E6C6 PRG:26C6 A9 00
SBC $00 ; CPU:$E6C8 PRG:26C8 E5 00
LDY #$00 ; CPU:$E6CA PRG:26CA A0 00
ObjectPathLoop_E6CC:
INY ; CPU:$E6CC PRG:26CC C8
SEC ; CPU:$E6CD PRG:26CD 38
SBC $00 ; CPU:$E6CE PRG:26CE E5 00
BCS ObjectPathLoop_E6CC ; CPU:$E6D0 PRG:26D0 B0 FA
TYA ; CPU:$E6D2 PRG:26D2 98
BNE UpdateObjectBufferOnNonZero_E6D7 ; CPU:$E6D3 PRG:26D3 D0 02
LDA #$FF ; CPU:$E6D5 PRG:26D5 A9 FF
UpdateObjectBufferOnNonZero_E6D7:
INX ; CPU:$E6D7 PRG:26D7 E8
STA $0370,X ; CPU:$E6D8 PRG:26D8 9D 70 03
INX ; CPU:$E6DB PRG:26DB E8
LDA $06 ; CPU:$E6DC PRG:26DC A5 06
STA $0370,X ; CPU:$E6DE PRG:26DE 9D 70 03
INX ; CPU:$E6E1 PRG:26E1 E8
SEC ; CPU:$E6E2 PRG:26E2 38
LDA $03 ; CPU:$E6E3 PRG:26E3 A5 03
SBC #$21 ; CPU:$E6E5 PRG:26E5 E9 21
STA $0370,X ; CPU:$E6E7 PRG:26E7 9D 70 03
INX ; CPU:$E6EA PRG:26EA E8
LDA WorkPtr1Lo ; CPU:$E6EB PRG:26EB A5 02
SBC #$00 ; CPU:$E6ED PRG:26ED E9 00
STA $0370,X ; CPU:$E6EF PRG:26EF 9D 70 03
ObjectPathLoop_E6F2:
RTS ; CPU:$E6F2 PRG:26F2 60
;------------------------------------------------------------
; ProcessObjectStateRoutine_E6F3
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessObjectStateRoutine_E6F3:
LDA #$FF ; CPU:$E6F3 PRG:26F3 A9 FF
STA $07 ; CPU:$E6F5 PRG:26F5 85 07
LDX #$FB ; CPU:$E6F7 PRG:26F7 A2 FB
ObjectPathLoop_E6F9:
INX ; CPU:$E6F9 PRG:26F9 E8
INX ; CPU:$E6FA PRG:26FA E8
INX ; CPU:$E6FB PRG:26FB E8
INX ; CPU:$E6FC PRG:26FC E8
ProcessObjectStateDispatch_E6FD:
INX ; CPU:$E6FD PRG:26FD E8
INC $07 ; CPU:$E6FE PRG:26FE E6 07
;------------------------------------------------------------
; UpdateObjectBuffer_E700
;
; Global:
; First-pass object-engine entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Object pointers, entity state, or gameplay state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateObjectBuffer_E700:
CPX #$14 ; CPU:$E700 PRG:2700 E0 14
BEQ ObjectPathLoop_E6F2 ; CPU:$E702 PRG:2702 F0 EE
LDY $07 ; CPU:$E704 PRG:2704 A4 07
LDA a:$0068,Y ; CPU:$E706 PRG:2706 B9 68 00
BNE ObjectPathLoop_E6F9 ; CPU:$E709 PRG:2709 D0 EE
LDA $0370,X ; CPU:$E70B PRG:270B BD 70 03
BEQ ObjectPathLoop_E6F9 ; CPU:$E70E PRG:270E F0 E9
DEC $0370,X ; CPU:$E710 PRG:2710 DE 70 03
LDA $0370,X ; CPU:$E713 PRG:2713 BD 70 03
STA $00 ; CPU:$E716 PRG:2716 85 00
INX ; CPU:$E718 PRG:2718 E8
LDA $0370,X ; CPU:$E719 PRG:2719 BD 70 03
STA a:$0068,Y ; CPU:$E71C PRG:271C 99 68 00
INX ; CPU:$E71F PRG:271F E8
LDA $0370,X ; CPU:$E720 PRG:2720 BD 70 03
CMP #$02 ; CPU:$E723 PRG:2723 C9 02
PHP ; CPU:$E725 PRG:2725 08
AND #$01 ; CPU:$E726 PRG:2726 29 01
BEQ ObjectPathOnZero_E731 ; CPU:$E728 PRG:2728 F0 07
LDA #$0C ; CPU:$E72A PRG:272A A9 0C
CLC ; CPU:$E72C PRG:272C 18
ADC $00 ; CPU:$E72D PRG:272D 65 00
STA $00 ; CPU:$E72F PRG:272F 85 00
ObjectPathOnZero_E731:
LDY $00 ; CPU:$E731 PRG:2731 A4 00
LDA $E682,Y ; CPU:$E733 PRG:2733 B9 82 E6
PLP ; CPU:$E736 PRG:2736 28
BCC UpdateObjectBufferOnNoCarry_E73C ; CPU:$E737 PRG:2737 90 03
CLC ; CPU:$E739 PRG:2739 18
ADC #$5B ; CPU:$E73A PRG:273A 69 5B
UpdateObjectBufferOnNoCarry_E73C:
CLC ; CPU:$E73C PRG:273C 18
ADC #$CC ; CPU:$E73D PRG:273D 69 CC
STA $02 ; CPU:$E73F PRG:273F 85 02
LDA #$00 ; CPU:$E741 PRG:2741 A9 00
ADC #$E5 ; CPU:$E743 PRG:2743 69 E5
STA $03 ; CPU:$E745 PRG:2745 85 03
INX ; CPU:$E747 PRG:2747 E8
LDA $0370,X ; CPU:$E748 PRG:2748 BD 70 03
STA $00 ; CPU:$E74B PRG:274B 85 00
INX ; CPU:$E74D PRG:274D E8
LDA $0370,X ; CPU:$E74E PRG:274E BD 70 03
STA $01 ; CPU:$E751 PRG:2751 85 01
STX $08 ; CPU:$E753 PRG:2753 86 08
JSR UpdateCommandBufferRoutine_F3A1 ; CPU:$E755 PRG:2755 20 A1 F3
LDX $08 ; CPU:$E758 PRG:2758 A6 08
JMP ProcessObjectStateDispatch_E6FD ; CPU:$E75A PRG:275A 4C FD E6
.byte $80, $C8, $80, $CB, $80, $D1, $80, $D4, $81, $25, $81, $2E, $81, $37, $81, $E5 ; CPU:$E75D PRG:275D 0B
.byte $81, $F7, $82, $48, $82, $54, $82, $AB, $82, $B1, $83, $0E, $C0, $C8, $C0, $CE ; CPU:$E76D PRG:276D 0B
.byte $C0, $D1, $C0 ; CPU:$E77D PRG:277D 0B
;------------------------------------------------------------
; Resource and level data with embedded PPU update code
; CPU $F20B-$F21A
; PRG $2780-$321A
;
; Pass 1 recursively traced from verified entry roots in this region.
; Direct branches, jumps, and subroutine calls are decoded.
; Bytes not reached by that trace remain explicit .byte data.
;------------------------------------------------------------
.byte $D7, $C1, $25, $C1, $3A, $C1, $85, $C1, $9A, $C1, $E8, $C1, $F7, $C2, $4B, $C2 ; CPU:$E780 PRG:2780 0B
.byte $54, $C2, $AE, $C2, $B1, $F1, $8B, $F1, $94, $FF, $80, $CB, $80, $D1, $81, $8B ; CPU:$E790 PRG:2790 0B
.byte $81, $91, $82, $45, $82, $57, $82, $A5, $82, $A8, $82, $AB, $82, $AE, $82, $B1 ; CPU:$E7A0 PRG:27A0 0B
.byte $82, $B4, $82, $B7, $82, $57, $83, $08, $83, $0B, $83, $0E, $83, $11, $83, $14 ; CPU:$E7B0 PRG:27B0 0B
.byte $C0, $CB, $C0, $CE, $C0, $D1, $C0, $D4, $C1, $2B, $C1, $2E, $C1, $31, $C1, $34 ; CPU:$E7C0 PRG:27C0 0B
.byte $C2, $45, $C2, $48, $C2, $57, $C2, $5A, $C2, $A8, $C2, $B7, $B1, $E5, $B1, $F7 ; CPU:$E7D0 PRG:27D0 0B
.byte $FF, $80, $CE, $81, $28, $81, $2B, $81, $2E, $81, $31, $81, $34, $81, $85, $81 ; CPU:$E7E0 PRG:27E0 0B
.byte $88, $81, $94, $81, $97, $81, $E5, $81, $F7, $82, $AE, $83, $0B, $83, $11, $C0 ; CPU:$E7F0 PRG:27F0 0B
.byte $CE, $C0, $D1, $C1, $28, $C1, $37, $C1, $85, $C1, $88, $C1, $8B, $C1, $94, $C1 ; CPU:$E800 PRG:2800 0B
.byte $97, $C1, $9A, $C1, $EB, $C1, $F4, $C2, $4B, $C2, $54, $C2, $AB, $C2, $AE, $C2 ; CPU:$E810 PRG:2810 0B
.byte $B1, $C2, $B4, $B1, $8E, $FF, $80, $CB, $80, $CE, $80, $D1, $81, $28, $81, $34 ; CPU:$E820 PRG:2820 0B
.byte $81, $85, $81, $97, $81, $E5, $81, $E8, $81, $EB, $81, $EE, $81, $F1, $81, $F4 ; CPU:$E830 PRG:2830 0B
.byte $81, $F7, $83, $08, $83, $0B, $83, $0E, $83, $11, $83, $14, $C0, $CB, $C0, $D4 ; CPU:$E840 PRG:2840 0B
.byte $C1, $28, $C1, $37, $C1, $85, $C1, $9A, $C1, $E8, $C1, $F7, $C2, $48, $C2, $57 ; CPU:$E850 PRG:2850 0B
.byte $C2, $A8, $C2, $B7, $F2, $4B, $F2, $54, $FF, $80, $CE, $80, $D1, $81, $31, $81 ; CPU:$E860 PRG:2860 0B
.byte $85, $81, $88, $81, $8B, $81, $91, $81, $94, $81, $97, $81, $E5, $81, $F7, $82 ; CPU:$E870 PRG:2870 0B
.byte $4B, $82, $51, $82, $AB, $82, $AE, $82, $B1, $83, $0B, $83, $11, $C0, $CE, $C0 ; CPU:$E880 PRG:2880 0B
.byte $D4, $C1, $2E, $C1, $31, $C1, $85, $C1, $9A, $C2, $AB, $C2, $AE, $C2, $B1, $C2 ; CPU:$E890 PRG:2890 0B
.byte $B4, $B1, $EB, $B1, $F1, $FF, $80, $C8, $80, $D4, $81, $28, $81, $2B, $81, $2E ; CPU:$E8A0 PRG:28A0 0B
.byte $81, $31, $81, $34, $81, $88, $81, $94, $82, $4E, $82, $AB, $82, $AE, $82, $B1 ; CPU:$E8B0 PRG:28B0 0B
.byte $83, $0E, $C0, $C8, $C0, $CB, $C0, $D4, $C0, $D7, $C1, $2B, $C1, $34, $C1, $88 ; CPU:$E8C0 PRG:28C0 0B
.byte $C1, $97, $C2, $4B, $C2, $54, $C2, $AE, $C2, $B1, $F1, $8E, $F1, $91, $FF, $81 ; CPU:$E8D0 PRG:28D0 0B
.byte $28, $81, $34, $81, $85, $81, $8B, $81, $91, $81, $97, $81, $E5, $81, $EB, $81 ; CPU:$E8E0 PRG:28E0 0B
.byte $F1, $81, $F7, $82, $4E, $83, $0E, $C1, $28, $C1, $2B, $C1, $34, $C1, $37, $C1 ; CPU:$E8F0 PRG:28F0 0B
.byte $85, $C1, $8E, $C1, $91, $C1, $9A, $C1, $EB, $C1, $F4, $C2, $AE, $C2, $B1, $B1 ; CPU:$E900 PRG:2900 0B
.byte $2E, $F2, $AB, $F2, $B4, $FF, $80, $CE, $81, $2B, $81, $31, $81, $88, $81, $94 ; CPU:$E910 PRG:2910 0B
.byte $81, $EE, $82, $4B, $82, $4E, $82, $51, $82, $AB, $82, $B1, $83, $0B, $83, $0E ; CPU:$E920 PRG:2920 0B
.byte $83, $11, $C0, $CE, $C0, $D1, $C1, $2B, $C1, $34, $C1, $88, $C1, $97, $C1, $EE ; CPU:$E930 PRG:2930 0B
.byte $C1, $F1, $C2, $AB, $C2, $B4, $B1, $8E, $FF, $81, $88, $81, $8B, $81, $91, $81 ; CPU:$E940 PRG:2940 0B
.byte $94, $81, $E5, $81, $EE, $81, $F7, $82, $A8, $82, $AB, $82, $B1, $82, $B4, $C0 ; CPU:$E950 PRG:2950 0B
.byte $C5, $C0, $DA, $C1, $25, $C1, $3A, $C1, $85, $C1, $88, $C1, $8E, $C1, $91, $C1 ; CPU:$E960 PRG:2960 0B
.byte $97, $C1, $9A, $C1, $E8, $C1, $EE, $C1, $F1, $C1, $F7, $C2, $48, $C2, $4E, $C2 ; CPU:$E970 PRG:2970 0B
.byte $51, $C2, $57, $B1, $28, $B1, $34, $FF, $81, $25, $81, $37, $81, $88, $81, $94 ; CPU:$E980 PRG:2980 0B
.byte $81, $EB, $81, $EE, $81, $F1, $82, $4B, $82, $51, $82, $A5, $82, $A8, $82, $AE ; CPU:$E990 PRG:2990 0B
.byte $82, $B4, $82, $B7, $C1, $25, $C1, $28, $C1, $37, $C1, $3A, $C1, $85, $C1, $8B ; CPU:$E9A0 PRG:29A0 0B
.byte $C1, $94, $C1, $9A, $C1, $E5, $C1, $EE, $C1, $F1, $C1, $FA, $C2, $45, $C2, $4B ; CPU:$E9B0 PRG:29B0 0B
.byte $C2, $4E, $C2, $51, $C2, $54, $C2, $5A, $F1, $2E, $F1, $31, $FF, $80, $C5, $80 ; CPU:$E9C0 PRG:29C0 0B
.byte $D7, $81, $28, $81, $2B, $81, $2E, $81, $31, $81, $34, $81, $85, $81, $97, $82 ; CPU:$E9D0 PRG:29D0 0B
.byte $48, $82, $4E, $82, $54, $82, $AB, $82, $AE, $82, $B1, $C0, $C5, $C0, $C8, $C0 ; CPU:$E9E0 PRG:29E0 0B
.byte $D7, $C0, $DA, $C1, $25, $C1, $3A, $C1, $88, $C1, $97, $C1, $E8, $C1, $F7, $C2 ; CPU:$E9F0 PRG:29F0 0B
.byte $4B, $C2, $4E, $C2, $51, $C2, $54, $B2, $A5, $B2, $B7, $B1, $8B, $B1, $91, $FF ; CPU:$EA00 PRG:2A00 0B
.byte $81, $8B, $81, $8E, $81, $97, $81, $E5, $81, $E8, $81, $EB, $81, $EE, $81, $F1 ; CPU:$EA10 PRG:2A10 0B
.byte $81, $F4, $81, $F7, $82, $54, $82, $57, $82, $A5, $82, $A8, $82, $AB, $82, $AE ; CPU:$EA20 PRG:2A20 0B
.byte $82, $B1, $82, $B7, $C1, $2E, $C1, $8B, $C1, $91, $C1, $97, $C1, $9A, $C1, $E5 ; CPU:$EA30 PRG:2A30 0B
.byte $C1, $F7, $C2, $45, $C2, $54, $C2, $57, $C2, $5A, $F0, $C8, $F0, $D7, $FF, $80 ; CPU:$EA40 PRG:2A40 0B
.byte $C8, $80, $D4, $81, $28, $81, $34, $81, $8E, $81, $E5, $81, $EE, $81, $F7, $82 ; CPU:$EA50 PRG:2A50 0B
.byte $45, $82, $4E, $82, $57, $82, $A8, $82, $B4, $83, $08, $83, $14, $C0, $C8, $C0 ; CPU:$EA60 PRG:2A60 0B
.byte $CB, $C0, $D4, $C0, $D7, $C1, $8E, $C1, $91, $C1, $E5, $C1, $E8, $C1, $EE, $C1 ; CPU:$EA70 PRG:2A70 0B
.byte $F1, $C1, $F7, $C1, $FA, $C2, $A8, $C2, $AB, $C2, $B4, $C2, $B7, $B1, $88, $B1 ; CPU:$EA80 PRG:2A80 0B
.byte $94, $F1, $EB, $F1, $F4, $FF, $80, $C5, $80, $C8, $80, $D4, $80, $D7, $81, $8B ; CPU:$EA90 PRG:2A90 0B
.byte $81, $8E, $81, $91, $82, $4B, $82, $4E, $82, $51, $83, $05, $83, $08, $83, $14 ; CPU:$EAA0 PRG:2AA0 0B
.byte $83, $17, $C0, $C5, $C0, $CB, $C0, $D4, $C0, $DA, $C1, $25, $C1, $2B, $C1, $34 ; CPU:$EAB0 PRG:2AB0 0B
.byte $C1, $3A, $C1, $85, $C1, $9A, $C1, $E5, $C1, $FA, $C2, $45, $C2, $4B, $C2, $54 ; CPU:$EAC0 PRG:2AC0 0B
.byte $C2, $5A, $C2, $A5, $C2, $AB, $C2, $B4, $C2, $BA, $B1, $EB, $B1, $F1, $F1, $88 ; CPU:$EAD0 PRG:2AD0 0B
.byte $F1, $97, $F2, $48, $F2, $57, $FF, $81, $25, $81, $28, $81, $34, $81, $37, $81 ; CPU:$EAE0 PRG:2AE0 0B
.byte $85, $81, $88, $81, $8B, $81, $8E, $81, $91, $81, $94, $81, $97, $82, $45, $82 ; CPU:$EAF0 PRG:2AF0 0B
.byte $48, $82, $4B, $82, $4E, $82, $51, $82, $54, $82, $57, $82, $A5, $82, $A8, $82 ; CPU:$EB00 PRG:2B00 0B
.byte $B4, $82, $B7, $C1, $25, $C1, $2B, $C1, $34, $C1, $3A, $C1, $8B, $C1, $94, $C1 ; CPU:$EB10 PRG:2B10 0B
.byte $EB, $C1, $F4, $C2, $45, $C2, $4B, $C2, $54, $C2, $5A, $B1, $E5, $B1, $EE, $B1 ; CPU:$EB20 PRG:2B20 0B
.byte $F7, $FF, $80, $C5, $80, $D7, $81, $28, $81, $34, $81, $85, $81, $88, $81, $94 ; CPU:$EB30 PRG:2B30 0B
.byte $81, $97, $82, $45, $82, $48, $82, $54, $82, $57, $82, $A5, $82, $B7, $83, $08 ; CPU:$EB40 PRG:2B40 0B
.byte $83, $14, $C0, $C5, $C0, $C8, $C0, $D7, $C0, $DA, $C1, $25, $C1, $2B, $C1, $34 ; CPU:$EB50 PRG:2B50 0B
.byte $C1, $3A, $C2, $45, $C2, $4B, $C2, $54, $C2, $5A, $C2, $A8, $C2, $AB, $C2, $B4 ; CPU:$EB60 PRG:2B60 0B
.byte $C2, $B7, $B1, $E5, $B1, $EB, $B1, $F1, $B1, $F7, $FF, $80, $C5, $80, $D7, $81 ; CPU:$EB70 PRG:2B70 0B
.byte $85, $81, $2E, $81, $97, $82, $45, $82, $AE, $82, $57, $83, $05, $83, $17, $C0 ; CPU:$EB80 PRG:2B80 0B
.byte $C8, $C0, $D7, $C1, $8E, $C1, $91, $C1, $EE, $C1, $F1, $C2, $A8, $C2, $B7, $B1 ; CPU:$EB90 PRG:2B90 0B
.byte $E8, $B1, $F4, $F1, $2B, $F1, $34, $F2, $4B, $F2, $54, $F1, $22, $F2, $5D, $FF ; CPU:$EBA0 PRG:2BA0 0B
.byte $81, $25, $81, $2E, $81, $37, $81, $82, $81, $88, $81, $8E, $81, $94, $81, $9A ; CPU:$EBB0 PRG:2BB0 0B
.byte $82, $42, $82, $48, $82, $4E, $82, $54, $82, $5A, $82, $A5, $82, $AE, $82, $B7 ; CPU:$EBC0 PRG:2BC0 0B
.byte $C0, $C8, $C0, $D7, $C2, $A8, $C2, $B7, $B1, $E8, $B1, $EE, $B1, $F4, $F0, $CB ; CPU:$EBD0 PRG:2BD0 0B
.byte $F0, $D4, $F2, $AB, $F2, $B4, $FF, $81, $2B, $81, $2E, $81, $31, $81, $85, $81 ; CPU:$EBE0 PRG:2BE0 0B
.byte $97, $81, $EE, $82, $45, $82, $57, $82, $AB, $82, $AE, $82, $B1, $C0, $CB, $C0 ; CPU:$EBF0 PRG:2BF0 0B
.byte $D4, $C1, $88, $C1, $97, $C1, $E8, $C1, $F7, $C2, $AB, $C2, $B4, $B1, $8E, $B2 ; CPU:$EC00 PRG:2C00 0B
.byte $4E, $F0, $C8, $F0, $D7, $F2, $A8, $F2, $B7, $F1, $3D, $F2, $42, $FF, $80, $C5 ; CPU:$EC10 PRG:2C10 0B
.byte $80, $C8, $80, $D4, $80, $D7, $81, $2B, $81, $31, $82, $AB, $82, $B1, $83, $05 ; CPU:$EC20 PRG:2C20 0B
.byte $83, $08, $83, $14, $83, $17, $C1, $22, $C1, $3D, $C1, $2B, $C1, $34, $C2, $4B ; CPU:$EC30 PRG:2C30 0B
.byte $C2, $54, $C2, $42, $C2, $5D, $B1, $8E, $B2, $4E, $B1, $E8, $B1, $F4, $F1, $28 ; CPU:$EC40 PRG:2C40 0B
.byte $F1, $37, $F2, $48, $F2, $57, $FF, $3F, $00, $20, $0F, $30, $17, $25, $0F, $30 ; CPU:$EC50 PRG:2C50 0B
.byte $17, $17, $0F, $30, $25, $05, $0F, $30, $21, $01, $0F, $30, $27, $16, $0F, $30 ; CPU:$EC60 PRG:2C60 0B
.byte $27, $1A, $0F, $30, $1C, $01, $0F, $30, $27, $08, $60, $20, $50, $04, $2A, $2B ; CPU:$EC70 PRG:2C70 0B
.byte $2C, $2D, $20, $49, $04, $26, $27, $28, $29, $20, $C2, $D3, $4E, $20, $C5, $D3 ; CPU:$EC80 PRG:2C80 0B
.byte $4E, $20, $C8, $D3, $4E, $20, $CB, $D3, $4E, $20, $CE, $D3, $4E, $20, $D1, $D3 ; CPU:$EC90 PRG:2C90 0B
.byte $4E, $20, $D4, $D3, $4E, $20, $D7, $D3, $4E, $20, $DA, $D3, $4E, $20, $DD, $D3 ; CPU:$ECA0 PRG:2CA0 0B
.byte $4E, $20, $E2, $5C, $24, $21, $02, $5C, $24, $21, $42, $5C, $24, $21, $62, $5C ; CPU:$ECB0 PRG:2CB0 0B
.byte $24, $21, $A2, $5C, $24, $21, $C2, $5C, $24, $22, $02, $5C, $24, $22, $22, $5C ; CPU:$ECC0 PRG:2CC0 0B
.byte $24, $22, $62, $5C, $24, $22, $82, $5C, $24, $22, $C2, $5C, $24, $22, $E2, $5C ; CPU:$ECD0 PRG:2CD0 0B
.byte $24, $60, $21, $02, $CF, $32, $21, $1D, $CF, $32, $20, $67, $52, $39, $23, $67 ; CPU:$ECE0 PRG:2CE0 0B
.byte $52, $39, $60, $04, $08, $22, $0F, $38, $18, $38, $D8, $4C, $57, $EC, $4C, $7B ; CPU:$ECF0 PRG:2CF0 0B
.byte $EC, $4C, $E2, $EC, $00, $00, $65, $10, $79, $23, $45, $33, $59, $00, $C2, $10 ; CPU:$ED00 PRG:2D00 0B
.byte $DC, $22, $E2, $32, $FC, $43, $1A, $53, $04, $60, $BA, $70, $A4, $FF, $06, $0A ; CPU:$ED10 PRG:2D10 0B
.byte $22, $C6, $22, $D8, $20, $60, $20, $90, $4C, $57, $EC, $3F, $08, $04, $0F, $30 ; CPU:$ED20 PRG:2D20 0B
.byte $2A, $0A, $4C, $7B, $EC, $4C, $E2, $EC, $00, $00, $65, $10, $79, $23, $45, $33 ; CPU:$ED30 PRG:2D30 0B
.byte $59, $00, $C2, $10, $DC, $22, $E2, $32, $FC, $43, $1A, $53, $04, $60, $BA, $70 ; CPU:$ED40 PRG:2D40 0B
.byte $A4, $C1, $E8, $C2, $4E, $C2, $51, $C1, $F7, $82, $48, $82, $54, $FF, $06, $0A ; CPU:$ED50 PRG:2D50 0B
.byte $22, $0C, $22, $12, $38, $78, $B0, $78, $4C, $57, $EC, $3F, $08, $04, $0F, $30 ; CPU:$ED60 PRG:2D60 0B
.byte $21, $01, $4C, $7B, $EC, $20, $64, $46, $39, $20, $CD, $46, $39, $20, $76, $46 ; CPU:$ED70 PRG:2D70 0B
.byte $39, $23, $64, $46, $39, $23, $0D, $46, $39, $23, $76, $46, $39, $20, $A2, $D5 ; CPU:$ED80 PRG:2D80 0B
.byte $32, $20, $BD, $D5, $32, $00, $00, $62, $10, $7C, $23, $42, $33, $5C, $00, $74 ; CPU:$ED90 PRG:2D90 0B
.byte $10, $6A, $23, $54, $33, $4A, $43, $0B, $53, $13, $60, $AB, $70, $B3, $FF, $0A ; CPU:$EDA0 PRG:2DA0 0B
.byte $0E, $21, $46, $21, $58, $22, $CC, $22, $D2, $20, $60, $20, $90, $4C, $57, $EC ; CPU:$EDB0 PRG:2DB0 0B
.byte $3F, $00, $0C, $0F, $30, $17, $2A, $0F, $30, $17, $17, $0F, $30, $23, $03, $4C ; CPU:$EDC0 PRG:2DC0 0B
.byte $7B, $EC, $4C, $E2, $EC, $20, $60, $60, $39, $20, $6F, $42, $24, $23, $60, $60 ; CPU:$EDD0 PRG:2DD0 0B
.byte $39, $23, $6F, $42, $24, $20, $C0, $D3, $39, $20, $DF, $D3, $39, $20, $AE, $C3 ; CPU:$EDE0 PRG:2DE0 0B
.byte $32, $20, $B1, $C3, $32, $22, $EE, $C3, $32, $22, $F1, $C3, $32, $20, $E0, $D1 ; CPU:$EDF0 PRG:2DF0 0B
.byte $FF, $21, $01, $CF, $FF, $21, $1E, $CF, $FF, $20, $FF, $D1, $FF, $00, $00, $71 ; CPU:$EE00 PRG:2E00 0B
.byte $10, $6D, $23, $51, $33, $4D, $42, $AE, $52, $B0, $61, $0E, $71, $10, $40, $DD ; CPU:$EE10 PRG:2E10 0B
.byte $50, $C1, $62, $FD, $72, $E1, $FF, $0A, $0E, $22, $06, $22, $0C, $22, $12, $22 ; CPU:$EE20 PRG:2E20 0B
.byte $18, $20, $18, $20, $D8, $4C, $57, $EC, $3F, $08, $04, $0F, $30, $27, $07, $4C ; CPU:$EE30 PRG:2E30 0B
.byte $7B, $EC, $20, $64, $49, $39, $20, $73, $49, $39, $23, $64, $49, $39, $23, $73 ; CPU:$EE40 PRG:2E40 0B
.byte $49, $39, $20, $C0, $01, $39, $20, $DF, $01, $39, $23, $00, $01, $39, $23, $1F ; CPU:$EE50 PRG:2E50 0B
.byte $01, $39, $00, $00, $62, $10, $7C, $23, $42, $33, $5C, $00, $71, $10, $6D, $23 ; CPU:$EE60 PRG:2E60 0B
.byte $51, $33, $4D, $43, $1D, $53, $01, $60, $BD, $70, $A1, $43, $0E, $53, $10, $60 ; CPU:$EE70 PRG:2E70 0B
.byte $AE, $70, $B0, $C1, $25, $C1, $3A, $C2, $45, $C2, $5A, $91, $E2, $91, $FA, $FF ; CPU:$EE80 PRG:2E80 0B
.byte $02, $06, $38, $60, $38, $90, $4C, $57, $EC, $3F, $04, $04, $0F, $30, $11, $11 ; CPU:$EE90 PRG:2E90 0B
.byte $3F, $1C, $04, $0F, $30, $21, $01, $4C, $89, $EC, $20, $63, $5A, $BF, $23, $63 ; CPU:$EEA0 PRG:2EA0 0B
.byte $5A, $BF, $20, $82, $D7, $BD, $20, $9D, $D7, $BD, $21, $8C, $48, $BF, $22, $4C ; CPU:$EEB0 PRG:2EB0 0B
.byte $48, $BF, $21, $AB, $C5, $BD, $21, $B4, $C5, $BD, $21, $AC, $48, $FF, $21, $CC ; CPU:$EEC0 PRG:2EC0 0B
.byte $08, $FF, $0B, $18, $17, $1E, $1C, $AD, $FF, $21, $EC, $48, $FF, $22, $0C, $08 ; CPU:$EED0 PRG:2ED0 0B
.byte $2A, $2B, $2C, $2D, $FF, $FF, $FF, $FF, $22, $2C, $48, $FF, $20, $62, $01, $B9 ; CPU:$EEE0 PRG:2EE0 0B
.byte $20, $7D, $01, $C2, $23, $62, $01, $BA, $23, $7D, $01, $C3, $21, $8B, $01, $BC ; CPU:$EEF0 PRG:2EF0 0B
.byte $21, $94, $01, $C0, $22, $4B, $01, $BE, $22, $54, $01, $C1, $00, $80, $C5, $80 ; CPU:$EF00 PRG:2F00 0B
.byte $C8, $80, $CB, $80, $CE, $80, $D1, $80, $D4, $80, $D7, $81, $25, $81, $28, $81 ; CPU:$EF10 PRG:2F10 0B
.byte $2B, $81, $2E, $81, $31, $81, $34, $81, $37, $81, $85, $81, $97, $81, $E5, $81 ; CPU:$EF20 PRG:2F20 0B
.byte $F7, $82, $45, $82, $57, $82, $A5, $82, $A8, $82, $AB, $82, $AE, $82, $B1, $82 ; CPU:$EF30 PRG:2F30 0B
.byte $B4, $82, $B7, $83, $05, $83, $08, $83, $0B, $83, $0E, $83, $11, $83, $14, $83 ; CPU:$EF40 PRG:2F40 0B
.byte $17, $C0, $C5, $C0, $C8, $C0, $CB, $C0, $CE, $C0, $D1, $C0, $D4, $C0, $D7, $C0 ; CPU:$EF50 PRG:2F50 0B
.byte $DA, $C1, $25, $C1, $28, $C1, $37, $C1, $3A, $C1, $85, $C1, $88, $C1, $97, $C1 ; CPU:$EF60 PRG:2F60 0B
.byte $9A, $C1, $E5, $C1, $E8, $C1, $F7, $C1, $FA, $C2, $45, $C2, $48, $C2, $57, $C2 ; CPU:$EF70 PRG:2F70 0B
.byte $5A, $C2, $A5, $C2, $A8, $C2, $AB, $C2, $AE, $C2, $B1, $C2, $B4, $C2, $B7, $C2 ; CPU:$EF80 PRG:2F80 0B
.byte $BA, $FF, $02, $4C, $57, $EC, $3F, $00, $14, $0F, $30, $21, $01, $0F, $30, $30 ; CPU:$EF90 PRG:2F90 0B
.byte $0F, $0F, $25, $25, $0F, $0F, $21, $21, $0F, $0F, $30, $26, $27, $23, $E0, $48 ; CPU:$EFA0 PRG:2FA0 0B
.byte $50, $23, $E8, $48, $A5, $23, $F0, $48, $F5, $20, $86, $14, $DA, $DF, $E3, $E5 ; CPU:$EFB0 PRG:2FB0 0B
.byte $24, $24, $E5, $24, $E5, $24, $24, $DA, $DF, $E3, $E5, $24, $24, $E5, $24, $E5 ; CPU:$EFC0 PRG:2FC0 0B
.byte $20, $A6, $14, $DB, $E0, $E4, $DC, $24, $24, $DC, $24, $DC, $24, $24, $DB, $E0 ; CPU:$EFD0 PRG:2FD0 0B
.byte $E4, $DC, $24, $24, $DC, $24, $DC, $20, $C6, $14, $DC, $24, $24, $DC, $24, $24 ; CPU:$EFE0 PRG:2FE0 0B
.byte $DC, $24, $DC, $24, $24, $DC, $24, $24, $DC, $24, $24, $DC, $24, $DC, $20, $E6 ; CPU:$EFF0 PRG:2FF0 0B
.byte $14, $DD, $E1, $E5, $DD, $24, $24, $DD, $E1, $DC, $24, $24, $DD, $E1, $E5, $DD ; CPU:$F000 PRG:3000 0B
.byte $24, $24, $DD, $E1, $DC, $21, $06, $14, $DE, $E2, $E6, $DE, $E2, $E7, $DE, $E2 ; CPU:$F010 PRG:3010 0B
.byte $E6, $24, $24, $DE, $E2, $E6, $DE, $E2, $E7, $DE, $E2, $E6, $20, $44, $57, $39 ; CPU:$F020 PRG:3020 0B
.byte $22, $05, $57, $39, $20, $83, $CB, $DC, $20, $7C, $CD, $DC, $20, $43, $82, $DA ; CPU:$F030 PRG:3030 0B
.byte $DB, $21, $E3, $01, $DD, $22, $03, $02, $DE, $E2, $20, $5B, $02, $DF, $E3, $20 ; CPU:$F040 PRG:3040 0B
.byte $7B, $01, $E0, $21, $FB, $01, $E1, $22, $1C, $01, $E6, $21, $46, $85, $E5, $DC ; CPU:$F050 PRG:3050 0B
.byte $DC, $DD, $DE, $21, $4B, $0F, $DA, $39, $39, $DF, $E3, $DA, $DF, $E3, $24, $E5 ; CPU:$F060 PRG:3060 0B
.byte $EA, $39, $39, $DF, $E3, $21, $6B, $0F, $DB, $24, $24, $E0, $DC, $DB, $E0, $DC ; CPU:$F070 PRG:3070 0B
.byte $24, $DC, $24, $EB, $24, $E0, $DC, $21, $8B, $0F, $DC, $24, $24, $24, $DC, $DC ; CPU:$F080 PRG:3080 0B
.byte $24, $DC, $24, $DC, $24, $DC, $24, $24, $DC, $21, $AB, $0F, $E8, $E9, $39, $E7 ; CPU:$F090 PRG:3090 0B
.byte $DC, $DC, $24, $DD, $E1, $DC, $24, $EC, $24, $E1, $DC, $21, $C7, $13, $E2, $39 ; CPU:$F0A0 PRG:30A0 0B
.byte $39, $E7, $EC, $24, $24, $24, $EC, $EC, $24, $DE, $E2, $E6, $EA, $39, $39, $39 ; CPU:$F0B0 PRG:30B0 0B
.byte $E6, $22, $4A, $0D, $01, $24, $19, $15, $0A, $22, $0E, $1B, $24, $10, $0A, $16 ; CPU:$F0C0 PRG:30C0 0B
.byte $0E, $22, $8A, $0D, $02, $24, $19, $15, $0A, $22, $0E, $1B, $24, $10, $0A, $16 ; CPU:$F0D0 PRG:30D0 0B
.byte $0E, $22, $CA, $04, $B5, $B6, $B7, $B8, $22, $D4, $04, $B2, $B3, $B4, $CC, $23 ; CPU:$F0E0 PRG:30E0 0B
.byte $04, $02, $AB, $B8, $23, $0C, $07, $B2, $B3, $B4, $CC, $24, $AC, $B8, $23, $19 ; CPU:$F0F0 PRG:30F0 0B
.byte $04, $B2, $B3, $B4, $CC, $23, $69, $0E, $25, $01, $09, $08, $04, $24, $17, $12 ; CPU:$F100 PRG:3100 0B
.byte $17, $1D, $0E, $17, $0D, $18, $00, $FF, $02, $4C, $7E, $F1, $00, $FF, $02, $4C ; CPU:$F110 PRG:3110 0B
.byte $7E, $F1, $2B, $E1, $46, $FA, $2B, $E9, $46, $FF, $2B, $F1, $46, $AF, $2B, $F1 ; CPU:$F120 PRG:3120 0B
.byte $01, $A5, $2A, $24, $58, $C7, $2B, $44, $58, $C8, $2A, $43, $C8, $C5, $2A, $5C ; CPU:$F130 PRG:3130 0B
.byte $C8, $CA, $2A, $23, $01, $C4, $2A, $3C, $01, $C9, $2B, $43, $01, $C6, $2B, $5C ; CPU:$F140 PRG:3140 0B
.byte $01, $CB, $2A, $4A, $0C, $2E, $24, $19, $15, $0A, $22, $0E, $1B, $24, $02, $24 ; CPU:$F150 PRG:3150 0B
.byte $2F, $2A, $8F, $4A, $C7, $2A, $CF, $4A, $C8, $2A, $8E, $83, $C4, $C5, $C6, $2A ; CPU:$F160 PRG:3160 0B
.byte $B5, $04, $B2, $B3, $B4, $CC, $2A, $99, $83, $C9, $CA, $CB, $00, $FF, $2B, $C0 ; CPU:$F170 PRG:3170 0B
.byte $60, $AA, $2B, $E0, $60, $AA, $2B, $C9, $46, $FF, $2B, $D1, $46, $FF, $2B, $D1 ; CPU:$F180 PRG:3180 0B
.byte $01, $55, $28, $64, $58, $C7, $29, $84, $58, $C8, $28, $83, $C8, $C5, $28, $9C ; CPU:$F190 PRG:3190 0B
.byte $C8, $CA, $28, $63, $01, $C4, $28, $7C, $01, $C9, $29, $83, $01, $C6, $29, $9C ; CPU:$F1A0 PRG:31A0 0B
.byte $01, $CB, $28, $8A, $0C, $2E, $24, $19, $15, $0A, $22, $0E, $1B, $24, $01, $24 ; CPU:$F1B0 PRG:31B0 0B
.byte $2F, $28, $CF, $4A, $C7, $29, $0F, $4A, $C8, $28, $CE, $83, $C4, $C5, $C6, $28 ; CPU:$F1C0 PRG:31C0 0B
.byte $F5, $04, $B2, $B3, $B4, $CC, $28, $D9, $83, $C9, $CA, $CB, $29, $A2, $45, $2E ; CPU:$F1D0 PRG:31D0 0B
.byte $29, $B9, $45, $2F, $29, $A8, $0E, $0C, $15, $1E, $B8, $0C, $15, $1E, $B8, $15 ; CPU:$F1E0 PRG:31E0 0B
.byte $0A, $17, $0D, $B8, $B8, $29, $E4, $04, $2A, $2B, $2C, $2D, $29, $EE, $04, $B5 ; CPU:$F1F0 PRG:31F0 0B
.byte $B6, $B7, $B8, $29, $F8, $04, $B2, $B3, $B4, $CC, $60 ; CPU:$F200 PRG:3200 0B
;------------------------------------------------------------
; ResourceAndLevelData
;
; Global:
; First-pass ResourceAndLevelData entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ResourceAndLevelData:
LDA $40 ; CPU:$F20B PRG:320B A5 40
AND #$FB ; CPU:$F20D PRG:320D 29 FB
STA PPUCTRL ; CPU:$F20F PRG:320F 8D 00 20
STA $40 ; CPU:$F212 PRG:3212 85 40
LDX PPUSTATUS ; CPU:$F214 PRG:3214 AE 02 20
LDY #$00 ; CPU:$F217 PRG:3217 A0 00
BEQ PPUCommandReadNextByte_F249 ; CPU:$F219 PRG:3219 F0 2E
; Branch target inside the final five bytes of the preceding raw region.
; This is part of the PPU command-processing loop continued at $F220.
PPUCommandLoop_F21B:
PHA ; CPU:$F21B PRG:321B 48
STA PPUADDR ; CPU:$F21C PRG:321C 8D 06 20
INY ; CPU:$F21F PRG:321F C8
;------------------------------------------------------------
; Resource, input, and collision code with embedded tables
; CPU $F220-$F7C0
; PRG $3220-$37C0
;
; Pass 1 recursively traced from verified entry roots in this region.
; Direct branches, jumps, and subroutine calls are decoded.
; Bytes not reached by that trace remain explicit .byte data.
;------------------------------------------------------------
;------------------------------------------------------------
; ResourceInputCollisionCode
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ResourceInputCollisionCode:
LDA $0301,Y ; CPU:$F220 PRG:3220 B9 01 03
STA PPUADDR ; CPU:$F223 PRG:3223 8D 06 20
INY ; CPU:$F226 PRG:3226 C8
LDA $0301,Y ; CPU:$F227 PRG:3227 B9 01 03
AND #$3F ; CPU:$F22A PRG:322A 29 3F
TAX ; CPU:$F22C PRG:322C AA
UpdateCommandBufferLoop_F22D:
INY ; CPU:$F22D PRG:322D C8
LDA $0301,Y ; CPU:$F22E PRG:322E B9 01 03
STA PPUDATA ; CPU:$F231 PRG:3231 8D 07 20
DEX ; CPU:$F234 PRG:3234 CA
BNE UpdateCommandBufferLoop_F22D ; CPU:$F235 PRG:3235 D0 F6
PLA ; CPU:$F237 PRG:3237 68
CMP #$3F ; CPU:$F238 PRG:3238 C9 3F
BNE UpdateCommandBufferOnNonZero_F248 ; CPU:$F23A PRG:323A D0 0C
STA PPUADDR ; CPU:$F23C PRG:323C 8D 06 20
STX PPUADDR ; CPU:$F23F PRG:323F 8E 06 20
STX PPUADDR ; CPU:$F242 PRG:3242 8E 06 20
STX PPUADDR ; CPU:$F245 PRG:3245 8E 06 20
UpdateCommandBufferOnNonZero_F248:
INY ; CPU:$F248 PRG:3248 C8
PPUCommandReadNextByte_F249:
LDA $0301,Y ; CPU:$F249 PRG:3249 B9 01 03
BNE PPUCommandLoop_F21B ; CPU:$F24C PRG:324C D0 CD
LDA #$00 ; CPU:$F24E PRG:324E A9 00
STA $0300 ; CPU:$F250 PRG:3250 8D 00 03
STA $0301 ; CPU:$F253 PRG:3253 8D 01 03
RTS ; CPU:$F256 PRG:3256 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F257
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F257:
LDA PPUSTATUS ; CPU:$F257 PRG:3257 AD 02 20
LDA $40 ; CPU:$F25A PRG:325A A5 40
AND #$FB ; CPU:$F25C PRG:325C 29 FB
STA PPUCTRL ; CPU:$F25E PRG:325E 8D 00 20
STA $40 ; CPU:$F261 PRG:3261 85 40
LDA #$1C ; CPU:$F263 PRG:3263 A9 1C
CLC ; CPU:$F265 PRG:3265 18
EnginePathLoop_F266:
ADC #$04 ; CPU:$F266 PRG:3266 69 04
DEC $01 ; CPU:$F268 PRG:3268 C6 01
BNE EnginePathLoop_F266 ; CPU:$F26A PRG:326A D0 FA
STA $02 ; CPU:$F26C PRG:326C 85 02
STA PPUADDR ; CPU:$F26E PRG:326E 8D 06 20
LDA #$00 ; CPU:$F271 PRG:3271 A9 00
STA PPUADDR ; CPU:$F273 PRG:3273 8D 06 20
LDX #$04 ; CPU:$F276 PRG:3276 A2 04
LDY #$00 ; CPU:$F278 PRG:3278 A0 00
LDA WorkPtr0Lo ; CPU:$F27A PRG:327A A5 00
EnginePathLoop_F27C:
STA PPUDATA ; CPU:$F27C PRG:327C 8D 07 20
DEY ; CPU:$F27F PRG:327F 88
BNE EnginePathLoop_F27C ; CPU:$F280 PRG:3280 D0 FA
DEX ; CPU:$F282 PRG:3282 CA
BNE EnginePathLoop_F27C ; CPU:$F283 PRG:3283 D0 F7
LDA WorkPtr1Lo ; CPU:$F285 PRG:3285 A5 02
ADC #$03 ; CPU:$F287 PRG:3287 69 03
STA PPUADDR ; CPU:$F289 PRG:3289 8D 06 20
LDA #$C0 ; CPU:$F28C PRG:328C A9 C0
STA PPUADDR ; CPU:$F28E PRG:328E 8D 06 20
LDY #$40 ; CPU:$F291 PRG:3291 A0 40
LDA #$00 ; CPU:$F293 PRG:3293 A9 00
EnginePathLoop_F295:
STA PPUDATA ; CPU:$F295 PRG:3295 8D 07 20
DEY ; CPU:$F298 PRG:3298 88
BNE EnginePathLoop_F295 ; CPU:$F299 PRG:3299 D0 FA
RTS ; CPU:$F29B PRG:329B 60
EnginePathLoop_F29C:
PHA ; CPU:$F29C PRG:329C 48
STA PPUADDR ; CPU:$F29D PRG:329D 8D 06 20
INY ; CPU:$F2A0 PRG:32A0 C8
LDA ($00),Y ; CPU:$F2A1 PRG:32A1 B1 00
STA PPUADDR ; CPU:$F2A3 PRG:32A3 8D 06 20
INY ; CPU:$F2A6 PRG:32A6 C8
LDA ($00),Y ; CPU:$F2A7 PRG:32A7 B1 00
ASL A ; CPU:$F2A9 PRG:32A9 0A
PHA ; CPU:$F2AA PRG:32AA 48
LDA $40 ; CPU:$F2AB PRG:32AB A5 40
ORA #$04 ; CPU:$F2AD PRG:32AD 09 04
BCS EnginePathOnCarry_F2B3 ; CPU:$F2AF PRG:32AF B0 02
AND #$FB ; CPU:$F2B1 PRG:32B1 29 FB
EnginePathOnCarry_F2B3:
STA PPUCTRL ; CPU:$F2B3 PRG:32B3 8D 00 20
STA $40 ; CPU:$F2B6 PRG:32B6 85 40
PLA ; CPU:$F2B8 PRG:32B8 68
ASL A ; CPU:$F2B9 PRG:32B9 0A
BCC EnginePathOnNoCarry_F2BF ; CPU:$F2BA PRG:32BA 90 03
ORA #$02 ; CPU:$F2BC PRG:32BC 09 02
INY ; CPU:$F2BE PRG:32BE C8
EnginePathOnNoCarry_F2BF:
LSR A ; CPU:$F2BF PRG:32BF 4A
LSR A ; CPU:$F2C0 PRG:32C0 4A
TAX ; CPU:$F2C1 PRG:32C1 AA
EnginePathLoop_F2C2:
BCS EnginePathOnCarry_F2C5 ; CPU:$F2C2 PRG:32C2 B0 01
INY ; CPU:$F2C4 PRG:32C4 C8
EnginePathOnCarry_F2C5:
LDA ($00),Y ; CPU:$F2C5 PRG:32C5 B1 00
STA PPUDATA ; CPU:$F2C7 PRG:32C7 8D 07 20
DEX ; CPU:$F2CA PRG:32CA CA
BNE EnginePathLoop_F2C2 ; CPU:$F2CB PRG:32CB D0 F5
PLA ; CPU:$F2CD PRG:32CD 68
CMP #$3F ; CPU:$F2CE PRG:32CE C9 3F
BNE EnginePathLoop_F2DE ; CPU:$F2D0 PRG:32D0 D0 0C
STA PPUADDR ; CPU:$F2D2 PRG:32D2 8D 06 20
STX PPUADDR ; CPU:$F2D5 PRG:32D5 8E 06 20
STX PPUADDR ; CPU:$F2D8 PRG:32D8 8E 06 20
STX PPUADDR ; CPU:$F2DB PRG:32DB 8E 06 20
EnginePathLoop_F2DE:
SEC ; CPU:$F2DE PRG:32DE 38
TYA ; CPU:$F2DF PRG:32DF 98
ADC $00 ; CPU:$F2E0 PRG:32E0 65 00
STA $00 ; CPU:$F2E2 PRG:32E2 85 00
LDA #$00 ; CPU:$F2E4 PRG:32E4 A9 00
ADC $01 ; CPU:$F2E6 PRG:32E6 65 01
STA $01 ; CPU:$F2E8 PRG:32E8 85 01
;------------------------------------------------------------
; ProcessResourceStateDispatch_F2EA
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateDispatch_F2EA:
LDX PPUSTATUS ; CPU:$F2EA PRG:32EA AE 02 20
LDY #$00 ; CPU:$F2ED PRG:32ED A0 00
LDA ($00),Y ; CPU:$F2EF PRG:32EF B1 00
BNE EnginePathOnNonZero_F2F4 ; CPU:$F2F1 PRG:32F1 D0 01
RTS ; CPU:$F2F3 PRG:32F3 60
EnginePathOnNonZero_F2F4:
CMP #$60 ; CPU:$F2F4 PRG:32F4 C9 60
BNE EnginePathOnNonZero_F302 ; CPU:$F2F6 PRG:32F6 D0 0A
PLA ; CPU:$F2F8 PRG:32F8 68
STA $01 ; CPU:$F2F9 PRG:32F9 85 01
PLA ; CPU:$F2FB PRG:32FB 68
STA $00 ; CPU:$F2FC PRG:32FC 85 00
LDY #$02 ; CPU:$F2FE PRG:32FE A0 02
BNE EnginePathLoop_F2DE ; CPU:$F300 PRG:3300 D0 DC
EnginePathOnNonZero_F302:
CMP #$4C ; CPU:$F302 PRG:3302 C9 4C
BNE EnginePathLoop_F29C ; CPU:$F304 PRG:3304 D0 96
LDA WorkPtr0Lo ; CPU:$F306 PRG:3306 A5 00
PHA ; CPU:$F308 PRG:3308 48
LDA WorkPtr0Hi ; CPU:$F309 PRG:3309 A5 01
PHA ; CPU:$F30B PRG:330B 48
INY ; CPU:$F30C PRG:330C C8
LDA ($00),Y ; CPU:$F30D PRG:330D B1 00
TAX ; CPU:$F30F PRG:330F AA
INY ; CPU:$F310 PRG:3310 C8
LDA ($00),Y ; CPU:$F311 PRG:3311 B1 00
STA $01 ; CPU:$F313 PRG:3313 85 01
STX $00 ; CPU:$F315 PRG:3315 86 00
JMP ProcessResourceStateDispatch_F2EA ; CPU:$F317 PRG:3317 4C EA F2
;------------------------------------------------------------
; ProcessResourceStateRoutine_F31A
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F31A:
STA $00 ; CPU:$F31A PRG:331A 85 00
LDX $00 ; CPU:$F31C PRG:331C A6 00
JSR UpdateCommandBufferRoutine_F32C ; CPU:$F31E PRG:331E 20 2C F3
LDA WorkPtr0Lo ; CPU:$F321 PRG:3321 A5 00
LSR A ; CPU:$F323 PRG:3323 4A
LSR A ; CPU:$F324 PRG:3324 4A
LSR A ; CPU:$F325 PRG:3325 4A
LSR A ; CPU:$F326 PRG:3326 4A
TAX ; CPU:$F327 PRG:3327 AA
JSR UpdateCommandBufferRoutine_F32C ; CPU:$F328 PRG:3328 20 2C F3
RTS ; CPU:$F32B PRG:332B 60
;------------------------------------------------------------
; UpdateCommandBufferRoutine_F32C
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateCommandBufferRoutine_F32C:
INX ; CPU:$F32C PRG:332C E8
TXA ; CPU:$F32D PRG:332D 8A
AND #$0F ; CPU:$F32E PRG:332E 29 0F
CMP #$09 ; CPU:$F330 PRG:3330 C9 09
BCS EnginePathContinue_F3A0 ; CPU:$F332 PRG:3332 B0 6C
ASL A ; CPU:$F334 PRG:3334 0A
ASL A ; CPU:$F335 PRG:3335 0A
TAY ; CPU:$F336 PRG:3336 A8
STA $02 ; CPU:$F337 PRG:3337 85 02
LDX $0300 ; CPU:$F339 PRG:3339 AE 00 03
LDA $0700,Y ; CPU:$F33C PRG:333C B9 00 07
STA $0301,X ; CPU:$F33F PRG:333F 9D 01 03
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F342 PRG:3342 20 F5 F3
INY ; CPU:$F345 PRG:3345 C8
LDA $0700,Y ; CPU:$F346 PRG:3346 B9 00 07
STA $0301,X ; CPU:$F349 PRG:3349 9D 01 03
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F34C PRG:334C 20 F5 F3
INY ; CPU:$F34F PRG:334F C8
LDA $0700,Y ; CPU:$F350 PRG:3350 B9 00 07
AND #$07 ; CPU:$F353 PRG:3353 29 07
STA $0301,X ; CPU:$F355 PRG:3355 9D 01 03
STA $01 ; CPU:$F358 PRG:3358 85 01
TXA ; CPU:$F35A PRG:335A 8A
SEC ; CPU:$F35B PRG:335B 38
ADC $01 ; CPU:$F35C PRG:335C 65 01
JSR UpdateCommandBufferRoutine_F3F7 ; CPU:$F35E PRG:335E 20 F7 F3
TAX ; CPU:$F361 PRG:3361 AA
STX $0300 ; CPU:$F362 PRG:3362 8E 00 03
LDA #$00 ; CPU:$F365 PRG:3365 A9 00
STA $0301,X ; CPU:$F367 PRG:3367 9D 01 03
INY ; CPU:$F36A PRG:336A C8
LDA $0700,Y ; CPU:$F36B PRG:336B B9 00 07
STA $03 ; CPU:$F36E PRG:336E 85 03
UpdateCommandBufferLoop_F370:
DEX ; CPU:$F370 PRG:3370 CA
LDA a:$0020,Y ; CPU:$F371 PRG:3371 B9 20 00
AND #$0F ; CPU:$F374 PRG:3374 29 0F
STA $0301,X ; CPU:$F376 PRG:3376 9D 01 03
DEC $01 ; CPU:$F379 PRG:3379 C6 01
BEQ UpdateCommandBufferOnZero_F38F ; CPU:$F37B PRG:337B F0 12
DEX ; CPU:$F37D PRG:337D CA
LDA a:$0020,Y ; CPU:$F37E PRG:337E B9 20 00
AND #$F0 ; CPU:$F381 PRG:3381 29 F0
LSR A ; CPU:$F383 PRG:3383 4A
LSR A ; CPU:$F384 PRG:3384 4A
LSR A ; CPU:$F385 PRG:3385 4A
LSR A ; CPU:$F386 PRG:3386 4A
STA $0301,X ; CPU:$F387 PRG:3387 9D 01 03
DEY ; CPU:$F38A PRG:338A 88
DEC $01 ; CPU:$F38B PRG:338B C6 01
BNE UpdateCommandBufferLoop_F370 ; CPU:$F38D PRG:338D D0 E1
UpdateCommandBufferOnZero_F38F:
LDA $03 ; CPU:$F38F PRG:338F A5 03
AND #$01 ; CPU:$F391 PRG:3391 29 01
BEQ EnginePathContinue_F3A0 ; CPU:$F393 PRG:3393 F0 0B
LDY $02 ; CPU:$F395 PRG:3395 A4 02
CLC ; CPU:$F397 PRG:3397 18
LDA a:$0020,Y ; CPU:$F398 PRG:3398 B9 20 00
ADC #$B1 ; CPU:$F39B PRG:339B 69 B1
STA $0301,X ; CPU:$F39D PRG:339D 9D 01 03
EnginePathContinue_F3A0:
RTS ; CPU:$F3A0 PRG:33A0 60
;------------------------------------------------------------
; UpdateCommandBufferRoutine_F3A1
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateCommandBufferRoutine_F3A1:
LDY #$00 ; CPU:$F3A1 PRG:33A1 A0 00
LDA ($02),Y ; CPU:$F3A3 PRG:33A3 B1 02
AND #$0F ; CPU:$F3A5 PRG:33A5 29 0F
STA $05 ; CPU:$F3A7 PRG:33A7 85 05
LDA ($02),Y ; CPU:$F3A9 PRG:33A9 B1 02
LSR A ; CPU:$F3AB PRG:33AB 4A
LSR A ; CPU:$F3AC PRG:33AC 4A
LSR A ; CPU:$F3AD PRG:33AD 4A
LSR A ; CPU:$F3AE PRG:33AE 4A
STA $04 ; CPU:$F3AF PRG:33AF 85 04
LDX $0300 ; CPU:$F3B1 PRG:33B1 AE 00 03
UpdateCommandBufferLoop_F3B4:
LDA WorkPtr0Hi ; CPU:$F3B4 PRG:33B4 A5 01
STA $0301,X ; CPU:$F3B6 PRG:33B6 9D 01 03
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F3B9 PRG:33B9 20 F5 F3
LDA WorkPtr0Lo ; CPU:$F3BC PRG:33BC A5 00
STA $0301,X ; CPU:$F3BE PRG:33BE 9D 01 03
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F3C1 PRG:33C1 20 F5 F3
LDA $05 ; CPU:$F3C4 PRG:33C4 A5 05
STA $06 ; CPU:$F3C6 PRG:33C6 85 06
STA $0301,X ; CPU:$F3C8 PRG:33C8 9D 01 03
UpdateCommandBufferLoop_F3CB:
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F3CB PRG:33CB 20 F5 F3
INY ; CPU:$F3CE PRG:33CE C8
LDA ($02),Y ; CPU:$F3CF PRG:33CF B1 02
STA $0301,X ; CPU:$F3D1 PRG:33D1 9D 01 03
DEC $06 ; CPU:$F3D4 PRG:33D4 C6 06
BNE UpdateCommandBufferLoop_F3CB ; CPU:$F3D6 PRG:33D6 D0 F3
JSR ProcessResourceStateRoutine_F3F5 ; CPU:$F3D8 PRG:33D8 20 F5 F3
STX $0300 ; CPU:$F3DB PRG:33DB 8E 00 03
CLC ; CPU:$F3DE PRG:33DE 18
LDA #$20 ; CPU:$F3DF PRG:33DF A9 20
ADC $00 ; CPU:$F3E1 PRG:33E1 65 00
STA $00 ; CPU:$F3E3 PRG:33E3 85 00
LDA #$00 ; CPU:$F3E5 PRG:33E5 A9 00
ADC $01 ; CPU:$F3E7 PRG:33E7 65 01
STA $01 ; CPU:$F3E9 PRG:33E9 85 01
DEC $04 ; CPU:$F3EB PRG:33EB C6 04
BNE UpdateCommandBufferLoop_F3B4 ; CPU:$F3ED PRG:33ED D0 C5
LDA #$00 ; CPU:$F3EF PRG:33EF A9 00
STA $0301,X ; CPU:$F3F1 PRG:33F1 9D 01 03
RTS ; CPU:$F3F4 PRG:33F4 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F3F5
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F3F5:
INX ; CPU:$F3F5 PRG:33F5 E8
TXA ; CPU:$F3F6 PRG:33F6 8A
;------------------------------------------------------------
; UpdateCommandBufferRoutine_F3F7
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdateCommandBufferRoutine_F3F7:
CMP #$4E ; CPU:$F3F7 PRG:33F7 C9 4E
BCC EnginePathOnNoCarry_F407 ; CPU:$F3F9 PRG:33F9 90 0C
LDX $0300 ; CPU:$F3FB PRG:33FB AE 00 03
LDA #$00 ; CPU:$F3FE PRG:33FE A9 00
STA $0301,X ; CPU:$F400 PRG:3400 9D 01 03
PLA ; CPU:$F403 PRG:3403 68
PLA ; CPU:$F404 PRG:3404 68
LDA #$01 ; CPU:$F405 PRG:3405 A9 01
EnginePathOnNoCarry_F407:
RTS ; CPU:$F407 PRG:3407 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F408
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F408:
LDX #$FF ; CPU:$F408 PRG:3408 A2 FF
BNE EnginePathOnNonZero_F40E ; CPU:$F40A PRG:340A D0 02
;------------------------------------------------------------
; ProcessResourceStateRoutine_F40C
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F40C:
LDX #$00 ; CPU:$F40C PRG:340C A2 00
EnginePathOnNonZero_F40E:
STX $04 ; CPU:$F40E PRG:340E 86 04
LDX #$00 ; CPU:$F410 PRG:3410 A2 00
STX $05 ; CPU:$F412 PRG:3412 86 05
STX $06 ; CPU:$F414 PRG:3414 86 06
STX $07 ; CPU:$F416 PRG:3416 86 07
LDA WorkPtr0Hi ; CPU:$F418 PRG:3418 A5 01
AND #$08 ; CPU:$F41A PRG:341A 29 08
BNE EnginePathOnNonZero_F41F ; CPU:$F41C PRG:341C D0 01
INX ; CPU:$F41E PRG:341E E8
EnginePathOnNonZero_F41F:
LDA WorkPtr0Lo ; CPU:$F41F PRG:341F A5 00
STA $06,X ; CPU:$F421 PRG:3421 95 06
LDA WorkPtr0Hi ; CPU:$F423 PRG:3423 A5 01
JSR ProcessResourceStateRoutine_F429 ; CPU:$F425 PRG:3425 20 29 F4
RTS ; CPU:$F428 PRG:3428 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F429
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F429:
AND #$07 ; CPU:$F429 PRG:3429 29 07
ASL A ; CPU:$F42B PRG:342B 0A
ASL A ; CPU:$F42C PRG:342C 0A
TAX ; CPU:$F42D PRG:342D AA
LDA $04 ; CPU:$F42E PRG:342E A5 04
BEQ EnginePathOnZero_F459 ; CPU:$F430 PRG:3430 F0 27
LDA $24,X ; CPU:$F432 PRG:3432 B5 24
BEQ EnginePathOnZero_F45D ; CPU:$F434 PRG:3434 F0 27
EnginePathLoop_F436:
CLC ; CPU:$F436 PRG:3436 18
LDA $27,X ; CPU:$F437 PRG:3437 B5 27
STA $03 ; CPU:$F439 PRG:3439 85 03
LDA $07 ; CPU:$F43B PRG:343B A5 07
JSR ProcessResourceStateRoutine_F4AE ; CPU:$F43D PRG:343D 20 AE F4
STA $27,X ; CPU:$F440 PRG:3440 95 27
LDA $26,X ; CPU:$F442 PRG:3442 B5 26
STA $03 ; CPU:$F444 PRG:3444 85 03
LDA $06 ; CPU:$F446 PRG:3446 A5 06
JSR ProcessResourceStateRoutine_F4AE ; CPU:$F448 PRG:3448 20 AE F4
STA $26,X ; CPU:$F44B PRG:344B 95 26
LDA $25,X ; CPU:$F44D PRG:344D B5 25
STA $03 ; CPU:$F44F PRG:344F 85 03
LDA $05 ; CPU:$F451 PRG:3451 A5 05
JSR ProcessResourceStateRoutine_F4AE ; CPU:$F453 PRG:3453 20 AE F4
STA $25,X ; CPU:$F456 PRG:3456 95 25
RTS ; CPU:$F458 PRG:3458 60
EnginePathOnZero_F459:
LDA $24,X ; CPU:$F459 PRG:3459 B5 24
BEQ EnginePathLoop_F436 ; CPU:$F45B PRG:345B F0 D9
EnginePathOnZero_F45D:
SEC ; CPU:$F45D PRG:345D 38
LDA $27,X ; CPU:$F45E PRG:345E B5 27
STA $03 ; CPU:$F460 PRG:3460 85 03
LDA $07 ; CPU:$F462 PRG:3462 A5 07
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F464 PRG:3464 20 CF F4
STA $27,X ; CPU:$F467 PRG:3467 95 27
LDA $26,X ; CPU:$F469 PRG:3469 B5 26
STA $03 ; CPU:$F46B PRG:346B 85 03
LDA $06 ; CPU:$F46D PRG:346D A5 06
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F46F PRG:346F 20 CF F4
STA $26,X ; CPU:$F472 PRG:3472 95 26
LDA $25,X ; CPU:$F474 PRG:3474 B5 25
STA $03 ; CPU:$F476 PRG:3476 85 03
LDA $05 ; CPU:$F478 PRG:3478 A5 05
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F47A PRG:347A 20 CF F4
STA $25,X ; CPU:$F47D PRG:347D 95 25
LDA $25,X ; CPU:$F47F PRG:347F B5 25
BNE EnginePathOnNonZero_F48B ; CPU:$F481 PRG:3481 D0 08
LDA $26,X ; CPU:$F483 PRG:3483 B5 26
BNE EnginePathOnNonZero_F48B ; CPU:$F485 PRG:3485 D0 04
LDA $27,X ; CPU:$F487 PRG:3487 B5 27
BEQ EnginePathOnZero_F491 ; CPU:$F489 PRG:3489 F0 06
EnginePathOnNonZero_F48B:
BCS EnginePathOnCarry_F4AD ; CPU:$F48B PRG:348B B0 20
LDA $24,X ; CPU:$F48D PRG:348D B5 24
EOR #$FF ; CPU:$F48F PRG:348F 49 FF
EnginePathOnZero_F491:
STA $24,X ; CPU:$F491 PRG:3491 95 24
SEC ; CPU:$F493 PRG:3493 38
LDA #$00 ; CPU:$F494 PRG:3494 A9 00
STA $03 ; CPU:$F496 PRG:3496 85 03
LDA $27,X ; CPU:$F498 PRG:3498 B5 27
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F49A PRG:349A 20 CF F4
STA $27,X ; CPU:$F49D PRG:349D 95 27
LDA $26,X ; CPU:$F49F PRG:349F B5 26
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F4A1 PRG:34A1 20 CF F4
STA $26,X ; CPU:$F4A4 PRG:34A4 95 26
LDA $25,X ; CPU:$F4A6 PRG:34A6 B5 25
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F4A8 PRG:34A8 20 CF F4
STA $25,X ; CPU:$F4AB PRG:34AB 95 25
EnginePathOnCarry_F4AD:
RTS ; CPU:$F4AD PRG:34AD 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F4AE
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F4AE:
JSR ProcessResourceStateRoutine_F4F1 ; CPU:$F4AE PRG:34AE 20 F1 F4
ADC $01 ; CPU:$F4B1 PRG:34B1 65 01
CMP #$0A ; CPU:$F4B3 PRG:34B3 C9 0A
BCC EnginePathOnNoCarry_F4B9 ; CPU:$F4B5 PRG:34B5 90 02
ADC #$05 ; CPU:$F4B7 PRG:34B7 69 05
EnginePathOnNoCarry_F4B9:
CLC ; CPU:$F4B9 PRG:34B9 18
ADC $02 ; CPU:$F4BA PRG:34BA 65 02
STA $02 ; CPU:$F4BC PRG:34BC 85 02
LDA $03 ; CPU:$F4BE PRG:34BE A5 03
AND #$F0 ; CPU:$F4C0 PRG:34C0 29 F0
ADC $02 ; CPU:$F4C2 PRG:34C2 65 02
BCC EnginePathOnNoCarry_F4CA ; CPU:$F4C4 PRG:34C4 90 04
EnginePathLoop_F4C6:
ADC #$5F ; CPU:$F4C6 PRG:34C6 69 5F
SEC ; CPU:$F4C8 PRG:34C8 38
RTS ; CPU:$F4C9 PRG:34C9 60
EnginePathOnNoCarry_F4CA:
CMP #$A0 ; CPU:$F4CA PRG:34CA C9 A0
BCS EnginePathLoop_F4C6 ; CPU:$F4CC PRG:34CC B0 F8
RTS ; CPU:$F4CE PRG:34CE 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F4CF
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F4CF:
JSR ProcessResourceStateRoutine_F4F1 ; CPU:$F4CF PRG:34CF 20 F1 F4
SBC $01 ; CPU:$F4D2 PRG:34D2 E5 01
STA $01 ; CPU:$F4D4 PRG:34D4 85 01
BCS EnginePathOnCarry_F4E2 ; CPU:$F4D6 PRG:34D6 B0 0A
ADC #$0A ; CPU:$F4D8 PRG:34D8 69 0A
STA $01 ; CPU:$F4DA PRG:34DA 85 01
LDA WorkPtr1Lo ; CPU:$F4DC PRG:34DC A5 02
ADC #$0F ; CPU:$F4DE PRG:34DE 69 0F
STA $02 ; CPU:$F4E0 PRG:34E0 85 02
EnginePathOnCarry_F4E2:
LDA $03 ; CPU:$F4E2 PRG:34E2 A5 03
AND #$F0 ; CPU:$F4E4 PRG:34E4 29 F0
SEC ; CPU:$F4E6 PRG:34E6 38
SBC $02 ; CPU:$F4E7 PRG:34E7 E5 02
BCS EnginePathOnCarry_F4EE ; CPU:$F4E9 PRG:34E9 B0 03
ADC #$A0 ; CPU:$F4EB PRG:34EB 69 A0
CLC ; CPU:$F4ED PRG:34ED 18
EnginePathOnCarry_F4EE:
ORA $01 ; CPU:$F4EE PRG:34EE 05 01
RTS ; CPU:$F4F0 PRG:34F0 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F4F1
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F4F1:
PHA ; CPU:$F4F1 PRG:34F1 48
AND #$0F ; CPU:$F4F2 PRG:34F2 29 0F
STA $01 ; CPU:$F4F4 PRG:34F4 85 01
PLA ; CPU:$F4F6 PRG:34F6 68
AND #$F0 ; CPU:$F4F7 PRG:34F7 29 F0
STA $02 ; CPU:$F4F9 PRG:34F9 85 02
LDA $03 ; CPU:$F4FB PRG:34FB A5 03
AND #$0F ; CPU:$F4FD PRG:34FD 29 0F
RTS ; CPU:$F4FF PRG:34FF 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F500
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F500:
LDA #$00 ; CPU:$F500 PRG:3500 A9 00
STA $04 ; CPU:$F502 PRG:3502 85 04
CLC ; CPU:$F504 PRG:3504 18
LDA WorkPtr0Lo ; CPU:$F505 PRG:3505 A5 00
ADC #$10 ; CPU:$F507 PRG:3507 69 10
AND #$F0 ; CPU:$F509 PRG:3509 29 F0
LSR A ; CPU:$F50B PRG:350B 4A
LSR A ; CPU:$F50C PRG:350C 4A
TAY ; CPU:$F50D PRG:350D A8
LDA WorkPtr0Lo ; CPU:$F50E PRG:350E A5 00
AND #$07 ; CPU:$F510 PRG:3510 29 07
ASL A ; CPU:$F512 PRG:3512 0A
ASL A ; CPU:$F513 PRG:3513 0A
TAX ; CPU:$F514 PRG:3514 AA
EnginePathLoop_F515:
LDA a:$0020,Y ; CPU:$F515 PRG:3515 B9 20 00
BEQ EnginePathOnZero_F56B ; CPU:$F518 PRG:3518 F0 51
LDA $24,X ; CPU:$F51A PRG:351A B5 24
BEQ EnginePathLoop_F544 ; CPU:$F51C PRG:351C F0 26
EnginePathLoop_F51E:
SEC ; CPU:$F51E PRG:351E 38
LDA a:$0023,Y ; CPU:$F51F PRG:351F B9 23 00
STA $03 ; CPU:$F522 PRG:3522 85 03
LDA $27,X ; CPU:$F524 PRG:3524 B5 27
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F526 PRG:3526 20 CF F4
LDA a:$0022,Y ; CPU:$F529 PRG:3529 B9 22 00
STA $03 ; CPU:$F52C PRG:352C 85 03
LDA $26,X ; CPU:$F52E PRG:352E B5 26
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F530 PRG:3530 20 CF F4
LDA a:$0021,Y ; CPU:$F533 PRG:3533 B9 21 00
STA $03 ; CPU:$F536 PRG:3536 85 03
LDA $25,X ; CPU:$F538 PRG:3538 B5 25
JSR ProcessResourceStateRoutine_F4CF ; CPU:$F53A PRG:353A 20 CF F4
BCS EnginePathOnCarry_F56F ; CPU:$F53D PRG:353D B0 30
LDA a:$0020,Y ; CPU:$F53F PRG:353F B9 20 00
BNE EnginePathOnNonZero_F574 ; CPU:$F542 PRG:3542 D0 30
EnginePathLoop_F544:
LDA #$FF ; CPU:$F544 PRG:3544 A9 FF
STA $04 ; CPU:$F546 PRG:3546 85 04
SEC ; CPU:$F548 PRG:3548 38
EnginePathLoop_F549:
TYA ; CPU:$F549 PRG:3549 98
BNE EnginePathContinue_F56A ; CPU:$F54A PRG:354A D0 1E
BCC EnginePathOnNoCarry_F55E ; CPU:$F54C PRG:354C 90 10
LDA $24,X ; CPU:$F54E PRG:354E B5 24
STA $20 ; CPU:$F550 PRG:3550 85 20
LDA $25,X ; CPU:$F552 PRG:3552 B5 25
STA $21 ; CPU:$F554 PRG:3554 85 21
LDA $26,X ; CPU:$F556 PRG:3556 B5 26
STA $22 ; CPU:$F558 PRG:3558 85 22
LDA $27,X ; CPU:$F55A PRG:355A B5 27
STA $23 ; CPU:$F55C PRG:355C 85 23
EnginePathOnNoCarry_F55E:
LDA WorkPtr0Lo ; CPU:$F55E PRG:355E A5 00
AND #$08 ; CPU:$F560 PRG:3560 29 08
BEQ EnginePathContinue_F56A ; CPU:$F562 PRG:3562 F0 06
DEX ; CPU:$F564 PRG:3564 CA
DEX ; CPU:$F565 PRG:3565 CA
DEX ; CPU:$F566 PRG:3566 CA
DEX ; CPU:$F567 PRG:3567 CA
BPL EnginePathLoop_F515 ; CPU:$F568 PRG:3568 10 AB
EnginePathContinue_F56A:
RTS ; CPU:$F56A PRG:356A 60
EnginePathOnZero_F56B:
LDA $24,X ; CPU:$F56B PRG:356B B5 24
BEQ EnginePathLoop_F51E ; CPU:$F56D PRG:356D F0 AF
EnginePathOnCarry_F56F:
LDA a:$0020,Y ; CPU:$F56F PRG:356F B9 20 00
BNE EnginePathLoop_F544 ; CPU:$F572 PRG:3572 D0 D0
EnginePathOnNonZero_F574:
CLC ; CPU:$F574 PRG:3574 18
BCC EnginePathLoop_F549 ; CPU:$F575 PRG:3575 90 D2
;------------------------------------------------------------
; ProcessResourceStateRoutine_F577
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F577:
LDX #$1E ; CPU:$F577 PRG:3577 A2 1E
DEC $50 ; CPU:$F579 PRG:3579 C6 50
BPL EnginePathLoop_F583 ; CPU:$F57B PRG:357B 10 06
LDA #$0A ; CPU:$F57D PRG:357D A9 0A
STA $50 ; CPU:$F57F PRG:357F 85 50
LDX #$2E ; CPU:$F581 PRG:3581 A2 2E
EnginePathLoop_F583:
LDA $51,X ; CPU:$F583 PRG:3583 B5 51
BEQ EnginePathOnZero_F589 ; CPU:$F585 PRG:3585 F0 02
DEC $51,X ; CPU:$F587 PRG:3587 D6 51
EnginePathOnZero_F589:
DEX ; CPU:$F589 PRG:3589 CA
BPL EnginePathLoop_F583 ; CPU:$F58A PRG:358A 10 F7
RTS ; CPU:$F58C PRG:358C 60
;------------------------------------------------------------
; EnginePath_F58D
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
EnginePath_F58D:
LDA $10 ; CPU:$F58D PRG:358D A5 10
AND #$02 ; CPU:$F58F PRG:358F 29 02
STA $00 ; CPU:$F591 PRG:3591 85 00
LDA $11 ; CPU:$F593 PRG:3593 A5 11
AND #$02 ; CPU:$F595 PRG:3595 29 02
EOR $00 ; CPU:$F597 PRG:3597 45 00
CLC ; CPU:$F599 PRG:3599 18
BEQ EnginePathOnZero_F59D ; CPU:$F59A PRG:359A F0 01
SEC ; CPU:$F59C PRG:359C 38
EnginePathOnZero_F59D:
ROR $10 ; CPU:$F59D PRG:359D 66 10
ROR $11 ; CPU:$F59F PRG:359F 66 11
ROR $12 ; CPU:$F5A1 PRG:35A1 66 12
ROR $13 ; CPU:$F5A3 PRG:35A3 66 13
ROR $14 ; CPU:$F5A5 PRG:35A5 66 14
ROR $15 ; CPU:$F5A7 PRG:35A7 66 15
ROR $16 ; CPU:$F5A9 PRG:35A9 66 16
ROR $17 ; CPU:$F5AB PRG:35AB 66 17
RTS ; CPU:$F5AD PRG:35AD 60
;------------------------------------------------------------
; EnginePath_F5AE
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
EnginePath_F5AE:
LDA #$01 ; CPU:$F5AE PRG:35AE A9 01
STA JOY1 ; CPU:$F5B0 PRG:35B0 8D 16 40
LDX #$00 ; CPU:$F5B3 PRG:35B3 A2 00
LDA #$00 ; CPU:$F5B5 PRG:35B5 A9 00
STA JOY1 ; CPU:$F5B7 PRG:35B7 8D 16 40
JSR ProcessResourceStateRoutine_F5BE ; CPU:$F5BA PRG:35BA 20 BE F5
INX ; CPU:$F5BD PRG:35BD E8
;------------------------------------------------------------
; ProcessResourceStateRoutine_F5BE
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F5BE:
LDY #$08 ; CPU:$F5BE PRG:35BE A0 08
EnginePathLoop_F5C0:
PHA ; CPU:$F5C0 PRG:35C0 48
LDA JOY1,X ; CPU:$F5C1 PRG:35C1 BD 16 40
STA $00 ; CPU:$F5C4 PRG:35C4 85 00
LSR A ; CPU:$F5C6 PRG:35C6 4A
ORA $00 ; CPU:$F5C7 PRG:35C7 05 00
LSR A ; CPU:$F5C9 PRG:35C9 4A
PLA ; CPU:$F5CA PRG:35CA 68
ROL A ; CPU:$F5CB PRG:35CB 2A
DEY ; CPU:$F5CC PRG:35CC 88
BNE EnginePathLoop_F5C0 ; CPU:$F5CD PRG:35CD D0 F1
LDY $44,X ; CPU:$F5CF PRG:35CF B4 44
STY $00 ; CPU:$F5D1 PRG:35D1 84 00
PHA ; CPU:$F5D3 PRG:35D3 48
STA $44,X ; CPU:$F5D4 PRG:35D4 95 44
LDY $46,X ; CPU:$F5D6 PRG:35D6 B4 46
AND #$3F ; CPU:$F5D8 PRG:35D8 29 3F
STA $46,X ; CPU:$F5DA PRG:35DA 95 46
PLA ; CPU:$F5DC PRG:35DC 68
ORA $00 ; CPU:$F5DD PRG:35DD 05 00
EOR $00 ; CPU:$F5DF PRG:35DF 45 00
AND #$C0 ; CPU:$F5E1 PRG:35E1 29 C0
ORA $46,X ; CPU:$F5E3 PRG:35E3 15 46
STA $46,X ; CPU:$F5E5 PRG:35E5 95 46
TYA ; CPU:$F5E7 PRG:35E7 98
AND #$0F ; CPU:$F5E8 PRG:35E8 29 0F
AND $46,X ; CPU:$F5EA PRG:35EA 35 46
BEQ EnginePathOnZero_F5F4 ; CPU:$F5EC PRG:35EC F0 06
ORA #$F0 ; CPU:$F5EE PRG:35EE 09 F0
AND $46,X ; CPU:$F5F0 PRG:35F0 35 46
STA $46,X ; CPU:$F5F2 PRG:35F2 95 46
EnginePathOnZero_F5F4:
RTS ; CPU:$F5F4 PRG:35F4 60
EnginePathLoop_F5F5:
BMI EnginePathLoop_F600 ; CPU:$F5F5 PRG:35F5 30 09
CPX #$F4 ; CPU:$F5F7 PRG:35F7 E0 F4
BEQ EnginePathLoop_F600 ; CPU:$F5F9 PRG:35F9 F0 05
LDA #$F4 ; CPU:$F5FB PRG:35FB A9 F4
JSR ProcessResourceStateRoutine_F6FB ; CPU:$F5FD PRG:35FD 20 FB F6
EnginePathLoop_F600:
RTS ; CPU:$F600 PRG:3600 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F601
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F601:
LDY #$0B ; CPU:$F601 PRG:3601 A0 0B
LDA ($00),Y ; CPU:$F603 PRG:3603 B1 00
STA $02 ; CPU:$F605 PRG:3605 85 02
LDA #$02 ; CPU:$F607 PRG:3607 A9 02
STA $03 ; CPU:$F609 PRG:3609 85 03
LDY #$06 ; CPU:$F60B PRG:360B A0 06
LDA ($00),Y ; CPU:$F60D PRG:360D B1 00
STA $0B ; CPU:$F60F PRG:360F 85 0B
LDY #$01 ; CPU:$F611 PRG:3611 A0 01
LDA ($00),Y ; CPU:$F613 PRG:3613 B1 00
TAX ; CPU:$F615 PRG:3615 AA
STA $08 ; CPU:$F616 PRG:3616 85 08
DEY ; CPU:$F618 PRG:3618 88
LDA ($00),Y ; CPU:$F619 PRG:3619 B1 00
BNE EnginePathLoop_F5F5 ; CPU:$F61B PRG:361B D0 D8
LDY #$0A ; CPU:$F61D PRG:361D A0 0A
LDA ($00),Y ; CPU:$F61F PRG:361F B1 00
TAX ; CPU:$F621 PRG:3621 AA
LSR A ; CPU:$F622 PRG:3622 4A
LSR A ; CPU:$F623 PRG:3623 4A
LSR A ; CPU:$F624 PRG:3624 4A
LSR A ; CPU:$F625 PRG:3625 4A
BEQ EnginePathLoop_F600 ; CPU:$F626 PRG:3626 F0 D8
STA $04 ; CPU:$F628 PRG:3628 85 04
STA $06 ; CPU:$F62A PRG:362A 85 06
TXA ; CPU:$F62C PRG:362C 8A
AND #$0F ; CPU:$F62D PRG:362D 29 0F
BEQ EnginePathLoop_F600 ; CPU:$F62F PRG:362F F0 CF
STA $05 ; CPU:$F631 PRG:3631 85 05
STA $07 ; CPU:$F633 PRG:3633 85 07
LDY #$08 ; CPU:$F635 PRG:3635 A0 08
LDA ($00),Y ; CPU:$F637 PRG:3637 B1 00
AND #$C0 ; CPU:$F639 PRG:3639 29 C0
INY ; CPU:$F63B PRG:363B C8
ORA ($00),Y ; CPU:$F63C PRG:363C 11 00
STA $09 ; CPU:$F63E PRG:363E 85 09
LDY #$03 ; CPU:$F640 PRG:3640 A0 03
LDA ($00),Y ; CPU:$F642 PRG:3642 B1 00
STA $0A ; CPU:$F644 PRG:3644 85 0A
LDY #$02 ; CPU:$F646 PRG:3646 A0 02
LDA $09 ; CPU:$F648 PRG:3648 A5 09
CMP ($02),Y ; CPU:$F64A PRG:364A D1 02
BNE EnginePathOnNonZero_F6B0 ; CPU:$F64C PRG:364C D0 62
LDY #$00 ; CPU:$F64E PRG:364E A0 00
LDA $08 ; CPU:$F650 PRG:3650 A5 08
CMP ($02),Y ; CPU:$F652 PRG:3652 D1 02
BEQ EnginePathOnZero_F659 ; CPU:$F654 PRG:3654 F0 03
JSR ProcessResourceStateRoutine_F707 ; CPU:$F656 PRG:3656 20 07 F7
EnginePathOnZero_F659:
LDY #$03 ; CPU:$F659 PRG:3659 A0 03
LDA $0A ; CPU:$F65B PRG:365B A5 0A
CMP ($02),Y ; CPU:$F65D PRG:365D D1 02
BEQ EnginePathOnZero_F677 ; CPU:$F65F PRG:365F F0 16
EnginePathLoop_F661:
LDX $05 ; CPU:$F661 PRG:3661 A6 05
STX $07 ; CPU:$F663 PRG:3663 86 07
EnginePathLoop_F665:
LDX $04 ; CPU:$F665 PRG:3665 A6 04
EnginePathLoop_F667:
STA ($02),Y ; CPU:$F667 PRG:3667 91 02
INY ; CPU:$F669 PRG:3669 C8
INY ; CPU:$F66A PRG:366A C8
INY ; CPU:$F66B PRG:366B C8
INY ; CPU:$F66C PRG:366C C8
DEX ; CPU:$F66D PRG:366D CA
BNE EnginePathLoop_F667 ; CPU:$F66E PRG:366E D0 F7
CLC ; CPU:$F670 PRG:3670 18
ADC #$08 ; CPU:$F671 PRG:3671 69 08
DEC $07 ; CPU:$F673 PRG:3673 C6 07
BNE EnginePathLoop_F665 ; CPU:$F675 PRG:3675 D0 EE
EnginePathOnZero_F677:
LDY #$05 ; CPU:$F677 PRG:3677 A0 05
LDA ($00),Y ; CPU:$F679 PRG:3679 B1 00
STA $08 ; CPU:$F67B PRG:367B 85 08
LDA #$00 ; CPU:$F67D PRG:367D A9 00
LDX $0B ; CPU:$F67F PRG:367F A6 0B
CLC ; CPU:$F681 PRG:3681 18
EnginePathLoop_F682:
ADC $08 ; CPU:$F682 PRG:3682 65 08
DEX ; CPU:$F684 PRG:3684 CA
BNE EnginePathLoop_F682 ; CPU:$F685 PRG:3685 D0 FB
LDY #$07 ; CPU:$F687 PRG:3687 A0 07
ADC ($00),Y ; CPU:$F689 PRG:3689 71 00
TAX ; CPU:$F68B PRG:368B AA
LDY #$01 ; CPU:$F68C PRG:368C A0 01
LDA #$FF ; CPU:$F68E PRG:368E A9 FF
STA $0A ; CPU:$F690 PRG:3690 85 0A
BIT $09 ; CPU:$F692 PRG:3692 24 09
BMI EnginePathOnNegative_F6BE ; CPU:$F694 PRG:3694 30 28
BVS EnginePathOnOverflowSet_F6C0 ; CPU:$F696 PRG:3696 70 28
LDA #$01 ; CPU:$F698 PRG:3698 A9 01
STA $0A ; CPU:$F69A PRG:369A 85 0A
EnginePathLoop_F69C:
TXA ; CPU:$F69C PRG:369C 8A
CMP ($02),Y ; CPU:$F69D PRG:369D D1 02
BEQ EnginePathOnZero_F6AF ; CPU:$F69F PRG:369F F0 0E
LDX $0B ; CPU:$F6A1 PRG:36A1 A6 0B
EnginePathLoop_F6A3:
STA ($02),Y ; CPU:$F6A3 PRG:36A3 91 02
CLC ; CPU:$F6A5 PRG:36A5 18
ADC $0A ; CPU:$F6A6 PRG:36A6 65 0A
INY ; CPU:$F6A8 PRG:36A8 C8
INY ; CPU:$F6A9 PRG:36A9 C8
INY ; CPU:$F6AA PRG:36AA C8
INY ; CPU:$F6AB PRG:36AB C8
DEX ; CPU:$F6AC PRG:36AC CA
BNE EnginePathLoop_F6A3 ; CPU:$F6AD PRG:36AD D0 F4
EnginePathOnZero_F6AF:
RTS ; CPU:$F6AF PRG:36AF 60
EnginePathOnNonZero_F6B0:
JSR ProcessResourceStateRoutine_F6FB ; CPU:$F6B0 PRG:36B0 20 FB F6
LDY #$00 ; CPU:$F6B3 PRG:36B3 A0 00
JSR ProcessResourceStateRoutine_F707 ; CPU:$F6B5 PRG:36B5 20 07 F7
LDA $0A ; CPU:$F6B8 PRG:36B8 A5 0A
LDY #$03 ; CPU:$F6BA PRG:36BA A0 03
BNE EnginePathLoop_F661 ; CPU:$F6BC PRG:36BC D0 A3
EnginePathOnNegative_F6BE:
BVC EnginePathOnOverflowClear_F6D4 ; CPU:$F6BE PRG:36BE 50 14
EnginePathOnOverflowSet_F6C0:
TXA ; CPU:$F6C0 PRG:36C0 8A
ADC $0B ; CPU:$F6C1 PRG:36C1 65 0B
TAX ; CPU:$F6C3 PRG:36C3 AA
DEX ; CPU:$F6C4 PRG:36C4 CA
ASL $09 ; CPU:$F6C5 PRG:36C5 06 09
BCS EnginePathLoop_F69C ; CPU:$F6C7 PRG:36C7 B0 D3
LDA #$01 ; CPU:$F6C9 PRG:36C9 A9 01
STA $0A ; CPU:$F6CB PRG:36CB 85 0A
LDA #$00 ; CPU:$F6CD PRG:36CD A9 00
SEC ; CPU:$F6CF PRG:36CF 38
SBC $06 ; CPU:$F6D0 PRG:36D0 E5 06
STA $06 ; CPU:$F6D2 PRG:36D2 85 06
EnginePathOnOverflowClear_F6D4:
TXA ; CPU:$F6D4 PRG:36D4 8A
LDX $04 ; CPU:$F6D5 PRG:36D5 A6 04
CLC ; CPU:$F6D7 PRG:36D7 18
ADC $06 ; CPU:$F6D8 PRG:36D8 65 06
CLC ; CPU:$F6DA PRG:36DA 18
ADC $0A ; CPU:$F6DB PRG:36DB 65 0A
CMP ($02),Y ; CPU:$F6DD PRG:36DD D1 02
BNE EnginePathOnNonZero_F6E7 ; CPU:$F6DF PRG:36DF D0 06
RTS ; CPU:$F6E1 PRG:36E1 60
EnginePathLoop_F6E2:
LDX $04 ; CPU:$F6E2 PRG:36E2 A6 04
EnginePathLoop_F6E4:
CLC ; CPU:$F6E4 PRG:36E4 18
ADC $0A ; CPU:$F6E5 PRG:36E5 65 0A
EnginePathOnNonZero_F6E7:
STA ($02),Y ; CPU:$F6E7 PRG:36E7 91 02
INY ; CPU:$F6E9 PRG:36E9 C8
INY ; CPU:$F6EA PRG:36EA C8
INY ; CPU:$F6EB PRG:36EB C8
INY ; CPU:$F6EC PRG:36EC C8
DEX ; CPU:$F6ED PRG:36ED CA
BNE EnginePathLoop_F6E4 ; CPU:$F6EE PRG:36EE D0 F4
CLC ; CPU:$F6F0 PRG:36F0 18
ADC $06 ; CPU:$F6F1 PRG:36F1 65 06
CLC ; CPU:$F6F3 PRG:36F3 18
ADC $06 ; CPU:$F6F4 PRG:36F4 65 06
DEC $05 ; CPU:$F6F6 PRG:36F6 C6 05
BNE EnginePathLoop_F6E2 ; CPU:$F6F8 PRG:36F8 D0 E8
RTS ; CPU:$F6FA PRG:36FA 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F6FB
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F6FB:
LDX $0B ; CPU:$F6FB PRG:36FB A6 0B
EnginePathLoop_F6FD:
STA ($02),Y ; CPU:$F6FD PRG:36FD 91 02
INY ; CPU:$F6FF PRG:36FF C8
INY ; CPU:$F700 PRG:3700 C8
INY ; CPU:$F701 PRG:3701 C8
INY ; CPU:$F702 PRG:3702 C8
DEX ; CPU:$F703 PRG:3703 CA
BNE EnginePathLoop_F6FD ; CPU:$F704 PRG:3704 D0 F7
RTS ; CPU:$F706 PRG:3706 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F707
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F707:
LDA $08 ; CPU:$F707 PRG:3707 A5 08
LDX $04 ; CPU:$F709 PRG:3709 A6 04
EnginePathLoop_F70B:
STA ($02),Y ; CPU:$F70B PRG:370B 91 02
INY ; CPU:$F70D PRG:370D C8
INY ; CPU:$F70E PRG:370E C8
INY ; CPU:$F70F PRG:370F C8
INY ; CPU:$F710 PRG:3710 C8
CLC ; CPU:$F711 PRG:3711 18
ADC #$08 ; CPU:$F712 PRG:3712 69 08
DEX ; CPU:$F714 PRG:3714 CA
BNE EnginePathLoop_F70B ; CPU:$F715 PRG:3715 D0 F4
DEC $07 ; CPU:$F717 PRG:3717 C6 07
;------------------------------------------------------------
; EnginePath_F719
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
EnginePath_F719:
BNE ProcessResourceStateRoutine_F707 ; CPU:$F719 PRG:3719 D0 EC
RTS ; CPU:$F71B PRG:371B 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F71C
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F71C:
CLC ; CPU:$F71C PRG:371C 18
LDY #$00 ; CPU:$F71D PRG:371D A0 00
LDA ($00),Y ; CPU:$F71F PRG:371F B1 00
BNE EnginePathContinue_F77C ; CPU:$F721 PRG:3721 D0 59
LDA ($02),Y ; CPU:$F723 PRG:3723 B1 02
BNE EnginePathContinue_F77C ; CPU:$F725 PRG:3725 D0 55
LDY #$0C ; CPU:$F727 PRG:3727 A0 0C
LDA ($02),Y ; CPU:$F729 PRG:3729 B1 02
LDY #$01 ; CPU:$F72B PRG:372B A0 01
ADC ($02),Y ; CPU:$F72D PRG:372D 71 02
STA $04 ; CPU:$F72F PRG:372F 85 04
LDA ($00),Y ; CPU:$F731 PRG:3731 B1 00
LDY #$0E ; CPU:$F733 PRG:3733 A0 0E
CLC ; CPU:$F735 PRG:3735 18
ADC ($00),Y ; CPU:$F736 PRG:3736 71 00
CMP $04 ; CPU:$F738 PRG:3738 C5 04
BCC EnginePathContinue_F77C ; CPU:$F73A PRG:373A 90 40
LDY #$0C ; CPU:$F73C PRG:373C A0 0C
LDA ($00),Y ; CPU:$F73E PRG:373E B1 00
LDY #$01 ; CPU:$F740 PRG:3740 A0 01
CLC ; CPU:$F742 PRG:3742 18
ADC ($00),Y ; CPU:$F743 PRG:3743 71 00
STA $04 ; CPU:$F745 PRG:3745 85 04
LDA ($02),Y ; CPU:$F747 PRG:3747 B1 02
LDY #$0E ; CPU:$F749 PRG:3749 A0 0E
CLC ; CPU:$F74B PRG:374B 18
ADC ($02),Y ; CPU:$F74C PRG:374C 71 02
CMP $04 ; CPU:$F74E PRG:374E C5 04
BCC EnginePathContinue_F77C ; CPU:$F750 PRG:3750 90 2A
LDY #$0D ; CPU:$F752 PRG:3752 A0 0D
LDA ($02),Y ; CPU:$F754 PRG:3754 B1 02
LDY #$03 ; CPU:$F756 PRG:3756 A0 03
CLC ; CPU:$F758 PRG:3758 18
ADC ($02),Y ; CPU:$F759 PRG:3759 71 02
STA $04 ; CPU:$F75B PRG:375B 85 04
LDA ($00),Y ; CPU:$F75D PRG:375D B1 00
LDY #$0F ; CPU:$F75F PRG:375F A0 0F
CLC ; CPU:$F761 PRG:3761 18
ADC ($00),Y ; CPU:$F762 PRG:3762 71 00
CMP $04 ; CPU:$F764 PRG:3764 C5 04
BCC EnginePathContinue_F77C ; CPU:$F766 PRG:3766 90 14
LDY #$0D ; CPU:$F768 PRG:3768 A0 0D
LDA ($00),Y ; CPU:$F76A PRG:376A B1 00
LDY #$03 ; CPU:$F76C PRG:376C A0 03
CLC ; CPU:$F76E PRG:376E 18
ADC ($00),Y ; CPU:$F76F PRG:376F 71 00
STA $04 ; CPU:$F771 PRG:3771 85 04
LDA ($02),Y ; CPU:$F773 PRG:3773 B1 02
LDY #$0F ; CPU:$F775 PRG:3775 A0 0F
CLC ; CPU:$F777 PRG:3777 18
ADC ($02),Y ; CPU:$F778 PRG:3778 71 02
CMP $04 ; CPU:$F77A PRG:377A C5 04
EnginePathContinue_F77C:
RTS ; CPU:$F77C PRG:377C 60
;------------------------------------------------------------
; ProcessResourceStateRoutine_F77D
;
; Global:
; First-pass resource/input/collision entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessResourceStateRoutine_F77D:
STA $00 ; CPU:$F77D PRG:377D 85 00
STX $01 ; CPU:$F77F PRG:377F 86 01
LDY #$04 ; CPU:$F781 PRG:3781 A0 04
LDA ($00),Y ; CPU:$F783 PRG:3783 B1 00
STA $03 ; CPU:$F785 PRG:3785 85 03
DEY ; CPU:$F787 PRG:3787 88
LDA ($00),Y ; CPU:$F788 PRG:3788 B1 00
STA $02 ; CPU:$F78A PRG:378A 85 02
DEY ; CPU:$F78C PRG:378C 88
LDA ($00),Y ; CPU:$F78D PRG:378D B1 00
STA $05 ; CPU:$F78F PRG:378F 85 05
DEY ; CPU:$F791 PRG:3791 88
LDA ($00),Y ; CPU:$F792 PRG:3792 B1 00
STA $04 ; CPU:$F794 PRG:3794 85 04
DEY ; CPU:$F796 PRG:3796 88
LDA ($00),Y ; CPU:$F797 PRG:3797 B1 00
STA $06 ; CPU:$F799 PRG:3799 85 06
LDA #$05 ; CPU:$F79B PRG:379B A9 05
EnginePathLoop_F79D:
CLC ; CPU:$F79D PRG:379D 18
ADC a:$0000,Y ; CPU:$F79E PRG:379E 79 00 00
STA a:$0000,Y ; CPU:$F7A1 PRG:37A1 99 00 00
LDA #$00 ; CPU:$F7A4 PRG:37A4 A9 00
ADC a:$0001,Y ; CPU:$F7A6 PRG:37A6 79 01 00
STA a:$0001,Y ; CPU:$F7A9 PRG:37A9 99 01 00
LDY #$00 ; CPU:$F7AC PRG:37AC A0 00
LDX $05 ; CPU:$F7AE PRG:37AE A6 05
EnginePathLoop_F7B0:
LDA ($00),Y ; CPU:$F7B0 PRG:37B0 B1 00
STA ($02),Y ; CPU:$F7B2 PRG:37B2 91 02
INY ; CPU:$F7B4 PRG:37B4 C8
DEX ; CPU:$F7B5 PRG:37B5 CA
BNE EnginePathLoop_F7B0 ; CPU:$F7B6 PRG:37B6 D0 F8
LDA $06 ; CPU:$F7B8 PRG:37B8 A5 06
LDY #$02 ; CPU:$F7BA PRG:37BA A0 02
DEC $04 ; CPU:$F7BC PRG:37BC C6 04
BNE EnginePathLoop_F79D ; CPU:$F7BE PRG:37BE D0 DD
RTS ; CPU:$F7C0 PRG:37C0 60
;------------------------------------------------------------
; Audio driver code and embedded tables
; CPU $F7C1-$FC77
; PRG $37C1-$3C77
;
; Pass 1 recursively traced from AudioDriverCode ($F7C1).
; Direct branches, jumps, and subroutine calls are decoded.
; Bytes not reached by that trace remain explicit .byte data.
;------------------------------------------------------------
;------------------------------------------------------------
; AudioDriverCode
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
AudioDriverCode:
LDA #$FF ; CPU:$F7C1 PRG:37C1 A9 FF
STA JOY2 ; CPU:$F7C3 PRG:37C3 8D 17 40
JSR ProcessAudioStateRoutine_F898 ; CPU:$F7C6 PRG:37C6 20 98 F8
JSR ProcessAudioStateRoutine_FA2E ; CPU:$F7C9 PRG:37C9 20 2E FA
JSR ProcessAudioStateRoutine_FACF ; CPU:$F7CC PRG:37CC 20 CF FA
JSR ProcessAudioStateRoutine_FB22 ; CPU:$F7CF PRG:37CF 20 22 FB
LDA #$00 ; CPU:$F7D2 PRG:37D2 A9 00
STA AudioRequest4 ; CPU:$F7D4 PRG:37D4 85 FF
STA AudioRequest3 ; CPU:$F7D6 PRG:37D6 85 FE
STA AudioRequest1 ; CPU:$F7D8 PRG:37D8 85 FC
STA AudioRequest0 ; CPU:$F7DA PRG:37DA 85 FB
LDY $07FE ; CPU:$F7DC PRG:37DC AC FE 07
LDA AudioNoiseState ; CPU:$F7DF PRG:37DF A5 F3
AND #$1C ; CPU:$F7E1 PRG:37E1 29 1C
BEQ AudioPathOnZero_F7EC ; CPU:$F7E3 PRG:37E3 F0 07
INC $07FE ; CPU:$F7E5 PRG:37E5 EE FE 07
CPY #$50 ; CPU:$F7E8 PRG:37E8 C0 50
BCC AudioPathContinue_F7F2 ; CPU:$F7EA PRG:37EA 90 06
AudioPathOnZero_F7EC:
TYA ; CPU:$F7EC PRG:37EC 98
BEQ AudioPathContinue_F7F2 ; CPU:$F7ED PRG:37ED F0 03
DEC $07FE ; CPU:$F7EF PRG:37EF CE FE 07
AudioPathContinue_F7F2:
STY $4011 ; CPU:$F7F2 PRG:37F2 8C 11 40
RTS ; CPU:$F7F5 PRG:37F5 60
;------------------------------------------------------------
; UpdatePulse1Routine_F7F6
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdatePulse1Routine_F7F6:
STX SQ1_VOL ; CPU:$F7F6 PRG:37F6 8E 00 40
STY SQ1_SWEEP ; CPU:$F7F9 PRG:37F9 8C 01 40
RTS ; CPU:$F7FC PRG:37FC 60
;------------------------------------------------------------
; ProcessAudioStateRoutine_F7FD
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_F7FD:
JSR UpdatePulse1Routine_F7F6 ; CPU:$F7FD PRG:37FD 20 F6 F7
;------------------------------------------------------------
; ProcessAudioStateRoutine_F800
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_F800:
LDX #$00 ; CPU:$F800 PRG:3800 A2 00
UpdatePulse1Loop_F802:
TAY ; CPU:$F802 PRG:3802 A8
LDA $FF01,Y ; CPU:$F803 PRG:3803 B9 01 FF
BEQ AudioPathOnZero_F813 ; CPU:$F806 PRG:3806 F0 0B
STA SQ1_LO,X ; CPU:$F808 PRG:3808 9D 02 40
LDA $FF00,Y ; CPU:$F80B PRG:380B B9 00 FF
ORA #$08 ; CPU:$F80E PRG:380E 09 08
STA SQ1_HI,X ; CPU:$F810 PRG:3810 9D 03 40
AudioPathOnZero_F813:
RTS ; CPU:$F813 PRG:3813 60
;------------------------------------------------------------
; ProcessAudioStateRoutine_F814
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_F814:
LDX #$04 ; CPU:$F814 PRG:3814 A2 04
BNE UpdatePulse1Loop_F802 ; CPU:$F816 PRG:3816 D0 EA
;------------------------------------------------------------
; ProcessAudioStateRoutine_F818
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_F818:
LDX #$08 ; CPU:$F818 PRG:3818 A2 08
BNE UpdatePulse1Loop_F802 ; CPU:$F81A PRG:381A D0 E6
STY $7E85 ; CPU:$F81C PRG:381C 8C 85 7E
.byte $77, $70, $69, $62, $5B, $54, $4D, $46, $3F, $38, $31, $2A, $23, $04, $0E, $04 ; CPU:$F81F PRG:381F 0B
.byte $2E, $0E, $2E, $2C, $0E, $2C, $2A, $0E, $2A, $28, $2C, $28, $26, $91, $91, $51 ; CPU:$F82F PRG:382F 0B
.byte $92, $92, $92, $53, $93, $93, $93, $54, $94, $94, $54, $54, $95, $95, $95, $55 ; CPU:$F83F PRG:383F 0B
.byte $95, $95, $96, $56, $96, $96, $97, $57, $97, $97, $57, $57, $98, $98, $98, $58 ; CPU:$F84F PRG:384F 0B
.byte $98, $99, $99, $59, $9A, $9A, $9B, $5C, $9D, $9E, $5A, $5A ; CPU:$F85F PRG:385F 0B
AudioPathLoop_F86B:
STY AudioPulse1State ; CPU:$F86B PRG:386B 84 F0
LDA #$8C ; CPU:$F86D PRG:386D A9 8C
STA AudioPeriodOrEnvelope ; CPU:$F86F PRG:386F 85 F4
AudioPathLoop_F871:
LDA AudioPeriodOrEnvelope ; CPU:$F871 PRG:3871 A5 F4
LDY #$10 ; CPU:$F873 PRG:3873 A0 10
AudioPathLoop_F875:
CMP $F81B,Y ; CPU:$F875 PRG:3875 D9 1B F8
BNE AudioPathOnNonZero_F881 ; CPU:$F878 PRG:3878 D0 07
LDA $F82B,Y ; CPU:$F87A PRG:387A B9 2B F8
LDY #$7F ; CPU:$F87D PRG:387D A0 7F
BNE AudioPathOnNonZero_F890 ; CPU:$F87F PRG:387F D0 0F
AudioPathOnNonZero_F881:
DEY ; CPU:$F881 PRG:3881 88
BNE AudioPathLoop_F875 ; CPU:$F882 PRG:3882 D0 F1
CMP #$16 ; CPU:$F884 PRG:3884 C9 16
BCS AudioPathContinue_F895 ; CPU:$F886 PRG:3886 B0 0D
AND #$03 ; CPU:$F888 PRG:3888 29 03
BNE AudioPathContinue_F895 ; CPU:$F88A PRG:388A D0 09
LDY #$A3 ; CPU:$F88C PRG:388C A0 A3
LDA #$2A ; CPU:$F88E PRG:388E A9 2A
AudioPathOnNonZero_F890:
LDX #$9F ; CPU:$F890 PRG:3890 A2 9F
JSR ProcessAudioStateRoutine_F7FD ; CPU:$F892 PRG:3892 20 FD F7
AudioPathContinue_F895:
JMP ProcessAudioStateDispatch_F9CB ; CPU:$F895 PRG:3895 4C CB F9
;------------------------------------------------------------
; ProcessAudioStateRoutine_F898
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_F898:
LDY AudioRequest4 ; CPU:$F898 PRG:3898 A4 FF
LDA $F0 ; CPU:$F89A PRG:389A A5 F0
LSR AudioRequest4 ; CPU:$F89C PRG:389C 46 FF
BCS AudioPathLoop_F86B ; CPU:$F89E PRG:389E B0 CB
LSR A ; CPU:$F8A0 PRG:38A0 4A
BCS AudioPathLoop_F871 ; CPU:$F8A1 PRG:38A1 B0 CE
LSR AudioRequest4 ; CPU:$F8A3 PRG:38A3 46 FF
BCC UpdatePulse1OnNoCarry_F8F9 ; CPU:$F8A5 PRG:38A5 90 52
STY AudioPulse1State ; CPU:$F8A7 PRG:38A7 84 F0
LDA #$2F ; CPU:$F8A9 PRG:38A9 A9 2F
STA $07F4 ; CPU:$F8AB PRG:38AB 8D F4 07
LDX #$5F ; CPU:$F8AE PRG:38AE A2 5F
LDY #$93 ; CPU:$F8B0 PRG:38B0 A0 93
JSR UpdatePulse1Routine_F7F6 ; CPU:$F8B2 PRG:38B2 20 F6 F7
AudioPathLoop_F8B5:
LDA $07F4 ; CPU:$F8B5 PRG:38B5 AD F4 07
CMP #$C0 ; CPU:$F8B8 PRG:38B8 C9 C0
BCC AudioPathOnNoCarry_F8BD ; CPU:$F8BA PRG:38BA 90 01
LSR A ; CPU:$F8BC PRG:38BC 4A
AudioPathOnNoCarry_F8BD:
LSR A ; CPU:$F8BD PRG:38BD 4A
LSR A ; CPU:$F8BE PRG:38BE 4A
LSR A ; CPU:$F8BF PRG:38BF 4A
LSR A ; CPU:$F8C0 PRG:38C0 4A
CLC ; CPU:$F8C1 PRG:38C1 18
ADC $07F4 ; CPU:$F8C2 PRG:38C2 6D F4 07
BCC UpdatePulse1OnNoCarry_F8EA ; CPU:$F8C5 PRG:38C5 90 23
AudioPathLoop_F8C7:
JMP ProcessAudioStateDispatch_F9CF ; CPU:$F8C7 PRG:38C7 4C CF F9
AudioPathLoop_F8CA:
STY AudioPulse1State ; CPU:$F8CA PRG:38CA 84 F0
LDA #$FE ; CPU:$F8CC PRG:38CC A9 FE
STA $07F4 ; CPU:$F8CE PRG:38CE 8D F4 07
LDX #$5C ; CPU:$F8D1 PRG:38D1 A2 5C
LDY #$BA ; CPU:$F8D3 PRG:38D3 A0 BA
JSR UpdatePulse1Routine_F7F6 ; CPU:$F8D5 PRG:38D5 20 F6 F7
AudioPathLoop_F8D8:
LDA $07F4 ; CPU:$F8D8 PRG:38D8 AD F4 07
LSR A ; CPU:$F8DB PRG:38DB 4A
LSR A ; CPU:$F8DC PRG:38DC 4A
LSR A ; CPU:$F8DD PRG:38DD 4A
BNE AudioPathOnNonZero_F8E2 ; CPU:$F8DE PRG:38DE D0 02
LDA #$01 ; CPU:$F8E0 PRG:38E0 A9 01
AudioPathOnNonZero_F8E2:
EOR #$FF ; CPU:$F8E2 PRG:38E2 49 FF
SEC ; CPU:$F8E4 PRG:38E4 38
ADC $07F4 ; CPU:$F8E5 PRG:38E5 6D F4 07
BCC AudioPathLoop_F8C7 ; CPU:$F8E8 PRG:38E8 90 DD
UpdatePulse1OnNoCarry_F8EA:
STA $07F4 ; CPU:$F8EA PRG:38EA 8D F4 07
ROL A ; CPU:$F8ED PRG:38ED 2A
ROL A ; CPU:$F8EE PRG:38EE 2A
STA SQ1_LO ; CPU:$F8EF PRG:38EF 8D 02 40
ROL A ; CPU:$F8F2 PRG:38F2 2A
AND #$03 ; CPU:$F8F3 PRG:38F3 29 03
STA SQ1_HI ; CPU:$F8F5 PRG:38F5 8D 03 40
RTS ; CPU:$F8F8 PRG:38F8 60
UpdatePulse1OnNoCarry_F8F9:
LSR A ; CPU:$F8F9 PRG:38F9 4A
BCS AudioPathLoop_F8B5 ; CPU:$F8FA PRG:38FA B0 B9
LSR AudioRequest4 ; CPU:$F8FC PRG:38FC 46 FF
BCS AudioPathLoop_F8CA ; CPU:$F8FE PRG:38FE B0 CA
LSR A ; CPU:$F900 PRG:3900 4A
BCS AudioPathLoop_F8D8 ; CPU:$F901 PRG:3901 B0 D5
LSR AudioRequest4 ; CPU:$F903 PRG:3903 46 FF
BCC UpdatePulse1OnNoCarry_F95F ; CPU:$F905 PRG:3905 90 58
STY AudioPulse1State ; CPU:$F907 PRG:3907 84 F0
LDA #$3A ; CPU:$F909 PRG:3909 A9 3A
STA AudioPeriodOrEnvelope ; CPU:$F90B PRG:390B 85 F4
LDA #$6A ; CPU:$F90D PRG:390D A9 6A
STA $07F4 ; CPU:$F90F PRG:390F 8D F4 07
LDA #$82 ; CPU:$F912 PRG:3912 A9 82
STA SQ1_SWEEP ; CPU:$F914 PRG:3914 8D 01 40
UpdatePulse1Loop_F917:
LDA AudioPeriodOrEnvelope ; CPU:$F917 PRG:3917 A5 F4
CMP #$34 ; CPU:$F919 PRG:3919 C9 34
BCC UpdatePulse1OnNoCarry_F935 ; CPU:$F91B PRG:391B 90 18
BEQ UpdatePulse1OnZero_F92B ; CPU:$F91D PRG:391D F0 0C
ORA #$90 ; CPU:$F91F PRG:391F 09 90
STA SQ1_VOL ; CPU:$F921 PRG:3921 8D 00 40
LDA $07F4 ; CPU:$F924 PRG:3924 AD F4 07
SBC #$FC ; CPU:$F927 PRG:3927 E9 FC
BNE UpdatePulse1OnNonZero_F94D ; CPU:$F929 PRG:3929 D0 22
UpdatePulse1OnZero_F92B:
LDX #$FF ; CPU:$F92B PRG:392B A2 FF
STX $07F4 ; CPU:$F92D PRG:392D 8E F4 07
LDY #$8C ; CPU:$F930 PRG:3930 A0 8C
STY SQ1_SWEEP ; CPU:$F932 PRG:3932 8C 01 40
UpdatePulse1OnNoCarry_F935:
LSR A ; CPU:$F935 PRG:3935 4A
LSR A ; CPU:$F936 PRG:3936 4A
ORA #$90 ; CPU:$F937 PRG:3937 09 90
STA SQ1_VOL ; CPU:$F939 PRG:3939 8D 00 40
LDA AudioPeriodOrEnvelope ; CPU:$F93C PRG:393C A5 F4
AND #$03 ; CPU:$F93E PRG:393E 29 03
BNE AudioPathOnNonZero_F95C ; CPU:$F940 PRG:3940 D0 1A
LDA $07F4 ; CPU:$F942 PRG:3942 AD F4 07
LSR A ; CPU:$F945 PRG:3945 4A
LSR A ; CPU:$F946 PRG:3946 4A
LSR A ; CPU:$F947 PRG:3947 4A
LSR A ; CPU:$F948 PRG:3948 4A
SEC ; CPU:$F949 PRG:3949 38
SBC $07F4 ; CPU:$F94A PRG:394A ED F4 07
UpdatePulse1OnNonZero_F94D:
STA $07F4 ; CPU:$F94D PRG:394D 8D F4 07
ROL A ; CPU:$F950 PRG:3950 2A
ROL A ; CPU:$F951 PRG:3951 2A
ROL A ; CPU:$F952 PRG:3952 2A
STA SQ1_LO ; CPU:$F953 PRG:3953 8D 02 40
ROL A ; CPU:$F956 PRG:3956 2A
AND #$07 ; CPU:$F957 PRG:3957 29 07
STA SQ1_HI ; CPU:$F959 PRG:3959 8D 03 40
AudioPathOnNonZero_F95C:
JMP ProcessAudioStateDispatch_F9CB ; CPU:$F95C PRG:395C 4C CB F9
UpdatePulse1OnNoCarry_F95F:
LSR A ; CPU:$F95F PRG:395F 4A
BCS UpdatePulse1Loop_F917 ; CPU:$F960 PRG:3960 B0 B5
LSR $FF ; CPU:$F962 PRG:3962 46 FF
BCC AudioPathOnNoCarry_F9D9 ; CPU:$F964 PRG:3964 90 73
STY $F0 ; CPU:$F966 PRG:3966 84 F0
LDA #$30 ; CPU:$F968 PRG:3968 A9 30
STA AudioPeriodOrEnvelope ; CPU:$F96A PRG:396A 85 F4
LDA #$8A ; CPU:$F96C PRG:396C A9 8A
STA SQ1_SWEEP ; CPU:$F96E PRG:396E 8D 01 40
AudioPathLoop_F971:
LDY $F4 ; CPU:$F971 PRG:3971 A4 F4
LDA $F83A,Y ; CPU:$F973 PRG:3973 B9 3A F8
UpdatePulse1Dispatch_F976:
LDX $F83A,Y ; CPU:$F976 PRG:3976 BE 3A F8
STX SQ1_VOL ; CPU:$F979 PRG:3979 8E 00 40
BNE UpdatePulse1OnNonZero_F9C3 ; CPU:$F97C PRG:397C D0 45
AudioPathLoop_F97E:
STY $F0 ; CPU:$F97E PRG:397E 84 F0
LDA #$28 ; CPU:$F980 PRG:3980 A9 28
STA $F4 ; CPU:$F982 PRG:3982 85 F4
LDX #$82 ; CPU:$F984 PRG:3984 A2 82
LDY #$A7 ; CPU:$F986 PRG:3986 A0 A7
LDA #$30 ; CPU:$F988 PRG:3988 A9 30
JSR ProcessAudioStateRoutine_F7FD ; CPU:$F98A PRG:398A 20 FD F7
AudioPathLoop_F98D:
LDA $F4 ; CPU:$F98D PRG:398D A5 F4
CMP #$25 ; CPU:$F98F PRG:398F C9 25
BNE AudioPathOnNonZero_F999 ; CPU:$F991 PRG:3991 D0 06
LDX #$5F ; CPU:$F993 PRG:3993 A2 5F
LDY #$F6 ; CPU:$F995 PRG:3995 A0 F6
BNE AudioPathOnNonZero_F9A9 ; CPU:$F997 PRG:3997 D0 10
AudioPathOnNonZero_F999:
CMP #$20 ; CPU:$F999 PRG:3999 C9 20
BNE AudioPathOnNonZero_F9A1 ; CPU:$F99B PRG:399B D0 04
LDY #$BC ; CPU:$F99D PRG:399D A0 BC
BNE AudioPathOnNonZero_F9A7 ; CPU:$F99F PRG:399F D0 06
AudioPathOnNonZero_F9A1:
CMP #$10 ; CPU:$F9A1 PRG:39A1 C9 10
BNE ProcessAudioStateDispatch_F9CB ; CPU:$F9A3 PRG:39A3 D0 26
LDY #$9C ; CPU:$F9A5 PRG:39A5 A0 9C
AudioPathOnNonZero_F9A7:
LDX #$48 ; CPU:$F9A7 PRG:39A7 A2 48
AudioPathOnNonZero_F9A9:
JSR UpdatePulse1Routine_F7F6 ; CPU:$F9A9 PRG:39A9 20 F6 F7
BNE ProcessAudioStateDispatch_F9CB ; CPU:$F9AC PRG:39AC D0 1D
AudioPathLoop_F9AE:
STY $F0 ; CPU:$F9AE PRG:39AE 84 F0
LDA #$17 ; CPU:$F9B0 PRG:39B0 A9 17
STA $F4 ; CPU:$F9B2 PRG:39B2 85 F4
LDX #$5F ; CPU:$F9B4 PRG:39B4 A2 5F
LDY #$7F ; CPU:$F9B6 PRG:39B6 A0 7F
JSR UpdatePulse1Routine_F7F6 ; CPU:$F9B8 PRG:39B8 20 F6 F7
AudioPathLoop_F9BB:
LDA $F4 ; CPU:$F9BB PRG:39BB A5 F4
AND #$07 ; CPU:$F9BD PRG:39BD 29 07
TAY ; CPU:$F9BF PRG:39BF A8
LDA $FFC2,Y ; CPU:$F9C0 PRG:39C0 B9 C2 FF
UpdatePulse1OnNonZero_F9C3:
STA SQ1_LO ; CPU:$F9C3 PRG:39C3 8D 02 40
LDA #$08 ; CPU:$F9C6 PRG:39C6 A9 08
STA SQ1_HI ; CPU:$F9C8 PRG:39C8 8D 03 40
ProcessAudioStateDispatch_F9CB:
DEC $F4 ; CPU:$F9CB PRG:39CB C6 F4
BNE AudioPathOnNonZero_F9D8 ; CPU:$F9CD PRG:39CD D0 09
ProcessAudioStateDispatch_F9CF:
LDA #$00 ; CPU:$F9CF PRG:39CF A9 00
STA $F0 ; CPU:$F9D1 PRG:39D1 85 F0
;------------------------------------------------------------
; UpdatePulse1Routine_F9D3
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdatePulse1Routine_F9D3:
LDA #$90 ; CPU:$F9D3 PRG:39D3 A9 90
STA SQ1_VOL ; CPU:$F9D5 PRG:39D5 8D 00 40
AudioPathOnNonZero_F9D8:
RTS ; CPU:$F9D8 PRG:39D8 60
AudioPathOnNoCarry_F9D9:
LSR A ; CPU:$F9D9 PRG:39D9 4A
BCS AudioPathLoop_F971 ; CPU:$F9DA PRG:39DA B0 95
LSR $FF ; CPU:$F9DC PRG:39DC 46 FF
BCS AudioPathLoop_F97E ; CPU:$F9DE PRG:39DE B0 9E
LSR A ; CPU:$F9E0 PRG:39E0 4A
BCS AudioPathLoop_F98D ; CPU:$F9E1 PRG:39E1 B0 AA
LSR $FF ; CPU:$F9E3 PRG:39E3 46 FF
BCS AudioPathLoop_F9AE ; CPU:$F9E5 PRG:39E5 B0 C7
LSR A ; CPU:$F9E7 PRG:39E7 4A
BCS AudioPathLoop_F9BB ; CPU:$F9E8 PRG:39E8 B0 D1
LSR $FF ; CPU:$F9EA PRG:39EA 46 FF
BCS AudioPathOnCarry_F9F2 ; CPU:$F9EC PRG:39EC B0 04
LSR A ; CPU:$F9EE PRG:39EE 4A
BCS AudioPathOnCarry_F9FC ; CPU:$F9EF PRG:39EF B0 0B
RTS ; CPU:$F9F1 PRG:39F1 60
AudioPathOnCarry_F9F2:
STY $F0 ; CPU:$F9F2 PRG:39F2 84 F0
LDA #$20 ; CPU:$F9F4 PRG:39F4 A9 20
STA $F4 ; CPU:$F9F6 PRG:39F6 85 F4
LDA #$8A ; CPU:$F9F8 PRG:39F8 A9 8A
BNE UpdatePulse1OnNonZero_FA04 ; CPU:$F9FA PRG:39FA D0 08
AudioPathOnCarry_F9FC:
LDY $F4 ; CPU:$F9FC PRG:39FC A4 F4
CPY #$19 ; CPU:$F9FE PRG:39FE C0 19
BNE AudioPathOnNonZero_FA07 ; CPU:$FA00 PRG:3A00 D0 05
LDA #$82 ; CPU:$FA02 PRG:3A02 A9 82
UpdatePulse1OnNonZero_FA04:
STA SQ1_SWEEP ; CPU:$FA04 PRG:3A04 8D 01 40
AudioPathOnNonZero_FA07:
LDA #$47 ; CPU:$FA07 PRG:3A07 A9 47
JMP UpdatePulse1Dispatch_F976 ; CPU:$FA09 PRG:3A09 4C 76 F9
;------------------------------------------------------------
; UpdatePulse2Routine_FA0C
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
UpdatePulse2Routine_FA0C:
STY $F1 ; CPU:$FA0C PRG:3A0C 84 F1
STX $07FF ; CPU:$FA0E PRG:3A0E 8E FF 07
LDA #$9F ; CPU:$FA11 PRG:3A11 A9 9F
STA SQ2_VOL ; CPU:$FA13 PRG:3A13 8D 04 40
LDA #$7F ; CPU:$FA16 PRG:3A16 A9 7F
STA SQ2_SWEEP ; CPU:$FA18 PRG:3A18 8D 05 40
LDA #$08 ; CPU:$FA1B PRG:3A1B A9 08
STA SQ2_HI ; CPU:$FA1D PRG:3A1D 8D 07 40
RTS ; CPU:$FA20 PRG:3A20 60
AudioPathLoop_FA21:
LDX #$08 ; CPU:$FA21 PRG:3A21 A2 08
JSR UpdatePulse2Routine_FA0C ; CPU:$FA23 PRG:3A23 20 0C FA
AudioPathLoop_FA26:
LDY $07FF ; CPU:$FA26 PRG:3A26 AC FF 07
LDA $FFB9,Y ; CPU:$FA29 PRG:3A29 B9 B9 FF
BNE UpdatePulse2OnNonZero_FA4E ; CPU:$FA2C PRG:3A2C D0 20
;------------------------------------------------------------
; ProcessAudioStateRoutine_FA2E
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_FA2E:
LDY $FE ; CPU:$FA2E PRG:3A2E A4 FE
LDA $F1 ; CPU:$FA30 PRG:3A30 A5 F1
LSR $FE ; CPU:$FA32 PRG:3A32 46 FE
BCS AudioPathLoop_FA21 ; CPU:$FA34 PRG:3A34 B0 EB
LSR A ; CPU:$FA36 PRG:3A36 4A
BCS AudioPathLoop_FA26 ; CPU:$FA37 PRG:3A37 B0 ED
LSR $FE ; CPU:$FA39 PRG:3A39 46 FE
BCS AudioPathOnCarry_FA41 ; CPU:$FA3B PRG:3A3B B0 04
LSR A ; CPU:$FA3D PRG:3A3D 4A
BCS AudioPathOnCarry_FA46 ; CPU:$FA3E PRG:3A3E B0 06
RTS ; CPU:$FA40 PRG:3A40 60
AudioPathOnCarry_FA41:
LDX #$23 ; CPU:$FA41 PRG:3A41 A2 23
JSR UpdatePulse2Routine_FA0C ; CPU:$FA43 PRG:3A43 20 0C FA
AudioPathOnCarry_FA46:
LDA $07FF ; CPU:$FA46 PRG:3A46 AD FF 07
LSR A ; CPU:$FA49 PRG:3A49 4A
TAY ; CPU:$FA4A PRG:3A4A A8
LDA $FA5B,Y ; CPU:$FA4B PRG:3A4B B9 5B FA
UpdatePulse2OnNonZero_FA4E:
STA SQ2_LO ; CPU:$FA4E PRG:3A4E 8D 06 40
DEC $07FF ; CPU:$FA51 PRG:3A51 CE FF 07
BNE AudioPathOnNonZero_FA5A ; CPU:$FA54 PRG:3A54 D0 04
LDA #$00 ; CPU:$FA56 PRG:3A56 A9 00
STA $F1 ; CPU:$FA58 PRG:3A58 85 F1
AudioPathOnNonZero_FA5A:
RTS ; CPU:$FA5A PRG:3A5A 60
.byte $00, $54, $00, $5F, $00, $6A, $00, $71, $00, $6A, $00, $71, $00, $7E, $00, $86 ; CPU:$FA5B PRG:3A5B 0B
.byte $00, $7E, $10, $12, $12, $12, $15, $15, $15, $13, $13, $13, $13, $16, $16, $16 ; CPU:$FA6B PRG:3A6B 0B
.byte $16, $16, $14, $14, $14, $14, $17, $17, $17, $17, $15, $15, $15, $15, $18, $19 ; CPU:$FA7B PRG:3A7B 0B
.byte $19, $1A, $1A, $1A, $1B, $1B, $1C, $1D, $1E, $1F, $13, $15, $16, $16, $18, $18 ; CPU:$FA8B PRG:3A8B 0B
.byte $1A, $1A, $07, $05, $05, $05, $05, $05, $06, $06, $06, $04, $04, $04, $04, $05 ; CPU:$FA9B PRG:3A9B 0B
.byte $05, $05, $09, $09, $0A, $0A, $07, $07, $08, $08 ; CPU:$FAAB PRG:3AAB 0B
AudioPathLoop_FAB5:
STY $F2 ; CPU:$FAB5 PRG:3AB5 84 F2
LDA #$30 ; CPU:$FAB7 PRG:3AB7 A9 30
STA $07FB ; CPU:$FAB9 PRG:3AB9 8D FB 07
UpdateNoiseLoop_FABC:
LDY $07FB ; CPU:$FABC PRG:3ABC AC FB 07
LDA $FA6C,Y ; CPU:$FABF PRG:3ABF B9 6C FA
STA NOISE_VOL ; CPU:$FAC2 PRG:3AC2 8D 0C 40
LDA $07FB ; CPU:$FAC5 PRG:3AC5 AD FB 07
LSR A ; CPU:$FAC8 PRG:3AC8 4A
TAY ; CPU:$FAC9 PRG:3AC9 A8
LDA $FA9C,Y ; CPU:$FACA PRG:3ACA B9 9C FA
BNE UpdateNoiseOnNonZero_FB10 ; CPU:$FACD PRG:3ACD D0 41
;------------------------------------------------------------
; ProcessAudioStateRoutine_FACF
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_FACF:
LDY $FC ; CPU:$FACF PRG:3ACF A4 FC
LDA $F2 ; CPU:$FAD1 PRG:3AD1 A5 F2
LSR $FC ; CPU:$FAD3 PRG:3AD3 46 FC
BCS AudioPathLoop_FAB5 ; CPU:$FAD5 PRG:3AD5 B0 DE
LSR A ; CPU:$FAD7 PRG:3AD7 4A
BCS UpdateNoiseLoop_FABC ; CPU:$FAD8 PRG:3AD8 B0 E2
LSR $FC ; CPU:$FADA PRG:3ADA 46 FC
BCS AudioPathOnCarry_FAE9 ; CPU:$FADC PRG:3ADC B0 0B
LSR A ; CPU:$FADE PRG:3ADE 4A
BCS UpdateNoiseOnCarry_FAF0 ; CPU:$FADF PRG:3ADF B0 0F
LSR $FC ; CPU:$FAE1 PRG:3AE1 46 FC
BCS AudioPathOnCarry_FAFE ; CPU:$FAE3 PRG:3AE3 B0 19
LSR A ; CPU:$FAE5 PRG:3AE5 4A
BCS UpdateNoiseOnCarry_FB05 ; CPU:$FAE6 PRG:3AE6 B0 1D
RTS ; CPU:$FAE8 PRG:3AE8 60
AudioPathOnCarry_FAE9:
STY $F2 ; CPU:$FAE9 PRG:3AE9 84 F2
LDA #$20 ; CPU:$FAEB PRG:3AEB A9 20
STA $07FB ; CPU:$FAED PRG:3AED 8D FB 07
UpdateNoiseOnCarry_FAF0:
LDY $07FB ; CPU:$FAF0 PRG:3AF0 AC FB 07
LDA $FF50,Y ; CPU:$FAF3 PRG:3AF3 B9 50 FF
STA NOISE_VOL ; CPU:$FAF6 PRG:3AF6 8D 0C 40
LDA $FF70,Y ; CPU:$FAF9 PRG:3AF9 B9 70 FF
BNE UpdateNoiseOnNonZero_FB10 ; CPU:$FAFC PRG:3AFC D0 12
AudioPathOnCarry_FAFE:
STY $F2 ; CPU:$FAFE PRG:3AFE 84 F2
LDA #$09 ; CPU:$FB00 PRG:3B00 A9 09
STA $07FB ; CPU:$FB02 PRG:3B02 8D FB 07
UpdateNoiseOnCarry_FB05:
LDY $07FB ; CPU:$FB05 PRG:3B05 AC FB 07
LDA $FF90,Y ; CPU:$FB08 PRG:3B08 B9 90 FF
STA NOISE_VOL ; CPU:$FB0B PRG:3B0B 8D 0C 40
LDA #$04 ; CPU:$FB0E PRG:3B0E A9 04
UpdateNoiseOnNonZero_FB10:
STA NOISE_LO ; CPU:$FB10 PRG:3B10 8D 0E 40
LDA #$08 ; CPU:$FB13 PRG:3B13 A9 08
STA NOISE_HI ; CPU:$FB15 PRG:3B15 8D 0F 40
DEC $07FB ; CPU:$FB18 PRG:3B18 CE FB 07
BNE AudioPathOnNonZero_FB21 ; CPU:$FB1B PRG:3B1B D0 04
LDA #$00 ; CPU:$FB1D PRG:3B1D A9 00
STA $F2 ; CPU:$FB1F PRG:3B1F 85 F2
AudioPathOnNonZero_FB21:
RTS ; CPU:$FB21 PRG:3B21 60
;------------------------------------------------------------
; ProcessAudioStateRoutine_FB22
;
; Global:
; First-pass audio-driver entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the audio naming pass.
;
; Parameters:
; Audio workspace and APU register state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_FB22:
LDA $FB ; CPU:$FB22 PRG:3B22 A5 FB
BNE AudioPathLoop_FB2B ; CPU:$FB24 PRG:3B24 D0 05
LDA $F3 ; CPU:$FB26 PRG:3B26 A5 F3
BNE AudioPathOnNonZero_FB6E ; CPU:$FB28 PRG:3B28 D0 44
RTS ; CPU:$FB2A PRG:3B2A 60
AudioPathLoop_FB2B:
STA $F3 ; CPU:$FB2B PRG:3B2B 85 F3
LDY #$00 ; CPU:$FB2D PRG:3B2D A0 00
STY $F8 ; CPU:$FB2F PRG:3B2F 84 F8
UpdatePulse1Loop_FB31:
INY ; CPU:$FB31 PRG:3B31 C8
LSR A ; CPU:$FB32 PRG:3B32 4A
BCC UpdatePulse1Loop_FB31 ; CPU:$FB33 PRG:3B33 90 FC
LDA $FC64,Y ; CPU:$FB35 PRG:3B35 B9 64 FC
TAY ; CPU:$FB38 PRG:3B38 A8
LDA $FC65,Y ; CPU:$FB39 PRG:3B39 B9 65 FC
STA $F5 ; CPU:$FB3C PRG:3B3C 85 F5
LDA $FC66,Y ; CPU:$FB3E PRG:3B3E B9 66 FC
STA $F6 ; CPU:$FB41 PRG:3B41 85 F6
LDA $FC67,Y ; CPU:$FB43 PRG:3B43 B9 67 FC
STA $F7 ; CPU:$FB46 PRG:3B46 85 F7
LDA $FC68,Y ; CPU:$FB48 PRG:3B48 B9 68 FC
STA $FA ; CPU:$FB4B PRG:3B4B 85 FA
LDA $FC69,Y ; CPU:$FB4D PRG:3B4D B9 69 FC
STA $F9 ; CPU:$FB50 PRG:3B50 85 F9
LDA $FC6A,Y ; CPU:$FB52 PRG:3B52 B9 6A FC
STA $07F2 ; CPU:$FB55 PRG:3B55 8D F2 07
LDA #$01 ; CPU:$FB58 PRG:3B58 A9 01
STA $07EE ; CPU:$FB5A PRG:3B5A 8D EE 07
STA $07F0 ; CPU:$FB5D PRG:3B5D 8D F0 07
STA $07F1 ; CPU:$FB60 PRG:3B60 8D F1 07
STA $07F3 ; CPU:$FB63 PRG:3B63 8D F3 07
LDA #$7F ; CPU:$FB66 PRG:3B66 A9 7F
STA SQ1_SWEEP ; CPU:$FB68 PRG:3B68 8D 01 40
STA SQ2_SWEEP ; CPU:$FB6B PRG:3B6B 8D 05 40
AudioPathOnNonZero_FB6E:
DEC $07EE ; CPU:$FB6E PRG:3B6E CE EE 07
BNE AudioPathOnNonZero_FBBD ; CPU:$FB71 PRG:3B71 D0 4A
AudioPathLoop_FB73:
LDY $F8 ; CPU:$FB73 PRG:3B73 A4 F8
INC $F8 ; CPU:$FB75 PRG:3B75 E6 F8
LDA ($F6),Y ; CPU:$FB77 PRG:3B77 B1 F6
BEQ UpdatePulse2OnZero_FB84 ; CPU:$FB79 PRG:3B79 F0 09
CMP #$01 ; CPU:$FB7B PRG:3B7B C9 01
BNE AudioPathOnNonZero_FB95 ; CPU:$FB7D PRG:3B7D D0 16
LDA $10 ; CPU:$FB7F PRG:3B7F A5 10
LSR A ; CPU:$FB81 PRG:3B81 4A
BCC AudioPathLoop_FB73 ; CPU:$FB82 PRG:3B82 90 EF
UpdatePulse2OnZero_FB84:
LDA $F3 ; CPU:$FB84 PRG:3B84 A5 F3
AND #$1C ; CPU:$FB86 PRG:3B86 29 1C
BNE AudioPathLoop_FB2B ; CPU:$FB88 PRG:3B88 D0 A1
LDA #$00 ; CPU:$FB8A PRG:3B8A A9 00
STA $F3 ; CPU:$FB8C PRG:3B8C 85 F3
JSR UpdatePulse1Routine_F9D3 ; CPU:$FB8E PRG:3B8E 20 D3 F9
STA SQ2_VOL ; CPU:$FB91 PRG:3B91 8D 04 40
RTS ; CPU:$FB94 PRG:3B94 60
AudioPathOnNonZero_FB95:
JSR ProcessAudioStateRoutine_FF41 ; CPU:$FB95 PRG:3B95 20 41 FF
STA $07EE ; CPU:$FB98 PRG:3B98 8D EE 07
TXA ; CPU:$FB9B PRG:3B9B 8A
AND #$3E ; CPU:$FB9C PRG:3B9C 29 3E
JSR ProcessAudioStateRoutine_F814 ; CPU:$FB9E PRG:3B9E 20 14 F8
BEQ AudioPathOnZero_FBAA ; CPU:$FBA1 PRG:3BA1 F0 07
LDY #$1F ; CPU:$FBA3 PRG:3BA3 A0 1F
STY $07EF ; CPU:$FBA5 PRG:3BA5 8C EF 07
BNE AudioPathOnNonZero_FBAF ; CPU:$FBA8 PRG:3BA8 D0 05
AudioPathOnZero_FBAA:
LDY #$00 ; CPU:$FBAA PRG:3BAA A0 00
STY $07EF ; CPU:$FBAC PRG:3BAC 8C EF 07
AudioPathOnNonZero_FBAF:
LDX #$84 ; CPU:$FBAF PRG:3BAF A2 84
LDA $07EE ; CPU:$FBB1 PRG:3BB1 AD EE 07
CMP #$10 ; CPU:$FBB4 PRG:3BB4 C9 10
BCS UpdatePulse2OnCarry_FBBA ; CPU:$FBB6 PRG:3BB6 B0 02
LDX #$82 ; CPU:$FBB8 PRG:3BB8 A2 82
UpdatePulse2OnCarry_FBBA:
STX SQ2_VOL ; CPU:$FBBA PRG:3BBA 8E 04 40
AudioPathOnNonZero_FBBD:
LDA $F3 ; CPU:$FBBD PRG:3BBD A5 F3
AND #$1C ; CPU:$FBBF PRG:3BBF 29 1C
BEQ AudioPathOnZero_FBD1 ; CPU:$FBC1 PRG:3BC1 F0 0E
LDY $07EF ; CPU:$FBC3 PRG:3BC3 AC EF 07
BEQ UpdatePulse2OnZero_FBCB ; CPU:$FBC6 PRG:3BC6 F0 03
DEC $07EF ; CPU:$FBC8 PRG:3BC8 CE EF 07
UpdatePulse2OnZero_FBCB:
LDA $FF9A,Y ; CPU:$FBCB PRG:3BCB B9 9A FF
STA SQ2_VOL ; CPU:$FBCE PRG:3BCE 8D 04 40
AudioPathOnZero_FBD1:
LDY $F9 ; CPU:$FBD1 PRG:3BD1 A4 F9
BEQ AudioPathContinue_FC04 ; CPU:$FBD3 PRG:3BD3 F0 2F
DEC $07F0 ; CPU:$FBD5 PRG:3BD5 CE F0 07
BNE AudioPathContinue_FC04 ; CPU:$FBD8 PRG:3BD8 D0 2A
UpdatePulse1Loop_FBDA:
LDY $F9 ; CPU:$FBDA PRG:3BDA A4 F9
INC $F9 ; CPU:$FBDC PRG:3BDC E6 F9
LDA ($F6),Y ; CPU:$FBDE PRG:3BDE B1 F6
BNE AudioPathOnNonZero_FBED ; CPU:$FBE0 PRG:3BE0 D0 0B
LDY $F9 ; CPU:$FBE2 PRG:3BE2 A4 F9
INC $F9 ; CPU:$FBE4 PRG:3BE4 E6 F9
LDA ($F6),Y ; CPU:$FBE6 PRG:3BE6 B1 F6
STA SQ1_SWEEP ; CPU:$FBE8 PRG:3BE8 8D 01 40
BNE UpdatePulse1Loop_FBDA ; CPU:$FBEB PRG:3BEB D0 ED
AudioPathOnNonZero_FBED:
JSR ProcessAudioStateRoutine_FF41 ; CPU:$FBED PRG:3BED 20 41 FF
STA $07F0 ; CPU:$FBF0 PRG:3BF0 8D F0 07
TXA ; CPU:$FBF3 PRG:3BF3 8A
AND #$3E ; CPU:$FBF4 PRG:3BF4 29 3E
JSR ProcessAudioStateRoutine_F800 ; CPU:$FBF6 PRG:3BF6 20 00 F8
BNE AudioPathOnNonZero_FBFF ; CPU:$FBF9 PRG:3BF9 D0 04
LDX #$10 ; CPU:$FBFB PRG:3BFB A2 10
BNE UpdatePulse1OnNonZero_FC01 ; CPU:$FBFD PRG:3BFD D0 02
AudioPathOnNonZero_FBFF:
LDX #$06 ; CPU:$FBFF PRG:3BFF A2 06
UpdatePulse1OnNonZero_FC01:
STX SQ1_VOL ; CPU:$FC01 PRG:3C01 8E 00 40
AudioPathContinue_FC04:
LDY $FA ; CPU:$FC04 PRG:3C04 A4 FA
BEQ AudioPathContinue_FC2B ; CPU:$FC06 PRG:3C06 F0 23
DEC $07F1 ; CPU:$FC08 PRG:3C08 CE F1 07
BNE AudioPathContinue_FC2B ; CPU:$FC0B PRG:3C0B D0 1E
INC $FA ; CPU:$FC0D PRG:3C0D E6 FA
LDA ($F6),Y ; CPU:$FC0F PRG:3C0F B1 F6
JSR ProcessAudioStateRoutine_FF41 ; CPU:$FC11 PRG:3C11 20 41 FF
STA $07F1 ; CPU:$FC14 PRG:3C14 8D F1 07
CLC ; CPU:$FC17 PRG:3C17 18
ADC #$FE ; CPU:$FC18 PRG:3C18 69 FE
CMP #$0E ; CPU:$FC1A PRG:3C1A C9 0E
BCC UpdateTriangleOnNoCarry_FC20 ; CPU:$FC1C PRG:3C1C 90 02
LDA #$0E ; CPU:$FC1E PRG:3C1E A9 0E
UpdateTriangleOnNoCarry_FC20:
ASL A ; CPU:$FC20 PRG:3C20 0A
ASL A ; CPU:$FC21 PRG:3C21 0A
STA TRI_LINEAR ; CPU:$FC22 PRG:3C22 8D 08 40
TXA ; CPU:$FC25 PRG:3C25 8A
AND #$3E ; CPU:$FC26 PRG:3C26 29 3E
JSR ProcessAudioStateRoutine_F818 ; CPU:$FC28 PRG:3C28 20 18 F8
AudioPathContinue_FC2B:
LDA $F3 ; CPU:$FC2B PRG:3C2B A5 F3
AND #$43 ; CPU:$FC2D PRG:3C2D 29 43
BEQ AudioPathContinue_FC64 ; CPU:$FC2F PRG:3C2F F0 33
DEC $07F3 ; CPU:$FC31 PRG:3C31 CE F3 07
BNE AudioPathContinue_FC64 ; CPU:$FC34 PRG:3C34 D0 2E
LDY $07F2 ; CPU:$FC36 PRG:3C36 AC F2 07
INC $07F2 ; CPU:$FC39 PRG:3C39 EE F2 07
LDA ($F6),Y ; CPU:$FC3C PRG:3C3C B1 F6
JSR ProcessAudioStateRoutine_FF41 ; CPU:$FC3E PRG:3C3E 20 41 FF
STA $07F3 ; CPU:$FC41 PRG:3C41 8D F3 07
TXA ; CPU:$FC44 PRG:3C44 8A
AND #$3E ; CPU:$FC45 PRG:3C45 29 3E
BEQ AudioPathContinue_FC64 ; CPU:$FC47 PRG:3C47 F0 1B
AND #$20 ; CPU:$FC49 PRG:3C49 29 20
BNE AudioPathOnNonZero_FC55 ; CPU:$FC4B PRG:3C4B D0 08
LDA #$02 ; CPU:$FC4D PRG:3C4D A9 02
LDX #$00 ; CPU:$FC4F PRG:3C4F A2 00
LDY #$28 ; CPU:$FC51 PRG:3C51 A0 28
BNE UpdateNoiseOnNonZero_FC5B ; CPU:$FC53 PRG:3C53 D0 06
AudioPathOnNonZero_FC55:
LDA #$00 ; CPU:$FC55 PRG:3C55 A9 00
LDX #$02 ; CPU:$FC57 PRG:3C57 A2 02
LDY #$08 ; CPU:$FC59 PRG:3C59 A0 08
UpdateNoiseOnNonZero_FC5B:
STA NOISE_VOL ; CPU:$FC5B PRG:3C5B 8D 0C 40
STX NOISE_LO ; CPU:$FC5E PRG:3C5E 8E 0E 40
STY NOISE_HI ; CPU:$FC61 PRG:3C61 8C 0F 40
AudioPathContinue_FC64:
RTS ; CPU:$FC64 PRG:3C64 60
.byte $0C, $16, $20, $1C, $24, $12, $28, $08, $07, $F7, $FF, $00, $00, $93, $FC, $3F ; CPU:$FC65 PRG:3C65 0B
.byte $1C, $60, $07 ; CPU:$FC75 PRG:3C75 0B
;------------------------------------------------------------
; Audio data with embedded sequence helper code
; CPU $FC78-$FFF9
; PRG $3C78-$3FF9
;
; Pass 1 recursively traced from verified entry roots in this region.
; Direct branches, jumps, and subroutine calls are decoded.
; Bytes not reached by that trace remain explicit .byte data.
;------------------------------------------------------------
AudioDataTables:
.byte $FB, $FE, $00, $00, $05, $FD, $3E, $1B, $4E, $07, $69, $FD, $3D, $00, $CA, $FD ; CPU:$FC78 PRG:3C78 0B
.byte $6E, $00, $AD, $FE, $27, $00, $CA, $FF, $15, $09, $1F, $42, $8C, $44, $4C, $84 ; CPU:$FC88 PRG:3C88 0B
.byte $44, $27, $42, $8C, $44, $4C, $84, $44, $2B, $43, $6A, $84, $AA, $92, $52, $02 ; CPU:$FC98 PRG:3C98 0B
.byte $16, $4A, $02, $88, $02, $05, $00, $42, $84, $66, $4C, $84, $84, $60, $66, $44 ; CPU:$FCA8 PRG:3CA8 0B
.byte $4C, $88, $84, $AA, $64, $6A, $A4, $A4, $64, $6A, $44, $4C, $88, $C4, $62, $AA ; CPU:$FCB8 PRG:3CB8 0B
.byte $A2, $88, $48, $02, $08, $62, $02, $A2, $02, $21, $5B, $5A, $5B, $9A, $5A, $60 ; CPU:$FCC8 PRG:3CC8 0B
.byte $66, $44, $AE, $6A, $65, $64, $65, $A4, $5C, $64, $6A, $44, $AE, $6A, $63, $62 ; CPU:$FCD8 PRG:3CD8 0B
.byte $A2, $A2, $AE, $6E, $02, $2E, $6A, $02, $AA, $02, $27, $80, $E0, $E0, $E0, $E0 ; CPU:$FCE8 PRG:3CE8 0B
.byte $E0, $E0, $E0, $E0, $E0, $E0, $E0, $A0, $10, $10, $10, $10, $11, $42, $A6, $60 ; CPU:$FCF8 PRG:3CF8 0B
.byte $AA, $AA, $6C, $AA, $A6, $5E, $60, $A6, $84, $6A, $88, $88, $AE, $52, $02, $10 ; CPU:$FD08 PRG:3D08 0B
.byte $4E, $02, $88, $02, $45, $45, $C4, $00, $42, $A0, $5A, $A0, $A0, $66, $A2, $A0 ; CPU:$FD18 PRG:3D18 0B
.byte $5A, $5A, $9A, $AA, $62, $AA, $AA, $A6, $48, $02, $08, $48, $02, $AE, $02, $00 ; CPU:$FD28 PRG:3D28 0B
.byte $95, $0C, $8C, $02, $2E, $AE, $02, $22, $A2, $02, $42, $9A, $A0, $A6, $AA, $AC ; CPU:$FD38 PRG:3D38 0B
.byte $AA, $A6, $A0, $A2, $AA, $84, $AA, $09, $53, $4F, $CC, $80, $E0, $E0, $E0, $E0 ; CPU:$FD48 PRG:3D48 0B
.byte $E0, $A0, $11, $10, $10, $10, $10, $42, $10, $10, $10, $10, $42, $10, $10, $10 ; CPU:$FD58 PRG:3D58 0B
.byte $11, $66, $0C, $04, $26, $0C, $04, $26, $0C, $04, $26, $0C, $04, $26, $0C, $04 ; CPU:$FD68 PRG:3D68 0B
.byte $6A, $10, $08, $2A, $10, $08, $2A, $10, $08, $2A, $10, $08, $2A, $10, $08, $6A ; CPU:$FD78 PRG:3D78 0B
.byte $0E, $04, $2A, $0E, $04, $2A, $0E, $04, $2A, $0E, $04, $2A, $0E, $04, $6E, $12 ; CPU:$FD88 PRG:3D88 0B
.byte $08, $2E, $12, $08, $2E, $12, $12, $0E, $0E, $0C, $0C, $08, $08, $00, $5A, $60 ; CPU:$FD98 PRG:3D98 0B
.byte $66, $6A, $44, $6A, $66, $60, $5C, $64, $6A, $6E, $48, $6E, $6A, $64, $62, $6A ; CPU:$FDA8 PRG:3DA8 0B
.byte $44, $48, $4E, $48, $44, $6A, $66, $6E, $48, $4E, $18, $18, $16, $16, $12, $12 ; CPU:$FDB8 PRG:3DB8 0B
.byte $0E, $0E, $60, $66, $88, $44, $A6, $60, $62, $64, $66, $6A, $A2, $6A, $8C, $4A ; CPU:$FDC8 PRG:3DC8 0B
.byte $89, $44, $6A, $8E, $4C, $88, $6E, $92, $50, $4E, $4C, $60, $62, $64, $66, $6A ; CPU:$FDD8 PRG:3DD8 0B
.byte $A7, $60, $66, $8C, $48, $84, $66, $A0, $62, $66, $6A, $68, $6A, $6E, $44, $48 ; CPU:$FDE8 PRG:3DE8 0B
.byte $D6, $42, $44, $44, $6E, $92, $4C, $44, $44, $6A, $8E, $4C, $48, $66, $68, $6A ; CPU:$FDF8 PRG:3DF8 0B
.byte $6C, $6E, $48, $85, $01, $44, $6E, $44, $6A, $6E, $44, $44, $6E, $44, $60, $62 ; CPU:$FE08 PRG:3E08 0B
.byte $66, $6A, $68, $6A, $64, $66, $6A, $AE, $44, $49, $44, $6A, $6A, $44, $6A, $6A ; CPU:$FE18 PRG:3E18 0B
.byte $44, $66, $66, $44, $66, $66, $6A, $64, $66, $6A, $6E, $44, $8C, $4A, $49, $00 ; CPU:$FE28 PRG:3E28 0B
.byte $9A, $66, $A0, $66, $9A, $66, $A0, $66, $5C, $48, $46, $44, $6A, $62, $9C, $6A ; CPU:$FE38 PRG:3E38 0B
.byte $A2, $6A, $A2, $44, $AA, $44, $A6, $48, $AE, $48, $9A, $66, $A0, $66, $9A, $66 ; CPU:$FE48 PRG:3E48 0B
.byte $A0, $66, $9A, $66, $A0, $66, $9A, $66, $A0, $66, $9C, $6A, $A2, $6A, $9C, $6A ; CPU:$FE58 PRG:3E58 0B
.byte $A2, $6A, $66, $6E, $48, $66, $44, $4C, $62, $6A, $48, $62, $6A, $48, $66, $64 ; CPU:$FE68 PRG:3E68 0B
.byte $66, $68, $6A, $6E, $44, $66, $62, $61, $62, $44, $6A, $62, $44, $6A, $60, $44 ; CPU:$FE78 PRG:3E78 0B
.byte $66, $60, $44, $66, $5C, $6A, $64, $5C, $6A, $64, $66, $48, $6E, $66, $48, $6E ; CPU:$FE88 PRG:3E88 0B
.byte $62, $44, $6A, $62, $44, $6A, $60, $44, $66, $60, $44, $66, $5C, $6A, $64, $5C ; CPU:$FE98 PRG:3E98 0B
.byte $6A, $64, $A2, $62, $27, $45, $67, $84, $AA, $60, $AE, $60, $84, $88, $62, $AA ; CPU:$FEA8 PRG:3EA8 0B
.byte $48, $84, $AE, $66, $84, $66, $88, $4D, $84, $44, $8C, $57, $8C, $4A, $48, $44 ; CPU:$FEB8 PRG:3EB8 0B
.byte $8E, $6A, $8C, $6A, $8E, $8C, $4A, $88, $6E, $44, $48, $00, $5B, $A0, $66, $44 ; CPU:$FEC8 PRG:3EC8 0B
.byte $6E, $6B, $84, $4C, $56, $54, $5D, $A2, $6A, $48, $6A, $67, $AE, $48, $8E, $5B ; CPU:$FED8 PRG:3ED8 0B
.byte $A0, $66, $44, $6E, $6B, $84, $4C, $56, $4C, $5D, $A2, $6A, $48, $44, $67, $AE ; CPU:$FEE8 PRG:3EE8 0B
.byte $48, $4C, $4E, $26, $2E, $08, $13, $00, $03, $57, $00, $00, $00, $D4, $00, $C8 ; CPU:$FEF8 PRG:3EF8 0B
.byte $00, $BD, $00, $B2, $00, $A8, $00, $9F, $00, $96, $00, $8D, $00, $85, $00, $7E ; CPU:$FF08 PRG:3F08 0B
.byte $00, $70, $01, $AB, $01, $7C, $01, $67, $01, $52, $01, $3F, $01, $2D, $01, $1C ; CPU:$FF18 PRG:3F18 0B
.byte $01, $0C, $00, $FD, $00, $EE, $00, $E1, $01, $FC, $01, $C4, $04, $08, $10, $20 ; CPU:$FF28 PRG:3F28 0B
.byte $40, $18, $30, $05, $0A, $14, $28, $50, $1E ; CPU:$FF38 PRG:3F38 0B
;------------------------------------------------------------
; ProcessAudioStateRoutine_FF41
;
; Global:
; First-pass AudioDataTables entry point or directly called helper.
;
; Local:
; Exact semantic role is deferred to the semantic naming pass.
;
; Parameters:
; Zero-page pointers, object state, or PPU state; exact contract unresolved.
;
; Returns:
; Register and flag effects are defined by the decoded instructions.
;------------------------------------------------------------
ProcessAudioStateRoutine_FF41:
TAX ; CPU:$FF41 PRG:3F41 AA
ROR A ; CPU:$FF42 PRG:3F42 6A
TXA ; CPU:$FF43 PRG:3F43 8A
ROL A ; CPU:$FF44 PRG:3F44 2A
ROL A ; CPU:$FF45 PRG:3F45 2A
ROL A ; CPU:$FF46 PRG:3F46 2A
AND #$07 ; CPU:$FF47 PRG:3F47 29 07
CLC ; CPU:$FF49 PRG:3F49 18
ADC $F5 ; CPU:$FF4A PRG:3F4A 65 F5
TAY ; CPU:$FF4C PRG:3F4C A8
LDA $FF34,Y ; CPU:$FF4D PRG:3F4D B9 34 FF
RTS ; CPU:$FF50 PRG:3F50 60
.byte $10, $15, $16, $16, $16, $15, $15, $17, $17, $17, $16, $16, $18, $18, $18, $16 ; CPU:$FF51 PRG:3F51 0B
.byte $16, $1A, $1A, $1A, $16, $16, $1C, $1C, $1C, $16, $16, $1E, $1E, $1E, $16, $16 ; CPU:$FF61 PRG:3F61 0B
.byte $0A, $0A, $0A, $0A, $08, $08, $08, $08, $08, $08, $08, $08, $09, $09, $09, $09 ; CPU:$FF71 PRG:3F71 0B
.byte $09, $09, $07, $07, $07, $07, $07, $07, $07, $07, $08, $08, $08, $08, $08, $08 ; CPU:$FF81 PRG:3F81 0B
.byte $10, $11, $1C, $1A, $18, $16, $14, $12, $11, $50, $51, $51, $51, $51, $51, $51 ; CPU:$FF91 PRG:3F91 0B
.byte $51, $51, $52, $52, $52, $52, $52, $52, $53, $53, $53, $53, $53, $54, $54, $54 ; CPU:$FFA1 PRG:3FA1 0B
.byte $54, $55, $55, $55, $56, $56, $56, $56, $57, $01, $01, $01, $BE, $01, $01, $01 ; CPU:$FFB1 PRG:3FB1 0B
.byte $8E, $00, $FE, $00, $00, $FE, $00, $00, $FE, $6B, $6B, $AA, $6F, $6F, $AE, $03 ; CPU:$FFC1 PRG:3FC1 0B
.byte $05, $00, $00, $95, $5D, $49, $9C, $63, $4F, $A2, $03, $00, $9D, $27, $A2, $84 ; CPU:$FFD1 PRG:3FD1 0B
.byte $A2, $84, $A6, $88, $A6, $88, $03, $0D, $01, $01, $A0, $60, $00, $20, $A0, $60 ; CPU:$FFE1 PRG:3FE1 0B
.byte $00, $20, $20, $20, $20, $21, $00, $4F, $0F ; CPU:$FFF1 PRG:3FF1 0B
;------------------------------------------------------------
; VectorTable
; CPU $FFFA-$FFFF
; PRG $3FFA-$3FFF
; NMI, RESET, IRQ/BRK vectors
; Pass 1 preserves this range exactly with .incbin.
;------------------------------------------------------------
VectorTable:
.word NMIHandler ; CPU:$FFFA PRG:3FFA 0B
.word ResetEntry ; CPU:$FFFC PRG:3FFC 0B
.word IRQHandler ; CPU:$FFFE PRG:3FFE 0B
Reference in new issue View Git Blame Copy Permalink