mirror of
https://github.com/bryanthaboi/gen1recomp
synced 2026-09-26 13:33:27 -04:00
bryanthaboi
2127 lines
86 KiB
Lua
2127 lines
86 KiB
Lua
-- The Gen 2 battle screen against the cart's own HUD and pacing rules:
|
|
-- minimum damage out of BattleCommand_DamageCalc's tail, the -6/+6 stat stage
|
|
-- wall, the HP bar chase (engine/battle/anim_hp_bar.asm), the status tag in
|
|
-- the level's spot (PlaceNonFaintStatus), BattleMenu's empty textbox, the
|
|
-- intro slide's one-piece back pic, and ItemRestoreHP's pick-a-mon flow.
|
|
--
|
|
-- GOLD_CACHE="..." luajit tests/gen2_battle_ui_test.lua
|
|
--
|
|
-- ROM-free: fixtures below are the extractor's shapes; the one cache-fed
|
|
-- section (the GROWL animation's cry) skips cleanly when there is no cache.
|
|
package.path = "./?.lua;./?/init.lua;" .. package.path
|
|
|
|
local S = require("tests.harness").suite("gen2 battle ui")
|
|
local check, eq = S.check, S.eq
|
|
|
|
love = require("tests.love_stub")
|
|
|
|
local Battle = require("src.battle.gen2.Battle")
|
|
local BattleAnimView = require("src.ui.gen2.BattleAnimView")
|
|
local BattleState = require("src.ui.gen2.BattleState")
|
|
local Damage = require("src.battle.gen2.Damage")
|
|
local Input = require("src.core.Input")
|
|
local Mon = require("src.battle.gen2.Mon")
|
|
local PackMenu = require("src.ui.gen2.PackMenu")
|
|
local PartyMenu = require("src.ui.gen2.PartyMenu")
|
|
local Sound = require("src.core.Sound")
|
|
local Typer = require("src.ui.gen2.Typer")
|
|
|
|
-- ---------------------------------------------------------------- fixtures
|
|
|
|
local TYPES = {
|
|
NORMAL = { id = "NORMAL", index = 0, category = "physical" },
|
|
FLYING = { id = "FLYING", index = 2, category = "physical" },
|
|
GROUND = { id = "GROUND", index = 4, category = "physical" },
|
|
ROCK = { id = "ROCK", index = 5, category = "physical" },
|
|
FIRE = { id = "FIRE", index = 20, category = "special" },
|
|
WATER = { id = "WATER", index = 21, category = "special" },
|
|
ELECTRIC = { id = "ELECTRIC", index = 23, category = "special" },
|
|
}
|
|
|
|
local MATCHUPS = {
|
|
{ attacker = "NORMAL", defender = "ROCK", multiplier = 5 },
|
|
{ attacker = "FIRE", defender = "WATER", multiplier = 5 },
|
|
{ attacker = "ELECTRIC", defender = "GROUND", multiplier = 0 },
|
|
}
|
|
|
|
local MOVES = {
|
|
TACKLE = { id = "TACKLE", name = "TACKLE", power = 35, type = "NORMAL",
|
|
accuracy = 95, pp = 35, effect = "EFFECT_NORMAL_HIT" },
|
|
GROWL = { id = "GROWL", name = "GROWL", power = 0, type = "NORMAL",
|
|
accuracy = 100, pp = 40, effect = "EFFECT_ATTACK_DOWN" },
|
|
THUNDER_WAVE = { id = "THUNDER_WAVE", name = "THUNDERWAVE", power = 0,
|
|
type = "ELECTRIC", accuracy = 100, pp = 20, effect = "EFFECT_PARALYZE" },
|
|
}
|
|
|
|
local GROWTH = {
|
|
GROWTH_MEDIUM_SLOW = { numerator = 6, denominator = 5, squared = -15,
|
|
linear = 100, constant = 140 },
|
|
}
|
|
|
|
local POKEMON = {
|
|
growthRates = GROWTH,
|
|
CYNDAQUIL = {
|
|
id = "CYNDAQUIL", index = 155, name = "CYNDAQUIL",
|
|
baseStats = { hp = 39, attack = 52, defense = 43, speed = 65,
|
|
specialAttack = 60, specialDefense = 50 },
|
|
types = { "FIRE", "FIRE" }, catchRate = 45, baseExp = 65,
|
|
growthRate = "GROWTH_MEDIUM_SLOW", genderRatio = 31,
|
|
levelMoves = { { level = 1, move = "TACKLE" } }, evolutions = {},
|
|
},
|
|
TOTODILE = {
|
|
id = "TOTODILE", index = 158, name = "TOTODILE",
|
|
baseStats = { hp = 50, attack = 65, defense = 64, speed = 43,
|
|
specialAttack = 44, specialDefense = 48 },
|
|
types = { "WATER", "WATER" }, catchRate = 45, baseExp = 66,
|
|
growthRate = "GROWTH_MEDIUM_SLOW", genderRatio = 31,
|
|
levelMoves = { { level = 1, move = "TACKLE" } }, evolutions = {},
|
|
},
|
|
PIDGEY = {
|
|
id = "PIDGEY", index = 16, name = "PIDGEY",
|
|
baseStats = { hp = 40, attack = 45, defense = 40, speed = 56,
|
|
specialAttack = 35, specialDefense = 35 },
|
|
types = { "NORMAL", "FLYING" }, catchRate = 255, baseExp = 55,
|
|
growthRate = "GROWTH_MEDIUM_SLOW", genderRatio = 127,
|
|
levelMoves = { { level = 1, move = "TACKLE" } }, evolutions = {},
|
|
},
|
|
GEODUDE = {
|
|
id = "GEODUDE", index = 74, name = "GEODUDE",
|
|
baseStats = { hp = 40, attack = 80, defense = 100, speed = 20,
|
|
specialAttack = 30, specialDefense = 30 },
|
|
types = { "ROCK", "GROUND" }, catchRate = 255, baseExp = 73,
|
|
growthRate = "GROWTH_MEDIUM_SLOW", genderRatio = 31,
|
|
levelMoves = { { level = 1, move = "TACKLE" } }, evolutions = {},
|
|
},
|
|
}
|
|
|
|
local DATA = {
|
|
pokemon = POKEMON,
|
|
moves = MOVES,
|
|
type_chart = { types = TYPES, matchups = MATCHUPS },
|
|
items = {
|
|
-- `index` is the ROM item id, which is what wBattleAnimParam carries.
|
|
MASTER_BALL = { id = "MASTER_BALL", pocket = "BALL", name = "MASTER BALL",
|
|
index = 1 },
|
|
POKE_BALL = { id = "POKE_BALL", pocket = "BALL", name = "POKe BALL",
|
|
index = 5 },
|
|
FAST_BALL = { id = "FAST_BALL", pocket = "BALL", name = "FAST BALL",
|
|
index = 160 },
|
|
POTION = { id = "POTION", pocket = "ITEM", name = "POTION" },
|
|
},
|
|
}
|
|
|
|
local perfect = { attack = 15, defense = 15, speed = 15, special = 15 }
|
|
perfect.hp = Mon.hpDV(perfect)
|
|
|
|
-- Deterministic and range-respecting: the smallest roll that is neither a
|
|
-- critical hit (rollCritical wants 0) nor a miss.
|
|
local function detRandom(n)
|
|
if (n or 1) <= 1 then return 0 end
|
|
return 1
|
|
end
|
|
|
|
-- ---- DamageCalc's minimum (engine/battle/effect_commands.asm) -------------
|
|
do
|
|
-- Stats weak enough that the raw formula floors to 0: the cart still walks
|
|
-- out of DamageCalc with MIN_DAMAGE (2).
|
|
local weak = Damage.calc({
|
|
level = 5, power = 35, moveType = "NORMAL",
|
|
attacker = { attack = 6, types = { "FIRE" } },
|
|
defender = { defense = 40, types = { "WATER" } },
|
|
types = TYPES, matchups = MATCHUPS, variation = 100,
|
|
})
|
|
eq(weak, Damage.MIN_DAMAGE,
|
|
"a hit whose stat math floors to nothing still deals MIN_DAMAGE")
|
|
|
|
-- The same hit into a resist: BattleCommand_Stab's zero-quotient arm forces
|
|
-- the row's floor back up to 1, so not-very-effective never reads 0.
|
|
local resisted = Damage.calc({
|
|
level = 5, power = 35, moveType = "NORMAL",
|
|
attacker = { attack = 6, types = { "FIRE" } },
|
|
defender = { defense = 40, types = { "ROCK" } },
|
|
types = TYPES, matchups = MATCHUPS, variation = 100,
|
|
})
|
|
check(resisted >= 1, "a resisted hit that lands deals at least 1")
|
|
local _, info = Damage.calc({
|
|
level = 5, power = 35, moveType = "NORMAL",
|
|
attacker = { attack = 6, types = { "FIRE" } },
|
|
defender = { defense = 40, types = { "ROCK" } },
|
|
types = TYPES, matchups = MATCHUPS, variation = 100,
|
|
})
|
|
eq(info.effectiveness, 5, "and still reports not-very-effective")
|
|
|
|
-- Immunity is the one zero left: the row's multiplier IS 0.
|
|
local immune = Damage.calc({
|
|
level = 50, power = 95, moveType = "ELECTRIC",
|
|
attacker = { specialAttack = 100, types = { "ELECTRIC" } },
|
|
defender = { specialDefense = 50, types = { "GROUND" } },
|
|
types = TYPES, matchups = MATCHUPS, variation = 100,
|
|
})
|
|
eq(immune, 0, "an immune matchup still deals nothing at all")
|
|
end
|
|
|
|
-- ---- the same minimum through the real turn engine ------------------------
|
|
do
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 5, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local wild = Mon.new(DATA, "GEODUDE", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local battle = Battle.new({ data = DATA, party = { player }, wild = wild,
|
|
random = detRandom })
|
|
local before = wild.hp
|
|
local events = battle:takeTurn({ kind = "move", move = "TACKLE" })
|
|
local dealt, sawNve = nil, false
|
|
for _, event in ipairs(events) do
|
|
if event.kind == "damage" and event.side == "enemy" and not dealt then
|
|
dealt = event.amount
|
|
end
|
|
if event.kind == "message"
|
|
and event.text == "It's not very\neffective…" then
|
|
sawNve = true
|
|
end
|
|
end
|
|
check(sawNve, "TACKLE into GEODUDE reads as not very effective")
|
|
check((dealt or 0) >= 1, "and the landed hit dealt at least 1 HP, not 0")
|
|
eq(wild.hp, before - dealt, "with the HP moving by exactly that much")
|
|
end
|
|
|
|
-- ---- the -6 stage wall (BattleCommand_StatDown's .CantLower) --------------
|
|
do
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
player.moves = { { id = "GROWL", pp = 40, maxPp = 40 } }
|
|
player.hp = 200
|
|
player.maxHp = 200
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local battle = Battle.new({ data = DATA, party = { player }, wild = wild,
|
|
random = detRandom })
|
|
for turn = 1, 6 do
|
|
battle:takeTurn({ kind = "move", move = "GROWL" })
|
|
eq(battle.stages.enemy.attack, -turn,
|
|
"GROWL " .. turn .. " lands one stage")
|
|
end
|
|
local events = battle:takeTurn({ kind = "move", move = "GROWL" })
|
|
eq(battle.stages.enemy.attack, -6, "the seventh GROWL moves nothing")
|
|
local refused = false
|
|
for _, event in ipairs(events) do
|
|
if event.kind == "message"
|
|
and event.text == "PIDGEY's ATTACK won't drop anymore!" then
|
|
refused = true
|
|
end
|
|
end
|
|
check(refused, "and the cart's refusal line is emitted instead")
|
|
|
|
-- The stage -6 multiplier is 25/100 with a floor of 1: a stat can shrink to
|
|
-- a quarter but never to zero.
|
|
eq(Damage.applyStage(11, -6), math.max(1, math.floor(11 * 25 / 100)),
|
|
"stage -6 is a quarter of the stat")
|
|
eq(Damage.applyStage(1, -6), 1, "and never zero")
|
|
eq(Damage.applyStage(11, -9), Damage.applyStage(11, -6),
|
|
"stages below -6 read as -6")
|
|
end
|
|
|
|
-- ---- BattleState with a stub game -----------------------------------------
|
|
|
|
local function newScreen(opts)
|
|
opts = opts or {}
|
|
Input:init()
|
|
local pushed = {}
|
|
local player = opts.player
|
|
or Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
if not player.moves or #player.moves == 0 then
|
|
player.moves = {
|
|
{ id = "TACKLE", pp = 35, maxPp = 35 },
|
|
{ id = "THUNDER_WAVE", pp = 20, maxPp = 20 },
|
|
}
|
|
end
|
|
local party = opts.party or { player }
|
|
local wild = opts.wild or Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = wild.moves or { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local save = { party = party, inventory = opts.inventory
|
|
or { POTION = 2, POKE_BALL = 3 } }
|
|
local game = {
|
|
data = DATA,
|
|
save = save,
|
|
input = Input,
|
|
options = {},
|
|
stack = {
|
|
push = function(_, screen) pushed[#pushed + 1] = screen end,
|
|
pop = function() table.remove(pushed) end,
|
|
top = function() return pushed[#pushed] end,
|
|
},
|
|
}
|
|
local battle = Battle.new({ data = DATA, party = party, wild = wild,
|
|
random = detRandom })
|
|
local screen = BattleState.new(game, { battle = battle, save = save })
|
|
return screen, battle, player, wild, save, pushed
|
|
end
|
|
|
|
local function run(screen, frames)
|
|
for _ = 1, frames do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
end
|
|
|
|
-- One frame of a drain. Battle lines end in `prompt` and PromptButton waits
|
|
-- on A or B with no countdown (home/joypad.asm:383-412); the stats box waits
|
|
-- the same way (engine/battle/core.asm:7069), so a drain presses rather than
|
|
-- idling for a timer that never runs out.
|
|
local function drainStep(screen)
|
|
local waiting = (screen.messageTimer or 0) > 0 or screen.phase == "stats-box"
|
|
if waiting then Input:overlayPressed("a") end
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
if waiting then Input:overlayReleased("a") end
|
|
end
|
|
|
|
local function runToMenu(screen, cap)
|
|
for _ = 1, (cap or 3000) do
|
|
drainStep(screen)
|
|
if screen.phase == "menu" then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- engine/items/item_effects.asm:1748
|
|
local function drainItemResult(picker)
|
|
for _ = 1, 400 do
|
|
if not picker.itemResult then return true end
|
|
Input:overlayPressed("a")
|
|
Input:step()
|
|
picker:update(1 / 60)
|
|
Input:overlayReleased("a")
|
|
end
|
|
return not picker.itemResult
|
|
end
|
|
|
|
do
|
|
local screen = newScreen({ inventory = {
|
|
MASTER_BALL = 1, POKE_BALL = 1,
|
|
} })
|
|
eq(screen:catchChance("MASTER_BALL"), 100,
|
|
"the battle screen exposes a certain Master Ball preview")
|
|
check(type(screen:catchChance("POKE_BALL")) == "number",
|
|
"the battle screen exposes the live wild catch preview")
|
|
end
|
|
|
|
-- ---- BattleMenu empties the textbox ---------------------------------------
|
|
do
|
|
local screen = newScreen()
|
|
eq(screen.shownHp.enemy, screen.battle.enemy.hp,
|
|
"the bar opens on the real HP")
|
|
check(runToMenu(screen), "the intro drains to the battle menu")
|
|
eq(screen.message, nil,
|
|
"BattleMenu runs EmptyBattleTextbox: no prompt beside the 2x2 menu")
|
|
end
|
|
|
|
-- ---- the HP bar chase -----------------------------------------------------
|
|
do
|
|
local screen, battle, player, wild = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
local shown0 = screen.shownHp.enemy
|
|
eq(shown0, wild.hp, "the enemy bar sits on the wild mon's real HP")
|
|
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
check(wild.hp < shown0, "the engine has already resolved the whole turn")
|
|
eq(screen.shownHp.enemy, shown0,
|
|
"but the drawn bar has not spoiled it: it still shows the pre-turn HP")
|
|
|
|
local sawIntermediate = false
|
|
for _ = 1, 3000 do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
local shown = screen.shownHp.enemy
|
|
if shown < shown0 and shown > wild.hp then sawIntermediate = true end
|
|
if screen.phase == "menu" then break end
|
|
end
|
|
eq(screen.phase, "menu", "the turn drains back to the menu")
|
|
check(sawIntermediate,
|
|
"the bar walked down through the middle values, one pixel per two frames")
|
|
eq(screen.shownHp.enemy, wild.hp, "and settled on the real enemy HP")
|
|
eq(screen.shownHp.player, player.hp,
|
|
"the player's bar caught its own hit too")
|
|
end
|
|
|
|
-- ---- the drain is sized by the mon whose bar is ON SCREEN -----------------
|
|
do
|
|
-- wCurHPAnimMaxHP is loaded from the battle struct of the mon being drawn
|
|
-- (wEnemyMonMaxHP -> wHPBuffer1, engine/battle/effect_commands.asm:3399-3404),
|
|
-- and after a faint that is still the OUTGOING mon: the engine rebinds
|
|
-- battle.enemy inside takeTurn, a whole queue before the replacement's
|
|
-- `send` event is dequeued.
|
|
local screen, battle = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
local outgoing = { maxHp = 240, hp = 240 }
|
|
local replacement = { maxHp = 24, hp = 24 }
|
|
screen.shownMon.enemy = outgoing
|
|
battle.enemy = replacement
|
|
screen.shownHp.enemy = 240
|
|
screen.hpAnim = { side = "enemy", to = 0 }
|
|
check(screen:stepHpAnim(), "the first tick steps")
|
|
eq(screen.hpAnim.bar.maxHp, 240,
|
|
"the chase is sized off the OUTGOING mon's 240 max HP, not the "
|
|
.. "replacement's 24")
|
|
eq(screen.shownHp.enemy, 239,
|
|
"LongAnim_UpdateVariables walks the number one hit point at a time")
|
|
local held = 1
|
|
while screen.hpAnim and held < 400 do
|
|
if not screen:stepHpAnim() then break end
|
|
held = held + 1
|
|
end
|
|
eq(screen.shownHp.enemy, 0, "the outgoing mon's bar drained to zero")
|
|
eq(held, 48 * 2, "48 pixels, two frames apiece (HPBarAnim_BGMapUpdate)")
|
|
end
|
|
|
|
do
|
|
-- _AnimateHPBar (engine/battle/anim_hp_bar.asm:1-40): under 48 max HP
|
|
local function drain(maxHp, from, to)
|
|
local screen = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.shownMon.enemy = { maxHp = maxHp, hp = from }
|
|
screen.shownHp.enemy = from
|
|
screen.hpAnim = { side = "enemy", to = to }
|
|
local mon = screen.shownMon.enemy
|
|
local trace = { { hp = from, px = screen:hudHpPixels(mon, "enemy") } }
|
|
local held = 0
|
|
while held < 400 do
|
|
if not screen:stepHpAnim() then break end
|
|
held = held + 1
|
|
trace[#trace + 1] = { hp = screen.shownHp.enemy,
|
|
px = screen:hudHpPixels(mon, "enemy") }
|
|
end
|
|
local changes, everySecond, onePixel = 0, true, true
|
|
for i = 2, #trace do
|
|
local moved = trace[i].px ~= trace[i - 1].px
|
|
if moved then
|
|
changes = changes + 1
|
|
if math.abs(trace[i].px - trace[i - 1].px) ~= 1 then onePixel = false end
|
|
end
|
|
if moved ~= (i % 2 == 0) then everySecond = false end
|
|
end
|
|
return screen, held, changes, everySecond, onePixel, trace
|
|
end
|
|
|
|
local screen, held, changes, everySecond, onePixel, trace = drain(15, 15, 0)
|
|
eq(held, 96, "15 max HP, 15 -> 0: 48 pixels x 2 frames = 96 held ticks")
|
|
eq(changes, 48, "the short loop moves every pixel of the bar")
|
|
check(everySecond, "and the bar changes on every second tick only")
|
|
check(onePixel, "one pixel at a time")
|
|
eq(trace[2].px, 47, "first step: 48 -> 47 pixels")
|
|
eq(trace[2].hp, 15, "CalcPixelFrame at 47px of 15: floor(705/48)+1 = 15")
|
|
eq(trace[88].hp, 2, "at 4px: floor(60/48)+1 = 2")
|
|
eq(trace[90].hp, 1, "at 3px: floor(45/48)+1 = 1")
|
|
eq(trace[95].hp, 1, "the number holds at 1 until the bar is empty")
|
|
eq(trace[96].hp, 0, "and drops to 0 on the last pixel")
|
|
eq(screen.shownHp.enemy, 0, "and lands on 0 when it is")
|
|
eq(screen.hpAnim, nil, "the chase is over")
|
|
|
|
local long
|
|
long, held, changes, everySecond, onePixel, trace = drain(100, 100, 0)
|
|
eq(held, 96, "100 max HP, 100 -> 0: 48 pixels x 2 frames = 96 held ticks")
|
|
eq(changes, 48, "the long loop spends a step per pixel change")
|
|
check(everySecond, "every second tick")
|
|
check(onePixel, "one pixel at a time")
|
|
eq(trace[2].hp, 99, "the first pixel falls at 99 (floor(99*48/100) = 47)")
|
|
eq(trace[4].hp, 97, "the next at 97 (floor(97*48/100) = 46)")
|
|
eq(long.shownHp.enemy, 0, "and the number lands on 0")
|
|
|
|
local up
|
|
up, held, changes = drain(15, 3, 15)
|
|
eq(up.shownHp.enemy, 15, "a heal climbs the same way")
|
|
eq(held, (48 - 9) * 2, "9px -> 48px is 39 pixels, two frames apiece")
|
|
eq(changes, 39, "one change per pixel on the way up too")
|
|
|
|
local live = newScreen()
|
|
check(runToMenu(live), "reached the menu")
|
|
live.shownMon.enemy = { maxHp = 15, hp = 15 }
|
|
live.shownHp.enemy = 15
|
|
live.hpAnim = { side = "enemy", to = 0 }
|
|
local mon = live.shownMon.enemy
|
|
local seen = {}
|
|
for i = 1, 6 do
|
|
Input:step()
|
|
live:update(1 / 60)
|
|
seen[i] = live:hudHpPixels(mon, "enemy")
|
|
end
|
|
eq(table.concat(seen, ","), "47,47,46,46,45,45",
|
|
"update() moves the bar one pixel every second tick")
|
|
end
|
|
|
|
-- ---- the exp bar crawls, and the level waits for it -----------------------
|
|
do
|
|
-- AnimateExpBar (engine/battle/core.asm:7191) runs BEFORE the exp is
|
|
-- committed and walks the bar one pixel at a time, topping out at 64 and
|
|
-- restarting at 0 for each level crossed, with wBattleMonLevel advanced only
|
|
-- as each segment fills (:7267-7274).
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 5, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local growth = DATA.pokemon.growthRates.GROWTH_MEDIUM_SLOW
|
|
-- One point short of level 6, so whatever the kill pays levels the mon.
|
|
player.experience = Mon.experienceForLevel(growth, 6) - 1
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
wild.hp = 1
|
|
local screen = newScreen({ player = player, wild = wild })
|
|
check(runToMenu(screen), "reached the menu")
|
|
eq(screen.shownLevel, 5, "the HUD opens on the mon's real level")
|
|
local startExp = screen.shownExp
|
|
check(startExp > 0 and startExp < 64,
|
|
"and on its real place along the bar (CalcExpBar's 64 pixels)")
|
|
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
eq(wild.hp, 0, "the wild mon went down on the first TACKLE")
|
|
eq(player.level, 6, "and the engine has already levelled the player")
|
|
eq(screen.shownLevel, 5,
|
|
"but the HUD still prints the pre-kill level, several boxes before the "
|
|
.. "grew-to-level line")
|
|
eq(screen.shownExp, startExp, "and the bar has not moved yet either")
|
|
|
|
local crawled, restarted = false, false
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.shownLevel == 5 and (screen.shownExp or 0) > startExp then
|
|
crawled = true
|
|
end
|
|
if screen.shownLevel == 6 and (screen.shownExp or 0) == 0 then
|
|
restarted = true
|
|
end
|
|
if screen.phase == "done" then break end
|
|
end
|
|
eq(screen.phase, "done", "the win drains out")
|
|
check(crawled, "the bar walked up through the middle pixels")
|
|
check(restarted,
|
|
"topped out, took the level with it and restarted the segment at 0")
|
|
eq(screen.shownLevel, player.level, "the HUD level caught up")
|
|
eq(screen.shownExp,
|
|
screen:expPixels(player, player.level, player.experience),
|
|
"and the bar landed on the mon's real place in level 6")
|
|
end
|
|
|
|
do
|
|
-- sparks have gone (../pokecrystal/engine/battle/core.asm:7529-7541).
|
|
local EXP_FULL = require("src.ui.gen2.BattleHud").EXP_LENGTH_PX
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 5, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local growth = DATA.pokemon.growthRates.GROWTH_MEDIUM_SLOW
|
|
player.experience = Mon.experienceForLevel(growth, 6) - 1
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
wild.hp = 1
|
|
local screen = newScreen({ player = player, wild = wild })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
|
|
-- ../pokecrystal/engine/battle/core.asm:7121-7128, :7516-7545
|
|
local trace = {}
|
|
local startExp
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.expAnim and not startExp then startExp = screen.shownExp end
|
|
trace[#trace + 1] = {
|
|
exp = screen.shownExp, level = screen.shownLevel,
|
|
burst = screen.expBurst and screen.expBurst.frame,
|
|
message = tostring(screen.message or ""),
|
|
typing = screen:syncTyper(),
|
|
timer = screen.messageTimer or 0, phase = screen.phase,
|
|
}
|
|
if screen.phase == "done" then break end
|
|
end
|
|
eq(screen.phase, "done", "the win drains out")
|
|
check(startExp ~= nil and startExp < EXP_FULL, "the crawl armed short of 64")
|
|
|
|
local promptAt, crawlAt, armAt, lineAt, zeroAt, boxAt
|
|
local drawn, full, quiet, prompted = {}, true, true, false
|
|
for i, t in ipairs(trace) do
|
|
if not promptAt and t.message:find("gained") and t.timer > 0 then
|
|
promptAt = i
|
|
end
|
|
if not crawlAt and startExp and t.exp > startExp then crawlAt = i end
|
|
if t.burst then
|
|
if t.burst == 0 and not armAt then armAt = i end
|
|
if t.burst >= 1 and t.burst <= 8 then drawn[#drawn + 1] = t.burst end
|
|
if t.exp ~= EXP_FULL then full = false end
|
|
if t.message:find("grew to level") then quiet = false end
|
|
end
|
|
if t.message:find("grew to level") then
|
|
if not lineAt then lineAt = i end
|
|
if t.timer > 0 then prompted = true end
|
|
if not zeroAt and t.exp == 0 then zeroAt = i end
|
|
end
|
|
if not boxAt and t.phase == "stats-box" then boxAt = i end
|
|
end
|
|
check(promptAt and crawlAt and promptAt < crawlAt,
|
|
"the A on \"gained N EXP. Points!\" comes before the bar moves")
|
|
check(armAt ~= nil, "the burst arms at frame 0 on the tick the bar tops out")
|
|
if armAt then
|
|
eq(trace[armAt].exp, EXP_FULL, "with the bar at 64 on that tick")
|
|
eq(trace[armAt].level, 6, "and the level already ticked over")
|
|
check(trace[armAt - 1].burst == nil and trace[armAt - 1].exp < EXP_FULL,
|
|
"one tick after the last pixel")
|
|
end
|
|
eq(#drawn, 8, "eight drawn spark frames")
|
|
for i = 1, 8 do eq(drawn[i], i, "spark frame " .. i .. " in order") end
|
|
check(full, "with the bar left full under them")
|
|
check(quiet, "and no grew-to-level line while any spark is up")
|
|
check(lineAt ~= nil, "the grew-to-level line prints inside the crawl")
|
|
if lineAt then
|
|
check(trace[lineAt - 1].burst ~= nil,
|
|
"on the tick after the last spark frame")
|
|
eq(trace[lineAt].exp, EXP_FULL, "with the bar still full")
|
|
local typedAt = lineAt
|
|
while trace[typedAt] and trace[typedAt].typing do
|
|
typedAt = typedAt + 1
|
|
end
|
|
for i = lineAt, typedAt + 9 do
|
|
if trace[i].exp ~= EXP_FULL then full = false end
|
|
end
|
|
check(full, "and full through .PlayExpBarSound's ten frames")
|
|
eq(zeroAt, typedAt + 10, "then zero at the first PlaceExpBar of segment 2")
|
|
eq(trace[typedAt + 13].exp, 1, "one pixel three frames later")
|
|
end
|
|
check(not prompted, "the level line takes no A")
|
|
check(boxAt and lineAt and boxAt > lineAt, "the stats box follows")
|
|
if boxAt then
|
|
eq(trace[boxAt - 1].message, trace[lineAt].message,
|
|
"with the level line still up when it opens")
|
|
eq(trace[boxAt].exp,
|
|
screen:expPixels(player, player.level, player.experience),
|
|
"after segment 2 has landed on the mon's real place")
|
|
end
|
|
local lines = 0
|
|
for i = 2, #trace do
|
|
if trace[i].message:find("grew to level")
|
|
and not trace[i - 1].message:find("grew to level") then
|
|
lines = lines + 1
|
|
end
|
|
end
|
|
eq(lines, 1, "and the level event prints no second copy of the line")
|
|
end
|
|
|
|
do
|
|
-- ../pokecrystal/engine/battle/core.asm:7568
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 5, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local growth = DATA.pokemon.growthRates.GROWTH_MEDIUM_SLOW
|
|
player.experience = Mon.experienceForLevel(growth, 6) - 1
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
wild.hp = 1
|
|
local screen = newScreen({ player = player, wild = wild })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
local requested = {}
|
|
screen.playSfx = function(_, name) requested[#requested + 1] = name end
|
|
local busy = false
|
|
local realBusy = Sound.sfxBusy
|
|
Sound.sfxBusy = function() return busy end
|
|
local armed = false
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.expAnim then armed = true break end
|
|
end
|
|
check(armed, "the crawl armed")
|
|
local startExp = screen.shownExp
|
|
busy = true
|
|
for _ = 1, 40 do drainStep(screen) end
|
|
local asked = false
|
|
for _, name in ipairs(requested) do
|
|
if name == "Sfx_ExpBar" then asked = true end
|
|
end
|
|
check(not asked, "SFX_EXP_BAR is not requested while the channels are busy")
|
|
eq(screen.shownExp, startExp, "and the bar has not moved")
|
|
busy = false
|
|
for _ = 1, 3 do drainStep(screen) end
|
|
asked = false
|
|
for _, name in ipairs(requested) do
|
|
if name == "Sfx_ExpBar" then asked = true end
|
|
end
|
|
check(asked, "and is requested once they are free")
|
|
Sound.sfxBusy = realBusy
|
|
end
|
|
|
|
do
|
|
-- ../pokecrystal/engine/sprite_anims/core.asm:572
|
|
local Chrome = require("src.ui.gen2.Chrome")
|
|
local screen = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.phase = "resolving"
|
|
screen.message = "CYNDAQUIL gained 54 EXP. Points!"
|
|
screen.expBurst = { frame = 8 }
|
|
local order = {}
|
|
local realBox = Chrome.box
|
|
Chrome.box = function(x, y, w, h)
|
|
order[#order + 1] = ("box %d,%d,%d,%d"):format(x, y, w, h)
|
|
end
|
|
local realEnd = screen.hud.drawExpBarEnd
|
|
screen.hud.drawExpBarEnd = function(_, x, y)
|
|
order[#order + 1] = ("spark %d,%d"):format(x, y)
|
|
return true
|
|
end
|
|
local ok, err = pcall(function() screen:drawSceneBody() end)
|
|
Chrome.box = realBox
|
|
screen.hud.drawExpBarEnd = realEnd
|
|
check(ok, "the scene draws with the burst up: " .. tostring(err))
|
|
local lastBox, firstSpark, sparks = 0, nil, 0
|
|
for i, entry in ipairs(order) do
|
|
if entry:find("^box") then lastBox = i end
|
|
if entry:find("^spark") then
|
|
sparks = sparks + 1
|
|
firstSpark = firstSpark or i
|
|
end
|
|
end
|
|
eq(sparks, 8, "eight sparks drawn")
|
|
check(lastBox > 0, "the message box was drawn")
|
|
check(firstSpark and firstSpark > lastBox,
|
|
"every spark comes after the last box of the frame")
|
|
end
|
|
|
|
do
|
|
-- OAM bias (../pokecrystal/engine/sprite_anims/core.asm:558-608).
|
|
local screen = newScreen()
|
|
local drawn = {}
|
|
screen.hud = { drawExpBarEnd = function(_, x, y)
|
|
drawn[#drawn + 1] = ("%d,%d"):format(x, y)
|
|
end }
|
|
|
|
screen.expBurst = { frame = 1 }
|
|
screen:drawExpBurst()
|
|
eq(#drawn, 8, "eight objects a frame")
|
|
local collapsed = true
|
|
for _, at in ipairs(drawn) do
|
|
if at ~= "76,88" then collapsed = false end
|
|
end
|
|
check(collapsed, "all on the bar's left end while the radius is still 0")
|
|
|
|
drawn = {}
|
|
screen.expBurst = { frame = 8 }
|
|
screen:drawExpBurst()
|
|
local seen = {}
|
|
for _, at in ipairs(drawn) do seen[at] = (seen[at] or 0) + 1 end
|
|
local ring = { "90,88", "85,97", "76,102", "67,97",
|
|
"62,88", "67,79", "76,74", "85,79" }
|
|
for _, at in ipairs(ring) do
|
|
eq(seen[at], 1, "a spark at " .. at .. " on the last frame")
|
|
end
|
|
|
|
drawn = {}
|
|
screen.expBurst = { frame = 9 }
|
|
screen:drawExpBurst()
|
|
eq(#drawn, 0, "and ClearSprites past the loop leaves nothing behind")
|
|
end
|
|
|
|
-- ---- a level-up REDRAWS the HP bar, it does not animate it ----------------
|
|
do
|
|
-- GiveExperiencePoints' `.skip_active_mon_update` guard
|
|
-- (engine/battle/core.asm:6999-7003) copies the recalculated HP and max HP
|
|
-- into the battle struct for the mon that is OUT and calls UpdatePlayerHUD
|
|
-- (:7034), which DRAWS the bar rather than chasing it.
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 5, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local growth = DATA.pokemon.growthRates.GROWTH_MEDIUM_SLOW
|
|
player.experience = Mon.experienceForLevel(growth, 6) - 1
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
wild.hp = 1
|
|
local screen = newScreen({ player = player, wild = wild })
|
|
check(runToMenu(screen), "reached the menu")
|
|
local maxBefore = player.maxHp
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.phase == "done" then break end
|
|
end
|
|
check(player.maxHp > maxBefore, "the level-up raised the maximum")
|
|
eq(screen.shownHp.player, player.hp,
|
|
"and the bar carries the HP the level-up added, without waiting for the "
|
|
.. "next damage or heal event")
|
|
end
|
|
|
|
-- ---- the status tag takes the level's spot --------------------------------
|
|
do
|
|
local screen, battle, _, wild = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:submit({ kind = "move", move = "THUNDER_WAVE" })
|
|
eq(wild.status, "paralyze", "THUNDER WAVE paralyzed the wild mon")
|
|
eq(screen:statusTag(wild), "PAR",
|
|
"so the enemy HUD wears PAR where the level was")
|
|
eq(screen:statusTag({ status = "poison" }), "PSN", "PSN for poison")
|
|
eq(screen:statusTag({ status = "toxic" }), "PSN",
|
|
"toxic wears the same PSN bit")
|
|
eq(screen:statusTag({ status = "burn" }), "BRN", "BRN for burn")
|
|
eq(screen:statusTag({ status = "freeze" }), "FRZ", "FRZ for freeze")
|
|
eq(screen:statusTag({ status = "sleep" }), "SLP", "SLP for sleep")
|
|
eq(screen:statusTag({ status = "confuse" }), nil,
|
|
"confusion is a substatus on the cart and shows no tag")
|
|
eq(screen:statusTag({}), nil, "no status, no tag: the level prints")
|
|
end
|
|
|
|
-- ---- the intro slide's one-piece back pic ---------------------------------
|
|
do
|
|
-- CopyBackpic's OAM copy crosses 144px in the 72 frames, 2 a frame.
|
|
eq(BattleAnimView.slideBackpicOffset(0), 144,
|
|
"the back pic starts just off the right edge")
|
|
eq(BattleAnimView.slideBackpicOffset(36), 72, "halfway at frame 36")
|
|
eq(BattleAnimView.slideBackpicOffset(72), 0, "and lands on its column")
|
|
local top, middle = BattleAnimView.slideOffsets(72)
|
|
eq(top, 0, "the enemy band finishes in place")
|
|
eq(middle, 0, "so does the player band")
|
|
|
|
-- While the bands are baked, the player-side pic is withheld from them and
|
|
-- drawn only by the overlay, so it cannot tear at the $40 boundary.
|
|
local screen = newScreen()
|
|
screen.slidingBackpic = true
|
|
local ok = pcall(screen.drawPic, screen, screen.battle.player, true)
|
|
check(ok, "drawPic returns cleanly while the overlay owns the back pic")
|
|
end
|
|
|
|
-- ---- ItemRestoreHP: pick a mon, heal that mon -----------------------------
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local bench = Mon.new(DATA, "TOTODILE", 8, { dvs = perfect })
|
|
bench.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
bench.hp = bench.hp - 15
|
|
local screen, battle, _, _, save, pushed =
|
|
newScreen({ player = lead, party = { lead, bench } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
|
|
local turn0 = battle.turn
|
|
screen:useItem("POTION")
|
|
eq(screen.phase, "submenu", "a healing item opens a submenu, not a heal")
|
|
local picker = pushed[#pushed]
|
|
eq(getmetatable(picker), PartyMenu,
|
|
"and the submenu is the party screen (UseItem_SelectMon)")
|
|
eq(picker.prompt, PartyMenu.PROMPTS.useItem,
|
|
"asking the cart's own question")
|
|
|
|
local benchBefore = bench.hp
|
|
picker.onChoose(2, bench)
|
|
eq(picker.itemResult and picker.itemResult.shown, benchBefore,
|
|
"the picked row's bar starts at the pre-heal HP (wWhichHPBar = $2)")
|
|
check(drainItemResult(picker), "and the button drops the list")
|
|
eq(bench.hp, math.min(bench.maxHp or bench.stats.hp, benchBefore + 20),
|
|
"the POTION landed on the BENCHED mon")
|
|
eq(save.inventory.POTION, 1, "and one POTION left the bag")
|
|
eq(battle.turn, turn0 + 1, "a heal that lands spends the turn")
|
|
check(runToMenu(screen), "the enemy's answer drains out")
|
|
|
|
-- A full-HP target refuses without costing the item or the turn
|
|
-- (IsMonAtFullHealth's arm of ItemRestoreHP).
|
|
local turn1 = battle.turn
|
|
screen:useItem("POTION")
|
|
pushed[#pushed].onChoose(2, bench)
|
|
eq(screen.message, "It won't have any\neffect.",
|
|
"a full-HP target answers the cart's refusal")
|
|
eq(save.inventory.POTION, 1, "with the POTION still in the bag")
|
|
eq(battle.turn, turn1, "and the turn not spent")
|
|
check(runToMenu(screen), "back to the menu")
|
|
|
|
-- An egg is refused before the health check (UseItem_SelectMon .not_egg).
|
|
screen:useItem("POTION")
|
|
pushed[#pushed].onChoose(3, { isEgg = true, hp = 1, maxHp = 12 })
|
|
eq(screen.message, "That can't be used\non an EGG.",
|
|
"an EGG answers CantUseOnEggMessage")
|
|
eq(save.inventory.POTION, 1, "still nothing spent")
|
|
check(runToMenu(screen), "back to the menu")
|
|
|
|
-- Backing out of the picker returns to the pack with nothing spent.
|
|
screen:useItem("POTION")
|
|
pushed[#pushed].onCancel()
|
|
eq(getmetatable(pushed[#pushed]), PackMenu,
|
|
"cancelling the picker reopens the PACK (.SelectMon's carry path)")
|
|
eq(save.inventory.POTION, 1, "with the POTION untouched")
|
|
end
|
|
|
|
-- ---- BattleMenu_PKMN opens BattleMonMenu over the list --------------------
|
|
do
|
|
-- `callfar BattleMonMenu`, then SWITCH -> TryPlayerSwitch, CANCEL ->
|
|
-- .Cancel -> BattleMenu (engine/battle/core.asm:4810-4816); the voluntary
|
|
-- list is PARTYMENUACTION_CHOOSE_POKEMON and the forced one
|
|
-- PARTYMENUACTION_SWITCH (:4795, :2702).
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local bench = Mon.new(DATA, "TOTODILE", 8, { dvs = perfect })
|
|
bench.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local screen, battle, _, _, _, pushed =
|
|
newScreen({ player = lead, party = { lead, bench } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
|
|
check(screen:openParty(), "the voluntary list opens")
|
|
local list = pushed[#pushed]
|
|
eq(list.prompt, PartyMenu.PROMPTS.choose, "asking ChooseAMonString")
|
|
check(list.wantsBattleSubmenu, "and it carries BattleMonMenu")
|
|
list.index = 2
|
|
list:openSubmenu()
|
|
eq(#list.submenu.items, 3, "BattleMonMenu has three rows")
|
|
eq(list.submenu.items[1].id, "SWITCH", "SWITCH first")
|
|
eq(list.submenu.items[2].id, "STATS", "then STATS")
|
|
eq(list.submenu.items[3].id, "CANCEL", "then CANCEL")
|
|
|
|
-- CANCEL leaves the list entirely and lands back on the battle menu.
|
|
list.submenu.index = 3
|
|
list:updateSubmenu({ wasPressed = function(_, b) return b == "a" end })
|
|
eq(screen.phase, "menu", ".Cancel returns to BattleMenu")
|
|
|
|
-- SWITCH takes the pick through to the engine.
|
|
check(screen:openParty(), "the list reopens")
|
|
local list2 = pushed[#pushed]
|
|
list2.index = 2
|
|
list2:openSubmenu()
|
|
list2:updateSubmenu({ wasPressed = function(_, b) return b == "a" end })
|
|
check(runToMenu(screen), "the switch drains back to the menu")
|
|
eq(battle.player, bench, "SWITCH reached TryPlayerSwitch")
|
|
|
|
-- BattleText_MonIsAlreadyOut, and the turn is NOT spent (:4863-4870).
|
|
local turn0 = battle.turn
|
|
check(screen:openParty(), "the list opens again")
|
|
local list3 = pushed[#pushed]
|
|
list3.index = 2
|
|
list3:openSubmenu()
|
|
list3:updateSubmenu({ wasPressed = function(_, b) return b == "a" end })
|
|
eq(screen.phase, "submenu", "the mon already out is refused in the list")
|
|
eq(pushed[#pushed], list3, "with the party list still up")
|
|
eq(list3.submenu, nil, "and the SWITCH/STATS/CANCEL box gone")
|
|
local refused = (list3.itemResult or {}).text or ""
|
|
check(refused:find("already"), "with BattleText_MonIsAlreadyOut")
|
|
-- SpeechTextbox's 18-tile interior (home/text.asm:124)
|
|
for line in refused:gmatch("[^\n]+") do
|
|
check(#line <= 18, "the refusal wraps inside the textbox")
|
|
end
|
|
eq(battle.turn, turn0, "and no turn is spent on it")
|
|
list3:updateItemResult({ wasPressed = function(_, b) return b == "a" end })
|
|
eq(list3.itemResult, nil, "A dismisses it back to a live list")
|
|
eq(pushed[#pushed], list3, "which is still the top of the stack")
|
|
list3.onCancel()
|
|
|
|
-- The forced list is PickPartyMonInBattle: WhichPKMNString, no submenu.
|
|
check(screen:openParty(true), "the forced list opens")
|
|
local forced = pushed[#pushed]
|
|
eq(forced.prompt, PartyMenu.PROMPTS.which, "asking WhichPKMNString")
|
|
eq(forced.wantsBattleSubmenu, false, "with no BattleMonMenu over it")
|
|
end
|
|
|
|
-- ---- SHIFT offers a free swap when the trainer sends its next mon ---------
|
|
do
|
|
-- EnemySwitch's shift arm: OfferSwitch, then the enemy's send-out, then
|
|
-- `jp PlayerSwitch` with both participant bitfields zeroed
|
|
-- (engine/battle/core.asm:2941-2963); CheckWhetherToAskSwitch reads the
|
|
-- BATTLE_SHIFT bit CLEAR as SHIFT (:3269-3295).
|
|
local function shiftScreen(style)
|
|
Input:init()
|
|
local pushed = {}
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 30, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local bench = Mon.new(DATA, "TOTODILE", 30, { dvs = perfect })
|
|
bench.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local foe1 = Mon.new(DATA, "PIDGEY", 3, { dvs = perfect })
|
|
foe1.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local foe2 = Mon.new(DATA, "GEODUDE", 3, { dvs = perfect })
|
|
foe2.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local party = { lead, bench }
|
|
local save = { party = party, inventory = {} }
|
|
local game = {
|
|
data = DATA, save = save, input = Input,
|
|
options = { battleStyle = style },
|
|
stack = {
|
|
push = function(_, screen) pushed[#pushed + 1] = screen end,
|
|
pop = function() table.remove(pushed) end,
|
|
top = function() return pushed[#pushed] end,
|
|
},
|
|
}
|
|
local battle = Battle.new({ data = DATA, party = party, random = detRandom,
|
|
trainer = { class = "FALKNER", name = "FALKNER", party = { foe1, foe2 } } })
|
|
local screen = BattleState.new(game, { battle = battle, save = save })
|
|
return screen, battle, party, pushed
|
|
end
|
|
|
|
local function runToPhase(screen, phase, cap)
|
|
for _ = 1, (cap or 4000) do
|
|
drainStep(screen)
|
|
if screen.phase == phase then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function settleText(screen, cap)
|
|
for _ = 1, (cap or 400) do
|
|
if not screen:syncTyper() then return true end
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- SET never asks (`bit BATTLE_SHIFT, a / jr nz, .return_nc`, :3280-3282).
|
|
local setScreen, setBattle = shiftScreen("SET")
|
|
check(runToMenu(setScreen), "the SET battle reaches its menu")
|
|
setBattle.enemy.hp = 1
|
|
setScreen:submit({ kind = "move", move = "TACKLE" })
|
|
check(runToMenu(setScreen), "the KO drains without stopping")
|
|
eq(setScreen.phase, "menu", "SET is never offered a shift")
|
|
|
|
-- SHIFT stops on the prompt before the enemy's send-out line.
|
|
local noScreen, noBattle, noParty = shiftScreen("SHIFT")
|
|
check(runToMenu(noScreen), "the SHIFT battle reaches its menu")
|
|
noBattle.enemy.hp = 1
|
|
local noTurn = noBattle.turn
|
|
noScreen:submit({ kind = "move", move = "TACKLE" })
|
|
-- The `para` in BattleText_EnemyIsAboutToUseWillPlayerChangeMon splits the
|
|
-- offer (data/text/battle.asm:222-231): the incoming mon is named on an
|
|
-- earlier page, and only the last one carries the yes/no box (#1158).
|
|
check(runToPhase(noScreen, "shift-intro"), "the KO stops on OfferSwitch")
|
|
check((noScreen.message or ""):find("is about to use"),
|
|
"with BattleText_EnemyIsAboutToUseWillPlayerChangeMon")
|
|
check(runToPhase(noScreen, "ask-shift"), "and its pages reach the question")
|
|
check((noScreen.message or ""):find("change POK"),
|
|
"whose last page is the one YesNoBox opens over")
|
|
|
|
-- NO falls through to the send-out with nothing switched and nothing spent.
|
|
check(settleText(noScreen), "the question finishes printing")
|
|
noScreen.messageTimer = 0
|
|
noScreen.shiftIndex = 2
|
|
Input:overlayPressed("a")
|
|
Input:step()
|
|
noScreen:update(1 / 60)
|
|
Input:overlayReleased("a")
|
|
check(runToMenu(noScreen), "NO drains back to the menu")
|
|
eq(noBattle.player, noParty[1], "the lead is still out")
|
|
eq(noBattle.turn, noTurn + 1, "and only the attacking turn was spent")
|
|
|
|
-- YES picks a mon, and the switch lands AFTER the enemy's send-out.
|
|
local yesScreen, yesBattle, yesParty, pushed = shiftScreen("SHIFT")
|
|
check(runToMenu(yesScreen), "the second SHIFT battle reaches its menu")
|
|
yesBattle.enemy.hp = 1
|
|
yesScreen:submit({ kind = "move", move = "TACKLE" })
|
|
check(runToPhase(yesScreen, "ask-shift"), "it stops on OfferSwitch too")
|
|
check(settleText(yesScreen), "and its question finishes printing")
|
|
yesScreen.messageTimer = 0
|
|
yesScreen.shiftIndex = 1
|
|
Input:overlayPressed("a")
|
|
Input:step()
|
|
yesScreen:update(1 / 60)
|
|
Input:overlayReleased("a")
|
|
eq(yesScreen.phase, "submenu", "YES opens PickSwitchMonInBattle")
|
|
local picker = pushed[#pushed]
|
|
eq(picker.prompt, PartyMenu.PROMPTS.which, "asking WhichPKMNString")
|
|
eq(picker.wantsBattleSubmenu, false, "with no BattleMonMenu over it")
|
|
picker.onChoose(2, yesParty[2])
|
|
check(runToMenu(yesScreen), "the shift drains back to the menu")
|
|
eq(yesBattle.player, yesParty[2], "the picked mon is out")
|
|
eq(yesBattle.participants[1], nil,
|
|
"and both participant bitfields were zeroed first")
|
|
eq(yesBattle.participants[2], true, "leaving only the incoming slot")
|
|
end
|
|
|
|
-- ---- healing the active mon refills its bar on screen ---------------------
|
|
do
|
|
local screen, battle, player = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
-- Take a hit so there is something to refill.
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
check(runToMenu(screen), "first exchange drains")
|
|
check(player.hp < (player.maxHp or player.stats.hp),
|
|
"the player took damage")
|
|
eq(screen.shownHp.player, player.hp, "and the bar followed it down")
|
|
|
|
local screenSave = screen.save
|
|
screenSave.inventory.POTION = 1
|
|
screen:useItem("POTION")
|
|
local picker = screen.game.stack.top()
|
|
local hurt = player.hp
|
|
picker.onChoose(1, player)
|
|
-- engine/items/item_effects.asm:1671
|
|
check(picker.itemResult ~= nil and picker.itemResult.shown == hurt
|
|
and picker.itemResult.target == player.hp,
|
|
"healing the ACTIVE mon climbs the party row's bar")
|
|
eq(screen.hpAnim, nil, "with no HUD chase armed behind the list")
|
|
check(drainItemResult(picker), "the button drops the list")
|
|
check(runToMenu(screen), "the heal turn drains")
|
|
eq(screen.shownHp.player, player.hp, "and the HUD came back at the new HP")
|
|
end
|
|
|
|
-- ---- GROWL's sound comes from its own anim script (cache-fed) -------------
|
|
do
|
|
local cache = os.getenv("GOLD_CACHE")
|
|
if not cache then
|
|
local home = os.getenv("HOME") or ""
|
|
cache = home .. "/Library/Application Support/LOVE/gold-dev/gold"
|
|
end
|
|
local path = cache .. "/data/generated/battle_anims.lua"
|
|
local file = io.open(path, "r")
|
|
if not file then
|
|
check(true, "no Gold cache at " .. path .. " (SKIP)")
|
|
else
|
|
file:close()
|
|
local anims = assert(loadfile(path))()
|
|
if not (anims.scripts and anims.moves and anims.moves.GROWL) then
|
|
check(true, "battle_anims.lua has no GROWL script (SKIP)")
|
|
else
|
|
local AnimRunner = require("src.battle.gen2.AnimRunner")
|
|
local constants =
|
|
assert(loadfile(cache .. "/data/generated/constants.lua"))()
|
|
local cried, sounds = nil, 0
|
|
local runner = AnimRunner.new({
|
|
data = anims,
|
|
constants = constants,
|
|
battleTurn = 0,
|
|
animId = "GROWL",
|
|
hooks = {
|
|
cry = function(side, pitch, length) cried = side end,
|
|
sound = function() sounds = sounds + 1 end,
|
|
},
|
|
})
|
|
runner:start(anims.moves.GROWL)
|
|
local frames = 0
|
|
while runner:step() and frames < 600 do frames = frames + 1 end
|
|
-- BattleAnim_Growl (data/moves/animations.asm): `anim_cry $0` plays the
|
|
-- USER's cry, which is the move's whole sound.
|
|
eq(cried, "player", "GROWL's script asks for the user's own cry")
|
|
check(frames > 0 and frames < 600, "and the script terminates")
|
|
|
|
-- The chain the SCREEN's cry hook walks, end to end: the same GROWL
|
|
-- script through BattleState:animForMove must reach Sound.playCry with
|
|
-- the user's SPECIES, because audio.cries is keyed by species (the
|
|
-- def.cry field the hook once read does not exist in a Gen 2 cache).
|
|
local audio = assert(loadfile(cache .. "/data/generated/audio.lua"))()
|
|
check(audio.cries and audio.cries.CYNDAQUIL ~= nil,
|
|
"audio.lua keys the cries by species")
|
|
local screen = newScreen()
|
|
screen.game.data.gen2BattleAnims = anims
|
|
screen.game.data.gen2Constants = constants
|
|
screen.game.data.audio = audio
|
|
screen.anims = anims
|
|
screen.animConstants = constants
|
|
check(runToMenu(screen), "reached the menu with the anim runtime live")
|
|
local Sound = require("src.core.Sound")
|
|
local realPlayCry = Sound.playCry
|
|
local played = nil
|
|
Sound.playCry = function(_, species) played = species end
|
|
check(screen:animForMove("GROWL", "player"),
|
|
"the extracted GROWL animation starts")
|
|
for _ = 1, 600 do
|
|
if not screen.anim then break end
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
Sound.playCry = realPlayCry
|
|
eq(screen.anim, nil, "the animation ran out")
|
|
eq(played, "CYNDAQUIL",
|
|
"and GROWL played the user's cry through Sound.playCry")
|
|
end
|
|
end
|
|
end
|
|
|
|
-- ---- the cursor bytes that live across menu openings ----------------------
|
|
--
|
|
-- MoveSelectionScreen seeds wMenuCursorY from wCurMoveNum + 1
|
|
-- (engine/battle/core.asm:5111) and the A-press writes the picked row back, so
|
|
-- the FIGHT list reopens on the move used last turn. SendOutPlayerMon
|
|
-- (core.asm:3809) is what zeroes it, together with wBattleMenuCursorPosition.
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 },
|
|
{ id = "THUNDER_WAVE", pp = 20, maxPp = 20 } }
|
|
local screen = newScreen({ player = lead })
|
|
check(runToMenu(screen), "reached the menu")
|
|
local function tap(button)
|
|
Input:overlayPressed(button)
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
Input:overlayReleased(button)
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
tap("a") -- FIGHT
|
|
eq(screen.phase, "moves", "A on FIGHT opens the move list")
|
|
tap("down")
|
|
eq(screen.moveIndex, 2, "down moves onto the second move")
|
|
tap("a")
|
|
check(runToMenu(screen), "the turn drains back to the menu")
|
|
eq(screen.moveIndex, 2, "wCurMoveNum survived the turn")
|
|
tap("a")
|
|
eq(screen.phase, "moves", "FIGHT reopens")
|
|
eq(screen.moveIndex, 2, "on the move used last turn, not on the first")
|
|
|
|
-- A moveset that shrank clamps rather than pointing past the end.
|
|
tap("b")
|
|
screen.moveIndex = 4
|
|
screen.battle.player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
tap("a")
|
|
eq(screen.phase, "moves", "FIGHT opens again")
|
|
eq(screen.moveIndex, 1, "and the row is clamped to the moves that are left")
|
|
end
|
|
|
|
-- SendOutPlayerMon zeroes both cursor bytes, so a switched-in mon opens on
|
|
-- FIGHT and on its first move.
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 },
|
|
{ id = "GROWL", pp = 40, maxPp = 40 } }
|
|
local bench = Mon.new(DATA, "TOTODILE", 8, { dvs = perfect })
|
|
bench.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local screen = newScreen({ player = lead, party = { lead, bench } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.menuIndex = 3
|
|
screen.moveIndex = 2
|
|
screen:submit({ kind = "switch", index = 2 })
|
|
check(runToMenu(screen), "the switch resolves back to the menu")
|
|
eq(screen.menuIndex, 1, "wBattleMenuCursorPosition is back on FIGHT")
|
|
eq(screen.moveIndex, 1, "and wCurMoveNum on the first move")
|
|
end
|
|
|
|
-- ---- no HUD rides in with the intro bands ---------------------------------
|
|
--
|
|
-- InitBattleDisplay blanks the whole tilemap before BattleIntroSlidingPics
|
|
-- (core.asm:8554/8564); UpdateEnemyHUD runs only after BattleStartMessage
|
|
-- returns (:7815) and UpdatePlayerHUD at the tail of SendOutPlayerMon (:3838).
|
|
do
|
|
local screen = newScreen()
|
|
eq(screen.showEnemyHud, false, "the enemy HUD does not exist at construction")
|
|
eq(screen.showPlayerHud, false, "nor the player's")
|
|
run(screen, BattleAnimView.SLIDE_FRAMES)
|
|
eq(screen.showEnemyHud, false, "and neither rode in with the bands")
|
|
eq(screen.showPlayerHud, false, "on either side")
|
|
-- The appeared line is read against an empty HUD area.
|
|
for _ = 1, 3000 do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
if screen.message == "Wild PIDGEY appeared!" then break end
|
|
end
|
|
eq(screen.message, "Wild PIDGEY appeared!", "BattleStartMessage's own line")
|
|
eq(screen.showEnemyHud, false, "with no enemy HUD under it yet")
|
|
check(runToMenu(screen), "the intro drains to the menu")
|
|
eq(screen.showEnemyHud, true, "UpdateEnemyHUD has run by the menu")
|
|
eq(screen.showPlayerHud, true, "and UpdatePlayerHUD after the send-out")
|
|
end
|
|
|
|
-- ../pokecrystal/engine/battle/core.asm:8063
|
|
do
|
|
local screen = newScreen()
|
|
check(screen:introGrayscale(), "PREDEFPAL_BLACKOUT covers frame 0")
|
|
run(screen, BattleAnimView.SLIDE_FRAMES - 1)
|
|
check(screen:introGrayscale(), "and the last frame of the slide")
|
|
run(screen, 1)
|
|
check(not screen:introGrayscale(),
|
|
"SCGB_BATTLE_COLORS at the tail of InitBattleDisplay")
|
|
end
|
|
|
|
-- engine/battle/core.asm:8733
|
|
do
|
|
local screen = newScreen()
|
|
eq(screen.ballRows.player, false, "no player ball row at construction")
|
|
eq(screen.ballRows.enemy, false, "nor an OT row")
|
|
run(screen, BattleAnimView.SLIDE_FRAMES)
|
|
eq(screen.ballRows.player, false, "and neither rode in with the bands")
|
|
eq(screen.ballRows.enemy, false, "on either side")
|
|
for _ = 1, 3000 do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
if screen.message == "Wild PIDGEY appeared!" then break end
|
|
end
|
|
eq(screen.message, "Wild PIDGEY appeared!", "BattleStartMessage's own line")
|
|
eq(screen.ballRows.player, true, "ShowPlayerMonsRemaining rides that line")
|
|
eq(screen.ballRows.enemy, false,
|
|
"and wBattleMode skips ShowOTTrainerMonsRemaining in the wild")
|
|
end
|
|
|
|
-- ---- the wild mon cries with BattleStartMessage ----------------------------
|
|
--
|
|
-- `.not_shiny`: `ld a, [wTempEnemyMonSpecies] / call PlayStereoCry` runs before
|
|
-- WildPokemonAppearedText (engine/battle/core.asm:8718-8721).
|
|
do
|
|
local screen = newScreen()
|
|
local realAudio = screen.game.data.audio
|
|
screen.game.data.audio = { cries = { PIDGEY = { pitch = 0 } } }
|
|
local realPlayCry = Sound.playCry
|
|
local played
|
|
Sound.playCry = function(_, species) played = species end
|
|
for _ = 1, 3000 do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
if screen.message == "Wild PIDGEY appeared!" then break end
|
|
end
|
|
Sound.playCry = realPlayCry
|
|
screen.game.data.audio = realAudio
|
|
eq(played, "PIDGEY", "the wild mon cries with its appeared line")
|
|
end
|
|
|
|
-- ---- the message box's two fixed rows -------------------------------------
|
|
--
|
|
-- LineChar reloads the cursor at TEXTBOX_INNERY + 2 (home/text.asm:397), so a
|
|
-- two-line battle string sits on rows 14 and 16 with row 15 blank.
|
|
do
|
|
local Chrome = require("src.ui.gen2.Chrome")
|
|
local screen = newScreen()
|
|
local realPrint = Chrome.print
|
|
local rows = {}
|
|
Chrome.print = function(text, tx, ty) rows[#rows + 1] = { text, tx, ty } end
|
|
screen.message = "CYNDAQUIL used TACKLE on the wild PIDGEY!"
|
|
screen:printMessage()
|
|
Chrome.print = realPrint
|
|
check(#rows >= 2, "a long line wraps onto a second row")
|
|
eq(rows[1][2], 1, "TEXTBOX_INNERX is column 1")
|
|
eq(rows[1][3], 14, "TEXTBOX_INNERY is row 14")
|
|
eq(rows[2][3], 16, "and LineChar's row is 16, not 15")
|
|
eq(#rows, 2, "with no third row: Paragraph clears only 14-16")
|
|
end
|
|
|
|
-- ---- PokeBallEffect's throw --------------------------------------------
|
|
do
|
|
local screen = newScreen()
|
|
-- `cp POKE_BALL + 1 / jr c, .not_kurt_ball / ld a, POKE_BALL`.
|
|
eq(screen:ballAnimParam("MASTER_BALL"), 1, "MASTER BALL throws as itself")
|
|
eq(screen:ballAnimParam("POKE_BALL"), 5, "so does a POKe BALL")
|
|
eq(screen:ballAnimParam("FAST_BALL"), 5,
|
|
"and a Kurt ball throws with POKE_BALL's param")
|
|
-- data/battle_anims/ball_colors.asm.
|
|
eq(screen:ballPalette("MASTER_BALL"), "PAL_BATTLE_OB_GREEN", "green")
|
|
eq(screen:ballPalette("POKE_BALL"), "PAL_BATTLE_OB_RED", "red")
|
|
eq(screen:ballPalette("FAST_BALL"), "PAL_BATTLE_OB_BLUE", "blue")
|
|
eq(screen:ballPalette("NEST_BALL"), "PAL_BATTLE_OB_GRAY",
|
|
"and anything off the table takes the terminator row's gray")
|
|
|
|
-- GetPokeBallWobble: three wobbles, then the verdict.
|
|
screen.battle.random = function() return 0 end
|
|
screen.ballThrow = { caught = true, rate = 255, wobble = 0 }
|
|
eq(screen:pokeballWobble(), 0, "a caught mon wobbles once")
|
|
eq(screen:pokeballWobble(), 0, "twice")
|
|
eq(screen:pokeballWobble(), 0, "three times")
|
|
eq(screen:pokeballWobble(), 1, "and the fourth call is the click")
|
|
|
|
screen.ballThrow = { caught = false, rate = 255, wobble = 0 }
|
|
eq(screen:pokeballWobble(), 0, "a doomed throw can still wobble")
|
|
eq(screen:pokeballWobble(), 0, "and again")
|
|
eq(screen:pokeballWobble(), 0, "and again")
|
|
eq(screen:pokeballWobble(), 2, "before it breaks free on the fourth")
|
|
eq(screen:ballFailureText(), "Shoot! It was so close too!",
|
|
"four wobbles is BallSoCloseText")
|
|
|
|
-- A roll that never comes in under the probability breaks free at once.
|
|
screen.battle.random = function(n) return (n or 256) - 1 end
|
|
screen.ballThrow = { caught = false, rate = 1, wobble = 0 }
|
|
eq(screen:pokeballWobble(), 2, "the first wobble already fails")
|
|
eq(screen:ballFailureText(), "Oh no! The POKéMON broke free!",
|
|
"one wobble is BallBrokeFreeText")
|
|
screen.ballThrow = { caught = false, rate = 1, wobble = 3 }
|
|
eq(screen:ballFailureText(), "Aargh! Almost had it!",
|
|
"three is BallAlmostHadItText")
|
|
end
|
|
|
|
-- ---- a full party sends the catch to the PC, and a full box refuses -------
|
|
do
|
|
-- `.SendToPC` / `predef SendMonIntoBox` (engine/items/item_effects.asm:548).
|
|
local party = {}
|
|
for i = 1, 6 do
|
|
local mon = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
mon.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
party[i] = mon
|
|
end
|
|
local screen, battle, _, wild, save =
|
|
newScreen({ player = party[1], party = party,
|
|
inventory = { MASTER_BALL = 1 } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:useItem("MASTER_BALL")
|
|
eq(battle.outcome, "caught", "the Master Ball catch lands")
|
|
eq(#save.party, 6, "the party is untouched")
|
|
eq((save.boxes and save.boxes[1] or {})[1], wild,
|
|
"and the catch went into the current box, not into nothing")
|
|
|
|
-- Ball_BoxIsFullMessage: party full AND box full refuses the throw outright
|
|
-- and reports the item unused, so neither the ball nor the turn goes
|
|
-- (item_effects.asm:217-226).
|
|
local party2 = {}
|
|
for i = 1, 6 do
|
|
local mon = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
mon.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
party2[i] = mon
|
|
end
|
|
local screen2, battle2, _, _, save2 =
|
|
newScreen({ player = party2[1], party = party2,
|
|
inventory = { MASTER_BALL = 1 } })
|
|
save2.boxes = { {} }
|
|
for i = 1, 20 do save2.boxes[1][i] = { species = "PIDGEY" } end
|
|
check(runToMenu(screen2), "reached the menu")
|
|
local turn0 = battle2.turn
|
|
screen2:useItem("MASTER_BALL")
|
|
eq(battle2.outcome, nil, "the throw is refused")
|
|
eq(save2.inventory.MASTER_BALL, 1, "the ball stays in the bag")
|
|
eq(battle2.turn, turn0, "and the turn is not spent")
|
|
check((screen2.message or ""):find("BOX"), "BallBoxFullText is what shows")
|
|
end
|
|
|
|
-- ---- SendMonIntoBox inserts at the HEAD, and reports a box it filled ------
|
|
do
|
|
-- The species loop cascades every entry one slot down and ShiftBoxMon does
|
|
-- the same for the OT names, nicknames and mon structs
|
|
-- (engine/pokemon/move_mon.asm:954-968), so the catch is slot 1 -- which is
|
|
-- what lets the FRIEND_BALL arm write sBoxMon1Happiness unconditionally
|
|
-- ("The captured mon is now first in the box", item_effects.asm:624).
|
|
local party = {}
|
|
for i = 1, 6 do
|
|
local mon = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
mon.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
party[i] = mon
|
|
end
|
|
local screen, battle, _, wild, save =
|
|
newScreen({ player = party[1], party = party,
|
|
inventory = { MASTER_BALL = 1 } })
|
|
local resident = { species = "PIDGEY" }
|
|
save.boxes = { { resident } }
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:useItem("MASTER_BALL")
|
|
eq(battle.outcome, "caught", "the Master Ball catch lands")
|
|
eq(save.boxes[1][1], wild, "the catch is FIRST in the box")
|
|
eq(save.boxes[1][2], resident, "and the mon already there shifted down one")
|
|
eq(#save.boxes[1], 2, "with nothing lost off the end")
|
|
eq(battle.boxFilled, nil, "a box with room left flags nothing")
|
|
|
|
-- `.SendToPC` re-reads sBoxCount after the insert and sets
|
|
-- BATTLERESULT_BOX_FULL when the catch is the one that filled it
|
|
-- (item_effects.asm:612-619), which is what rings Bill on the first step
|
|
-- back in the overworld.
|
|
local party2 = {}
|
|
for i = 1, 6 do
|
|
local mon = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
mon.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
party2[i] = mon
|
|
end
|
|
local screen2, battle2, _, _, save2 =
|
|
newScreen({ player = party2[1], party = party2,
|
|
inventory = { MASTER_BALL = 1 } })
|
|
save2.boxes = { {} }
|
|
for i = 1, 19 do save2.boxes[1][i] = { species = "PIDGEY" } end
|
|
check(runToMenu(screen2), "reached the menu")
|
|
screen2:useItem("MASTER_BALL")
|
|
eq(battle2.outcome, "caught", "the twentieth catch still goes in")
|
|
eq(#save2.boxes[1], 20, "and fills the box")
|
|
eq(battle2.boxFilled, true, "which is flagged on the battle for the reload")
|
|
end
|
|
|
|
-- ---- a new species opens NewPokedexEntry, gated on CheckReceivedDex -------
|
|
do
|
|
-- `predef NewPokedexEntry` sits between NewDexDataText and the party add
|
|
-- (engine/items/item_effects.asm:535-542, :570).
|
|
local function findEvent(screen, kind)
|
|
for index, event in ipairs(screen.queue or {}) do
|
|
if event.kind == kind then return index, event end
|
|
end
|
|
end
|
|
|
|
local screen, _, _, _, save = newScreen({ inventory = { MASTER_BALL = 1 } })
|
|
save.engineFlags = { [11] = true }
|
|
save.pokedex = { seen = {}, caught = {} }
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:useItem("MASTER_BALL")
|
|
local dexAt, dexEvent = findEvent(screen, "dex-entry")
|
|
check(dexEvent ~= nil, "the catch queues a dex-entry event")
|
|
eq(dexEvent and dexEvent.species, "PIDGEY", "on the species just caught")
|
|
local nickAt = findEvent(screen, "ask-nickname")
|
|
check(nickAt and dexAt and dexAt < nickAt,
|
|
"and it runs ahead of AskGiveNicknameText")
|
|
|
|
-- CheckReceivedDex: no dex, no line and no screen (item_effects.asm:532-533).
|
|
local screen2, _, _, _, save2 = newScreen({ inventory = { MASTER_BALL = 1 } })
|
|
save2.engineFlags = {}
|
|
save2.pokedex = { seen = {}, caught = {} }
|
|
check(runToMenu(screen2), "reached the menu")
|
|
screen2:useItem("MASTER_BALL")
|
|
eq(findEvent(screen2, "dex-entry"), nil, "a dexless player gets no entry")
|
|
|
|
-- `jr nz, .skip_pokedex`: a row already owned skips both (:528-530).
|
|
local screen3, _, _, _, save3 = newScreen({ inventory = { MASTER_BALL = 1 } })
|
|
save3.engineFlags = { [11] = true }
|
|
save3.pokedex = { seen = {}, caught = { PIDGEY = true } }
|
|
check(runToMenu(screen3), "reached the menu")
|
|
screen3:useItem("MASTER_BALL")
|
|
eq(findEvent(screen3, "dex-entry"), nil, "an owned row opens nothing")
|
|
end
|
|
|
|
-- ---- the low-HP siren dies with the enemy, and with a healing item --------
|
|
do
|
|
-- StopDangerSound plus the wBattleLowHealthAlarm latch on every wild enemy
|
|
-- faint (engine/battle/core.asm:2071-2074), read first by CheckDanger
|
|
-- (:4396-4399); and wLowHealthAlarm zeroed by the healing items before the
|
|
-- HP even moves (engine/items/item_effects.asm:1657-1658).
|
|
local siren = false
|
|
local realStart, realStop = Sound.startLoop, Sound.stopLoop
|
|
Sound.startLoop = function(_, name)
|
|
if name == "Low_Health_Alarm" then siren = true end
|
|
end
|
|
Sound.stopLoop = function(name)
|
|
if name == "Low_Health_Alarm" then siren = false end
|
|
end
|
|
|
|
local player = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
player.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local wild = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
wild.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local screen = newScreen({ player = player, wild = wild })
|
|
check(runToMenu(screen), "reached the menu")
|
|
player.hp = 2
|
|
screen.shownHp.player = 2
|
|
run(screen, 1)
|
|
check(siren, "a red bar raises the siren")
|
|
|
|
wild.hp = 1
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
-- The drain to zero still rings: AnimateHPBar runs before
|
|
-- UpdateBattleStateAndExperienceAfterEnemyFaint is even reached. What may
|
|
-- not ring is anything from the faint onward.
|
|
local latched, rangAfterFaint, sawExpLine = false, false, false
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.lowHealthAlarmDisabled then latched = true end
|
|
if latched and siren then rangAfterFaint = true end
|
|
if latched and (screen.message or ""):find("EXP") then sawExpLine = true end
|
|
if screen.phase == "done" then break end
|
|
end
|
|
eq(screen.phase, "done", "the win drains out")
|
|
check(latched, "the enemy's faint latched wBattleLowHealthAlarm")
|
|
check(sawExpLine, "and the exp lines ran after it with the bar still red")
|
|
check(not rangAfterFaint,
|
|
"and the siren is cut the instant the enemy goes down, not left blaring "
|
|
.. "under the exp bar and the level-up lines")
|
|
|
|
-- The item exception: silent from the frame it is used, all through the
|
|
-- climb, with no latch behind it.
|
|
local player2 = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
player2.moves = { { id = "TACKLE", pp = 35, maxPp = 35 } }
|
|
local screen2 = newScreen({ player = player2,
|
|
inventory = { POTION = 1 } })
|
|
check(runToMenu(screen2), "reached the menu")
|
|
player2.hp = 2
|
|
screen2.shownHp.player = 2
|
|
run(screen2, 1)
|
|
check(siren, "the second battle's siren is up too")
|
|
screen2:useItem("POTION")
|
|
local picker2 = screen2.game.stack.top()
|
|
picker2.onChoose(1, player2)
|
|
check(not siren, "the POTION silences it where UseDisposableItem sits")
|
|
check(picker2.itemResult and picker2.itemResult.shown == 2,
|
|
"with the party row's bar only starting to climb")
|
|
local rangDuringClimb = false
|
|
for _ = 1, 600 do
|
|
if not picker2.itemResult then break end
|
|
Input:overlayPressed("a")
|
|
Input:step()
|
|
picker2:update(1 / 60)
|
|
Input:overlayReleased("a")
|
|
if picker2.itemResult and siren then rangDuringClimb = true end
|
|
end
|
|
for _ = 1, 600 do
|
|
Input:step()
|
|
screen2:update(1 / 60)
|
|
if screen2.phase == "menu" then break end
|
|
end
|
|
check(not rangDuringClimb, "and it stays silent for the whole climb")
|
|
|
|
Sound.startLoop, Sound.stopLoop = realStart, realStop
|
|
end
|
|
|
|
-- ---- the move list refuses a dry or disabled row --------------------------
|
|
--
|
|
-- `.no_pp_left` and `.move_disabled` both end on `jp MoveSelectionScreen`
|
|
-- (engine/battle/core.asm:5213-5246), so neither spends the turn.
|
|
local function tapper(screen)
|
|
return function(button)
|
|
for _ = 1, 400 do
|
|
if not screen:syncTyper() then break end
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
Input:overlayPressed(button)
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
Input:overlayReleased(button)
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
end
|
|
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "GROWL", pp = 40, maxPp = 40 },
|
|
{ id = "TACKLE", pp = 5, maxPp = 35 } }
|
|
local screen, _, _, wild = newScreen({ player = lead })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.battle:volatile(screen.battle.player).disabled = "GROWL"
|
|
local tap = tapper(screen)
|
|
tap("a")
|
|
eq(screen.phase, "moves", "A on FIGHT still opens the list")
|
|
local before = wild.hp
|
|
tap("a")
|
|
eq(screen.phase, "refuse-move", "the disabled row is refused")
|
|
eq(screen.message, "The move is DISABLED!", "with BattleText_TheMoveIsDisabled")
|
|
eq(wild.hp, before, "and the enemy got no free turn")
|
|
-- Both refusal lines end in `prompt` (data/text/battle.asm:315-323), so the
|
|
-- list comes back on a press, not on a timer.
|
|
tap("a")
|
|
eq(screen.phase, "moves", "the list comes back")
|
|
|
|
-- The same for a spent row.
|
|
screen.battle:volatile(screen.battle.player).disabled = nil
|
|
screen.battle.player.moves[2].pp = 0
|
|
tap("down")
|
|
eq(screen.moveIndex, 2, "onto the spent move")
|
|
tap("a")
|
|
eq(screen.phase, "refuse-move", "a 0 PP row is refused too")
|
|
eq(screen.message, "There's no PP left for this move!",
|
|
"with BattleText_TheresNoPPLeftForThisMove")
|
|
eq(wild.hp, before, "and still no enemy turn")
|
|
tap("a")
|
|
eq(screen.phase, "moves", "and the list comes back again")
|
|
end
|
|
|
|
-- .CheckPlayerHasUsableMoves runs at MoveSelectionScreen's head
|
|
-- (engine/battle/core.asm:5058-5059): nothing usable never opens the list.
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "GROWL", pp = 40, maxPp = 40 },
|
|
{ id = "TACKLE", pp = 0, maxPp = 35 } }
|
|
local screen = newScreen({ player = lead })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.battle:volatile(screen.battle.player).disabled = "GROWL"
|
|
local messages = {}
|
|
local realPush = screen.pushAll
|
|
screen.pushAll = function(self, events)
|
|
for _, event in ipairs(events or {}) do
|
|
if event.kind == "message" then messages[#messages + 1] = event.text end
|
|
end
|
|
return realPush(self, events)
|
|
end
|
|
tapper(screen)("a")
|
|
check(screen.phase ~= "moves", "the list never opened")
|
|
local struggled = false
|
|
for _, text in ipairs(messages) do
|
|
if text:find("has no moves left!", 1, true) then struggled = true end
|
|
end
|
|
check(struggled, "and the turn resolved as STRUGGLE")
|
|
end
|
|
|
|
-- ---- the move-learn prompts (engine/pokemon/learn.asm) -------------------
|
|
--
|
|
-- ForgetMove asks first (:123-127), the picker's B is LearnMove's .cancel
|
|
-- (:104-108) and a NO there is `jp c, .loop`, back to the ask.
|
|
local function learnScreen()
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 35, maxPp = 35 },
|
|
{ id = "GROWL", pp = 40, maxPp = 40 },
|
|
{ id = "THUNDER_WAVE", pp = 20, maxPp = 20 },
|
|
{ id = "SURF", pp = 15, maxPp = 15 } }
|
|
local screen = newScreen({ player = lead, party = { lead } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen:push({ kind = "choose-forget", index = 1,
|
|
move = { id = "EMBER", pp = 25, maxPp = 25 }, moveName = "EMBER",
|
|
text = "CYNDAQUIL wants to learn EMBER!" })
|
|
screen:advanceQueue()
|
|
return screen, lead
|
|
end
|
|
|
|
-- AskForgetMoveText's `para`/`cont` each want a press (home/text.asm:403-448),
|
|
-- so the question is reached by pages rather than by one button.
|
|
local function runToPhase(screen, phase, cap)
|
|
for _ = 1, (cap or 900) do
|
|
drainStep(screen)
|
|
if screen.phase == phase then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
do
|
|
local screen, lead = learnScreen()
|
|
eq(screen.phase, "learn-intro", "AskForgetMoveText's first page holds")
|
|
eq(screen.message, "CYNDAQUIL is\ntrying to learn",
|
|
"with _AskForgetMoveText's own wording (data/text/common_3.asm:141-165)")
|
|
check(runToPhase(screen, "ask-forget"), "and its pages run into the question")
|
|
eq(screen.message, "move to make room\nfor EMBER?",
|
|
"whose last page is the one YesNoBox opens over")
|
|
local tap = tapper(screen)
|
|
-- The question's own `prompt` is read first and YesNoBox opens after it,
|
|
-- exactly as OfferSwitch does (engine/battle/core.asm:3298-3305), so the
|
|
-- answer is the second press, not the first.
|
|
tap("a")
|
|
eq(screen.phase, "ask-forget", "the last page holds until it is read")
|
|
tap("b")
|
|
eq(screen.phase, "stop-learning", "NO there asks whether to stop learning")
|
|
tap("a")
|
|
tap("b")
|
|
eq(screen.phase, "learn-intro", "and NO to THAT reprints the ask")
|
|
check(runToPhase(screen, "ask-forget"), "which is a loop, not an exit")
|
|
eq(lead.moves[1].id, "TACKLE", "and the moveset is untouched throughout")
|
|
eq(#lead.moves, 4, "with nothing added")
|
|
end
|
|
|
|
do
|
|
local screen, lead = learnScreen()
|
|
check(runToPhase(screen, "ask-forget"), "the pages reach the question")
|
|
local tap = tapper(screen)
|
|
tap("a") -- read the question
|
|
tap("a") -- YES
|
|
eq(screen.phase, "choose-forget", "YES opens the picker")
|
|
tap("a") -- slot 1
|
|
eq(lead.moves[1].id, "EMBER", "and A on slot 1 learns the move there")
|
|
end
|
|
|
|
-- IsHMMove refuses the slot and `jr .loop` redraws the list (learn.asm:193-197).
|
|
do
|
|
local screen, lead = learnScreen()
|
|
check(runToPhase(screen, "ask-forget"), "the pages reach the question")
|
|
local tap = tapper(screen)
|
|
tap("a") -- read the question
|
|
tap("a") -- YES
|
|
eq(screen.phase, "choose-forget", "the picker is up")
|
|
screen.forgetIndex = 4
|
|
tap("a")
|
|
eq(screen.phase, "choose-forget", "A on the HM row keeps the list")
|
|
eq(screen.message, "HM moves can't be\nforgotten now.",
|
|
"with MoveCantForgetHMText")
|
|
eq(screen.forgetIndex, 1, "and `jr .loop` puts the cursor back on slot 1")
|
|
tap("a")
|
|
eq(screen.phase, "choose-forget", "the picker is still up after the line")
|
|
eq(lead.moves[4].id, "SURF", "and SURF is still there")
|
|
end
|
|
|
|
-- ---- GetMovePriority's Vital Throw carve-out (#1475) ----------------------
|
|
-- engine/battle/core.asm:787-789
|
|
do
|
|
local screen = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
local battle = screen.battle
|
|
local moves = battle.data.moves
|
|
moves.VITAL_THROW = { id = "VITAL_THROW", name = "VITALTHROW", power = 70,
|
|
type = "NORMAL", accuracy = 100, pp = 10, effect = "EFFECT_ALWAYS_HIT" }
|
|
moves.SWIFT = { id = "SWIFT", name = "SWIFT", power = 60, type = "NORMAL",
|
|
accuracy = 100, pp = 20, effect = "EFFECT_ALWAYS_HIT" }
|
|
moves.QUICK_ATTACK = { id = "QUICK_ATTACK", name = "QUICKATTACK", power = 40,
|
|
type = "NORMAL", accuracy = 100, pp = 30, effect = "EFFECT_PRIORITY_HIT" }
|
|
eq(battle:movePriority("VITAL_THROW"), -1, "VITAL_THROW goes last")
|
|
eq(battle:movePriority("SWIFT"), 0,
|
|
"while SWIFT, which shares its effect, keeps BASE_PRIORITY")
|
|
eq(battle:movePriority("QUICK_ATTACK"), 1, "and the table still reads")
|
|
moves.ROAR_FIX = { id = "ROAR_FIX", name = "ROAR", power = 0,
|
|
type = "NORMAL", accuracy = 100, pp = 20, effect = "EFFECT_FORCE_SWITCH" }
|
|
-- MoveEffectPriorities: EFFECT_FORCE_SWITCH is 0, below BASE_PRIORITY
|
|
-- (data/moves/effects_priorities.asm:5)
|
|
eq(battle:movePriority("ROAR_FIX"), -1,
|
|
"Whirlwind and Roar sit below BASE_PRIORITY")
|
|
eq(battle:orderOf("VITAL_THROW", "ROAR_FIX"), "player",
|
|
"VITAL_THROW ties a force-switch move (0 vs 0), so Speed decides")
|
|
eq(battle:orderOf("TACKLE", "TACKLE"), "player",
|
|
"the faster mon leads on equal priority")
|
|
eq(battle:orderOf("VITAL_THROW", "TACKLE"), "enemy",
|
|
"but VITAL_THROW loses to a normal move whatever the Speed")
|
|
moves.VITAL_THROW, moves.SWIFT, moves.QUICK_ATTACK = nil, nil, nil
|
|
moves.ROAR_FIX = nil
|
|
end
|
|
|
|
-- ---- a send-out snapshots HP at send time (#1514) -------------------------
|
|
-- SendOutPlayerMon's tail (engine/battle/core.asm:3796-3838)
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
local bench = Mon.new(DATA, "TOTODILE", 10, { dvs = perfect })
|
|
local screen, battle = newScreen({ player = lead, party = { lead, bench } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
battle:takeEvents()
|
|
check(battle:switch(2), "the bench mon comes in")
|
|
local send = battle:takeEvents()[1]
|
|
eq(send.kind, "send", "the switch emits a send-out")
|
|
eq(send.hp, bench.hp, "carrying a numeric HP snapshot")
|
|
bench.hp = bench.hp - 7
|
|
check(send.hp ~= bench.hp,
|
|
"which the rest of the turn's damage cannot walk back")
|
|
screen.shownHp.player = 0
|
|
screen:push(send)
|
|
screen:advanceQueue()
|
|
eq(screen.shownHp.player, send.hp,
|
|
"and the HUD opens on the snapshot, not on the post-hit value")
|
|
end
|
|
|
|
-- ---- the send-out snapshots level and exp the same way (#1514) ------------
|
|
-- SendOutPlayerMon reloads wBattleMon* from the party slot (core.asm:3796-3838)
|
|
do
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
local bench = Mon.new(DATA, "TOTODILE", 10, { dvs = perfect })
|
|
local screen, battle = newScreen({ player = lead, party = { lead, bench } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
battle:takeEvents()
|
|
check(battle:switch(2), "the bench mon comes in")
|
|
local send = battle:takeEvents()[1]
|
|
eq(send.level, bench.level, "the send carries a level snapshot")
|
|
eq(send.experience, bench.experience, "and an experience snapshot")
|
|
-- awardExperience mutates the live table before the UI dequeues the send
|
|
bench.level = bench.level + 3
|
|
bench.experience = (bench.experience or 0) + 5000
|
|
screen:push(send)
|
|
screen:advanceQueue()
|
|
eq(screen.shownLevel, send.level,
|
|
"the HUD opens on the send-time level, not the post-award one")
|
|
eq(screen.shownExp, screen:expPixels(bench, send.level, send.experience),
|
|
"and the exp bar fills from the send-time experience")
|
|
end
|
|
|
|
-- ---- LearnMove finishes before the queued send-out (#1516) ----------------
|
|
-- LearnMove inside GiveExperiencePoints (engine/battle/core.asm:1959-2010)
|
|
do
|
|
local screen, lead = learnScreen()
|
|
screen:push({ kind = "send", side = "enemy", mon = { hp = 1 }, hp = 1,
|
|
text = Battle.sentOutText("JOE", "PIDGEY") })
|
|
check(runToPhase(screen, "ask-forget"), "the pages reach the question")
|
|
local tap = tapper(screen)
|
|
tap("a") -- read the question
|
|
tap("a") -- YES
|
|
eq(screen.phase, "choose-forget", "YES opens the picker")
|
|
tap("a") -- slot 1
|
|
eq(lead.moves[1].id, "EMBER", "the move is learned")
|
|
eq(screen.message, "1, 2 and…", "the count line prints first")
|
|
-- ../pokecrystal/home/text.asm:887-896
|
|
eq(screen.messageTimer, 0, "and text_pause holds it for no button")
|
|
local poofed = false
|
|
for _ = 1, 400 do
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
if screen.message and screen.message:find("forgot", 1, true) then
|
|
poofed = true
|
|
break
|
|
end
|
|
end
|
|
check(poofed, "the forgot line follows the pause with no press between")
|
|
check(screen.message and screen.message:find("forgot", 1, true) ~= nil,
|
|
"and its line prints ahead of the send-out that was already queued")
|
|
end
|
|
|
|
-- ../pokecrystal/data/text/battle.asm:240-246
|
|
-- ../pokecrystal/engine/battle/core.asm:3146-3147
|
|
-- ../pokecrystal/home/text.asm:502-526
|
|
do
|
|
local function typed(screen)
|
|
for _ = 1, 400 do
|
|
if not screen:syncTyper() then break end
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
end
|
|
return table.concat(screen:messageLines(), "|")
|
|
end
|
|
local function sendOutScreen(trainer, monName)
|
|
local screen, battle = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
battle:takeEvents()
|
|
local mon = Mon.new(DATA, "PIDGEY", 5, { dvs = perfect })
|
|
mon.nickname = monName
|
|
screen.phase = "resolving"
|
|
screen.showEnemyHud = false
|
|
screen:push({ kind = "send", side = "enemy", mon = mon, hp = mon.hp,
|
|
text = Battle.sentOutText(trainer, monName) })
|
|
screen:advanceQueue()
|
|
return screen
|
|
end
|
|
local function sendStarted(screen)
|
|
return screen.afterSendOut ~= nil or screen.showEnemyHud == true
|
|
end
|
|
|
|
local screen = sendOutScreen("CHAMPION LANCE", "DRAGONITE")
|
|
eq(typed(screen), "CHAMPION LANCE|sent out",
|
|
"the trainer and 'sent out' are the first page, no name on it")
|
|
check(not sendStarted(screen) and screen.pendingSendOut ~= nil,
|
|
"the ball stays shut while the first page waits for A")
|
|
local tap = tapper(screen)
|
|
tap("a")
|
|
Input:step()
|
|
screen:update(1 / 60)
|
|
local lines = screen:messageLines()
|
|
eq(lines[1], "sent out", "cont scrolls 'sent out' up already printed")
|
|
check(lines[2] ~= "DRAGONITE!", "and only the name types")
|
|
eq(typed(screen), "sent out|DRAGONITE!",
|
|
"a nine-letter name lands whole on the scrolled row")
|
|
check(sendStarted(screen) and screen.pendingSendOut == nil,
|
|
"and ANIM_SEND_OUT_MON starts with the name page")
|
|
|
|
local short = sendOutScreen("CHAMPION LANCE", "PIDGEY")
|
|
eq(typed(short), "CHAMPION LANCE|sent out",
|
|
"a short name still gets the cart's unconditional third row")
|
|
tapper(short)("a")
|
|
eq(typed(short), "sent out|PIDGEY!", "and lands on the scrolled page")
|
|
|
|
local long = newScreen()
|
|
check(runToMenu(long), "reached the menu")
|
|
long.battle:takeEvents()
|
|
long.phase = "resolving"
|
|
long:push({ kind = "message",
|
|
text = "SOMELONGNAME gained 12345 EXP. Points!" })
|
|
long:advanceQueue()
|
|
eq(typed(long), "SOMELONGNAME|gained 12345 EXP.",
|
|
"an overlong line shows its first two rows")
|
|
tapper(long)("a")
|
|
eq(typed(long), "gained 12345 EXP.|Points!",
|
|
"and the third row scrolls in instead of being cut")
|
|
end
|
|
|
|
-- ---- MoveSelectionScreen's two boxes (#1478) ------------------------------
|
|
-- engine/battle/core.asm:5074-5094, MoveInfoBox :5403-5478
|
|
do
|
|
local Chrome = require("src.ui.gen2.Chrome")
|
|
local lead = Mon.new(DATA, "CYNDAQUIL", 10, { dvs = perfect })
|
|
lead.moves = { { id = "TACKLE", pp = 30, maxPp = 35 },
|
|
{ id = "THUNDER_WAVE", pp = 20, maxPp = 20 } }
|
|
local screen = newScreen({ player = lead, party = { lead } })
|
|
check(runToMenu(screen), "reached the menu")
|
|
screen.phase = "moves"
|
|
screen.moveIndex = 1
|
|
|
|
local boxes, prints = {}, {}
|
|
local saved = { box = Chrome.box, print = Chrome.print,
|
|
printRight = Chrome.printRight, cursor = Chrome.cursor }
|
|
Chrome.box = function(x, y, w, h)
|
|
boxes[#boxes + 1] = ("%d,%d,%d,%d"):format(x, y, w, h)
|
|
end
|
|
Chrome.print = function(text, x, y)
|
|
prints[#prints + 1] = ("%s@%d,%d"):format(tostring(text), x, y)
|
|
end
|
|
Chrome.printRight = function(text, x, y)
|
|
prints[#prints + 1] = ("R:%s@%d,%d"):format(tostring(text), x, y)
|
|
end
|
|
Chrome.cursor = function(x, y)
|
|
prints[#prints + 1] = ("cursor@%d,%d"):format(x, y)
|
|
end
|
|
local ok, err = pcall(function() screen:drawPanel() end)
|
|
Chrome.box, Chrome.print = saved.box, saved.print
|
|
Chrome.printRight, Chrome.cursor = saved.printRight, saved.cursor
|
|
check(ok, "the move menu draws: " .. tostring(err))
|
|
|
|
local drawn = table.concat(boxes, " ")
|
|
check(drawn:find("0,8,11,5", 1, true) ~= nil, "the TYPE/PP box is drawn")
|
|
check(drawn:find("4,12,16,6", 1, true) ~= nil, "over the narrow list box")
|
|
-- SafeLoadTempTilemapToTilemap keeps the full battle textbox under the
|
|
-- move list (core.asm:4689); Textbox then MoveInfoBox over it (:5084, :5157).
|
|
check(drawn:find("0,12,20,6", 1, true) ~= nil,
|
|
"over the restored full-width message box")
|
|
local base = drawn:find("0,12,20,6", 1, true)
|
|
local list = drawn:find("4,12,16,6", 1, true)
|
|
local info = drawn:find("0,8,11,5", 1, true)
|
|
check(base < list and list < info,
|
|
"painted base box, then list box, then info box")
|
|
local text = table.concat(prints, " ")
|
|
check(text:find("TACKLE@6,13", 1, true) ~= nil, "names sit at column 6")
|
|
check(text:find("cursor@5,13", 1, true) ~= nil, "with the cursor at 5")
|
|
check(text:find("TYPE/@1,9", 1, true) ~= nil, "TYPE/ at (1,9)")
|
|
check(text:find("NORMAL@2,10", 1, true) ~= nil, "the type name at (2,10)")
|
|
check(text:find("30/35@5,11", 1, true) ~= nil,
|
|
"and only the highlighted move's PP, at (5,11)")
|
|
check(text:match("R:%d+/%d+@19,1%d") == nil, "no PP is printed per row")
|
|
end
|
|
|
|
-- data/text/battle.asm:484 InLoveWithText, :490 InfatuationText: three rows
|
|
do
|
|
local Chrome = require("src.ui.gen2.Chrome")
|
|
local screen, battle = newScreen()
|
|
check(runToMenu(screen), "reached the menu")
|
|
battle:volatile(battle.player).attract = true
|
|
battle.random = function(n) return (n or 1) - 1 end
|
|
screen:submit({ kind = "move", move = "TACKLE" })
|
|
local seen, printed, widest, tallest = {}, {}, 0, 0
|
|
for _ = 1, 3000 do
|
|
local msg = screen.message
|
|
if msg and not seen[msg] then
|
|
seen[msg] = true
|
|
local rows = Chrome.wrap(msg, 18)
|
|
tallest = math.max(tallest, #rows)
|
|
for i = 1, math.min(#rows, 2) do
|
|
widest = math.max(widest, #rows[i])
|
|
printed[#printed + 1] = rows[i]
|
|
end
|
|
printed[#printed + 1] = "|"
|
|
end
|
|
drainStep(screen)
|
|
if screen.phase == "menu" then break end
|
|
end
|
|
local shown = table.concat(printed, "\n")
|
|
check(shown:find(battle:monName(battle.player) .. "\nis in love with",
|
|
1, true) ~= nil, "the in-love line opens on the user")
|
|
check(shown:find("is in love with\n" .. battle:monName(battle.enemy) .. "!",
|
|
1, true) ~= nil, "and scrolls onto the target it never used to reach")
|
|
check(shown:find("infatuation kept", 1, true) ~= nil,
|
|
"InfatuationText prints")
|
|
check(shown:find("it from attacking!", 1, true) ~= nil,
|
|
"and so does the row the two-row box used to cut")
|
|
eq(tallest, 2, "no drawn message runs past the box's two rows")
|
|
check(widest <= 18, "and no row past its 18 tiles")
|
|
end
|
|
|
|
-- ---- SendOutPlayerMon (../pokecrystal/engine/battle/core.asm:82-93, :4027) --
|
|
do
|
|
-- ../pokecrystal/data/moves/animations.asm:414-427
|
|
local SEND_OUT = {
|
|
ids = { ANIM_SEND_OUT_MON = "sendout" },
|
|
scripts = {
|
|
sendout = {
|
|
{ "wait", 7 },
|
|
{ "bgeffect", "BATTLE_BG_EFFECT_ENTER_MON", 0, 1, 0 },
|
|
{ "wait", 12 },
|
|
{ "bgeffect", "BATTLE_BG_EFFECT_SHOW_MON", 0, 1, 0 },
|
|
{ "wait", 6 },
|
|
{ "ret" },
|
|
},
|
|
},
|
|
}
|
|
local function animScreen()
|
|
local screen, battle, player, wild = newScreen()
|
|
screen.anims = SEND_OUT
|
|
screen.animConstants = {}
|
|
return screen, battle, player, wild
|
|
end
|
|
|
|
local screen, _, _, wild = animScreen()
|
|
local sawSlide, trainerDuringSlide, hudDuringSlide = false, true, false
|
|
local sentOut = false
|
|
for _ = 1, 3000 do
|
|
drainStep(screen)
|
|
if screen.backpicSlide then
|
|
sawSlide = true
|
|
trainerDuringSlide = trainerDuringSlide and screen.showPlayerTrainer
|
|
hudDuringSlide = hudDuringSlide or screen.showPlayerHud
|
|
end
|
|
if screen.afterSendOut then sentOut = true break end
|
|
end
|
|
check(sentOut, "the intro reaches the player's send-out")
|
|
check(sawSlide, "the trainer's back pic slides out first (core.asm:82-84)")
|
|
check(trainerDuringSlide, "and it is the TRAINER that slides, not the mon")
|
|
check(not hudDuringSlide, "with no player HUD yet")
|
|
check(not screen.showPlayerTrainer, "the back pic is gone once the slide ends")
|
|
eq(screen.message, "Go! CYNDAQUIL!", "the Go! line is up")
|
|
check(screen:picBoxCleared("player"),
|
|
"and the box is EMPTY while it types: the mon is not drawn before "
|
|
.. "ANIM_SEND_OUT_MON reveals it")
|
|
check(not screen.showPlayerHud, "and the player HUD is not up yet")
|
|
|
|
local revealFrame, sizeAtReveal, typedAtReveal
|
|
local hudBeforeReveal = false
|
|
for frame = 1, 400 do
|
|
run(screen, 1)
|
|
hudBeforeReveal = hudBeforeReveal or screen.showPlayerHud
|
|
if not screen:picBoxCleared("player") then
|
|
revealFrame = frame
|
|
local anim = screen:animPicState("player")
|
|
sizeAtReveal = anim and anim.size
|
|
typedAtReveal = screen.typer == nil or screen.typer:done()
|
|
break
|
|
end
|
|
end
|
|
check(revealFrame ~= nil, "the mon does appear")
|
|
check(typedAtReveal, "only after the Go! line has finished typing")
|
|
check(not hudBeforeReveal, "and before the HUD, never after it")
|
|
check(screen.afterSendOut ~= nil and screen.anim ~= nil,
|
|
"while ANIM_SEND_OUT_MON is still running")
|
|
eq(sizeAtReveal, 2,
|
|
"on BattleBGEffect_EnterMon's first row, the 2x2 square "
|
|
.. "(bg_effects.asm:664-666)")
|
|
|
|
-- ../pokecrystal/data/text/common_2.asm:137-140
|
|
local menuFrames
|
|
for frame = 1, 400 do
|
|
run(screen, 1)
|
|
if screen.phase == "menu" then menuFrames = frame break end
|
|
end
|
|
check(menuFrames ~= nil, "the menu comes up with no A press after Go!")
|
|
check(screen.showPlayerHud, "with the player HUD up")
|
|
check(not screen:picBoxCleared("player"), "and the mon on the field")
|
|
check(screen.afterSendOut == nil, "and the send-out retired")
|
|
|
|
-- ../pokecrystal/engine/battle/core.asm:3549-3600
|
|
screen:startSendOut("enemy", wild)
|
|
check(screen:picBoxCleared("enemy"),
|
|
"an enemy send-out starts with its box empty")
|
|
local enemySize
|
|
for _ = 1, 400 do
|
|
run(screen, 1)
|
|
if not screen:picBoxCleared("enemy") then
|
|
local anim = screen:animPicState("enemy")
|
|
enemySize = anim and anim.size
|
|
break
|
|
end
|
|
end
|
|
eq(enemySize, 5, "and the enemy's first square is the 5x5 (bg_effects.asm:669)")
|
|
for _ = 1, 400 do
|
|
if not screen.afterSendOut then break end
|
|
run(screen, 1)
|
|
end
|
|
check(screen.afterSendOut == nil and not screen:picBoxCleared("enemy"),
|
|
"and it ends with the enemy on the field")
|
|
|
|
local bare = newScreen()
|
|
bare.anims = nil
|
|
bare.showPlayerTrainer = false
|
|
bare:startSendOut("player", bare.battle.player)
|
|
check(not bare:picBoxCleared("player") and bare.showPlayerHud,
|
|
"without scripts the mon and the HUD come up together")
|
|
end
|
|
|
|
-- SlideBattlePicOut + EmptyBattleTextbox (core.asm:3221)
|
|
do
|
|
local screen, battle = newScreen()
|
|
check(runToMenu(screen), "the intro drains")
|
|
screen.showEnemyTrainer = true
|
|
screen.picHidden.enemy = false
|
|
screen.trainerSlide = 0
|
|
for _ = 1, 400 do
|
|
run(screen, 1)
|
|
if not screen.trainerSlide then break end
|
|
end
|
|
eq(screen.showEnemyTrainer, false, "the trainer pic slides off")
|
|
eq(screen.picHidden.enemy, true, "and the box it emptied stays empty")
|
|
check(screen:picBoxCleared("enemy"), "so drawPic paints nothing there")
|
|
|
|
screen:startSendOut("enemy", battle.enemy)
|
|
for _ = 1, 400 do
|
|
if not screen.afterSendOut then break end
|
|
run(screen, 1)
|
|
end
|
|
check(not screen:picBoxCleared("enemy"),
|
|
"the send-out animation is the only thing that brings the mon back")
|
|
end
|
|
|
|
-- home/text.asm:630
|
|
-- (home/joypad.asm:428)
|
|
do
|
|
local screen = newScreen()
|
|
local held = false
|
|
for _ = 1, 600 do
|
|
run(screen, 1)
|
|
if (screen.messageTimer or 0) > 0 and not Typer.typing(screen) then
|
|
held = true
|
|
break
|
|
end
|
|
end
|
|
check(held, "WildPokemonAppearedText holds for PromptButton")
|
|
|
|
screen.arrowBlink = 0
|
|
check(screen:messageArrowVisible(), "the cursor is on at phase 0")
|
|
screen.arrowBlink = 15
|
|
check(screen:messageArrowVisible(), "and through phase 15")
|
|
screen.arrowBlink = 16
|
|
check(not screen:messageArrowVisible(), "UnloadBlinkingCursor at phase 16")
|
|
screen.arrowBlink = 31
|
|
check(not screen:messageArrowVisible(), "and through phase 31")
|
|
|
|
-- byte (home/text.asm:887-902)
|
|
screen.arrowBlink = 0
|
|
screen.waitSfx = "SFX_TACKLE"
|
|
check(not screen:messageArrowVisible(), "no cursor under a held SFX")
|
|
screen.waitSfx = nil
|
|
screen.messageDelay = 10
|
|
check(not screen:messageArrowVisible(), "none through a text_pause")
|
|
screen.messageDelay = 0
|
|
check(screen:messageArrowVisible(), "back on once the pause is done")
|
|
|
|
-- DoneText / text_end lines never load it (home/text.asm:566)
|
|
screen.messageTimer = 0
|
|
check(not screen:messageArrowVisible(), "and never on a `done` line")
|
|
|
|
local sliding = newScreen()
|
|
local before = sliding.arrowBlink
|
|
run(sliding, 1)
|
|
check(sliding.slideFrame > 0 and sliding.arrowBlink ~= before,
|
|
"the blink phase advances through update's early returns")
|
|
end
|
|
|
|
S.finish()
|