MvC1 Frame Data for 16 Characters, Measured in the Game and Read From the ROM

I ran the stock Euro 980123 program in a headless build of FBNeo (the core Fightcade uses) and drove it with ordinary inputs, the way a player would:

• Normal speed. With factory settings my runs played at a Turbo speed, which adds an extra logic tick every few frames and makes frame counts drift. The game reads its speed setting from $FFF960; I set it to Normal before the match.
• Ryu as the dummy, standing, with player 1 on the left. "Close" means walking forward until the gap stops shrinking.
• Frame 1 is the first frame of the move. An input made on one frame shows on the next, for attacks, jumps and walking alike, so that delay cancels out.
• When can each side act again? Player 1 holds back after the move; holding back can't cancel anything, so the first frame player 1 walks is the end of the move. Player 2 holds up from the frame after contact, so the first frame player 2 starts a jump is the end of its stun.
• Advantage is player 2's first free frame minus player 1's.

One detail matters for blockstun. The last few frames of the guard animation can be cancelled into a jump or an attack but not into walking, so a dummy that just holds back looks stuck for about six frames longer than it really is. The jump probe catches the true end.

Launchers and knockdowns are labelled as such. Their "advantage" is the time until the opponent lands or gets up, which is not what anyone means by plus or minus.

Two rules make the static reading work:

• An attack box is in slot 0 of the box row, or in slot 1 when that slot's flag bits are clear. Slot 1 normally holds a flagged box that isn't an attack.
• The last frame of an animation is followed by a pointer. When the last hold runs out, the engine jumps there, usually back to the start of the loop. A normal move ends at that point because its state code sees the end.

For air normals the reading covers startup and active frames, since landing ends them. The 8 normals it misses are moves whose code takes over the animation: War Machine's and Venom's standing HP, Captain Commando's standing HK, Jin's standing MK and HK, crouching MK and HK, and jumping LK. Some loop until the code stops them; others end on a landing or link to another animation. For those, the measured number is the right one, and the training room's frame meters follow it.

The boxes also say when a move connects. Stand Ryu in his idle stance (animation group 0, number 0) with the two push boxes touching, the way the measuring runs left him, and find the first frame whose attack box overlaps one of his hurt boxes. For 185 of the 191 ground normals with a measured hit, that is the frame the running game hit on. The other 6 have no attack box on the fighter at all: War Machine's standing and crouching HP and MK and Mega Man's standing and crouching HP hit with something they spawn.

That check is narrower than it sounds. At point blank all 185 touch on their first attack-box frame, so it confirms where the boxes sit (with the attacker left unmirrored, none of them touch at all), not how far they reach. The training room uses the same rule to move Ryu back until a move stops reaching him, and to crouch him (crouching idle is group 3, number 1), so its reach and crouching results are what the boxes predict, not measured. By the boxes, six standing normals never touch a crouching Ryu: War Machine's, Captain America's, Gambit's, Zangief's and Morrigan's standing LP, and Gambit's standing HP.

The reason is in the routine that runs while a fighter's hitstop counter (+$85) is non-zero:

; stock mvsc, decrypted CPU view; a6 = the attacker
$0145A4  move.b  $3D(a6),d5        ; low byte of the frame's attribute word
$0145A8  bpl.b   $0145D6           ; bit 7 clear: stay frozen
$0145AA  movea.l $34(a6),a4
$0145AE  jsr     $001DD8           ; bit 7 set: advance the animation one tick
$0145B4  cmp.b   $3D(a6),d5        ; did that load a frame with a different attribute?
$0145B8  beq.b   $0145D6
$0145BA  btst    #6,d5
$0145BE  bne.b   $0145D8           ; bit 6: jump by the low 6 bits instead
$0145C0  andi.w  #$F,d5            ; low nibble n
$0145C4  beq.b   $0145D6           ; 0: carry on into the new frame
$0145C6  subq.w  #1,d5             ; otherwise go back n - 1 frames
...

So each frame decides for itself:

• Bit 7 of the frame's attribute word keeps it moving during hitstop. Mega Man's standing MP sets it on its two active frames, which play out before the freeze starts.
• The attribute's low nibble makes the frame loop during hitstop instead of moving on. Captain America's standing LP sets it on its active frame, so his fist stays out for the whole freeze and the move gets the full 10 frames longer.

Those two rules reproduce the attacker's measured recovery on 352 of 374 hits and blocks. The 22 they miss belong to 11 normals: the 9 that hit twice, which freeze twice, and Captain Commando's standing HK and Jin's crouching HK, whose code runs the animation.

1. Damage level, a game setting: 34, 38, 44 or 48 over 32. A factory-default board uses 38.
2. Attacker power, 32/32 at the start of a match.
3. Random: the record's +$01 picks a row of 32 entries; row 0, used by normals, is 31, 32 or 33 (a quarter, half and a quarter of the time).
4. Damage taken: each character has a row of ten values. A round starts at level 4, where Ryu takes 32/32, Mega Man 34/32 and Hulk 28/32. The game moves that level with the life gap between the teams.
5. Combo scaling by the hit number: 32, 32, 30, 28, 26, 20, 16, 14, 12, 10, 8, 6, 4, then 2. The row belongs to the attacker. The routine picks it through the defender's +$C4, which holds the opponent's ID, and Hulk's row is steeper: 32, 32, 30, 24, 20, 16, 12, 10, 8, 6, 4, 2, 1, then 0. Records with +$04 bit 5 set use a gentler table at $0E9BBA.
6. Guts: a defender below 96, 32 or 16 life takes 30, 20 or 16 thirty-seconds. This step only applies to records whose +$04 high nibble is 0 or has bit 4 set.
7. At least 1.

