There Is No Minimum Pin Count in WCW/nWo Revenge — There Is a Three-Tick Cap, and Spirit Lifts It

# the whole legend, in nine lines
#
#   the referee reaches three after 90 ticks of holding somebody down.
#   this is what the game does to that number.

if victim.kickouts_this_match < 2:

    if attacker.spirit - victim.spirit >= 70 and victim.health == 0:
        pass                        # the one exception: a first cover can win

    else if hold_time >= 88:
        hold_time = 87              # three ticks short. every time.

"""WCW/nWo Revenge (N64) - the fight logic, as running code.

Every constant and every branch below was read out of the cartridge's own
MIPS code and then checked by executing that code in an interpreter.  The
ROM address each part comes from is named in the comment above it, so any
line here can be traced back to the machine code it models.

Units: health 0..255, spirit 0..100, limb condition 0..127.
Time is measured in ticks of the game's own logic loop.

    python3 revenge_pin.py        # runs the self-check at the bottom
"""

from dataclasses import dataclass, field

REFEREE_PERIOD = 30      # 0x800B8D8C calls tick(clock, 30)
COUNT_TO_WIN = 3         # measured: count 1 at tick 30, 2 at 60, 3 at 90
TICKS_TO_WIN = REFEREE_PERIOD * COUNT_TO_WIN            # = 90


@dataclass
class Wrestler:
    """One 944-byte record at 0x800F9D10 + 944 * slot."""
    health: int = 255                    # +0x10
    max_health: int = 255                # +0x12, permanent, floor 128
    spirit: int = 50                     # +0x14
    limb_condition: list = field(default_factory=lambda: [100] * 5)   # +0x34C

    # the ten ability bytes of the 64-byte parameter file, each 1..5
    attack: list = field(default_factory=lambda: [3] * 5)      # bytes 5..9
    defence: list = field(default_factory=lambda: [3] * 5)     # bytes 10..14

    # bits of the flag word at +0x24
    being_pinned: bool = False           # 0x00000400
    spirit_empty: bool = False           # 0x00020000
    spirit_full: bool = False            # 0x00040000
    special_active: bool = False         # 0x00080000
    marked: bool = False                 # 0x00000100, position-dependent

    # per-wrestler match counters, wiped to zero at the bell
    holds: int = 0                       # 0x800FADD2 + 2 * slot
    escapes: int = 0                     # 0x800F9B80 + 2 * slot   <- the rule
    hold_timer: int = 0                  # +0x18


@dataclass
class Move:
    damage: int
    limb: int = 0
    limb_damage: int = 0
    spirit_gain: int = 0
    spirit_drain: int = 0


@dataclass
class Rules:
    """Two bits of the word at 0x8007F0A0, set by the match options screen."""
    pinfalls_enabled: bool = True        # bit 0x0020; off -> every pin lasts 5 ticks
    bit_0x0100: bool = True


# ── how fresh the limb is ───────────────────────────────────────── 0x800BF1E0
def limb_condition(w: Wrestler, limb: int) -> int:
    if w.special_active:
        return 50                        # flat, whatever the real wear is
    return w.limb_condition[limb]


# ── which health value counts ───────────────────────────────────── 0x800BF2FC
def life(w: Wrestler) -> int:
    """The pin reads MAXIMUM health while the special is up.  That single
    substitution is why a charged wrestler cannot be pinned."""
    return w.max_health if w.special_active else w.health


# ── the spirit meter ────────────────────────────────────────────── 0x800BF62C
def spirit_apply(w: Wrestler, amount: int) -> None:
    if w.spirit_empty or w.spirit_full or w.special_active:
        return                           # frozen in all three states
    w.spirit += amount
    if w.spirit >= 100:
        w.spirit, w.spirit_full = 100, True
    elif w.spirit <= 0:
        w.spirit, w.spirit_empty = 0, True


