Mike Tyson's Punch-Out!! (nmikstas's partial disassembly of the NES Rev 1)

In Mike Tyson's Punch-Out!! (NES, Rev 1), each opponent move is a script of state data that one interpreter, OppStateUpdate, steps through. A control byte's upper nibble picks a handler, and for upper nibbles $B to $F the lower nibble picks a sub-command from a second table. The commands, named by the disassembly's ST_ constants, load sprites and frame timers, call and return from shared sub-scripts, jump, branch when a zero-page byte holds a given value, repeat a step, mark the opponent as punching, and set the punch's side and damage. At a punch's active step the script waits until the punch is resolved. A landed punch goes on past the step's three index bytes; a blocked, ducked, or dodged one jumps to the first, second, or third index. A path through a move ends with ST_END, which marks the state STAT_FINISHED ("Indicate the end of the current state has been reached", per the comment), or with ST_WAIT_STATE, which stores $81 in OppCurState: the opponent's wait state, in the comment's words. mike-tysons-punch-out/opponent-script

About: Mike Tyson's Punch-Out!! Attack pattern

The four handlers named OppStateUpdate1 in the first table take upper nibble $B to $E, and $F goes to OppStateUpdate2, so ST_CALL_FUNC ($E0, OppCallFunc), ST_RETURN_FUNC ($E1, OppReturnFunc), ST_JUMP ($F1), and ST_END ($FF, StateDone) are sub-commands. The define for OppCurState says its high bit means "initialize new state", so $81 is state 1 waiting to start. The disassembly is partial: several handlers in each table are bare addresses with no label.

Cited by: Attack pattern, Mike Tyson's Punch-Out!!

Glass Joe's right hook in the NES Rev 1 is the commented script GJRighHook. It loads defense values, shows sprite data $0A ("6 frames for this sub-state", per the comment), flags the opponent as punching, and writes OPP_RGHT_HOOK to $BB. It then sets OppOutlineTimer to $84, a count of 4 calls of SetOppOutlineClr (the comment: "Change outline color for 4 frames"), and waits a variable time, VariableStTime. At index $1E, ST_CHK_REPEAT jumps to index $24 while its repeat counter, loaded as 1, hasn't run out; with 1 it falls through. If MacStatus holds MAC_SUPER_PUNCH, it branches to index $59; otherwise it starts the punch sound and sets the punch on Little Mac's left side with damage 7, which the comment says is added to base damage. Glass Joe's fight data sets that base damage at 4. At the punch's active step (index $32), a landed punch falls through to index $36: a 4-frame timer (per the comment), sprite moves, and ST_END at index $44. The step gives index $45 for a block, which jumps into his straight punch's state at index $3B, and index $49 for a duck or a dodge, which loads a special timer, sets his defense values to zero, moves his sprites, and waits for the combo timer before the wait state. mike-tysons-punch-out/right-hook

About: Mike Tyson's Punch-Out!! Attack pattern

{
 "outline_timer_calls": 4,
 "punch_damage": 7,
 "base_damage": 4,
 "windup_frames_per_comment": 6
}

The annotator's index comments drift near the end: the bytes he marks #$59, #$5B, and #$5C sit at offsets $55, $57, and $58, so the super-punch branch's target, $59, lands in the bytes he marks unused. The statement leaves out where that branch goes for that reason. The indexes $32, $36, $45, and $49 check out against the addresses. The defense values' meaning isn't commented, and the routine that turns a damage value into lost health hasn't been read.

Cited by: Attack pattern, Mike Tyson's Punch-Out!!

The NES Rev 1 cues a dodge by recoloring the opponent's outline. A script writes OppOutlineTimer with its high bit set; the main game loop calls SetOppOutlineClr, which then clears that bit, keeps the count, and writes the fight's dodge outline color into four sprite palette entries. Each later call counts the timer down, and at zero it writes the normal color back. Glass Joe's fight data gives palette values $26 for the dodge outline and $08 for the normal one, and his right hook sets the timer to $84, a count of 4 later calls (4 frames by the comment), before its variable wait and the punch. mike-tysons-punch-out/outline-tell

About: Mike Tyson's Punch-Out!! Telegraph

{
 "dodge_color": 38,
 "normal_color": 8,
 "glass_joe_right_hook_timer_calls": 4
}

The labels on the two outline bytes are one off: the fight data copied to $05A0 puts $05EC at $9362, and the atlas read $26 and $08 at $9362 and $9363 of bank 0 in the ROM, which is what the labeled lines hold. In the NES palette $26 is a light red and $08 a dark olive. How long the dodge color shows in frames depends on how often the main loop runs, which hasn't been measured.

Cited by: Mike Tyson's Punch-Out!!, Telegraph