The check: all 178 normals that hit Ryu once land inside the predicted range, and so does each hit of the 9 that hit twice. For the multi-hit specials and hypers, 654 of 682 hits land inside it; the rest go through steps this model leaves out.

The values are 8.8 fixed point, in pixels per frame at the game's 384-pixel width:

• Walk at $0E860A: forward and back, 4 bytes per entry.
• Jumps at $0E877A: neutral, forward and back, each as vertical speed, gravity, horizontal speed and horizontal drag. 24 bytes per entry. The horizontal values are stored for a fighter facing left.
• Super jumps at $0E8F06, same layout.

Mega Man's values are the same as in MvC2, where the reference lists them too. The check covered walk forward and back, and vertical speed, gravity, horizontal speed and drag for all three jumps and all three super jumps, for 16 characters. I haven't found what halves War Machine's forward super jump; in the game he leaves at 4 and slows by the table's drag.

The game jumps through a copy of those addresses at $018DF0, which also covers the secret characters. To measure the moves, I tried every common motion with every button and button pair, from far away and at point blank, then kept the inputs that started a special or hyper animation. Each one was measured like the normals, and the record that hit came from the dummy itself, since the game writes it there on contact.

That search reproduced 109 of the 121 commands. The 12 it missed need a mode (Zangief's Iron Body, Ryu's Ken and Akuma styles) or a particular distance (Zangief's 360 hypers), or they share an animation with another command, so the search couldn't tell them apart.

Two caveats for these rows. Damage is the life loss in one run, so it includes the random step, and hypers ran with the meter set to level 3.

These are data reads, and CPS-2 encryption only touches instructions, so the raw ROM bytes are the real values. The secret characters borrow: Red Venom, Gold War Machine, Shadow Lady and Lilith point at their base character's attack, box-row and box tables, and Orange Hulk has his own attack table. ID $00 has a full set of tables too, but no one on the select screen uses it.

Record n sits at the character's attack pointer + 32 × n. Records 0 to 17 are usually the normals, in MvC2's order (standing LP to HK, crouching, then air), with specials and hypers after them. Not always: Captain America's standing MP and HP, crouching LP, MP and HP and jumping MP and HP use records 18 to 24, Ryu's jumping MP uses 21 and 22, Captain Commando's standing HK 25 and Chun-Li's jumping HK 25 and 26. The second hit of a two-hit normal usually comes from a record past 24, and Mega Man's two buster normals hit with record 48, the shot's own. Select a move in the training room to see the record that hits.

Two fields are new since the first version of this map: +$01 picks the damage formula's random row (0 on every normal), and +$07 is hitstop, the value both fighters freeze for, though the attacker can keep moving through it.

MSH vs. SF uses the same formats. Its directories sit at $13775A (animation), $1377F6 (boxes), $13785E (box rows) and $1378C6 (attack records) in the US program, and its records have the same 32-byte layout, field for field. X-Men vs. SF's directories start at $08A946. Neither has been measured in a running game yet.

A character's animations hang off a two-level tree at its anim pointer: 31 group offsets, then a list of animations per group, then 16-byte frames. MvC1 has MvC2's groups plus one at 7.

An earlier draft of this map said MvC1's extra group was 11. The running game says otherwise: the standing LP is animation 8/0, and the extra group is 7. Everything on this page uses the corrected numbers.

The routine that plays animations is at $001DD8. It counts the hold down at fighter +$3E, loads the next frame when it reaches zero, and follows the pointer after the last frame. A hold of 0 is loaded and replaced in the same update, so no one ever sees it.

Player 1's fighter is at $FF3000 and player 2's at $FF3400.

This needs Python 3 and a stock mvsc.zip. It prints every animation in the four ground-normal groups with its timing read off the animation data. A * marks frames with an attack box, and ! marks frames that keep moving during hitstop.

import sys, zipfile
 
PROGRAM = [('mvce.03a', 0x000000), ('mvce.04a', 0x080000), ('mvc.05a', 0x100000),
           ('mvc.06a', 0x180000), ('mvc.07', 0x200000), ('mvc.08', 0x280000),
           ('mvc.09', 0x300000), ('mvc.10', 0x380000)]
MOVEPROP, ANIM, HITBOX = 0x0E68AE, 0x0E676C, 0x0E6852   # one long per entry (entry = ID / 2)
GROUPS = {8: 'standing punches', 9: 'standing kicks', 10: 'crouching punches', 11: 'crouching kicks'}
 
def load_program(zip_path):
    rom = bytearray(0x400000)
    with zipfile.ZipFile(zip_path) as z:
        for name, base in PROGRAM:
            data = z.read(name)
            rom[base:base + len(data)] = data
    rom[0::2], rom[1::2] = rom[1::2], rom[0::2]   # members store each word byte-swapped
    return bytes(rom)
 
def u16(rom, a): return int.from_bytes(rom[a:a + 2], 'big')
def u32(rom, a): return int.from_bytes(rom[a:a + 4], 'big')
def table(rom, directory, char_id): return u32(rom, directory + (char_id // 2) * 4)
 
def animations(rom, char_id, group):
    """(index, first-frame address) for each animation in a group. A list ends where the
    next group's list or the first animation begins; an empty slot keeps its index."""
    base = table(rom, ANIM, char_id)
    offsets = [u16(rom, base + 2 * g) for g in range(31)]
    first = min(base + o + u16(rom, base + o) for o in offsets if o)
    start = base + offsets[group]
    end = min([base + o for o in offsets if o > offsets[group]] + [first])
    slots = [u16(rom, p) for p in range(start, end, 2)]
    return [(index, start + off) for index, off in enumerate(slots) if off]
 
def frames(rom, char_id, addr):
    rows = table(rom, HITBOX, char_id)
    while True:
        attr, ctrl, row = u16(rom, addr), u16(rom, addr + 2), u16(rom, addr + 14)
        s0, s1 = u16(rom, rows + row * 16), u16(rom, rows + row * 16 + 2)
        attack = bool(s0 & 0x1FFF) or (bool(s1 & 0x1FFF) and not s1 & 0xE000)
        yield ctrl & 0x7FFF, attack, bool(attr & 0x80)
        if ctrl & 0x8000:
            return
        addr += 16
 
def timing(shown):
    holds = [h for h, a, i in shown]
    act = [k for k, (h, a, i) in enumerate(shown) if a]
    if not act:
        return f'total {sum(holds)}'
    return (f'startup {sum(holds[:act[0]]) + 1}, active {sum(h for h, a, i in shown[act[0]:act[-1] + 1] if a)}, '
            f'recovery {sum(holds[act[-1] + 1:])}, total {sum(holds)}')
 
if __name__ == '__main__':
    rom = load_program(sys.argv[1])            # path to mvsc.zip
    char_id = int(sys.argv[2], 16)             # character ID in hex, e.g. 20 = Mega Man
    for group, label in GROUPS.items():
        for index, addr in animations(rom, char_id, group):
            shown = [f for f in frames(rom, char_id, addr) if f[0]]
            holds = ' '.join(f'{h}{"*" if a else ""}{"!" if i else ""}' for h, a, i in shown)
            print(f'{group}/{index} {label:18} {holds:30} {timing(shown)}')
    attacks = table(rom, MOVEPROP, char_id)
    print(f'attack records at ${attacks:06X}; record 0 is {rom[attacks:attacks + 32].hex()}')

Run it as python3 mvc1_frames.py mvsc.zip 20. The ID is hex; 20 is Mega Man. His first line shows 1 2* 4 2 3 with startup 2, active 2, recovery 9, total 12, the same as the training room at the top of the page. For most characters, animations 0, 1 and 2 of a group are the light, medium and heavy buttons. A few aren't: Captain America's standing HP (8/4), crouching MP and HP (10/4 and 10/5) and jumping MP and HP (12/6 and 12/7), Chun-Li's jumping HK (13/5), and Ryu's jumping MK and HK, which sit in group 21 (21/4 and 21/5). The training room shows the animation each move uses.

The layout borrows from recent research on reading charts and on attention. None of these papers tests a frame-data page or ADHD readers of articles, so each line says what was borrowed. The dates are arXiv upload dates.

• Nothing moves until you ask. In Juicy Interactive Visualization (October 2026), the clearest engagement gains came from feedback after an interaction, not from stronger effects. The training room waits on its first frame.
• Play stops on each phase. Cutting instructional videos into one-step segments with fixed pauses helped everyone in Leveling the Playing Field (July 2026), and helped learners with ADHD more. Loop plays straight through.
• One line of setup. Removing distractions made videos easier to watch for viewers with ADHD in FocusView (July 2025), whose authors suggest keeping options few so adjusting them doesn't distract too. A study of r/ADHD posts (October 2026) found tools often demand the self-regulation they're meant to support, so nothing here needs setting first.
• A sentence, then the chart. Text first led readers to confirm its claim, and a chart first led them to explore, in Multimodal Data Comprehension (July 2026, revised October). Chart titles shape what people see in them (Quick-View Takeaways, September 2026), so the titles here state the result.
• One real case, step by step. Interactive worked examples beat passive ones in a February 2026 study. The frame meter, the damage chain and the pointer chain each follow one move.
• The same colors everywhere. Under divided attention, designs that break expected mappings cost more time and accuracy (Divided Attention, August 2026). Startup is always green, active amber and recovery cyan, and a longer bar always means more frames.
• Common words, one name per idea. Fewer words can still mean harder words: in an October 2026 comparison, shortened rewrites were predicted to take longer per word, because the words were longer and rarer.

These studies shape the presentation. They don't establish anything about MvC1; that comes from the ROM and the running game.