433 lines
25 KiB
Markdown
433 lines
25 KiB
Markdown
# Baseball (UE) — Game Flow from Power-On
|
||
|
||
This document describes the execution flow of the disassembled Baseball (UE) PRG bank (16 KB, mapped at CPU **$C000–$FFFF**), starting from power-on. It is based entirely on `copilot/prg.s` in the repository. The rebuild is verified **byte-identical** to the original `prg.bin`.
|
||
|
||
---
|
||
|
||
## 1. ROM and Memory Layout
|
||
|
||
| Property | Value |
|
||
|----------|-------|
|
||
| Format | iNES / NES 2.0 |
|
||
| PRG | 1 × 16 KB (mapped at CPU $C000–$FFFF) |
|
||
| CHR | 1 × 8 KB |
|
||
| Mirroring | Horizontal |
|
||
| PRG bank start | CPU $C000 (`.org $C000`) |
|
||
| Linker output | `reconstructed_prg.bin`, byte-identical to `prg.bin` |
|
||
|
||
### Interrupt vectors (CPU $FFFA–$FFFF)
|
||
|
||
| Vector | Address | Handler | Notes |
|
||
|--------|---------|---------|-------|
|
||
| NMI | $C046 | `NMI` | Runs once per frame; the primary frame driver |
|
||
| RESET | $C40B | `Reset` | Cold-start initialization |
|
||
| IRQ / BRK | $C43E | `IRQ` | Just `rti` (unused) |
|
||
|
||
---
|
||
|
||
## 2. Reset — CPU $FFFC → $C40B
|
||
|
||
**`Reset`** ($C40B)
|
||
|
||
On power-on or reset:
|
||
|
||
1. `sei` / `cld` — disable maskable interrupts, clear decimal mode.
|
||
2. **Clear CPU RAM** $0000–$07FF — one 256-byte page at a time using the indirect pointer at $00/$01, repeatedly writing $2000 to PPUCTRL during the clear.
|
||
3. `jsr InitializeSpriteSortTables` ($C7B1) — set up the sprite sort/index tables at $0377, $038C, $0399.
|
||
4. `jsr DisablePpuRendering` ($E96C) — turn off PPU output.
|
||
5. **Disable APU** — write $00 to APUSTATUS ($4015) to silence all channels, then select the five-step frame-counter mode and inhibit frame-counter IRQ via JOY2 ($4017).
|
||
6. `jsr ExpandRecordPointerList` ($C8BB) with inline data — builds record pointer structures.
|
||
7. `lda #$1A / sta PpuMaskShadow` — initial PPU mask shadow value.
|
||
8. `jmp InitializeTitleScreen` ($C74A) — RESET does not return; it transfers directly to the title screen.
|
||
|
||
---
|
||
|
||
## 3. NMI / Frame Heartbeat — `NMI` ($C046)
|
||
|
||
The NMI fires once per frame and is the central frame driver. It does **not** simply return; it performs substantial per-frame work:
|
||
|
||
1. **Save X and Y** into `NmiSavedX` ($0D) / `NmiSavedY` ($0E).
|
||
2. **Read PPUSTATUS** ($2002) to reset the PPU address latch.
|
||
3. **OAM DMA** — write $02 to OAMDMA ($4014) to copy $0200–$02FF to sprite memory.
|
||
4. **Process the PPU command queue** at $0300 — walk variable-length packets (write packets to $2007, read packets discarded), terminating on a zero-length entry, then reset the queue head (`stx $0300`).
|
||
5. **Apply scroll** — write `ScrollX` ($DF) and `ScrollY` ($E0) to $2005.
|
||
6. **Apply PPU registers** — write `PpuMaskShadow` ($DE) to $2001 and `PpuCtrlShadow` ($DD) to $2000.
|
||
7. `jsr InitializeAudioEngine` ($F9D0) — initialize/advance the audio engine.
|
||
8. **Latch controllers** — strobe JOY1 ($4016) with $01 then $00.
|
||
9. **Read both controllers** — sample JOY1/JOY2 eight times each, shifting button states into `ControllerPressed1` ($15) / `ControllerPressed2` ($16).
|
||
10. **Update controller state** — compute newly-pressed edges (`Pressed = (Pressed & ~Held) | raw`) and update `ControllerHeld1/2` ($11/$12).
|
||
11. **START-button branch**:
|
||
- If START pressed and `SessionActive` ($1E) is set → `jsr ProcessQueuedObjectEvent` with command $0B.
|
||
- If START pressed and session is **not** active → set `TransitionActive` ($1D) and `GameplaySuspended` ($EF), then `jmp InitializeNewSession` ($C49C).
|
||
12. `NMI_CheckState` — if `NmiStateFlag` ($1F) is nonzero, skip ahead and restore registers.
|
||
13. Otherwise `jsr QueueInlineObjectEvent` ($EB55) with inline command bytes `$05,$21,$C1`, then `jsr ProcessQueuedObjectEvent` ($EB2A) with command $0B.
|
||
14. `inc FrameCounter` ($E3).
|
||
15. `jsr CalculateControllerAssignments` ($C87E) — derive per-player control state.
|
||
16. Store derived input into `InputState1/2` ($13/$14) and `InputAux1/2` ($17/$18).
|
||
17. **Restore X, Y, A**, `rti`.
|
||
|
||
Because the NMI does controller reading and event dispatch, the main loop largely waits on the NMI-driven queued-event system rather than polling hardware directly.
|
||
|
||
---
|
||
|
||
## 4. Title Screen — InitializeTitleScreen ($C74A)
|
||
|
||
Shared entry point used by RESET and by post-match/transition paths:
|
||
|
||
1. `jsr InitializeQueuedEventSystem` ($EB9D) — clear the $0600–$06FF event page, the queue count ($E2), active-event slots, and set `CurrentObjectIndex` ($E1) = 1.
|
||
2. `GameplaySuspended` ($EF) = 0; `TransitionActive` ($1D) = 1.
|
||
3. `PpuCtrlShadow` = $80; disable PPU rendering; fill PPU memory (`FillPpuMemoryAfterValueSaved` at $E985 with value $25).
|
||
4. `jsr ProcessInlinePpuStream` ($EA63) twice — streams title PPU data (inline records `$8D,$F8` and `$00,$C0`).
|
||
5. `jsr EnableNmiAndWaitForFrame` ($E978) — enable NMI and synchronize to a frame.
|
||
6. Enable APU channels ($4015 = $0F), set timing byte $FD = $08.
|
||
7. `RefreshTitleScreen` ($C77A) loop:
|
||
- Update `ModeFlags` ($40).
|
||
- `jsr QueueModeIndicatorTiles` ($E5CF).
|
||
- Wait for controller input release (SELECT/$20) and for the frame counter / delay byte $1B to elapse.
|
||
8. On exit: `TransitionActive` = 0, `GameplaySuspended` = 1, clear audio ($4015), re-init the event system, queue an inline command `$03,$88,$C4`, then `jmp InitializeSessionDisplay` ($C4AA).
|
||
|
||
### Attract mode — RunAttractMessageLoop ($C43F)
|
||
|
||
Before reaching the title input loop, `Reset` can flow into `RunAttractMessageLoop`, which:
|
||
- Clears `NmiStateFlag`, selects object event bank 1.
|
||
- Draws encoded six-character messages via `CopyInlineDisplayRecord` ($EA17) with inline text bytes.
|
||
- Exchanges the object event bank ($EB4E), increments `NmiStateFlag`, and loops back to itself — this is the idle attract display until the player presses START.
|
||
|
||
---
|
||
|
||
## 5. Session and Match Initialization
|
||
|
||
### InitializeSessionDisplay ($C4AA)
|
||
PPU shadow setup, disable rendering, fill PPU memory with $26, then process an inline PPU stream (`$F2,$F4`).
|
||
|
||
### InitializeMatchState ($C4B9)
|
||
- Clears base position and acceleration fields ($C94F/$C943).
|
||
- Sets `$053B` and `PositionSignState` ($B7) to $80.
|
||
- `jsr EnableNmiAndWaitForFrame`.
|
||
- **Player/team selection**:
|
||
- `Random0To5` ($C850) → `PlayerOneSelection` ($34).
|
||
- Repeatedly `Random0To5` until a value different from player one → `PlayerTwoSelection` ($35).
|
||
- If `GameplaySuspended` is set, skip side selection; otherwise derive `ActivePlayerSide` ($4B) from mode flags or a random bit.
|
||
- Queue inline object events `$03,$19,$C8` and `$02,$19,$C8`, set `PlayerSelectionActive` ($44) = 1.
|
||
- `WaitForPlayerSelection` ($C4FF) spins until `$43` (`SelectionState`) becomes negative, then queues `$03,$3E,$C4` and falls into `CompleteMatchSetup` ($C50C).
|
||
|
||
### CompleteMatchSetup ($C50C)
|
||
- `FillSelectionBackgroundBlocks` ($C85A), `QueuePlayerSelectionDisplay` ($C7DD), `InitializeRandomBitfields` ($C899), `QueuePlayerValueDisplay` ($CF8B).
|
||
- Queue inline command `$09,$37,$CE`, then enter `InitializeRoundState` ($C51E).
|
||
|
||
---
|
||
|
||
## 6. Round / Gameplay State Machine
|
||
|
||
### InitializeRoundState ($C51E)
|
||
Round-setup entry point:
|
||
- If gameplay is not suspended and `RoundStateIndex` ($33) < $12, select round music cue; otherwise reset round counters.
|
||
- `EnableRoundAudio` ($C52A): enable APU channels ($4015 = $0F), set $FD = $08.
|
||
- `ResetRoundCounters` ($C536): clear scores ($67/$68) and `RoundStateIndex`.
|
||
- `jsr InitializeObjectsFromTable` ($D06B) — initialize objects from the table at $D0A0–$D131.
|
||
- Set `$053B` / `PositionSignState` = $80.
|
||
- Store a $3C-tick delay, draw an 8-character message, store another $3C delay.
|
||
- `SelectRoundMusicCue` ($C566): choose a music delay value ($20 or $40) based on `RoundStateIndex` parity → store in $FD.
|
||
- `PrepareRoundObjects` ($C573): queue player-selection display, queue random-state record, clear `MatchCompleteFlag` ($45) and `SecondarySequenceState` ($64).
|
||
|
||
### ResetGameplayState ($C57F)
|
||
- Clear `InningOrSharedScore` ($66), `BaseMotionActive` ($5C).
|
||
- Mark four state entries ($0598–$059B) inactive ($FF).
|
||
- `jsr QueueRoundNumberDisplay` ($CF67), re-init objects, set sign state to $80.
|
||
- Store a $B4-tick delay.
|
||
|
||
### Round setup continuation points
|
||
- `ResumeRoundSetupAtRandomDirection` ($C5A4): queue random-direction record, clear primary/transition sequence state, set `StateSequenceActive` ($46) = 1, clear state field pairs ($03,$23 via $CF51).
|
||
- `ResumeRoundSetupAtSelectionDisplay` ($C5BA): clear the 8-character field, clear $0597–$05A6, clear the 38-byte motion field range $056F–$0594.
|
||
- Based on `RoundStateIndex` and score comparison ($67 vs $68), either jump to `CompleteMatchState` ($C6F7) or finish the reset.
|
||
|
||
### FinishGameplayReset ($C5F1)
|
||
- `InitializeDefaultObjects` ($D030), clear sign state, select event bank 1 → enter `RunRoundStateLoop` ($C5FE).
|
||
|
||
### RunRoundStateLoop ($C5FE) — main per-round loop
|
||
This is the core gameplay loop:
|
||
- If `PendingStateTransition` ($60) is set → `InitializeObjectStateLookup` ($C8A3).
|
||
- If either `PendingStateTransition` or `StateSequenceActive` ($46) is nonzero → dispatch state-specific handlers via queued inline commands (`$0D,$77,$D4`, `$0F,$81,$D3`).
|
||
- `RunPrimaryRoundHandlers` ($C619):
|
||
- `InitializeSecondaryActors` ($D633), `InitializeConditionalObject` ($D126).
|
||
- Clear working state: `PendingScoreIncrement`, `BaseMotionPhase`, `BaseMotionEventCount`, `TrajectoryResult`, `PendingStateTransition`, `SpecialSequenceState`, `ObjectTransitionState`, `BaseMotionActive`, `ActionSequenceCounter`, `TrajectoryEvaluationEnabled`, and several others.
|
||
- Clear base acceleration and position fields.
|
||
- Queue three inline object events (`$25,$5A,$D8`, `$0E,$66,$D1`, `$1F,$76,$CA`).
|
||
- `jsr UpdateObjectEventBank_Exchange` with command $08.
|
||
- Walk the 22-entry `RoundEventSlotTable` ($C6E1) in reverse, dispatching each via `DispatchNextQueuedEvent` ($EB66).
|
||
- Write one inline character ($3F, value $28) to the PPU.
|
||
- `ApplyPendingScoreUpdate` ($C67E): if a score increment is pending and no state transition, `jsr UpdateCountersAndDisplay` ($CFA6), clear the increment.
|
||
- `StartPostRoundDelay` ($C68D): wait for `PendingEvent` ($6F) to clear, then count down delay counter $48.
|
||
- If match is not complete and no sequence is active → `jmp ResumeRoundSetupAtSelectionDisplay` ($C5BA) to start the next round.
|
||
- `ProcessPostRoundEvents` ($C6A5): dispatch event slots $0D and $0F, store a $0A-tick delay, decrement a counter based on `RoundStateIndex` parity.
|
||
- `CheckPostRoundContinuation` ($C6C5): if match complete → `AdvanceRoundNumber` ($C6CC); otherwise `jmp ResumeRoundSetupAtRandomDirection` ($C5A4).
|
||
- `AdvanceRoundNumber` ($C6CC): update counters/display, increment `RoundStateIndex`; if index reaches $12 → `InitializeResultsPosition` ($C708); otherwise `SelectRoundMusicCue` ($C566) to begin the next round.
|
||
|
||
---
|
||
|
||
## 7. Per-Frame Object and Motion Updates
|
||
|
||
### UpdateFrameObjectsAndTimers ($C122)
|
||
Called each frame to drive object motion:
|
||
- Reset PPU queue offset, OAM write offset, and `FrameState20` ($20).
|
||
- Queue/process inline object events ($07,$64,$C2 via bank, then command $01).
|
||
- Decrement per-object timers at $063F,X (30 slots); when a timer reaches zero, queue a decoded object event.
|
||
- Decrement four short countdowns at $05AD,X.
|
||
- If a transition is active, jump to `CommonEngineExit` ($EB6A); otherwise `IntegrateAllObjectPositions` ($C15B).
|
||
|
||
### IntegrateAllObjectPositions ($C15B)
|
||
- For 36 object slots (X stepping by 2, each logical object uses two indices):
|
||
- Sign-extend and add horizontal delta ($050B/$050C,X from $056F/$0570,X).
|
||
- Sign-extend and add vertical delta ($053C/$053D,X from $0570/$0571,X).
|
||
|
||
### UpdateBaseMotionSequence ($C18D)
|
||
- Integrate velocity/position for three base object indices ($00, $31, $62).
|
||
- Reflect base motion values when $056C is negative (negate $056B/$056C and halve $0569/$056A).
|
||
- Apply doubled horizontal/vertical velocity adjustments to $0507/$0508 and $0538/$0539.
|
||
- `jsr EvaluateTrajectoryResult` ($CAD2).
|
||
- Advance `BaseMotionPhase` ($5D); when motion settles, clear base acceleration/position fields.
|
||
- `UpdatePositionSignState` ($C228): compute a signed position delta relative to a $0A threshold, track sign changes in `PositionSignState` ($B7), and update rendering flags.
|
||
|
||
### IntegrateObjectVelocityAndPosition ($C3CA)
|
||
Signed fixed-point position integration used by the three base motion call sites: shifts the signed 16-bit velocity right twice (sign-preserving), adds to position ($0507/$0508), then adds the result to the secondary position ($0509/$050A).
|
||
|
||
---
|
||
|
||
## 8. Rendering and OAM
|
||
|
||
### BuildFrameOam ($C2DE)
|
||
- If `TransitionActive` is set: copy an 88-byte sprite/OAM template from $F94D into shadow OAM at $0200, set `OamWriteOffset` ($3F), and jump to `TerminatePpuUpdateQueue`.
|
||
- Otherwise, if `PlayerSelectionActive` ($44) is set: copy an 8-byte OAM template from $C331, position two sprites from player selection coordinates (scaled ×16 + $50), choose tiles based on `ModeFlags`.
|
||
- Otherwise: `SortObjectsByY` ($C339) — sort object indices by signed 16-bit Y coordinates ($0538/$0539) using the index table at $0377/$0378, then render each sorted object via `RenderSpriteRecordList` ($E77B).
|
||
|
||
### FinalizeOamAndPpuQueue ($C386)
|
||
- If `ObjectListFlag` ($C7) is set, skip status OAM; otherwise copy 20 bytes from $EBC2 into shadow OAM and select two extra bytes from $EBBC based on player selections.
|
||
- `TerminatePpuUpdateQueue` ($C3AA): write $00 to terminate the PPU command queue at $0300,Y.
|
||
- Hide unused sprites by writing $F0 to each remaining OAM Y coordinate (stepping by 4).
|
||
- `jsr AdvanceRandomState` ($E5F4), then `jmp CommonEngineExit` ($EB6A).
|
||
|
||
---
|
||
|
||
## 9. Batting and Pitching
|
||
|
||
### Pitching (RunPitcherWindupSequence, $C6044)
|
||
- `RunPitcherWindupSequence` animates the pitcher windup (frames selected via `SetWindupFrame`).
|
||
- `SelectPitchAction` ($C6139): reads controller input to choose the pitch action.
|
||
- `SelectPitchType` ($C6178): searches `PitchTypeThresholdTable` / `PitchDirectionThresholdTable` ($C5973/$C5980) to determine pitch type and direction.
|
||
- `AnimatePitchStart` ($C6229), `UpdatePitchMovement` ($C6321): apply pitch trajectory and controller-based horizontal/vertical input.
|
||
- Pitch tables: `PitchVelocityBiasTable` ($C6399), `PitchDelayTable` ($C6402), `PitchRenderFlagTable` ($C6405).
|
||
|
||
### Batting (SelectBatterAction, $C6414)
|
||
- `WaitForBatterAction` ($C6422): wait for batter input.
|
||
- `UseBatterControllerInput` ($C6464): map controller to batter action slot.
|
||
- `SelectActionFromObjectState` ($C6590) with `ObjectActionLookupTable` ($C6502).
|
||
- `DispatchActionType` ($C6614): route to the appropriate action handler.
|
||
|
||
### Object motion and collision
|
||
- `MoveControlledObject` ($D371): apply controlled horizontal/vertical offsets (`ControlledHorizontalOffsetTable` / `ControlledVerticalOffsetTable` at $D384/$D38C).
|
||
- `TestObjectCollision` ($D38B): object-vs-object collision testing.
|
||
- `TestCurrentObjectInput` ($D7D7): resolve controller input for the current object.
|
||
- Geometry helpers: `CalculateCurrentObjectGeometry` ($D7AE), `CalculateGeometryDifference` ($D566), `BuildGeometryVector` ($D74D), extensive trigonometry/vector math routines ($D5xx–$D8xx).
|
||
|
||
---
|
||
|
||
## 10. Audio Engine
|
||
|
||
### InitializeAudioEngine ($F9D0)
|
||
Initialize the APU: write DMC settings, configure pulse/triangle/noise channel presets, write pulse periods from tables ($FA00–), set up audio lookup data.
|
||
|
||
### UpdateAudioEngine ($FB05)
|
||
Per-frame audio update:
|
||
- Clear/finalize primary audio effects.
|
||
- Update pulse 1 and pulse 2 effects (preset effects, descending effects, state-change effects, phase effects).
|
||
- Update triangle pitch sweeps.
|
||
- Dispatch music and noise (`DispatchMusicAndNoise` at $FB65): update music sequencer, noise envelope, timed triangle effects, DMC output.
|
||
|
||
### Music
|
||
- `StartMusicSequence` ($FD34): initialize a music sequence by finding its bank and copying the descriptor.
|
||
- Channels: pulse 1 ($FD96), pulse 2 ($FDCF), triangle ($FE0B).
|
||
- Music sequence data tables at $FE60–$FFD0 (`MusicSequenceData_FE60` … `MusicSequenceData_FFD0`).
|
||
- Sound effect presets and noise/triangle envelopes throughout the $F9xx–$FE2x region.
|
||
|
||
Audio is advanced from the NMI via `jsr InitializeAudioEngine` ($F9D0) each frame; the broader `UpdateAudioEngine` ($FB05) is called from the event system.
|
||
|
||
---
|
||
|
||
## 11. Object Event System (the main-loop engine)
|
||
|
||
The game is driven by a **queued event system** rather than a simple polling loop:
|
||
|
||
- `InitializeQueuedEventSystem` ($EB9D): clear $0600–$06FF, queue count $E2, active slots, set current object index.
|
||
- `QueueInlineObjectEvent` ($EB55) / `QueueDecodedObjectEvent` ($EB2A): push an event onto the queue.
|
||
- `ProcessQueuedObjectEvent` ($EB2A): walk the queue and process active events.
|
||
- `DispatchNextQueuedEvent` ($EB66): pop the newest event, save its continuation address on the hardware stack (SP = $FF), and `rts` into it — this is how control transfers between event handlers.
|
||
- `CommonEngineExit` ($EB6A): mark the current object inactive; if the queue is empty, wait (`beq DispatchNextQueuedEvent_Wait`) polling $E2; otherwise disable NMI bit 7 and dispatch the next entry.
|
||
|
||
The main gameplay loop (`RunRoundStateLoop`) and most state handlers ultimately pass through `CommonEngineExit`, which blocks until the NMI or another producer queues the next event. This makes the NMI the real-time heartbeat and the main loop an event consumer.
|
||
|
||
---
|
||
|
||
## 12. PPU Streaming Helpers ($E9xx–$EBxx)
|
||
|
||
A family of routines drives PPU updates from inline byte streams embedded in the code:
|
||
- `DisablePpuRendering` ($E96C), `EnableNmiAndWaitForFrame` ($E978).
|
||
- `FillPpuMemoryWith26` / `FillPpuMemoryAfterValueSaved` ($E983/$E985): fill PPU memory with a byte value.
|
||
- `DecodeInlineParameters` ($EA09), `ReadInlineWord` ($EA28), `CopyInlineBytesToZeroPage` ($EA45).
|
||
- `WritePpuControlFromCarry` ($EA6E), `SetPpuAddressFromInlineRecord` ($EA97), `WritePendingPpuByte` ($EABF), `WriteInlinePpuBlock` ($EAC9), `PPUWriteString` ($EAFB).
|
||
- `CopyInlineDisplayRecord` ($EA17): draw an encoded text record (count byte followed by character data) — used heavily for titles, scores, round numbers, and announcements.
|
||
- `ProcessInlinePpuStream` ($EA63): process a stream of PPU commands.
|
||
|
||
Many routines are followed by `.byte` inline data that must **not** be disassembled as instructions; the disassembly marks these explicitly.
|
||
|
||
---
|
||
|
||
## 13. Match Completion and Results
|
||
|
||
### CompleteMatchState ($C6F7)
|
||
- Increment `RoundStateIndex`.
|
||
- If `InningOrSharedScore` ($66) is nonzero → `InitializeResultsPosition`; otherwise draw a single encoded character ($32).
|
||
- `InitializeResultsPosition` ($C708): set sign state to $80, draw a 10-character message (`$25,$10,$0A,$16,$0E,$25,$1C,$0E,$1D,$25`), set timing $FD = $4, dispatch event slot 2, queue inline `$02,$88,$C4`.
|
||
- `ResultsDelayLoop` ($C737): repeat a $3C-tick delay 10 times.
|
||
- Disable APU ($4015 = $00), clear `SessionActive` ($1E), then fall into `InitializeTitleScreen` ($C74A) to return to the title.
|
||
|
||
---
|
||
|
||
## 14. Summary of Execution Flow
|
||
|
||
```
|
||
Power On / Reset
|
||
│
|
||
▼
|
||
Reset ($C40B) ───► clear RAM $0000-$07FF, init sprite sort, disable PPU/APU
|
||
│
|
||
▼
|
||
jmp InitializeTitleScreen ($C74A)
|
||
│
|
||
├─ init event system, draw title screen
|
||
├─ EnableNmiAndWaitForFrame (NMI now runs each frame)
|
||
├─ WaitForTitleInputRelease (wait for START + input release)
|
||
▼
|
||
jmp InitializeSessionDisplay ($C4AA)
|
||
│
|
||
▼
|
||
jmp InitializeMatchState ($C4B9)
|
||
│
|
||
├─ Random0To5 → PlayerOneSelection ($34)
|
||
├─ Random0To5 (≠ P1) → PlayerTwoSelection ($35)
|
||
├─ derive ActivePlayerSide ($4B)
|
||
└─ WaitForPlayerSelection (spin until $43 < 0)
|
||
│
|
||
▼
|
||
CompleteMatchSetup ($C50C)
|
||
│
|
||
▼
|
||
InitializeRoundState ($C51E)
|
||
│
|
||
├─ enable audio, reset counters, init objects from table ($D06B)
|
||
├─ draw messages, select music cue
|
||
▼
|
||
ResetGameplayState ($C57F) → FinishGameplayReset ($C5F1)
|
||
│
|
||
▼
|
||
RunRoundStateLoop ($C5FE) ◄───────────────────┐
|
||
│ │
|
||
├─ InitializeObjectStateLookup │
|
||
├─ RunPrimaryRoundHandlers │
|
||
│ ├─ InitializeSecondaryActors │
|
||
│ ├─ InitializeConditionalObject │
|
||
│ ├─ walk RoundEventSlotTable │
|
||
│ └─ dispatch queued events │
|
||
├─ ApplyPendingScoreUpdate │
|
||
├─ StartPostRoundDelay (wait $48 ticks) │
|
||
├─ ProcessPostRoundEvents │
|
||
├─ CheckPostRoundContinuation │
|
||
│ ├─ match complete → results → title │
|
||
│ └─ AdvanceRoundNumber → next round │
|
||
└─ eventually → CommonEngineExit ($EB6A) │
|
||
wait for queued event ($E2) │
|
||
dispatch next event (rts into it)│
|
||
└────────────────────────────────┘
|
||
|
||
NMI ($C046) [every frame]
|
||
├─ PPU command queue flush ($0300)
|
||
├─ OAM DMA ($4014)
|
||
├─ scroll ($2005), PPU mask/ctrl ($2001/$2000)
|
||
├─ InitializeAudioEngine ($F9D0)
|
||
├─ controller latch + read (JOY1/JOY2)
|
||
├─ controller state (pressed/held edges)
|
||
├─ START branch → new session or command $0B
|
||
├─ QueueInlineObjectEvent + ProcessQueuedObjectEvent
|
||
├─ FrameCounter++, CalculateControllerAssignments
|
||
└─ restore registers, rti
|
||
```
|
||
|
||
---
|
||
|
||
## 15. Key Zero-Page / RAM Symbols
|
||
|
||
| Address | Symbol | Use |
|
||
|---------|--------|-----|
|
||
| $00–$01 | IndirectPtrLo/Hi | RAM-clear indirect pointer |
|
||
| $0D–$0E | NmiSavedX/Y | NMI register save |
|
||
| $0F | DerivedControl0 | Derived control input |
|
||
| $11–$12 | ControllerHeld1/2 | Currently held buttons |
|
||
| $13–$14 | InputState1/2 | Current input state |
|
||
| $15–$16 | ControllerPressed1/2 | Newly pressed buttons |
|
||
| $17–$18 | InputAux1/2 | Auxiliary input |
|
||
| $19–$1A | RandomStateLo/Hi | PRNG state |
|
||
| $1B | TransitionCounter | Transition delay |
|
||
| $1D | TransitionActive | Transition in progress |
|
||
| $1E | SessionActive | Session/game active flag |
|
||
| $1F | NmiStateFlag | NMI state flag |
|
||
| $20 | FrameState20 | Frame state |
|
||
| $21 | SelectedPitchAction | Current pitch action |
|
||
| $33 | RoundStateIndex | Current round/inning index |
|
||
| $34–$35 | PlayerOne/TwoSelection | Selected teams |
|
||
| $36–$39 | ObjectScreenX/Y (+Hi) | Object screen coordinates |
|
||
| $3E–$3F | PpuQueueOffset / OamWriteOffset | PPU/OAM write positions |
|
||
| $40 | ModeFlags | Display/mode flags |
|
||
| $42 | CurrentObjectArrayOffset | Current object slot |
|
||
| $43 | SelectionState | Selection state |
|
||
| $44 | PlayerSelectionActive | Player selection active |
|
||
| $45 | MatchCompleteFlag | Match finished |
|
||
| $46 | StateSequenceActive | State sequence running |
|
||
| $48 | DelayCounter | General delay |
|
||
| $4B | ActivePlayerSide | Active player (0/1) |
|
||
| $4D–$50 | RandomState0/1, RandomBits0/1 | Randomization state |
|
||
| $53–$56 | SavedBaseX/Y (Lo/Hi) | Saved base coordinates |
|
||
| $5C | BaseMotionActive | Base motion active |
|
||
| $5D | BaseMotionPhase | Base motion phase |
|
||
| $5E | BaseMotionEventCount | Base motion event count |
|
||
| $5F | TrajectoryResult | Trajectory result |
|
||
| $60 | PendingStateTransition | Pending state change |
|
||
| $66 | InningOrSharedScore | Inning / shared score |
|
||
| $67–$68 | PlayerOne/TwoScore | Scores |
|
||
| $69–$6A | EventWrite/ReadIndex | Event queue indices |
|
||
| $6F | PendingEvent | Pending event |
|
||
| $7E | ActionSequenceCounter | Action sequence counter |
|
||
| $83 | ObjectApproachCount | Approach counter |
|
||
| $86 | TrajectoryEvaluationEnabled | Trajectory eval enabled |
|
||
| $8E–$90 | RandomHorizontal/VerticalMotion | Random motion |
|
||
| $9D | CurrentActionState | Current action |
|
||
| $9F–$A1 | SecondaryActorState0–2 | Secondary actor states |
|
||
| $A2 | ObjectSequenceState | Object sequence state |
|
||
| $B7 | PositionSignState | Position sign tracking |
|
||
| $C7 | ObjectListFlag | Object list flag |
|
||
| $C9–$CA | SpriteSortBaseIndex / SpriteArrayEnd | Sort table bounds |
|
||
| $DD–$E0 | PpuCtrl/MaskShadow, ScrollX/Y | PPU/shadow/scroll state |
|
||
| $E1 | CurrentObjectIndex | Current object being processed |
|
||
| $E2 | ScriptDepth / queue count | Queued event count |
|
||
| $E3 | FrameCounter | Frame tick counter |
|
||
| $EF | GameplaySuspended | Gameplay suspended |
|
||
| $F6–$F7 | SoundPtrLo/Hi | Sound pointer |
|
||
| $FE | PendingAudioFlags | Pending audio flags |
|
||
| $FF | RenderStateFlags | Render state flags |
|
||
|
||
---
|
||
|
||
## 16. Notes on the Disassembly
|
||
|
||
- The source is **21,624 lines** and thoroughly annotated with symbolic names for nearly every routine, table, and data block — there are no generic `Label_Cxxxx` placeholders.
|
||
- Numerous routines are followed by inline `.byte` data blocks consumed by `QueueInlineObjectEvent`, `CopyInlineDisplayRecord`, or `ProcessInlinePpuStream`; these are intentionally left as raw bytes and marked in comments.
|
||
- The PRG is a single 16 KB bank at $C000–$FFFF; calls to $Dxxx/$Exxx/$Fxxx targets are all within the same bank (no bank switching).
|
||
- Build verification: `make` in `copilot/` produces `reconstructed_prg.bin` that is **byte-identical** to `prg.bin` and to the PRG bank of `baseball.nes`. |