Little Mac's hearts in the NES Rev 1 are a two-digit decimal count. Glass Joe's fight data, in its comments, starts rounds 1, 2, and 3 at 20, 20, and 15 hearts, with normal recoveries of 15, 15, and 10 and reduced ones of 9, 9, and 5. The round setup routine, uncommented (it also loads the round's clock rate and starts the round timer), sets hearts to the table's value in round 1 and raises them to it in rounds 2 and 3 if they're lower, and it copies the two recovery values for the round. An uncommented routine at $843E takes hearts away, 1 or 3 at each of its six callers; when the count reaches zero or below it clears MacCanPunch, which the define reads as "Little Mac can't punch". mike-tysons-punch-out/hearts

About: Mike Tyson's Punch-Out!! Stamina

{
 "glass_joe_start": [
  20,
  20,
  15
 ],
 "normal_recovery": [
  15,
  15,
  10
 ],
 "reduced_recovery": [
  9,
  9,
  5
 ],
 "costs": [
  1,
  3
 ]
}

Round 1 is index 3 of HeartTable, so X = 3 × round; with X = 3 the setup skips the comparison. Which actions cost 1 heart and which 3, and what the two recovery values are spent on, are in uncommented code the atlas hasn't traced. The other four callers are at bank 7 lines 191-192, 295-296, 325-326, and 352-353.

Cited by: Mike Tyson's Punch-Out!!, Stamina

The NES Rev 1 picks an opponent's next move with a second, uncommented script reader at $B196, run from the main game loop. While $38 is nonzero and OppCurState is 1 (the wait state, in the atlas's reading of the defines), it decrements $39 on each call and, when that reaches zero, reads a list of command bytes. In the atlas's reading of the code: 0n s sets OppCurState to s and $39 to n, the count of calls before the next command (n = 0 gives 256, as $39 wraps to $FF); 1n i jumps to list index i when n is greater than the low four bits of a random byte, n/16 of the time (computed), and always when n is 15; and 2n with eight state bytes after it sets $39 to n and starts one of the eight, chosen by the random byte's low three bits. The random byte is $18, which an uncommented routine at $85E9 in bank 7 sets to the sum of two scrambles: $ED, bits of FrameCounter moved to new positions, and $EC, moved bits of $19 with $19 AND $81 ORed in. $19 is a running total, kept from call to call, to which each call adds moved bits of Joy1Buttons. Two paths of the NMI handler call the routine, each right after it increments FrameCounter. $AEF1 rotates $18 three times after each read. Bytes from $80 up hold other commands, not read here. mike-tysons-punch-out/move-select

About: Mike Tyson's Punch-Out!! Attack pattern

LAEAB returns carry set when n > r (CMP) and clears it when n = r; with n = 15 it skips the draw and returns carry set. The 2n case adds 8 to the list index after the pick, so the list resumes after the eight bytes. Which list the reader starts on is set by uncommented code at $B10A from a table at $0500, loaded from the fight's data; the atlas hasn't traced it, so no opponent's list is decoded here. The nispio fork names $18 RNGValue and the bank 7 routine UpdateRNG.

Cited by: Attack pattern, Mike Tyson's Punch-Out!!

When KnockdownSts is 1 ("Opp down", per the define) in the NES Rev 1, uncommented code at $B2EB counts the knockdown in OppKDRound and OppKDFight, and at the third in a round it stops there. Otherwise, unless $BA held $FF, it reads one entry from the opponent's table at OppRefillPtr (its index set by conditions not traced here). An entry of 0 sets nothing. An entry whose upper nibble n is nonzero sets OppGetUpCount to $99 + n, which the define reads as a count of n. An entry whose upper nibble is 0 picks one of the eight entries of OppGetUpTable with three bits of the random byte $18; Glass Joe's eight read, by the comment's encoding, 2, 3, 4, 5, 6, 8, 3, and 4. mike-tysons-punch-out/opponent-getup

About: Mike Tyson's Punch-Out!! Knockdown

{
 "glass_joe_random_counts": [
  2,
  3,
  4,
  5,
  6,
  8,
  3,
  4
 ]
}

$18 shifted right four times and once more leaves its top three bits, 0 to 7. The upper-nibble path stores n = 1, 7, or 9 in SpecialKD as well. The code before LB356 picks the table index from $03C9 (which upstream labels MacKDRound and the nispio fork renames OppRefillIndex), MacStatus, the round, and the clock; the atlas hasn't traced it. What the get-up count is compared against, the referee's count, is also untraced. Little Mac's own get-up, the button-mashing rule players know, is in uncommented code the atlas hasn't read.

Cited by: Knockdown, Mike Tyson's Punch-Out!!