How a Move Works in the Six AKI N64 Wrestling Games, and a Shooting Star Press for Andre the Giant

You can watch Billy Kidman throw a Shooting Star Press in WCW/nWo Revenge. Andre the Giant stands in WWF No Mercy, two games and two years later. Somebody asked me whether that move could travel. The honest answer is not a yes or a no. It is a measurement, and I had two cartridges and my own tool. To make the measurement I first had to know what a move in these games really is. That turned out to be the better story.

What a move is: 98 bytes a frame

There is no curve in these files, no spline, no compression. An animation is a stack of whole poses, one after another, each exactly the same size. bun bin/animation.js roms/wcw_nwo_revenge_usa.z64 prints the shape in one line: header 4 B, frame 98 B, 19 bones, angle unit 0.3515625 degrees. The same line comes out of all six cartridges, unchanged.

Those 98 bytes go a long way, because nearly everything in them is an angle and an angle is ten bits. One bone is one big-endian 32-bit word: three angles of 10 bits in bits 0 to 9, 10 to 19 and 20 to 29, and two flag bits above them. The unit is 360 divided by 1024. The game does not hide that constant — it stands in the unpacker of every ROM, and verifyRotationConstants reads the chain out of the code per game rather than trusting the number.

4 B     header    base angle (10 bits) | header kind (6 bits) | duration (u16, half frames)
98 B    one frame, and every frame in the file is 98 B:

        19 bones x 4 B rotation word                 =  76 B
         1 root  x 4 B absolute translation          =   4 B
         6 bones x 3 B translation relative to root  =  18 B
                                                        98 B

bone word   bits  0..9   angle about X      x 360/1024 degrees
            bits 10..19  angle about Y
            bits 20..29  angle about Z
            bit  30      this translation is the relative 3-byte form
            bit  31      a translation block follows this word

file size   4 + 98 * frames        Revenge 1BCF: 4 + 98 * 13 = 1278 B

The header is four bytes and all three fields are read out of the game's own code. The u16 at byte 2 is the duration in half frames: the streamer forms the frame number as time >> 1 (No Mercy RAM 0x800129FC). In 94.2 to 96.9 percent of the files of each game, (duration >> 1) + 1 is exactly the frame count, and in not a single file of any of the six is it more. Bits 0 to 9 of byte 0 are an angle in the same unit as the bones; bits 10 to 15 are a 6-bit kind whose meaning is still unknown — it takes 0 to 32 in the three early games and 0 to 55 in the three later ones.

Every bone turns in world space

This is the part that decides whether a move can travel, so it is worth getting exactly right. In a normal skeleton an angle is relative to the parent: turn the upper arm and the forearm comes along, because the forearm's matrix is multiplied onto its parent's. AKI does not do that. Each of the 19 words is an absolute orientation in world space. The parent contributes a position and nothing else.

The evidence is a number that could have gone the other way. verifyPoseChain poses a frame the way the tool computes it, compares it against the game's own routines running in a MIPS interpreter, and computes the same frame the wrong way as a control. No Mercy, file 2DD9 frame 1: deviation 1.9e-7 in rotation and 9.5e-6 in position over 12,591 emulated steps. Chain the rotations like an ordinary skeleton and the deviation is 1.99; inherit the positions and it is 69.5 units. Revenge prints the same shape: 3.2e-7 against 1.95 and 69.3.

Where do the twelve other bones get their position? Not from the animation. The animation carries no bone lengths at all. Eighty bytes in the ROM do, and those eighty bytes are byte for byte identical in all six games, sitting exactly once in each: 40 bytes of joint offsets, 20 of processing order, 20 of parents. The pose loop reads exactly those three tables, and findPoseRoutines finds exactly one candidate per ROM.

  0 pelvis            parent -1   joint offset    0, 10, 0     translation: absolute
  1 lower_ab          parent -1   joint offset    0, 23, 0     translation: relative
  2 upper_body        parent -1   joint offset    0, 35, 0     translation: relative
  3 neck              parent  2   joint offset    0, 58, 0
  4 head              parent  3   joint offset    0, 72, 0
  6 upper_left_leg    parent -1   joint offset    9,  6, 0     translation: relative
  5 lower_left_leg    parent  6   joint offset    9,-31, 0
  7 left_foot         parent  5   joint offset    9,-74, 0
 11 upper_left_arm    parent -1   joint offset   22, 56, 0     translation: relative
 10 lower_left_arm    parent 11   joint offset   24, 29, 0
  8 left_hand         parent 10   joint offset   24,  7, 0
  9 left_fingers      parent  8   joint offset   24, -4, 0
                                  ... and the right side, mirrored

