Mechanic · combat · role-playing game

Fleeing

A battle command that ends the fight with no winner if a roll succeeds, and costs the turn if it fails.

draftAlso: flee, running away, run away, escape, escaping, escape from battle, RUN command, retreatUpdated 2026-10-22
On this page
  1. How it works
  2. Implementations
  3. Variants and combinations
  4. History
  5. Related
  6. Games
  7. References
  8. Sources

Fleeing ends a battle with no winner. The player picks a run command, a roll decides whether it works, and a failure hands the turn to the enemy1,2. Dragon Warrior’s manual calls running away “a very important ‘fighting’ technique” for a hero close to 0 HP3. Final Fantasy’s manual tells an overpowered party it “can try to RUN”4.

  • Final Fantasy V (1992). Once the party is running, every 20 ticks gives it a chance to get away.5
  • Stat against statDragon Warrior (1986). Agility helps the hero run, later monsters are harder to escape, and a sleeping one can always be left behind.6,1,7,8,3,9
  • Fixed chanceDragon Warrior II (1987). Running works two times in three however quick the party is, and never from a boss.10,11EarthBound Beginnings (1989). 1 time in 2, never in a battle an event started.12
  • Rising with triesDragon Warrior III (1988). Running fails half the time at first, less on the third try, and never on the fourth.13
  • Speed gap, rising by turnEarthBound (1994). 10 × the turn number plus the Speed gap, in 100; certain on a first strike, never against a boss.14
  • Luck against levelFinal Fantasy (1987). Running rests on Luck against a level the game misreads, and always works when the party strikes first.15,4,16
  • Speed ratioPokémon Red and Blue (1996). Speed at least the foe's escapes; otherwise 32 times Speed over a quarter of the foe's, plus 30 per try, out of 256.2Pokémon Yellow (1998). Red and Blue's escape formula, unchanged.17Pokémon Gold and Silver (1999). Red and Blue's formula, plus a held Smoke Ball that always escapes.18Pokémon Crystal (2000). Red and Blue's formula, plus a held Smoke Ball that always escapes.19Pokémon Ruby and Sapphire (2002). 128 times Speed over the foe's, plus 30 per try, out of 256; a Smoke Ball or Run Away always escapes.20Pokémon Emerald (2004). 128 times Speed over the foe's, plus 30 per try, out of 256; a Smoke Ball or Run Away always escapes.21Pokémon FireRed and LeafGreen (2004). Ruby's formula, plus a sure escape from a ghost the Silph Scope hasn't revealed.22
  • Own evadeFinal Fantasy II (1988). The better a character dodges, the likelier they are to get away.23
  • Rate less enemy levelFinal Fantasy III (1990). Some jobs run better than others, and higher-level monsters are harder to escape.24
  • Hold to runFinal Fantasy IV (1991). Holding L and R always gets the party away once a member's turn comes, except from the strongest monsters.25Final Fantasy VI (1994). A run counter per character, raised by a roll each status tick, against 2 per monster.26

#How it works

