Every WCW/nWo Revenge fighter, ranked by the game's own damage math

WCW/nWo Revenge has 90 roster slots, 62 real fighters and twenty-five years of argument about which of them is best. With the damage formula decoded, each fighter's move table can now be run through the game's own arithmetic, and this is the ranking that comes out.

Who counts as a fighter#

Two mechanical filters reduce the 90 roster slots in the ROM to the list that gets ranked.

• Thirteen slots are not wrestlers. Managers and valets have placeholder move tables worth 329 to 590 damage in total, against 1,765 to 2,172 for a real fighter. The cut-off is the largest relative jump in the sorted sums, a factor of three here. A fixed threshold would not transfer to other games: 1,200 suits Revenge but falls on the median of No Mercy. That leaves 77.
• Fifteen more are duplicates that share another slot's parameter file, mostly the same fighter under a second name. One is a valet, Sister Sherri, on Sting's file. That leaves 62 distinct fighters.

Why not a weighted score#

Tier lists usually normalise a few columns, weight them and add them up. The weights are a preference, since nothing says how much an ability byte should count against a whole move table. Normalising and rescaling also put 100 at the top and 0 at the bottom by construction, so a score of 100 means only "best of these 62". With the engine decoded, none of this is needed. The Rating of the AKI Anvil computes the ranking below in the browser for any supported cartridge, and there is nothing to configure.

Scoring with the engine's formula#

The damage formula comes from the write-up on the pin mechanic. Every fighter's move table runs through it against one standard opponent, the roster average, so all fighters are compared under the same conditions.

# a fresh limb has condition 50, so the condition term is exactly the
# move's base damage:  (50 + 50) * base / 100 == base

damage_per_move = max(0, base)
                + max(0, (my attack[limb] - their defence[limb]) * base / 10)

# each term is clipped at zero, as the engine clips it. Two things the
# engine does are left out on purpose: the spirit term (both sides sit at
# the same spirit here, so it is zero) and integer truncation (the average
# opponent has fractional defence, so this stays in floats)

# average that over the moves that carry damage, against the average
# defence of the 62-fighter field:

deals   = mean over my moves of damage_per_move        # health points
takes   = mean over the five limbs of the damage the   # health points
          average attacker's average move does to me

moves_to_finish = 255 / deals      # how long I need to empty someone
moves_i_survive = 255 / takes      # how long I last

index = moves_i_survive / moves_to_finish

Deals and takes are both in health points. Dividing 255 health by each gives the moves a fighter needs to finish an opponent and the moves they survive, and the index is the ratio of the two. Above 1.0, a fighter outlasts the time they need to win. The damage term was checked against the ROM in the pin write-up, while the averaging is this article's own arithmetic. An independent recomputation from the raw tables reproduces all 62 rows.

The ranking#

Scott Norton comes first with an index of 1.184. He needs 17.4 moves to finish the average opponent and survives 20.5, so his reputation among players as a hidden gem holds up. Goldberg is 8th, Sting 12th and Hollywood Hogan 24th.

Norton's parameter file reads 3 5 5 1 2 for offence and 3 4 4 2 4 for defence. That is 33 points, with two maxed offence values that only Giant, Norton, Luger and Goldberg have. Together with a move table near the top of the field, it puts him first.

A flat roster#

The roster is much flatter than the arguments suggest. Damage per move ranges from 11.71 to 14.70, a spread of 25 %, and the index from 0.874 to 1.184, about 35 %. No fighter deals double what another does. The ability bytes change a move's damage by a few percent either way, and the move's base damage does the rest.

Against the engine's order, the ability-byte total is off by 6.5 places on average and the move-table total by 16.0, while the two disagree with each other by 18.4. The stat sheet the game shows is a fair guide to what the engine does. The move-table totals are not.

Method and sources#

Everything was computed from a dump of my own cartridge with the AKI Anvil, and bin/strength.js <rom> prints the same table on the command line. The damage formula was read out of the game code and then executed in a MIPS interpreter against the cartridge's own memory image. No ROM data is reproduced here.

The ranking covers the three games whose per-wrestler move tables are decoded: World Tour, Virtual Pro-Wrestling 64 and Revenge. WrestleMania 2000, Virtual Pro-Wrestling 2 and No Mercy instead hold one shared move table of 1,702, 2,302 and 2,136 entries, which each wrestler's moveset points into. All of those movesets decode (58 of 58, 98 of 98 and 64 of 64), so the same ranking is possible there. It has not been built yet.

So the long argument has an answer: Scott Norton, by a narrow margin over Chris Benoit. More telling is how little separates the rest of the roster, and that the stat screen was a fair guide all along.