for a bone with a parent:
   position = parent matrix * (own joint offset - parent joint offset), z = 0

# No Mercy point transform 0x80038B20, called from the pose loop at 0x80012D34.
# The bone NAMES come from VPW Studio and are likely, not confirmed. Their
# POSITIONS are proven: the head sits highest, the foot 74 down, the hand 24
# out to the side, and exactly the six named movement bones carry a
# translation of their own.

For anyone posing a figure this is the whole ball game. An elbow bend is not an angle you add to the forearm: it is the forearm's world angle minus the upper arm's. Turn a shoulder and the hand keeps pointing exactly where it did, floating in the wrong place, until you turn it too. It is unusual, it is unforgiving in an editor, and it is the single reason a move survives a trip to another cartridge: 19 absolute orientations need no context to mean what they mean.

Half frames, and the 180 degree flip

The stored frames are not what you see. The animation timer of a wrestler advances by one half frame per update — confirmed in No Mercy, where the per-wrestler routine at RAM 0x80063080 reads the timer at struct offset 758, adds 1, and hands it to the streamer, which forms frame = time >> 1. So every stored frame is held for two updates, and on the odd half the player stands between two frames and blends.

The blend is linear and it is two different things at once. Translation is the obvious one: current += (target - current) * t. The angle is not, because angles wrap: the difference is first moved into the interval from -180 to +180, and only then scaled. In World Tour, VPW64 and No Mercy that normalisation is a routine of its own with the constants 180, 360 and -180 sitting next to it; emulated, it agrees with the tool's own wrapDegrees over 15 probes including both edges, largest deviation 0. In Revenge, WrestleMania 2000 and VPW2 the same three constants sit inline in the caller, so what is proven there is the place, not the computation. The tool marks interpolation likely for that reason, and says per game which of the two it has.

Then there is the strangest rule in the format. If the normalised difference on X or on Z is bigger than a threshold, the player adds 180 degrees to both of them and normalises again. Y is left alone. In No Mercy this is one site, RAM 0x800134CC to 0x80013534, with the threshold 120 loaded from 0x80055BF0. A rotation that would sweep the long way round is turned into a flip instead. poseSkeleton reproduces the branch and reports in flipped_bones how many bones it changed; at a whole frame the blend factor is 0 and the branch never fires, which is why a filmstrip of stored poses can look right while the motion between them does not.

Toki1: the track that does not travel

An animation says how a body moves. It says nothing about when the hit lands, when the other man may reverse it, when the camera cuts, or when the table breaks. That is a second file, one fixed-size record per animation, and the scene calls it Toki1. Revenge, WrestleMania 2000, VPW2 and No Mercy keep 36 bytes per record, World Tour and VPW64 32. The record is found by arithmetic, not by search: pointer + (animation id - first animation id) * stride.

That arithmetic is proven by running the game's own unpacker. findToki1Unpacker anchors on the bound check against the first animation id, puts a fake table behind every global the routine loads, and calls it for two consecutive ids: the bytes it reads lie exactly one stride apart, and two fill patterns show which record byte it copies where. All six unpackers read bytes 0x00 to 0x13 and copy 18 of them into one output struct. A sibling routine returns record + 0x14, where the eight effect pairs begin. The file id itself is not guessed either — the function that stores the pointer names it as an immediate.

The field names come from VPW Studio and are a label, not evidence: damage_begin, damage_end, reversal_begin, first_vulnerable, breakaway_frame, replay_frame, table_break_frame, and in the late games ground_hold_interrupt_frame. Exactly one pair is confirmed, and only in No Mercy: the camera reader at RAM 0x80011AE8 loads byte 0x0D, compares it against the animation timer, and returns byte 0x0E once the timer has reached it. Everything else is likely, held up by a second measurement instead of a proof: how often a labelled frame column falls inside the header duration when you read it as half frames. No Mercy and WrestleMania 2000 put 20 of 20 columns at 98 percent or above; Revenge and VPW2 17 of 20; World Tour 17 of 18; VPW64 15 of 18. Read them as whole frames instead and the same columns drop to 30 to 75 percent, which is the argument for the unit.

$ bun bin/animation.js roms/wcw_nwo_revenge_usa.z64 --toki1 1BCF
     file 020F, record 3478, 36 B, 13 frames, duration 25 half frames