on RUN:
    if escape is guaranteed (sleeping foe, Smoke Ball, first strike):   escape
    if escape is forbidden (trainer battle, boss formation):            fail
    if roll() passes test(own stat, foe's stat, attempts):             escape
    else:                                                               fail
on fail: the turn is lost, and the foe acts

The test is the part that differs: which stats it reads, whether failures make the next try easier, and what makes the result certain.

TestStatsAlways escapesNever escapes
Dragon WarriorAgility × a random byte ≥ the foe’s byte × a wider roll for later monsters6Agility against the monster’s defense byte6a sleeping monster6—
Final FantasyLuck > random[0, level + 15], with a misread level15Luck, and a misread level15striking first15no-run formations15
Red and Bluea byte ≤ Q + 30 per earlier try2Speed against Speed2equal or higher Speed; ghost, Safari Zone, and link battles2trainer battles2
Crystalas Red and Blue19Speed against Speed19a Smoke Ball19trainer battles, Mean Look, trapping moves19
Emerald⌊128P/E⌋+30n (a byte) > a random byte21,21Speed against Speed21a Smoke Ball, Run Away21—

#Implementations

#Dragon Warrior

TryRun lets the hero escape when Agility times a random byte is at least the monster’s defense byte times a roll whose range grows with the monster, 0–63 · 0–94 · 0–127 · 0–2556,6. The first group of monsters uses the same test as the first turn6,27. Running from a sleeping monster always works6. A failure prints “But was blocked in front” and passes the turn1.

Run in the ROM for all 65,536 generator states, Agility 40 against a defense byte of 40 escapes 87.70% · 81.64% · 75.20% · 50.20%8 of the time across the four groups. The NES manual says Agility helps the hero “run away”, and the code agrees9,6.

Monsters flee too. At the start of a battle and before each monster turn, a monster runs 1 time in 4 when half the hero’s Strength is at least its attack7.

#Dragon Warrior II and III

The North American Dragon Warrior II no longer weighs the hero’s Agility against the monster11,6. The party escapes 2/310 of the time, always in a round the monsters “did not see” it, and never from a boss10. In the North American Dragon Warrior III, the odds by try are 1/2, 1/2, 3/4, then certain13, and a special battle never lets the party run13.

#Final Fantasy

A character’s RUN succeeds when the character’s Luck exceeds a random number from 0 to level + 1515. The level in that range is read from the wrong place: Disch notes the code reads another character’s ailment byte or unrelated memory15. Striking first makes the escape certain, and a formation marked no-run makes it impossible15. A success prints “Close Call…” and ends the battle15.

The NES manual says the escape “depends on your agility level”4. The routine reads no Agility15.

#Final Fantasy II to VI

Final Fantasy II tests the runner’s own evade % in place of Final Fantasy’s Luck against level23,15. Run escapes when a roll of 0–100 is under it, unless the battle forbids escape23. Final Fantasy III rolls 0–100 against the job’s run probability plus 25, less the monsters’ average level24.

Final Fantasy IV has no roll: holding L and R escapes once a run counter reaches 025. A character’s turn sets the counter to 0, except against a monster of level 97 to 99, where it starts higher and drops by one each battle tick while the buttons are held25. In Final Fantasy V, CheckFlee rolls 0–99 against the encounter’s flee chance every 20 ticks while fleeing is under way; the source doesn’t show what starts an ordinary run5. In Final Fantasy VI, each character’s run counter gains a random 1 to their run factor each time their status counter overflows, and the character escapes at 2 per monster present26.

Enemies run by morale. On an active enemy’s turn it flees when its morale is below twice the party leader’s level, or when morale − 2 × level + random[0, 50] < 8016,16.

#Pokémon Red and Blue

In a wild battle, a Pokémon at least as fast as its foe always escapes2. A slower one escapes when a random byte is at most Q=⌊32P/(⌊E/4⌋mod256)⌋ for Speeds P and E, plus 30 for each earlier attempt, or at once when that sum passes 2552. Q is about 128P/E2. Choosing FIGHT resets the count of attempts2. Trainer battles refuse to let the player run, and ghost, Safari Zone, and link battles always let the player go2.

Pokémon Yellow keeps the formula and adds one battle type, BATTLE_TYPE_RUN, that always escapes17,2.

#Pokémon Gold, Silver, and Crystal

Pokémon Gold and Silver keep Red and Blue’s formula and add a held Smoke Ball that always escapes18,2. Crystal keeps the formula19. It adds two battle types, Celebi’s and Suicune’s, that block escape18. A held Smoke Ball always escapes, and Mean Look or a trapping move such as Wrap prevents it19.

#Pokémon Emerald

Emerald writes the formula as ⌊128P/E⌋+30n for n earlier attempts and escapes when it exceeds a random byte21. The sum is stored in a byte, so it wraps past 255; after 5 to 9 failed attempts, depending on the Speeds, the chance falls back under 12% for one try21. A Smoke Ball or the Run Away ability always escapes, except that Run Away loses its guarantee in the Battle Pyramid21.

Pokémon Ruby and Sapphire have the same formula, Smoke Ball, and Run Away; Emerald adds only the Battle Pyramid’s and Frontier’s rules20,21. Pokémon FireRed and LeafGreen keep Ruby’s formula and add a sure escape from a ghost battle fought without the Silph Scope22.

#EarthBound Beginnings and EarthBound

In the English build of EarthBound Beginnings, running works 1 in 212, with no stat in it, and never in a battle an event started12. In the US release of EarthBound, the chance is about 10 × turn + Speed gap, in 10014, from the fastest party member’s Speed less the fastest able enemy’s14. A first strike makes it certain on the first turn, and a boss rules it out14.

#Variants and combinations

  • Turn order. Dragon Warrior’s run test is its first-turn test with a wider roll6,27. Final Fantasy’s first strike guarantees an escape15,28.
  • Random encounters. Red and Blue allow running only from wild battles, which random encounters start2,29.

#History

The games read here run from Dragon Quest (Famicom, 1986) to Emerald (2004)30,31.

Combines with

  • Random encounter · the usual exit from a fight the player didn't choose
  • Turn order · Dragon Warrior uses one test for both; Final Fantasy's first strike guarantees an escape

See also

Mentioned in

Games

GameYearHowNote
Final Fantasy V1992once the party is running, every 20 ticks gives it a chance to get away
Dragon Warrior1986Stat against statAgility helps the hero run, later monsters are harder to escape, and a sleeping one can always be left behind
Dragon Warrior II1987Fixed chancerunning works two times in three however quick the party is, and never from a boss
EarthBound Beginnings1989Fixed chance1 time in 2, never in a battle an event started
Dragon Warrior III1988Rising with triesrunning fails half the time at first, less on the third try, and never on the fourth
EarthBound1994Speed gap, rising by turn10 × the turn number plus the Speed gap, in 100; certain on a first strike, never against a boss
Final Fantasy1987Luck against levelrunning rests on Luck against a level the game misreads, and always works when the party strikes first
Pokémon Red and Blue1996Speed ratioSpeed at least the foe's escapes; otherwise 32 times Speed over a quarter of the foe's, plus 30 per try, out of 256
Pokémon Yellow1998Speed ratioRed and Blue's escape formula, unchanged
Pokémon Gold and Silver1999Speed ratioRed and Blue's formula, plus a held Smoke Ball that always escapes
Pokémon Crystal2000Speed ratioRed and Blue's formula, plus a held Smoke Ball that always escapes
Pokémon Ruby and Sapphire2002Speed ratio128 times Speed over the foe's, plus 30 per try, out of 256; a Smoke Ball or Run Away always escapes
Pokémon Emerald2004Speed ratio128 times Speed over the foe's, plus 30 per try, out of 256; a Smoke Ball or Run Away always escapes
Pokémon FireRed and LeafGreen2004Speed ratioRuby's formula, plus a sure escape from a ghost the Silph Scope hasn't revealed
Final Fantasy II1988Own evadethe better a character dodges, the likelier they are to get away
Final Fantasy III1990Rate less enemy levelsome jobs run better than others, and higher-level monsters are harder to escape
Final Fantasy IV1991Hold to runholding L and R always gets the party away once a member's turn comes, except from the strongest monsters
Final Fantasy VI1994Hold to runa run counter per character, raised by a roll each status tick, against 2 per monster
Every claim about this mechanic, by game (26)
Dragon Warrior 1986TryRun lets the hero escape when Agility × a random byte is at least the monster's defense byte × a roll whose range grows with the monster: 0–63 from Slime to Druinlord, 0–94 from Drollmagi to Werewolf, 0–127 from Green Dragon to Blue Dragon, and 0–255 from Stoneman on. Running from a sleeping monster always works.Code
Measured in the ROM over all 65,536 generator states, with Agility 40 against a defense byte of 40, the hero escapes 87.70% of the time from the first group, 81.64% from the second, 75.20% from the third, and 50.20% from the fourth; the hero takes the first turn 87.70% of the time.Verified
At the start of a battle and before each monster turn, CheckEnRun gives the monster a 1-in-4 chance to flee when half the hero's Strength is at least the monster's attack.Code
A failed run prints "But was blocked in front" and passes the turn to the monster.Code
The NES manual advises running away when the hero's HP is close to 0, calling it “a very important ‘fighting’ technique”.Manual
The NES manual says Agility helps the hero escape: "This means that you can more easily avoid the enemy or run away."Manual
Dragon Warrior II 1987In Dragon Warrior II (NA NES), the party runs when the first hero chooses to; it never escapes a boss (monster $4E and up) or one fixed fight in the Sea Cave, always escapes in the round the monsters "did not see" it, and otherwise fails 1 time in 3.Code
Dragon Warrior II (NA NES) changes Dragon Warrior's battle rules: the hero's 1-in-32 "excellent move" becomes a 1-in-64 "tremendous blow", the fixed alternation of hero and monster becomes a round order sorted by half the agility plus a roll, and running no longer weighs the hero's Agility against the monster.Code
Final Fantasy 1987A character's RUN always succeeds when the party strikes first and always fails in a formation marked no-run; otherwise it succeeds when the character's Luck exceeds RandAX(0, level + 15), but the level is read from the wrong place: Disch notes the code reads another character's ailment byte or unrelated memory.Code
The NES manual says running depends on agility: "There is no guarantee that your escape will be successful — it depends on your agility level."Manual
On an active enemy's turn, it flees when its morale is below twice the party leader's level, or when morale minus twice that level plus RandAX(0, 50) is below 80.Code
Dragon Warrior III 1988In Dragon Warrior III (NA NES), running never works in a special battle; it always works when the party leader's level less a level the encounter setup stores at $5F (zeromus reads it as the enemies') is 10 or more, or when bit 3 of the battle-state byte $0566 is set, and otherwise it fails when a random byte is below 128, 128, 64, or 0 for the first, second, third, and fourth try, so the fourth try always escapes.Code
Final Fantasy II 1988A character's Run command rolls 0–100 and escapes when the roll is under the runner's own evade %, unless the battle forbids escape; no level or enemy stat enters.Code
EarthBound Beginnings 1989In EarthBound Beginnings (English build), running away works 1 time in 2 (the top bit of a random byte), with no stat in it, and never in a battle an event started.Code
Final Fantasy III 1990Run escapes when a roll of 0–100 is under the runner's run probability plus 25 less the average level of the monsters present (at least 0). The run probability is the third byte of the job modifiers.Code
Final Fantasy IV 1991Holding L and R escapes, with no roll, once the run counter reaches 0, if the battle allows running and some party member can act. The counter starts at $FF (no escape) and a character's turn sets it to 0, except against a monster of level 97, 98, or 99, where it starts at 3, 7, or 10 and drops by one each battle tick while L and R are held; at level 99 it resets to 15 whenever they are let go.Code
Final Fantasy V 1992While FleeSuccess is nonzero, CheckFlee counts a flee ticker up each pass; on the 20th it rolls 0–99 and escapes when the roll is under the encounter's flee chance, and otherwise the ticker restarts. A flee chance with the high bit set shows the can't-run message instead, and a FleeSuccess of $80 (the Exit spell) escapes at once. The source doesn't show what sets FleeSuccess for ordinary running; its RAM notes only guess that holding L and R does.Code
EarthBound 1994In EarthBound (US release), running away never works against a boss. Otherwise it works on the first turn of a battle the party started with the first strike, or when no enemy can act; else it works with a chance of about (10 × the turn number + the fastest party member's Speed − the fastest able enemy's Speed) in 100, and never when that is below 0.Code
Final Fantasy VI 1994While the characters are trying to run away, each character's run counter gains a random 1 to their run factor each time their status counter overflows, and the character escapes when the counter reaches the run difficulty. The difficulty is 2 for each monster present, or 6 for one marked harder to run from; a monster marked can't-escape, or a pincer attack, forbids running.Code
Pokémon Red and Blue 1996In a wild battle, TryRunningFromBattle lets the player escape when their Pokémon's Speed P is at least the foe's E; otherwise it computes Q=⌊32P/(⌊E/4⌋mod256)⌋, adds 30 for each earlier attempt, and escapes when a random byte is at most the result, or at once when the result passes 255.Code
Pokémon Yellow 1998Yellow keeps Red and Blue's escape formula, ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt against a random byte, and adds one battle type, BATTLE_TYPE_RUN, that always escapes.Code
Pokémon Gold and Silver 1999Gold and Silver's escape formula is Red and Blue's, ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt against a random byte, with a held Smoke Ball that always escapes; Crystal adds two battle types, Celebi's and Suicune's, that block escape.Code
Pokémon Crystal 2000Crystal keeps Red and Blue's escape formula: Speed at least the foe's escapes, and otherwise a random byte is compared with ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt; a held Smoke Ball always escapes, and Mean Look or a trapping move prevents it.Code
Pokémon Ruby and Sapphire 2002Ruby and Sapphire's TryRunFromBattle always escapes with a Smoke Ball or Run Away; otherwise, in a single battle, a Pokémon at least as fast as the foe escapes, and a slower one when ⌊128P/E⌋+30t, for t earlier tries, beats a random byte. Emerald adds only the Battle Pyramid's and Frontier's rules.Code
Pokémon Emerald 2004TryRunFromBattle always escapes with a Smoke Ball, or with the Run Away ability outside the Battle Pyramid. Otherwise, in a single battle outside the Pyramid, it escapes when the player's Pokémon is at least as fast as the foe, or when ⌊128P/E⌋+30n, stored in a byte, exceeds a random byte, for n earlier attempts.Code
Pokémon FireRed and LeafGreen 2004FireRed and LeafGreen keep Ruby's escape formula, ⌊128P/E⌋+30t against a random byte, with Smoke Ball and Run Away always escaping, and add that the player always escapes a ghost battle fought without the Silph Scope.Code