# ── the meter left to itself, every 120 ticks ───────────────────── 0x800BF700
def spirit_drift(w: Wrestler, opponent_marked: bool = False) -> None:
    if w.spirit_full or w.special_active or w.spirit_empty:
        return                           # each end has its own countdown
    if w.marked and not opponent_marked:
        w.spirit = max(1, w.spirit - 8)
    elif w.spirit > 50:
        w.spirit -= 1
    elif w.spirit == 50:
        pass                             # the resting point
    elif w.spirit >= 31:
        w.spirit += 2
    else:
        w.spirit += 3                    # the lower you are, the faster back


# ── damage ──────────────────────────────────────────────────────── 0x800B68A0
def hit(attacker: Wrestler, defender: Wrestler, move: Move,
        level_scale: float = 1.0) -> int:
    cond = limb_condition(attacker, move.limb)
    part1 = (cond + 50) * move.damage // 100
    part2 = (attacker.attack[move.limb] - defender.defence[move.limb]) * move.damage // 10
    part3 = (attacker.spirit - defender.spirit) // 20

    total = max(0, part1) + max(0, part2) + max(0, part3)
    if attacker.special_active:
        total = int(total * 1.2)
    total = int(total * level_scale)

    defender.health = max(0, defender.health - total)          # never negative
    defender.max_health = max(128, defender.max_health - total // 4)
    defender.limb_condition[move.limb] = max(0, defender.limb_condition[move.limb] - move.limb_damage)
    spirit_apply(attacker, move.spirit_gain)
    spirit_apply(defender, move.spirit_drain)
    return total


# ── how long the victim is held down ────────────────── 0x800CA760 / 0x800B6F64
def hold_time(victim: Wrestler, attacker: Wrestler, rules: Rules = Rules()) -> int:
    victim.holds += 1                    # counted BEFORE the formula reads it

    if not rules.pinfalls_enabled:       # 0x800CA830
        return 5                         # the referee never reaches one
    if victim.marked and not rules.bit_0x0100:
        return 30                        # exactly a one count, always

    hold = (110
            + attacker.spirit // 4
            + 3 * victim.holds
            - life(victim)
            - victim.spirit // 2)
    hold = max(0, hold)

    # ---- THE RULE, 0x800CA920, eighteen instructions ----------------
    if victim.escapes < 2:
        spirit_gap = attacker.spirit - victim.spirit
        exception = spirit_gap >= 70 and life(victim) == 0
        if not exception and hold >= 88:
            hold = 87                    # three ticks short of ninety
    # -----------------------------------------------------------------

    return max(15, hold)                 # 0x800CA9F8


# ── the race between the two counters ───────────────── 0x800CAA70 / 0x800B8D8C
def resolve_pin(victim: Wrestler, attacker: Wrestler, mash: int = 0,
                rules: Rules = Rules()) -> dict:
    """mash is 0, 1 or 2 extra ticks per turn (buttons A, B, L, R)."""
    timer = hold_time(victim, attacker, rules)
    start = timer
    tick = 0
    while timer >= 0:
        tick += 1
        timer -= (1 + mash)
    count = min(COUNT_TO_WIN, tick // REFEREE_PERIOD)
    if count >= COUNT_TO_WIN:
        return dict(hold=start, tick=tick, count=count, result="PINFALL")
    victim.escapes += 1                  # only a clean kick-out counts
    return dict(hold=start, tick=tick, count=count, result="kick-out")


# ── self-check against the numbers measured in the ROM ──────────────────────
if __name__ == "__main__":
    def fresh(hp, spirit, escapes=0, special=False, max_health=400):
        # In a run of pure pin attempts both counters advance together: every
        # attempt raises holds, every clean kick-out raises escapes.  So a
        # wrestler who has escaped twice has also been held twice.
        return Wrestler(health=hp, max_health=max_health, spirit=spirit,
                        escapes=escapes, holds=escapes, special_active=special)

    # (victim hp, victim spirit, attacker spirit, escapes) -> (hold, count)
    EXPECTED = [
        ((255, 20, 50, 0), (15, 0)), ((150, 20, 50, 0), (15, 0)),
        ((100, 20, 50, 0), (15, 0)), ((60, 20, 50, 0), (55, 1)),
        ((30, 20, 50, 0), (85, 2)),  ((0, 20, 50, 0), (87, 2)),
        ((0, 20, 50, 1), (87, 2)),   ((0, 20, 50, 2), (121, 3)),
        ((0, 20, 50, 3), (124, 3)),
        ((0, 0, 69, 0), (87, 2)),    ((0, 0, 70, 0), (130, 3)),
        ((0, 20, 90, 0), (125, 3)),
    ]
    bad = 0
    for (hp, vs, a_s, esc), (hold, count) in EXPECTED:
        r = resolve_pin(fresh(hp, vs, esc), fresh(255, a_s))
        ok = r["hold"] == hold and r["count"] == count
        bad += 0 if ok else 1
        print(f"  hp={hp:3d} spirit={vs:3d} atk={a_s:3d} escapes={esc}  "
              f"-> hold {r['hold']:3d} count {r['count']}  {r['result']:8s}"
              f"{'' if ok else f'   MISMATCH, expected {hold}/{count}'}")

    # a charged special cannot be pinned, at any health
    for hp in (255, 100, 0):
        r = resolve_pin(fresh(hp, 20, escapes=5, special=True), fresh(255, 100))
        ok = r["result"] == "kick-out" and r["count"] == 0
        bad += 0 if ok else 1
        print(f"  special active, hp={hp:3d} -> hold {r['hold']:3d} "
              f"count {r['count']}  {r['result']}{'' if ok else '   MISMATCH'}")

    print("\nall checks passed" if bad == 0 else f"\n{bad} MISMATCHES")

$ python3 revenge_pin.py

  hp=255 spirit= 20 atk= 50 escapes=0  -> hold  15 count 0  kick-out
  hp=150 spirit= 20 atk= 50 escapes=0  -> hold  15 count 0  kick-out
  hp=100 spirit= 20 atk= 50 escapes=0  -> hold  15 count 0  kick-out
  hp= 60 spirit= 20 atk= 50 escapes=0  -> hold  55 count 1  kick-out
  hp= 30 spirit= 20 atk= 50 escapes=0  -> hold  85 count 2  kick-out
  hp=  0 spirit= 20 atk= 50 escapes=0  -> hold  87 count 2  kick-out
  hp=  0 spirit= 20 atk= 50 escapes=1  -> hold  87 count 2  kick-out
  hp=  0 spirit= 20 atk= 50 escapes=2  -> hold 121 count 3  PINFALL
  hp=  0 spirit= 20 atk= 50 escapes=3  -> hold 124 count 3  PINFALL
  hp=  0 spirit=  0 atk= 69 escapes=0  -> hold  87 count 2  kick-out
  hp=  0 spirit=  0 atk= 70 escapes=0  -> hold 130 count 3  PINFALL
  hp=  0 spirit= 20 atk= 90 escapes=0  -> hold 125 count 3  PINFALL
  special active, hp=255 -> hold  15 count 0  kick-out
  special active, hp=100 -> hold  15 count 0  kick-out
  special active, hp=  0 -> hold  15 count 0  kick-out

all checks passed

.text   0x80090000 - 0x800E2B10    # 84,676 instructions, the actual program
.data   0x800E2B10 - 0x800E77B0    # 4,904 words of lookup tables
.bss    0x800E77B0 - 0x800FAFA0    # scratch space, empty until the game runs

0x800B8D8C   nobody is being pinned yet, so go looking

800B90A0   addu  $a0, $zero, $zero        # start at wrestler 0
800B90D4   lh    $v0, 0x800F9D12[slot]    # is this slot even in use?
800B90E8   lw    $v0, 0x800F9D30[slot]    # their flag words
800B90FC   and   $v1, $v1, 1024           # flag 0x400 - being pinned?
800B9104   beq   $v1, $zero, 800B911C     # no  -> try the next wrestler
800B9110   sb    $a0, 0x800EB46F          # yes -> remember who
800B9128   slti  $v0, $v0, 4              # four slots, then give up

0x800DA850   tick(clock, period)

800DA850   lhu   $v0, 4($a0)              # raw ticks
800DA85C   addiu $v0, $v0, 1              # one more
800DA86C   slt   $v0, $v0, $a1            # reached the period yet?
800DA870   bne   $v0, $zero, 800DA8AC     # no  -> done for this frame
800DA87C   sh    $zero, 4($a0)            # yes -> reset the ticks...
800DA884   sh    $v0, 2($a0)              # ...and add one to the count

--- 0x800DA850(clock, 30), executed against the real ROM image ---

  count reaches 1   at tick   30
  count reaches 2   at tick   60
  count reaches 3   at tick   90     # <- the match ends here
  count reaches 4   at tick  120

0x800B6F64   holdTime, case 1: the pin

800B6F64   lh    $v0, 20($t0)             # the attacker's spirit
800B6F70   sra   $v0, $v0, 2              #   divided by 4
800B6F74   addiu $v0, $v0, 110            #   plus 110          -> call this A
800B6F8C   lh    $v1, 0x800FADD2[slot]    # holds they have been in
800B6F98   addu  $v0, $v0, $v1            #   times 3           -> call this B
800B6F9C   jal   0x800BF2FC               # the victim's health
800B6FA4   lhu   $v1, 20($s0)             # the victim's spirit
800B6FC0   sra   $a0, $a0, 1              #   divided by 2
800B6FC4   addu  $v0, $v0, $a0            #   health + spirit/2  -> call this C
800B6FCC   subu  $v1, $v1, $v0            # result = A + B - C

0x800BF2FC   which health value to use

800BF2FC   lw    $a1, 36($a2)             # the victim's flag word
800BF318   and   $a1, $a1, 0x00080000     # is their special active?
800BF32C   lh    $v0, 16($a2)             # no  -> current health
800BF328   lh    $v0, 18($a2)             # yes -> MAXIMUM health

0x800CA920   inside the pin, right after the hold time is set

800CA924   lb    $v0, 0x800FADB8          # which wrestler is pinned
800CA934   lh    $v0, 0x800F9B80[slot]    # times HE has kicked out
800CA938   slti  $v0, $v0, 2              # fewer than two?
800CA93C   beq   $v0, $zero, 800CA99C     # no -> leave the pin alone

800CA954   lh    $v0, 20($v0)             # attacker's spirit
800CA958   lh    $v1, 20($a0)             # victim's spirit
800CA95C   subu  $v0, $v0, $v1            # the gap between them
800CA960   slti  $v0, $v0, 70             # under 70?
800CA964   bne   $v0, $zero, 800CA980     # yes -> shorten the hold
800CA96C   jal   0x800BF2FC               # else: the victim's health
800CA978   blez  $v0, 800CA99C            # exactly zero -> leave it alone

800CA988   lh    $v0, 24($v1)             # the hold time
800CA98C   slti  $v0, $v0, 88             # under 88 already?
800CA990   bne   $v0, $zero, 800CA99C     # yes -> nothing to do
800CA994   addiu $v0, $zero, 87           # no  -> make it 87
800CA998   sh    $v0, 24($v1)             # and write it back

                         ONE       TWO      THREE
  untouched     #####                                       15
  in trouble    ##################                          55
  nearly done   ############################                85
  0 hp, 1st pin #############################               87   trimmed from 115
  0 hp, 2nd pin #############################               87   trimmed from 118
  0 hp, 3rd pin ########################################   121   PINFALL
                +---------+---------+---------+---------+
                0        30        60        90        120

0x800CA830   two short-circuits before the real formula

800CA830   andi  $v0, $a3, 0x0020         # a match-rule bit
800CA834   beq   $v0, $zero, 800CAA18     # off -> hold time is just 5
800CA838   addiu $v0, $zero, 5

800CA858   and   $a1, $a1, 256            # victim carries flag 0x100?
800CA864   beq   $a1, $zero, 800CA87C     # no  -> the real formula
800CA860   andi  $v0, $a3, 0x0100         # and this rule bit is off?
800CA870   addiu $v0, $zero, 30           # then the hold is exactly 30
800CA878   sh    $v0, 24($a2)             #      - a one count, always

0x800CAA70   the escape, once per tick

800CAA70   jal   0x800D7690               # read the buttons, mask 0xC030
800CAAAC   addiu $v0, $a1, -1             # a press -> one extra tick off
800CAAB8   bne   $a0, $v0, 800CAAC4       # a stronger input?
800CAABC   addiu $v0, $a1, -2             #         -> two extra instead
800CAAD8   addiu $v0, $v0, -1             # and one always
800CAAF8   bgez  $v0, 800CAB3C            # below zero -> you are out

0x800BF62C   spiritApply(wrestler, amount)

800BF640   lui   $v1, 0x000E              # three flags: empty, full, special
800BF648   bne   $a0, $zero, 800BF6F8     # any of them set -> do nothing
800BF658   lhu   $v0, 20($a2)             # otherwise: spirit
800BF65C   addu  $v0, $v0, $a3            #   plus the amount
800BF66C   slti  $v0, $v0, 100            # reached 100?
800BF6A8   addiu $a0, $zero, 100          #   pin it at 100...
800BF6BC   or    $v1, $v1, 0x00040000     #   ...and raise SPECIAL READY
800BF6CC   bgtz  $v0, 800BF6F8            # dropped to zero or below?
800BF6E4   sh    $zero, 20($a2)           #   pin it at 0...
800BF6EC   or    $v1, $v1, 0x00020000     #   ...and raise EMPTY

0x800B68A0  hitRoutine(attacker, defender, move)
    |
    +-- 0x800BF1E0  conditionGetter   how fresh is the limb you strike with
    +-- 0x800BF338  hpApply           take it off health and off the ceiling
    +-- 0x800BF228  bodyApply         wear down the limb you landed on
    +-- 0x800BF62C  spiritApply       twice, once for each wrestler
    +-- 0x800BF700  meterTick         the 120 / 300 / 600 / 600 timers

part1  = (limb condition + 50) x base / 100
part2  = (your attack - their defence, that limb) x base / 10
part3  = (your spirit - their spirit) / 20
total  = part1 + part2 + part3            # negatives clipped to zero

health     = health - total               # clamped at 0
maxHealth  = maxHealth - total / 4        # permanent, floor of 128
limb       = limb - limb_damage           # floor of 0

0x800D4204   the number that gets compared

800D4204   lui   $a3, 0x5D58              # multiplier 0x5D588B65
800D4224   lui   $v0, 0x800F              # <- the loop comes back here
800D4228   lw    $v0, 0x800EB630          # state
800D422C   mult  $v0, $a3                 # state x multiplier
800D4234   addu  $v0, $v0, $a2            # + increment
800D4238   and   $v1, $v0, 0x000FFFFF     # keep 20 bits -> 0...1048575
800D423C   multu $v1, 0x10624DD3          # divide by 1000
800D4254   slti  $v0, $v1, 1000           # in range?
800D4258   beq   $v0, $zero, 800D4224     # no  -> draw again
800D4260   jr    $ra                      # yes -> return 0...999

0x800BF338   hpApply, once the health has gone

800BF384   lh    $v0, 16($s1)             # health after the hit
800BF388   bgtz  $v0, 800BF480            # still above zero -> nothing
800BF3A0   sh    $zero, 16($s1)           # clamp health at zero
800BF3CC   lhu   $v0, 0x800E3AA4[slot]    # has this been asked already?
800BF3DC   bne   $v0, $zero, 800BF480     # yes -> once per match only
800BF3E4   jal   roll
800BF3E8   addiu $a0, $zero, 250          #   250 => 25.1 %
800BF41C   sh    $v1, 0x800FADD0          # set a flag for this wrestler

--- and the only routine that reads that flag ---

0x800C01A8
800C0238   lhu   $v0, 0x800E3AB0[slot]    # this team's flag bit
800C0240   beq   $v0, $zero, 800C02D0     # not set -> nothing happens
800C0260   lh    $v0, 0x800F9D1A[slot]    # partner's current state
800C0264   xori  $v1, $v0, 0x0001         # is he pinning...
800C026C   xori  $v0, $v0, 0x002C         # ...or holding a submission?
800C028C   andi  $v0, $a1, 0xFFCF         # clear the flag, one use only
800C02B0   jal   setState                 # and off he goes...
800C02B4   addiu $a1, $zero, 143          # ...into state 143

# 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 = base + (my attack[limb] - their defence[limb]) * base / 10

# average that over all of a fighter's moves, 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