$ bun bin/animation.js roms/wwf_no_mercy_usa_rev_a.z64 --toki1 40D5
     file 02BF, record 4860, 36 B, 13 frames, duration 25 half frames

  field                     Revenge 1BCF   No Mercy 40D5    status
  damage_begin / _end          unset           unset         likely
  reversal_begin                   8               8         likely
  first_vulnerable             unset           unset         likely
  breakaway_frame              unset           unset         likely
  motion_effect_frame             14              10         likely
  camera_effect_frame              0               0         confirmed
  camera_effect_value              0               5         confirmed
  effect pairs set          1,3,4,5,6           2,6,8        likely

  of the 20 bytes the unpacker copies:  18 equal,  2 differ
  of the 16 effect bytes:                5 equal, 11 differ

How general is that? I measured it over every motion the two games share. Revenge and No Mercy have 2202 bone streams in common. Of those 2202, only 526 carry an identical four-byte header, and only 23 carry an identical Toki1 record. The event record belongs to the file id, not to the frames. Which means the rule for a transplant is simple and unavoidable: a move written into a new file fires the events of the file it overwrote.

How damage is computed

There is no randomness in it. The hit routine of each game was run in the interpreter against the cartridge's own memory image, and the formula that came out is three sums and a clamp. bun bin/engine.js roms/*.z64 --quiet grades it per game: 24 to 27 named cases, 1000 swept cases and 200 cases built from real ROM data, zero deviations in all six.

base   = the damage field of the move entry
         (No Mercy: byte 0x06 of a 36-byte entry; the early games: bits 11..16
          of word 0 of a 24-byte entry)
off, def = the two parameter slots the move names, each 0..4

part 1 = (condition[off] + 50) * base / 100      condition 0..50, 50 in special mode
part 2 = (attack[off] - defence[def]) * base / 10      both 1..5, from the parameters
part 3 = (spirit attacker - spirit defender) / 20      only when base is not 0

sum    = max(0, part 1) + max(0, part 2) + max(0, part 3)
         special mode:      sum = trunc(sum * 1.2)
         four of the six:   sum = trunc(sum * level factor)

HP     = min(MaxHP, HP - sum)
MaxHP -= sum / 4          floor 128 in the early three, 64 in the late three
condition[i] -= the move's body-part damage[i], floor 0

Two rules are local to one game each and worth knowing. No Mercy alone has special damage: if byte 0x1C/0x1D of an entry names a move and that move was the one played last, the base comes from byte 0x1B instead — a combo bonus, written into the table. And every late game has a hold bit (No Mercy 0x20, VPW2 0x1C, WrestleMania 2000 0x1E): when it is set the routine computes the whole sum and then applies none of it, leaving HP and MaxHP alone. That it means “this is a pin” is a hypothesis; the effect is measured, and every entry on the roster that has it is a pinning hold — School Boy, Backslide Pin, La Mahistral, Sunset Flip Pin.

The level factor is the split nobody would guess from the release dates. Four of the six scale the finished sum by a table of seven values, [0.5 0.625 0.75 0.875 1 1.16 1.33], indexed by one word in memory: World Tour 0x800618C8, VPW64 0x800724A8, Revenge 0x8007E838, WrestleMania 2000 0x800974A0. VPW2 and No Mercy have no such factor, and that absence is confirmed rather than assumed: the formula without one matches 1000 swept cases and 200 real ones exactly. That the word is the difficulty a player sets is only a hypothesis — what is proven is that it indexes that table.

Which gives the ceiling, and the ceiling is worth stating because it is what a home-made move runs into. engineLimit asks the formula for the heaviest hit it can compute: damage 255, the attacker in perfect condition with every ability at maximum, spirit 100 against 0, against a defender with nothing. The answer is 382 + 255 + 5 = 642 points, and with the level factor at its top step 853. A health bar holds 255. So one hit at the limit cannot be survived, it can only be capped — and it takes 160 points off the maximum health (213 in the four games with the factor), which never comes back for the rest of the match.

What differs between the six

The animation layer barely moved in four years. The frame is 98 bytes in all six games, the skeleton block is the same 80 bytes, the angle unit never changes, and the encoder reproduces every file of every game. What did move is everything wrapped around the frames: the event record, the display matrix, the damage table, and whether the game knows the name of its own moves.

Four things in that table surprised me:

• Revenge is already modern in the Toki1 record and still old everywhere else. It jumps to the 36-byte event record two years before WrestleMania 2000 does, while keeping the 24-byte damage entry, no move names and no per-bone display matrix. The break between the generations does not fall in one place.
• The level factor stops after WrestleMania 2000, not after Revenge. Four games scale every hit by a table of seven values; VPW2 and No Mercy do not, and the absence is measured rather than assumed. The same two games are the ones whose engine ceiling drops from 853 to 642.
• VPW2 holds more animation than No Mercy. 6,291 files and 153,300 frames against 5,789 and 152,778, on the same size of cartridge.
• The early games do not know what their own moves are called. World Tour, VPW64 and Revenge carry no move names at all — not hidden, not compressed, absent. That is the problem the next section solves, and it is why this article has an ending.

Carrying a move across a game

AKI reused motions between the six games without touching them. The identity of a motion is therefore the simplest thing imaginable: the bone stream from byte 4 on. Not the file, because the four header bytes were renumbered between generations. Not the id, which is local to a game. Just the frames.

bun bin/rosetta.js roms/*.z64 links all six in about a second. A checksum finds the candidates; the bytes decide. Every pair is then compared byte for byte, and a hash collision with unequal bytes aborts the run rather than reporting a wrong link. Over all 30 ordered pairs the run reports zero collisions.

Finding a move is one half. Writing it is the other, and there the six are not equal. A target has to carry four things: a packed moveset whose loader indexes category lists, a damage table with a name and an AKI key per entry, a category list with room to grow, and a Toki1 table. Measured: WrestleMania 2000 has 129 category lists, 71 of them growable, and 67 writable moveset slots; VPW2 133 and 73 and 83; No Mercy 138 and 83 and 109. The early three name no category lists at all — the module refuses them by name rather than guessing. So the source may be any of the six and the target must be one of three: 15 of the 30 ordered pairs.

Kidman's Shooting Star Press, for Andre the Giant

Everything above exists so that this question can be answered with numbers instead of an opinion. The question was: can you take a Shooting Star Press off Billy Kidman in WCW/nWo Revenge and give it to Andre the Giant in WWF No Mercy?

Finding a move in a game that has no move names

Revenge does not know what any of its moves are called. There is no name table, nothing hidden in a compressed file, nothing. What it has is a roster row with a moveset file, and a moveset file full of numbers.

Revenge roster index 19   "Kidman"   ID2 0x2E   ID4 0503   moveset file 0196

  moveset slots 397 and 402 both hold      2756
  first_move_animation_id                0x110B
  0x110B + 2756                          0x1BCF

$ bun bin/animation.js roms/wcw_nwo_revenge_usa.z64 --file 1BCF
  File 1BCF: 1278 B, 13 frames, 19 bones
  Header: base angle 0.000 degrees, kind 0,
          duration 25 half frames = 13 played frames
  Channels: 19 rotation, 1 absolute translation, 6 relative translation

The name arrives from the other cartridge. The bone stream of 1BCF from byte 4 on is byte for byte identical with No Mercy's file 40D5, and No Mercy does carry names: “Shooting Star Press”, AKI key N3804AA1, damage index 1635. That is not a similarity score and not a name match. It is 1274 identical bytes, compared one by one after the hash found the candidate. Kidman is one of 879 Revenge animations that get a No Mercy name this way.

The find I was not looking for

No Mercy has the Shooting Star Press. It has the animation, the damage entry, the AKI key, a place in a move category and a menu record. What it does not have is anybody who throws it.

Master move 30D4 maps to damage index 1635 and to animation 40D5. It sits in category list 98 at index 9 of 13, between “Rios Back Flip Splash” and “Swanton Bomb”. I walked every moveset in the cartridge looking for it: 101 movesets, 15,857 slots, zero uses. That list holds an empty first entry and twelve real moves, and it is not the only orphan in it: “Back Flip Splash 02” and “Dragon Attack” are on nobody either. The other nine are on somebody.

What the thirteen frames actually do

frame   pelvis X (deg)      root x, y, z
    0      158.555           0, 181,   0      stands, then leaves the floor
    1      150.117           0, 195,   1
    2      151.172           0, 198,  -1
    3      163.125           0, 199,  -9
    4      182.813           0, 202, -23
    5      196.875           0, 217, -44
    6      223.945           0, 232, -40
    7      267.891           0, 239, -37      top of the jump
    8      292.500           0, 237, -38
    9      309.375           0, 233, -39
   10      331.172           0, 226, -42
   11        6.680           0, 202, -48      wraps past 360
   12       33.750           0, 158, -53      lands below where it started

  rotation about X:  158.6 -> 393.8 degrees, a 235 degree somersault
  root height:       181 -> 239 -> 158
  root travel:         0 -> -53 on z, 0 on x throughout

The transplant

Andre the Giant in No Mercy is ID2 0x2E, ID4 0606, and his moveset slot 0x106 is a flying attack on a laying opponent. It held “Body Splash”. The Revenge file is read into the studio as a document of 13 keyframes, and the studio writes it back out as an animation file.

What carries and what does not is the interesting half. The written file is the same size, 1278 bytes, and 122 of those bytes differ from the Revenge original. I counted where they sit.

file 1BCF, 1278 B          differs after the round trip
    4 B  header                1     duration 25 -> 24 half frames
  988 B  19 x 13 rotations      0     every angle of every bone, to the unit
   52 B  13 root translations   0     the root, to the unit
  234 B  6 x 13 relative        121   re-derived from the joint offsets
                              ----
                               122

  worst relative deviation: 3 half units
  playerProof on the written file: angle deviation 0,
                                   matrix deviation 3.0e-8,
                                   root deviation 0

The rest is wiring, and the tool picks it rather than being told. The target file 411E was chosen automatically because it is a byte-identical duplicate of 349F with the same Toki1 record: overwriting it loses nothing, and the one reference that still named it — a row in the intro definitions — was re-pointed at its twin. The animation did not have to grow (1278 in, 1278 out, deficit 0). The wiring around it needed 24 bytes more than its slots held, which came out of re-packing, and 19,352 files moved as a result.

A fresh master move 307B was appended to category list 97, which grew from 12 entries to 13. A placeholder damage entry — No Mercy ships 89 rows named “((( none ok )))”, and 29 of them are in no category and no moveset — was renamed to “Shooting Star Press”, given the AKI id RV3804-A and the damage columns of 1635: damage 35, body 3, speed 3, pin 1, spirit gain 10. So the cartridge now carries the move twice: its own unused copy, and Andre's.

verifyMoveWrite            18 pass, 0 fail, 2 not measured
  animation bytes          411E 1278 B byte-identical to encodeAnimation(document)
  animation listed         readAnimations lists 411E with 13 frames, status confirmed
  toki1 record             record 4933 of file 02BF, no field scaled
  crc                      CIC-6102 header FA870EC6 C82D05CE = computed
  references re-pointed    1 of 1 now name 349F
  roster slot              ANDRE THE GIANT slot 106: master 307B "Shooting Star Press"
  moveset intact           157 slots, 0 undefined
  other files unchanged    19,449 files outside the plan byte-identical
analyze on the clone       22 checks, 0 fail

$ bun test/thirdparty.test.js
ok   rom64 nm-kidman: computes the checksum the header carries, CIC 6102
ok   n64crc nm-kidman: both checksum words Good on CIC-NUS-6102
ok   mupen64plus boots the clone nm-kidman to frame 200 with the same screen

Methodology

Everything here was read from dumps of my own cartridges with AKI Anvil on 11 September 2026. No ROM bytes are reproduced on this page — only counts, ids, offsets and rates. Structure names such as Toki1 and the bone names come from VPW Studio (MIT, AKI Club) and are not evidence in themselves: what each one does was measured against the cartridge, and the tool grades every statement as confirmed (emulated or re-encoded against a real ROM, with a check that could have gone red), likely (the place is pinned, the computation is not), auto (found by search alone) or hypothesis (observed and nothing more). The same MIPS interpreter is behind the pin mechanic, the engine ranking and the music format.

bun bin/animation.js roms/*.z64                     # the per-game report and its checks
bun bin/animation.js roms/*.z64 --encode-check      # "N of N files byte-identical"
bun bin/animation.js <rom> --file 1BCF              # one animation, bone by bone, frame by frame
bun bin/animation.js <rom> --toki1 1BCF             # its event record, every field with a status
bun bin/engine.js roms/*.z64 --quiet                # the damage formula, proven per game
bun bin/engine.js roms/wwf_no_mercy_usa_rev_a.z64   # the same with the formula printed out
bun bin/rosetta.js roms/*.z64                       # the same motion across game boundaries
bun bin/cartridge.js roms/*.z64                     # header, boot chip, tail padding, digest
python3 docs/revenge_pin.py                         # the pin mechanics, runnable, self-checking
bun test/thirdparty.test.js                         # rom64, n64crc and mupen64plus as judges

# The transplant itself is the Studio tab of the tool with both ROMs open:
# pick the reference animation by its No Mercy name, "Take into the studio",
# choose the wrestler and the slot, write. The same code path runs headless
# in test/thirdparty.test.js as nm-kidman.