References

  1. ^ abcA failed run prints "But was blocked in front" and passes the turn to the monster.Codenmikstas/dragon-warrior-disassembly
    How we know
    7194LE898:  JSR TryRun              ;($EE91)Determine if player can run.
7195LE89B:  BCS RunSuccessful       ;Was player able to run? If so, branch.
⋮
7197LE89D:  JSR DoDialogLoBlock     ;($C7CB)But was blocked in front...
⋮
7200LE8A1:  JMP StartEnemyTurn      ;($EB1B)It's the enemy's turn to attack.
    source_files/Bank03.asm lines 7194–7200 at ebe6a13 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  2. ^ abcdefghijklmnIn a wild battle, TryRunningFromBattle lets the player escape when their Pokémon's Speed P is at least the foe's E; otherwise it computes Q=⌊32P/(⌊E/4⌋mod256)⌋, adds 30 for each earlier attempt, and escapes when a random byte is at most the result, or at once when the result passes 255.Codepret/pokered
    How we know
    1498	jp z, .canEscape ; jump if it's a ghost battle
⋮
1501	jp z, .canEscape ; jump if it's a safari battle
⋮
1504	jp z, .canEscape
⋮
1507	jr nz, .trainerBattle ; jump if it's a trainer battle
1508	ld a, [wNumRunAttempts]
1509	inc a
1510	ld [wNumRunAttempts], a
⋮
1525	jr nc, .canEscape ; jump if player speed greater than enemy speed
⋮
1528	ld a, 32
⋮
1538; divide enemy speed by 4
⋮
1544	jr z, .canEscape ; jump if enemy speed divided by 4, mod 256 is 0
⋮
1551	ld a, [wNumRunAttempts]
⋮
    engine/battle/core.asm lines 1496–1578 at af51989 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  3. ^ abThe NES manual advises running away when the hero's HP is close to 0, calling it “a very important ‘fighting’ technique”.ManualDragon Warrior NES manual
    How we know
    So run away if you think you're dangerously close to that point. Remember, running away can be a very important “fighting” technique.
    p. 13, Entering Commands During Fighting Mode, Run · archived copy ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  4. ^ abcThe NES manual says running depends on agility: "There is no guarantee that your escape will be successful — it depends on your agility level."ManualFinal Fantasy NES manual
    How we know
    If you are overpowered, you can try to RUN. There is no guarantee that your escape will be successful — it depends on your agility level.
    p. 19, RUN · archived copy ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  5. ^ abWhile FleeSuccess is nonzero, CheckFlee counts a flee ticker up each pass; on the 20th it rolls 0–99 and escapes when the roll is under the encounter's flee chance, and otherwise the ticker restarts. A flee chance with the high bit set shows the can't-run message instead, and a FleeSuccess of $80 (the Exit spell) escapes at once. The source doesn't show what sets FleeSuccess for ordinary running; its RAM notes only guess that holding L and R does.Codeeverything8215, FF5 disassemblyrevised
    How we know
    13368CheckFlee:
13369        lda FleeTickerActive
13370        beq ResetFleeTicker
13371        lda FleeSuccess
13372        bmi _FleeSuccess	;80h: exit cast
13373        beq ResetFleeTicker
13374        lda EncounterInfo::FleeChance
13375        bpl AdvanceTicker
⋮
13379        lda #$20   	;can't run message
⋮
13383AdvanceTicker:
13384        inc FleeTicker
13385        lda FleeTicker
⋮
    src/battle/battle-main.asm lines 13368–13397 at 997c87d · upstream ↗
    1662FleeSuccess = $7BE8			;80h on Exit cast
1663					;0 seems to reset FleeTicker for normal running, so might be another value while holding L+R?
    src/battle/battle_ram.inc lines 1662–1663 at 997c87d · upstream ↗
    16012        lda EncounterInfo::FleeChance
16013        bmi Miss		;80h = can't run
16014        jsr Random_0_99
16015        cmp Param1
16016        bcs Miss
16017        lda #$80
16018        sta FleeSuccess
    src/battle/battle-main.asm lines 16011–16018 at 997c87d · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Revised after a check by a second AI model, 2026-10-21.

    In the claim ledger

  6. ^ abcdefghijkTryRun lets the hero escape when Agility × a random byte is at least the monster's defense byte × a roll whose range grows with the monster: 0–63 from Slime to Druinlord, 0–94 from Drollmagi to Werewolf, 0–127 from Green Dragon to Blue Dragon, and 0–255 from Stoneman on. Running from a sleeping monster always works.Codenmikstas/dragon-warrior-disassembly · Ryan8bit, DW Formulas
    How we know
    7191LE894:  BIT PlayerFlags         ;Is the enemy asleep?
7192LE896:  BVS RunSuccessful       ;If so, branch for a successful run.
⋮
7194LE898:  JSR TryRun              ;($EE91)Determine if player can run.
    source_files/Bank03.asm lines 7191–7195 at ebe6a13 · upstream ↗
    8260LEE96:  CMP #EN_STONEMAN        ;Dragonlord 1 or Dragonlord 2?
⋮
8263LEE9A:  LDA RandNumUB           ;Load a random number and keep all the bits(0-255).
⋮
8276LEEAC:  BCC CalcWhoIsNext       ;If not, branch.
⋮
8279LEEB0:  AND #$3F                ;
⋮
8284LEEB9:  AND #$1F                ;previous number to get a range of 0-95.
8285LEEBB:  ADC MultNum2LB          ;
    source_files/Bank03.asm lines 8256–8293 at ebe6a13 · upstream ↗
    970.alias EN_DRUINLORD     $13     ;Druinlord.
971.alias EN_DROLLMAGI     $14     ;Drollmagi.
⋮
981.alias EN_GDRAGON       $1E     ;Green dragon.
⋮
986.alias EN_STONEMAN      $23     ;Stoneman.
    source_files/Dragon_Warrior_Defines.asm lines 970–986 at ebe6a13 · upstream ↗
    Group 1: #00 (Slime) - #19 (Druinlord)
    II.B, Running · archived copy ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  7. ^ abAt the start of a battle and before each monster turn, CheckEnRun gives the monster a 1-in-4 chance to flee when half the hero's Strength is at least the monster's attack.Codenmikstas/dragon-warrior-disassembly
    How we know
    8456LEFB7:  LDA DisplayedStr        ;Is player's strength at least double the enemy's attack?
8457LEFB9:  LSR                     ;
8458LEFBA:  CMP EnBaseAtt           ;
8459LEFBD:  BCC EnRunExit           ;If not, branch. Enemy will not run.
⋮
8463LEFC4:  AND #$03                ;Player is very strong. 25% chance enemy will run.
    source_files/Bank03.asm lines 8455–8467 at ebe6a13 · upstream ↗
    6654LE5BC:  JSR CheckEnRun          ;($EFB7)Check if enemy is going to run away.
    source_files/Bank03.asm line 6654 at ebe6a13 · upstream ↗
    7683LEB48:  JSR CheckEnRun          ;($EFB7)Check if enemy is going to run away.
    source_files/Bank03.asm lines 7682–7683 at ebe6a13 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  8. ^ abMeasured in the ROM over all 65,536 generator states, with Agility 40 against a defense byte of 40, the hero escapes 87.70% of the time from the first group, 81.64% from the second, 75.20% from the third, and 50.20% from the fourth; the hero takes the first turn 87.70% of the time.Verified“Dragon Warrior (USA) (Rev 1)” · nmikstas/dragon-warrior-disassembly
    How we know

    In the cartridge (“Dragon Warrior (USA) (Rev 1)”): bank 3 $EE91-$EEFC, TryRun through CalcNextOdds, the code the probe calls. We don't reproduce the bytes.

    LDA RandNumUB AND #$7F … LDA EnBaseDef … JSR WordMultiply … LDA DisplayedAgi … SBC GenWord42LB LDA MultRsltUB SBC GenWord42UB
    source_files/Bank03.asm#L8256-L8325 · upstream ↗

    Measured by a script in MesenCE 2.2.1 (build 4b8a196), on Dragon Warrior (USA) (Rev 1) (SHA-1 66809063b828…). It fails if the result disagrees with the claim.

    The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.

    Checked by a second AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-25.

    In the claim ledger

  9. ^ abThe NES manual says Agility helps the hero escape: "This means that you can more easily avoid the enemy or run away."ManualDragon Warrior NES manual
    How we know
    Your character becomes faster at higher levels. This means that you can more easily avoid the enemy or run away.
    p. 15, Agility · archived copy ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  10. ^ abcIn Dragon Warrior II (NA NES), the party runs when the first hero chooses to; it never escapes a boss (monster $4E and up) or one fixed fight in the Sea Cave, always escapes in the round the monsters "did not see" it, and otherwise fails 1 time in 3.CodeNathan-R-Og/dq2
    How we know
    3153    lda $062F ; Midenhall Battle Command
⋮
3155    cmp #$32
3156    beq B04_9595
⋮
3165    lda #$0F ; String ID #$000F: [name] broke away and ran.[end-FC]
⋮
3171    cmp #$4E ; bosses start at #$4E
⋮
3173    bcs B04_95D2 ; can't run away from bosses
⋮
3187    beq B04_95D2 ; can't run away from this fixed combat either
⋮
3190    beq B04_95D2
3191B04_95BF:
3192    lda $06DD
3193    beq B04_95CB
3194    lda #$03
⋮
    src/us/prg/bank4.asm lines 3152–3200 at 0fb64a4 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  11. ^ abDragon Warrior II (NA NES) changes Dragon Warrior's battle rules: the hero's 1-in-32 "excellent move" becomes a 1-in-64 "tremendous blow", the fixed alternation of hero and monster becomes a round order sorted by half the agility plus a roll, and running no longer weighs the hero's Agility against the monster.Codenmikstas/dragon-warrior-disassembly · Nathan-R-Og/dq2revised
    How we know
    6733LE624:  AND #$1F                ;Did player get an excellent move(1/32 chance)?
    source_files/Bank03.asm lines 6724–6759 at ebe6a13 · upstream ↗
    6249    lda #$40
6250    sta $A6
    src/us/prg/bank4.asm lines 6249–6250 at 0fb64a4 · upstream ↗
    6807LE691:  JMP StartEnemyTurn      ;($EB1B)It's the enemy's turn to attack.
    source_files/Bank03.asm lines 6803–6807 at ebe6a13 · upstream ↗
    7777LEBE6:  JMP StartPlayerTurn     ;($E5CE)It's the player's turn to attack.
    source_files/Bank03.asm lines 7772–7777 at ebe6a13 · upstream ↗
    9274B04_B790:
9275    lsr
9276    sta $99
    src/us/prg/bank4.asm lines 9274–9286 at 0fb64a4 · upstream ↗
    8313LEEE6:  LDA DisplayedAgi        ;
    source_files/Bank03.asm lines 8290–8325 at ebe6a13 · upstream ↗
    3191B04_95BF:
3192    lda $06DD
3193    beq B04_95CB
3194    lda #$03
    src/us/prg/bank4.asm lines 3191–3197 at 0fb64a4 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Revised after a check by a second AI model, 2026-10-21.

    In the claim ledger

  12. ^ abcIn EarthBound Beginnings (English build), running away works 1 time in 2 (the top bit of a random byte), with no stat in it, and never in a battle an event started.CodeNathan-R-Og/mother
    How we know
    1474BATACT_RUN_AWAY:
1475ba_target BA_TARGET::OUR_LEADER_REAL
1476ba_misc BA_MISC::DISPTEXT, $43
1477ba_jumpif BA_CON::D2, @fail
1478ba_jumpif BA_CON::SCRIPTED, @fail
⋮
1487@fail:
1488ba_misc BA_MISC::DISPTEXT, $44
    src/global/battle_data.asm lines 1474–1489 at e0b3e3f · upstream ↗
    3219; no requirement 50-50
3220BINSTCONDITION8_50_50:
3221    jsr RNG_BYTE
3222    asl a
3223    rts
    src/global/prg/battle.asm lines 3219–3223 at e0b3e3f · upstream ↗
    3243; sees if battle is triggered (not random).
3244; different from battle being scripted
3245BINSTCONDITIONB_NOT_TRIGGERED_BATTLE:
3246    lda is_scripted
3247    bne :+
3248    sec
3249    rts
3250:   clc
3251    rts
    src/global/prg/battle.asm lines 3243–3251 at e0b3e3f · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  13. ^ abcIn Dragon Warrior III (NA NES), running never works in a special battle; it always works when the party leader's level less a level the encounter setup stores at $5F (zeromus reads it as the enemies') is 10 or more, or when bit 3 of the battle-state byte $0566 is set, and otherwise it fails when a random byte is below 128, 128, 64, or 0 for the first, second, third, and fourth try, so the fourth try always escapes.Code“Dragon Warrior III (USA)” · zeromus/DragonWarrior3revised
    How we know

    In the cartridge (“Dragon Warrior III (USA)”): bank 2 $A6AB-$A6FC, the checks, the failure counter, and the table 80 80 40 00. We don't reproduce the bytes.

    3309		LDA		byte_6A6B
3310		BNE		loc_3A6D7
3311		LDA		byte_566
⋮
3314		LDA		byte_6A6A ; a level difference between player and enemy was stored in here
3315		CMP		#$A
3316		BCS		loc_3A6CC
3317		LDA		byte_566
3318		AND		#3
3319		TAX
3320		JSR		_rand
3321		CMP		byte_3A6F9,X
3322		BCC		loc_3A6D7
⋮
    disassembly/bank02.inc lines 3309–3353 at b35d5fd · upstream ↗
    927		LDA		_players_level ; read the PARTY LEADER's LEVEL!
928		SEC
929		SBC		word_5E+1 ; enemy's level was in there, I hope
⋮
933		STA		byte_6A6A
    disassembly/bank00.inc lines 927–933 at b35d5fd · upstream ↗

    In the cartridge (“Dragon Warrior III (USA)”): bank 0 $85B3-$85C2, the leader's level ($0700) less $5F, floored at 0, stored at $6A6A. We don't reproduce the bytes.

    71		LDA		_battle_type_fight
72		STA		byte_6A6B
    disassembly/bank04.inc lines 66–72 at b35d5fd · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Revised after a check by a second AI model, 2026-10-21.

    In the claim ledger

  14. ^ abcdIn EarthBound (US release), running away never works against a boss. Otherwise it works on the first turn of a battle the party started with the first strike, or when no enemy can act; else it works with a chance of about (10 × the turn number + the fastest party member's Speed − the fastest able enemy's Speed) in 100, and never when that is below 0.CodeHerringway/ebsrc
    How we know
    1276	LDA @LOCAL07
1277	CMP #BATTLE_ACTIONS::RUN_AWAY
⋮
1286	CMP #1
1287	BNE @UNKNOWN85
1288	LDA #4
⋮
1295@UNKNOWN85:
1296	LDA #3
    src/battle/main_battle_routine.asm lines 1276–1300 at 68aec5c · upstream ↗
    1950@UNKNOWN136:
1951	LDA a:battler::consciousness,Y
1952	AND #$00FF
1953	BEQ @UNKNOWN139
1954	LDA a:battler::npc_id,Y
1955	AND #$00FF
1956	BNE @UNKNOWN139
1957	LDA a:battler::ally_or_enemy,Y
1958	AND #$00FF
1959	CMP #1
1960	BNE @UNKNOWN138
⋮
1965	ADC #enemy_data::boss
⋮
    src/battle/main_battle_routine.asm lines 1950–1969 at 68aec5c · upstream ↗
    1999@UNKNOWN138:
2000	LDA a:battler::speed,Y
2001	CMP @LOCAL05
2002	BLTEQ @UNKNOWN139
2003	STA @LOCAL05
    src/battle/main_battle_routine.asm lines 1999–2003 at 68aec5c · upstream ↗
    2019	LDA @VIRTUAL04
2020	BEQ @UNKNOWN142
⋮
2024	LDA @LOCAL06
2025.ENDIF
2026	CMP #4
2027	BEQ @UNKNOWN142
⋮
2031	LDA @LOCAL0A
2032.ENDIF
2033	OPTIMIZED_MULT @VIRTUAL04, 10
2034	CLC
2035	ADC @LOCAL05
⋮
2041.ENDIF
⋮
    src/battle/main_battle_routine.asm lines 2019–2068 at 68aec5c · upstream ↗
    1113.ELSE
1114	INC @LOCAL0A
1115.ENDIF
    src/battle/main_battle_routine.asm lines 1112–1116 at 68aec5c · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  15. ^ abcdefghijklA character's RUN always succeeds when the party strikes first and always fails in a formation marked no-run; otherwise it succeeds when the character's Luck exceeds RandAX(0, level + 15), but the level is read from the wrong place: Disch notes the code reads another character's ailment byte or unrelated memory.CodeDisch, FF1 disassembly
    How we know
    3755Battle_PlayerTryRun:
⋮
3762    LDA btl_strikingfirst           ; are we striking first?
3763    BNE @Success                    ; If yes, run success is guaranteed
⋮
3766    AND #$01                        ; if the 'no run' bit is set in the formation,
3767    BNE @Fail                       ;   then failure is guaranteed.
⋮
3771    ;   Run if:  Luck > random[0, level+15]
⋮
3773    ; The problem is... the game is BUGGED and reads the wrong value for the level.. it ends up reading
3774    ;  the ailment byte for 2 players after this one (for top 2 slots) or other garbage memory for the
⋮
3781    LDA (btl_ib_charstat_ptr), Y    ; BUGGED - Reading wrong value -- should be OB, not IB
⋮
3788    JSR RandAX                      ; random[ 0, level+15 ]
    Final Fantasy Disassembly/bank_0C.asm lines 3755–3790 at cbb87d3 · upstream ↗
    3807    LDA btl_mathbuf+2               ; success if low byte was nonzero (if luck > randomval)
3808    BNE @Success                    ; failure if zero (luck <= randomval)
⋮
3811    LDA #BTLMSG_CANTRUN             ; on failure, print 'Can't Run' 
⋮
3815    LDA #BTLMSG_CLOSECALL           ; on success, print 'Close Call....' 
⋮
3819    STA btl_result                  ; Set the battle result to 3 (party ran)
    Final Fantasy Disassembly/bank_0C.asm lines 3807–3819 at cbb87d3 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  16. ^ abcOn an active enemy's turn, it flees when its morale is below twice the party leader's level, or when morale minus twice that level plus RandAX(0, 50) is below 80.CodeDisch, FF1 disassembly
    How we know
    6780    STA $9E             ; $9E = 2*level of party leader
⋮
6785    ;   V = X + Morale - L
⋮
6788    ;   X = random number between [$00,$32]
⋮
6792    ;   if V is less than $50, the enemy will run!
⋮
6798    BCC @RunAway        ; run if morale < 2*level_of_leader
⋮
6801    LDX #$32
6802    JSR RandAX          ; random between [$00-$32]
⋮
6806    CMP #$50
6807    BCS Enemy_DoAi      ; if >= $50, do not run
    Final Fantasy Disassembly/bank_0C.asm lines 6778–6810 at cbb87d3 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  17. ^ abYellow keeps Red and Blue's escape formula, ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt against a random byte, and adds one battle type, BATTLE_TYPE_RUN, that always escapes.Codepret/pokeyellow · pret/pokeredrevised
    How we know
    1535TryRunningFromBattle:
⋮
1541	cp BATTLE_TYPE_RUN
1542	jp z, .canEscape ; hurry, get away?
⋮
1545	jp z, .canEscape
⋮
1569	ld a, 32
⋮
1598	ld b, 30
⋮
1625.canEscape
    engine/battle/core.asm lines 1535–1653 at b6696f2 · upstream ↗
    1496TryRunningFromBattle:
⋮
1528	ld a, 32
⋮
1557	ld b, 30
    engine/battle/core.asm lines 1496–1612 at af51989 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Revised after a check by a second AI model, 2026-10-21.

    In the claim ledger

  18. ^ abcGold and Silver's escape formula is Red and Blue's, ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt against a random byte, with a held Smoke Ball that always escapes; Crystal adds two battle types, Celebi's and Suicune's, that block escape.Codepret/pokegold · pret/pokered · pret/pokecrystalrevised
    How we know
    3504	cp HELD_ESCAPE
⋮
3537	ld a, 32
⋮
3547	srl b
3548	rr a
3549	srl b
3550	rr a
⋮
3564	ld b, 30
    engine/battle/core.asm lines 3504–3564 at fc702b6 · upstream ↗
    1496TryRunningFromBattle:
⋮
1528	ld a, 32
⋮
1557	ld b, 30
    engine/battle/core.asm lines 1496–1612 at af51989 · upstream ↗
    3689	cp BATTLETYPE_CELEBI
3690	jp z, .cant_escape
⋮
3692	jp z, .cant_escape
3693	cp BATTLETYPE_SUICUNE
3694	jp z, .cant_escape
    engine/battle/core.asm lines 3689–3694 at 97187cd · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Revised after a check by a second AI model, 2026-10-21.

    In the claim ledger

  19. ^ abcdefgCrystal keeps Red and Blue's escape formula: Speed at least the foe's escapes, and otherwise a random byte is compared with ⌊32P/(⌊E/4⌋mod256)⌋ plus 30 for each earlier attempt; a held Smoke Ball always escapes, and Mean Look or a trapping move prevents it.Codepret/pokecrystal
    How we know
    3700	ld a, [wBattleMode]
3701	dec a
3702	jp nz, .cant_run_from_trainer
⋮
3704	ld a, [wEnemySubStatus5]
3705	bit SUBSTATUS_CANT_RUN, a
3706	jp nz, .cant_escape
⋮
3708	ld a, [wPlayerWrapCount]
⋮
3710	jp nz, .cant_escape
⋮
3719	cp HELD_ESCAPE
⋮
3731	ld a, [wNumFleeAttempts]
3732	inc a
3733	ld [wNumFleeAttempts], a
⋮
    engine/battle/core.asm lines 3700–3792 at 97187cd · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  20. ^ abRuby and Sapphire's TryRunFromBattle always escapes with a Smoke Ball or Run Away; otherwise, in a single battle, a Pokémon at least as fast as the foe escapes, and a slower one when ⌊128P/E⌋+30t, for t earlier tries, beats a random byte. Emerald adds only the Battle Pyramid's and Frontier's rules.Codepret/pokeruby · pret/pokeemerald
    How we know
    5465    if (holdEffect == HOLD_EFFECT_CAN_ALWAYS_RUN)
⋮
5471    else if (gBattleMons[bank].ability == ABILITY_RUN_AWAY)
⋮
5477    else
⋮
5481            if (gBattleMons[bank].speed < gBattleMons[bank ^ BIT_SIDE].speed)
⋮
5483                speedVar = (gBattleMons[bank].speed * 128) / (gBattleMons[bank ^ BIT_SIDE].speed) + (gBattleStruct->runTries * 30);
5484                if (speedVar > (Random() & 0xFF))
    src/battle_main.c lines 5465–5490 at 5784633 · upstream ↗
    src/battle_util.c#L407-L485 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  21. ^ abcdefghiTryRunFromBattle always escapes with a Smoke Ball, or with the Run Away ability outside the Battle Pyramid. Otherwise, in a single battle outside the Pyramid, it escapes when the player's Pokémon is at least as fast as the foe, or when ⌊128P/E⌋+30n, stored in a byte, exceeds a random byte, for n earlier attempts.Codepret/pokeemeraldrevised
    How we know
    412    u8 speedVar;
⋮
416    else
⋮
421    if (holdEffect == HOLD_EFFECT_CAN_ALWAYS_RUN)
⋮
425        effect++;
⋮
427    else if (gBattleMons[battler].ability == ABILITY_RUN_AWAY)
⋮
429        if (CurrentBattlePyramidLocation() != PYRAMID_LOCATION_NONE)
⋮
431            gBattleStruct->runTries++;
⋮
434            if (speedVar > (Random() & 0xFF))
⋮
438                effect++;
⋮
441        else
⋮
445            effect++;
⋮
450        effect++;
⋮
    src/battle_util.c lines 407–475 at 731ad5b · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Revised after a check by a second AI model, 2026-10-21: The run formula holds only in single battles outside the Battle Pyramid.

    In the claim ledger

  22. ^ abFireRed and LeafGreen keep Ruby's escape formula, ⌊128P/E⌋+30t against a random byte, with Smoke Ball and Run Away always escaping, and add that the player always escapes a ghost battle fought without the Silph Scope.Codepret/pokefirered
    How we know
    4252    else if (IS_BATTLE_TYPE_GHOST_WITHOUT_SCOPE(gBattleTypeFlags))
⋮
4254        if (GetBattlerSide(battler) == B_SIDE_PLAYER)
4255            effect++;
⋮
4257    else
⋮
4263                speedVar = (gBattleMons[battler].speed * 128) / (gBattleMons[BATTLE_OPPOSITE(battler)].speed) + (gBattleStruct->runTries * 30);
    src/battle_main.c lines 4252–4263 at ce6406d · upstream ↗
    69#define IS_BATTLE_TYPE_GHOST_WITHOUT_SCOPE(flags) ((flags) & BATTLE_TYPE_GHOST && !((flags) & BATTLE_TYPE_GHOST_UNVEILED))
    include/constants/battle.h line 69 at ce6406d · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  23. ^ abcA character's Run command rolls 0–100 and escapes when the roll is under the runner's own evade %, unless the battle forbids escape; no level or enemy stat enters.Codeeverything8215, FF2 disassembly
    How we know
    152670C/A865: C9 FE     CMP #$FE
152680C/A867: D0 23     BNE $A88C          ; branch if not running away
152690C/A869: AD 4B 7B  LDA $7B4B
152700C/A86C: D0 18     BNE $A886
152710C/A86E: A2 00     LDX #$00
152720C/A870: A9 64     LDA #$64
152730C/A872: 20 11 FD  JSR $FD11          ; random (X..A)
152740C/A875: A0 01     LDY #$01
152750C/A877: F1 9F     SBC ($9F),Y        ; check vs. evade %
152760C/A879: B0 0B     BCS $A886          ; branch if check failed
152770C/A87B: A9 01     LDA #$01
152780C/A87D: 8D B7 7C  STA $7CB7          ; ran away
⋮
    ff2j.asm lines 15267–15281 at 8d26190 · upstream ↗
    $00 evade mult. $01 evade %
    ram-map.txt#L575-L576 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  24. ^ abRun escapes when a roll of 0–100 is under the runner's run probability plus 25 less the average level of the monsters present (at least 0). The run probability is the third byte of the job modifiers.Codeeverything8215, FF3 disassembly
    How we know
    26703; [ action $06: run ]
⋮
2672835/A8F2: B1 24     LDA ($24),Y        ; sum of monster levels
⋮
2673435/A8FE: E6 1A     INC $1A            ; divide by no. of monsters
⋮
2674535/A912: 20 92 FC  JSR $FC92          ; divide (16-bit)
2674635/A915: A0 2A     LDY #$2A
2674735/A917: B1 6E     LDA ($6E),Y        ; run probability
2674835/A919: 18        CLC 
2674935/A91A: 69 19     ADC #$19           ; add 25
2675035/A91C: 38        SEC 
2675135/A91D: E5 1C     SBC $1C
2675235/A91F: B0 02     BCS $A923
2675335/A921: A9 00     LDA #$00
⋮
    ff3j.asm lines 26703–26763 at 1acef81 · upstream ↗
    $28 crit probability (39/BB1A, byte 0) $29 crit bonus (39/BB1A, byte 1) $2A run probability (39/BB1A, byte 2)
    battle-ram.txt#L266-L268 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  25. ^ abcHolding L and R escapes, with no roll, once the run counter reaches 0, if the battle allows running and some party member can act. The counter starts at $FF (no escape) and a character's turn sets it to 0, except against a monster of level 97, 98, or 99, where it starts at 3, 7, or 10 and drops by one each battle tick while L and R are held; at level 99 it resets to 15 whenever they are let go.Codeeverything8215, FF4 disassembly
    How we know
    1697        lda     $352d
1698        beq     @a0f6       ; return if l and r buttons are not pressed
1699@a08d:  lda     $38d6
1700        cmp     #$ff
1701        beq     @a0f6
1702        lda     $38d6
1703        beq     @a0a3
1704        lda     $38f3
1705        bne     @a0a3       ; branch if used escape ???
1706        dec     $38d6
1707        bra     @a0f6
1708@a0a3:  lda     $38e5
⋮
    battle/battle.asm lines 1694–1730 at a360e2e · upstream ↗
    1073@8659:  jsr     CheckBattleEnd
    battle/battle.asm line 1073 at a360e2e · upstream ↗
    385        lda     $2282
386        cmp     #97
387        bcc     @8219                   ; branch if monster level is less than 97
388        sec
389        sbc     #97
390        tax
391        lda     f:MonsterRunTbl,x       ; run difficulty
392        sta     $38d6
    battle/battle.asm lines 385–392 at a360e2e · upstream ↗
    379; monster run difficulty (based on monster level)
⋮
393MonsterRunTbl:
394@ff0f:  .byte   3,7,10
    battle/battle_data.asm lines 379–394 at a360e2e · upstream ↗
    1060@8638:  lda     $2282
1061        cmp     #$63
1062        bne     @8649                   ; branch if not level 99 monster
1063        lda     $352d
1064        bne     @8649                   ; branch if l and r buttons are pressed
1065        lda     #$0f
1066        sta     $38d6                   ; reset run counter to 15
    battle/battle.asm lines 1060–1066 at a360e2e · upstream ↗
    344GetCharAttack:
⋮
354        lda     $2282
355        cmp     #$63
356        beq     @a399
357        cmp     #$62
358        beq     @a399
359        cmp     #$61
360        beq     @a399
361@a396:  stz     $38d6
    battle/char.asm lines 344–361 at a360e2e · upstream ↗
    409InitRAM:
⋮
440        sta     $d0         ; init #$ff
⋮
447        sta     $38d6
    battle/battle.asm lines 409–447 at a360e2e · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  26. ^ abWhile the characters are trying to run away, each character's run counter gains a random 1 to their run factor each time their status counter overflows, and the character escapes when the counter reaches the run difficulty. The difficulty is 2 for each monster present, or 6 for one marked harder to run from; a monster marked can't-escape, or a pincer attack, forbids running.Codeeverything8215, FF6 disassembly
    How we know
    293CheckRunAway:
294@5c1b:  cpx     #$08
295        bcs     @5c53        ; return if a monster
⋮
302        lda     near w7e3a3b
303        bne     @5c3a
304        jsr     @5c4d
305        jmp     CreateRunAwayAction
306@5c3a:  lda     near wTargetProp2::w7e3d71,x     ; run probability
307        jsr     RandA
308        inc
309        clc
310        adc     near wTargetProp2::w7e3d70,x     ; add to run counter
⋮
    src/battle/timer.asm lines 293–316 at 8130132 · upstream ↗
    239; 15: run away
240GlobalCounter_05:
241@5bd0:  lda     near w7e2f45
242        beq     _5c1a       ; return if characters are not trying to run away
    src/battle/timer.asm lines 239–242 at 8130132 · upstream ↗
    13; frame 0-9 (status counters for each character/monster)
⋮
20        lda     near wTargetProp2::w7e3adc,x ; slow/normal/haste counter
21        adc     near wTargetProp2::w7e3add,x ; add constant (+32/+64/+84)
⋮
23        bcc     _5ae9                   ; return if it didn't overflow
⋮
41@5ac9:  jsr     CheckRunAway
    src/battle/timer.asm lines 13–41 at 8130132 · upstream ↗
    23; [ update monster graphics buffer and run difficulty ]
⋮
35        lda     #$06
⋮
38        cmp     #BATTLE_TYPE::PINCER
39        bne     @5ca4       ; branch if not a pincer attack
⋮
46        lda     #$02                    ; can't run away
47        tsb     zb1
48@5ca4:  stz     near w7e3a3b       ; clear run difficulty
⋮
51        lsr
⋮
61        lda     near wTargetProp2::_4::MonsterStatus,y  ; MONSTER_STATUS::HARDER_TO_RUN
62        lsr                 ; set carry if harder to run
63        bit     #MONSTER_STATUS::CANT_ESCAPE >> 1
64        beq     @5cd0       ; branch if party can run
⋮
    src/battle/gfx_buf.asm lines 22–73 at 8130132 · upstream ↗
    182        lda     <$11dc
183        sta     near wTargetProp2::w7e3d71,x     ; run factor
    src/battle/init_attacker.asm lines 182–183 at 8130132 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-21.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  27. ^ abAt the start of a battle, CalcWhoIsNext gives the hero the first turn when Agility × a random byte is at least the monster's defense byte × a roll of 0–63; otherwise the monster attacks first.Codenmikstas/dragon-warrior-disassembly
    How we know
    6655LE5BF:  JSR CalcWhoIsNext       ;($EEC0)Randomly calculate who attacks next.
⋮
6657LE5C2:  BCS StartPlayerTurn     ;($E5CE)It's the player's turn to attack.
    source_files/Bank03.asm lines 6654–6663 at ebe6a13 · upstream ↗
    8293LEEC5:  AND #$3F                ;Keep only lower 6 bits(0-63).
⋮
8297LEEC9:  LDA EnBaseDef           ;
⋮
8313LEEE6:  LDA DisplayedAgi        ;
⋮
8321LEEF5:  SEC                     ;Subtract the enemy's defense*rnd from player's agility*rnd.
    source_files/Bank03.asm lines 8290–8325 at ebe6a13 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  28. ^At the start of a battle, unless the formation is marked no-run, the game draws V=S+RandAX(S,100)−surprise rate with S=⌊(Agility+Luck)/8⌋ of the party leader: below 11 the party is surprised and loses its first round of commands, and from 90 the party strikes first and the enemies skip the first round.CodeDisch, FF1 disassembly
    How we know
    383    AND #$01                ; see if "no run" bit is set.  If it is, there is no strike first/surprised check
⋮
389    ; S = (leaders_agility + leaders_luck) / 8
390    ; V = random[S+S, S+100] - surpised_rate
⋮
393    ; if V >= 90, party strikes first
⋮
399    LDA ch_agil
400    CLC
401    ADC ch_luck
⋮
422    CMP #11
423    BCC @Surprised          ; if < 11, SURPRISED!
424    CMP #90
⋮
430      INC btl_strikingfirst             ; set flag
⋮
437    JMP BattleLogicLoop_DoCombat        ; skip over first round of player input, and just do combat
    Final Fantasy Disassembly/bank_0C.asm lines 381–437 at cbb87d3 · upstream ↗
    3259      LDA btl_strikingfirst     ; if the party is striking first
3260      BNE @NextTurn             ;   skip their turn
    Final Fantasy Disassembly/bank_0C.asm lines 3259–3260 at cbb87d3 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  29. ^On each step in grass or water, TryDoWildEncounter starts a wild battle when the byte hRandomAdd is below the map's encounter rate, out of 256; Route 1's grass rate is 25.Codepret/pokered
    How we know
    26; determine if wild pokemon can appear in the half-block we're standing in
⋮
32	ld a, [wGrassRate]
33	jr z, .CanEncounter
⋮
37	jr z, .CanEncounter
⋮
47	ld a, [wGrassRate]
48.CanEncounter
49; compare encounter chance with a random number to determine if there will be an encounter
50	ld b, a
51	ldh a, [hRandomAdd]
52	cp b
53	jr nc, .CantEncounter2
    engine/battle/wild_encounters.asm lines 26–53 at af51989 · upstream ↗
    1Route1WildMons:
2	def_grass_wildmons 25 ; encounter rate
    data/wild/maps/Route1.asm lines 1–2 at af51989 · upstream ↗

    Checked against the evidence by its author, an AI model, 2026-10-20.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  30. ^Dragon Quest (developer Chunsoft, publisher Enix) came out for the Famicom in Japan on 27 May 1986, and Dragon Warrior for the NES in North America in August 1989.WikidataWikidata
    How we know
    +1986-05-27T00:00:00Z … +1989-08-00T00:00:00Z
    Q2313869, P178 developer, P123 publisher, and P577 publication date qualified by P291 place and P400 platform · archived copy ↗

    The quote matches our archived copy.

    Checked by a second AI model, 2026-10-21.

    In the claim ledger

  31. ^Pokémon Emerald (developer Game Freak, publisher Nintendo, Game Boy Advance, and Generation III core series) came out in Japan on 16 September 2004 and North America on 1 May 2005.WikiBulbapedia, “Pokémon Emerald Version”
    How we know
    Developer: Game Freak … Publisher: Nintendo … Part of: Generation III core series … Japan: September 16, 2004 … North America: May 1, 2005
    infobox, Basic info and Release dates · archived copy ↗

    The quote matches our archived copy.

    In the claim ledger

Sources

Code

Primary

Secondary