gen1recomp/tests/gen2_catch_tutorial_test.lua

-- The DUDE's catching tutorial (engine/events/catch_tutorial.asm,
-- engine/events/catch_tutorial_input.asm, and the BATTLETYPE_TUTORIAL arms in
-- engine/battle/core.asm / engine/items/item_effects.asm).
--   GOLD_CACHE="..." luajit tests/gen2_catch_tutorial_test.lua
--
-- ROM-free: the name swap, the DUDE's pack and the auto-input pacing are all
-- pure tables, and the battle screen is driven with a stub game so the whole
-- demo -- menu, pack, ball, catch -- runs here without a window.
package.path = "./?.lua;./?/init.lua;" .. package.path

local S = require("tests.harness").suite("gen2 catch tutorial")
local check, eq = S.check, S.eq

love = require("tests.love_stub")

local AutoInput = require("src.core.gen2.AutoInput")
local CatchTutorial = require("src.core.gen2.CatchTutorial")
local Vm = require("src.script.gen2.Vm")

-- ---- .LoadDudeData --------------------------------------------------------
do
  eq(CatchTutorial.DUDE_NAME, "DUDE", "CatchTutorial.Dude is `db \"DUDE@\"`")
  eq(CatchTutorial.BATTLETYPE_TUTORIAL, 3,
    "BATTLETYPE_TUTORIAL is the fourth constant in the const_def 0 block")
  eq(CatchTutorial.PACK.POTION, 1, "wDudeNumItems holds one POTION")
  eq(CatchTutorial.PACK.POKE_BALL, 5,
    "and the ball's quantity byte is written from POKE_BALL itself, so the "
    .. "DUDE's pocket really does read x5")
  eq(CatchTutorial.BALL, "POKE_BALL",
    "and POKE_BALL is what DoItemEffect is handed whatever the pack returned")

  local dude = CatchTutorial.dudeSave()
  eq(dude.player.name, "DUDE", "the pack is drawn as the DUDE's")
  eq(dude.inventory.POTION, 1, "out of his own buffers")
  dude.inventory.POTION = 99
  eq(CatchTutorial.PACK.POTION, 1,
    "and each opening gets a copy, not the shared table")
end

-- ---- the name and option bracket ------------------------------------------
do
  local save = { player = { name = "GOLD" }, mom = { name = "MOM" } }
  local options = { textSpeed = "SLOW", battleScene = true }
  local state = CatchTutorial.begin(save, options)
  eq(save.player.name, "DUDE", "the player answers to DUDE for the demo")
  eq(save.mom.name, "GOLD",
    "with the real name parked in wMomsName, which is where the cart keeps it")
  eq(options.textSpeed, "MID", "TEXT_DELAY_MED for the length of the battle")
  eq(options.battleScene, true, "and no other option bit is touched")

  CatchTutorial.finish(save, options, state)
  eq(save.player.name, "GOLD", "the name comes back out of wMomsName")
  eq(options.textSpeed, "SLOW", "and wOptions is popped")
  eq(save.mom.name, "GOLD",
    "Mom's name is NOT restored: the cart has nowhere left to restore it from")
end

-- ---- the re-arms ----------------------------------------------------------
do
  -- Every re-arm in the ASM is guarded by `ld a, [wInputType] / or a`, so the
  -- DUDE only answers while a stream is already running.
  local ring = AutoInput.new()
  check(not CatchTutorial.rearm(ring, CatchTutorial.PROMPT_STREAM),
    "an unarmed ring is never taken over by a re-arm")
  ring:start(CatchTutorial.BATTLE_STREAM)
  check(CatchTutorial.rearm(ring, CatchTutorial.PROMPT_STREAM),
    "but the lockout stream counts as wInputType == AUTO_INPUT")
  check(not CatchTutorial.rearm(ring, "NO_SUCH_STREAM"),
    "and a stream the ROM does not have arms nothing")
end

do
  -- Frame-paced: PromptButton's loop delays a frame per iteration, so DUDE_A's
  -- 0x51 blank frames are exactly the beat between two lines of text.
  local ring = AutoInput.new()
  ring:start(CatchTutorial.BATTLE_STREAM)
  CatchTutorial.rearm(ring, CatchTutorial.PROMPT_STREAM)
  local blanks = 0
  while ring:advance() == AutoInput.NO_INPUT and blanks < 200 do
    blanks = blanks + 1
  end
  eq(blanks, 0x51, "the prompt stream is replayed frame for frame")
end

do
  -- Poll-paced: the battle menu picks ITEM with DOWN then A, and the runs of
  -- blank pairs between them are loop iterations on the cart.
  local ring = AutoInput.new()
  ring:start(CatchTutorial.BATTLE_STREAM)
  CatchTutorial.rearm(ring, CatchTutorial.MENU_STREAM, nil, true)
  eq(ring:advance(), AutoInput.PAD_DOWN, "DOWN lands on the next step")
  eq(ring:advance(), AutoInput.PAD_A, "and A on the one after it")
  check(ring:isActive(), "the stream parks rather than handing control back")

  CatchTutorial.rearm(ring, CatchTutorial.PACK_STREAM, nil, true)
  eq(ring:advance(), AutoInput.PAD_RIGHT,
    "the pack stream crosses to the BALL pocket")
  eq(ring:advance(), AutoInput.PAD_A, "and picks the POKE BALL")
end

do
  -- skipIdle never eats a press, and never eats the $ff pair a stream parks
  -- on -- that pair is the lockout, not a pause.
  local ring = AutoInput.new()
  ring:start({ AutoInput.PAD_A, 0x00, AutoInput.NO_INPUT, 0xff })
  check(not ring:skipIdle(), "a stream that opens on a press is left alone")
  eq(ring:advance(), AutoInput.PAD_A, "and still presses it")
  check(not ring:skipIdle(), "the parked $ff pair is not skippable")
  check(ring:isActive(), "so the controller stays taken")
end

-- ---- Script_catchtutorial -------------------------------------------------
do
  -- Script_catchtutorial: one operand byte into wBattleType, then
  -- farcall CatchTutorial, then `jp Script_reloadmap`.  CatchTutorial itself
  -- brackets StartBattle in StartAutoInput / StopAutoInput.
  local order, got = {}, nil
  local vm = Vm.new({
    ["s:t"] = {
      { op = "setval", value = 5 },
      { op = "loadwildmon", args = { 19, 5 } },
      { op = "catchtutorial", args = { 3 } },
      { op = "writetext", text = "AFTER" },
      { op = "end" },
    },
  }, {}, nil, {
    autoInputStream = function(name) order[#order + 1] = "start:" .. name end,
    stopAutoInput = function() order[#order + 1] = "stop" end,
    reloadMap = function() order[#order + 1] = "reload" end,
    showText = function(_body, done)
      order[#order + 1] = "text"
      done()
    end,
    catchTutorial = function(wild, battleType, onDone)
      order[#order + 1] = "battle"
      got = { wild = wild, battleType = battleType }
      onDone()
    end,
  })
  vm:start("s:t")
  eq(table.concat(order, ","),
    "start:CATCH_TUTORIAL,battle,stop,reload,text",
    "the battle runs inside the lockout, and the script continues after the "
    .. "map reload -- catchtutorial is not a terminator")
  eq(got and got.battleType, 3, "wBattleType is the command's own byte")
  eq(got and got.wild and got.wild.species, 19,
    "and the wild mon is the one loadwildmon left behind")
  eq(got.wild.level, 5, "at the level it named")
  eq(vm.scriptVar, 5, "catchtutorial leaves wScriptVar alone")
  eq(vm.wildMon, nil,
    "and consumes the pair, so a later startbattle cannot inherit it")
end

do
  -- With no hook there is nothing to park on: the bracket collapses and the
  -- command still ends where the ASM ends it.
  local order = {}
  local vm = Vm.new({
    ["s:t"] = { { op = "catchtutorial", args = { 3 } }, { op = "end" } },
  }, {}, nil, {
    autoInputStream = function(name) order[#order + 1] = "start:" .. name end,
    stopAutoInput = function() order[#order + 1] = "stop" end,
    reloadMap = function() order[#order + 1] = "reload" end,
  })
  vm:start("s:t")
  eq(table.concat(order, ","), "start:CATCH_TUTORIAL,stop,reload",
    "the lockout still closes before the map reload")
end

-- ---- the demo battle itself -----------------------------------------------
-- BattleState with a stub game: no window, but the real update loop, the real
-- auto-input ring and the real Input edge detection, so the DUDE plays the
-- whole thing exactly as he would on screen.
local Battle = require("src.battle.gen2.Battle")
local BattleState = require("src.ui.gen2.BattleState")
local BattleAnimView = require("src.ui.gen2.BattleAnimView")
local Input = require("src.core.Input")
local PackMenu = require("src.ui.gen2.PackMenu")

local function tutorialScreen()
  Input:init()
  local ring = AutoInput.new()
  local pushed = {}
  local save = {
    player = { name = "DUDE" },
    party = { { species = "CYNDAQUIL", level = 5, hp = 20, maxHp = 20 } },
    inventory = { POKE_BALL = 3 },
    pokedex = { seen = {}, caught = {} },
  }
  local data = {
    pokemon = { RATTATA = { catchRate = 255 } },
    items = { POKE_BALL = { pocket = "BALL", name = "POKe BALL", index = 5 },
              POTION = { pocket = "ITEM", name = "POTION", index = 17 } },
  }
  local game = {
    data = data,
    save = save,
    input = Input,
    autoInput = ring,
    options = {},
    stack = {
      push = function(_, screen) pushed[#pushed + 1] = screen end,
      pop = function() table.remove(pushed) end,
    },
  }
  -- BATTLETYPE_TUTORIAL fights with an empty party: no mon is ever sent out.
  local battle = Battle.new({ data = data, party = {},
    wild = { species = "RATTATA", level = 5, hp = 19, maxHp = 19 } })
  local outcome
  local screen = BattleState.new(game, {
    battle = battle,
    save = save,
    tutorial = true,
    onDone = function(result) outcome = result end,
  })
  -- The 72-frame sliding intro reads no input at all.
  for _ = 1, BattleAnimView.SLIDE_FRAMES do screen:update(1 / 60) end
  return screen, ring, save, function() return outcome end, pushed, game
end

do
  local screen, ring, _, _, _ = tutorialScreen()
  eq(screen.battle.player, nil, "the tutorial opens with no mon out")
  check(screen.showPlayerTrainer,
    "so the player's box keeps a trainer back-pic for the whole battle")
  -- CatchTutorial armed the lockout before StartBattle.
  ring:start(CatchTutorial.BATTLE_STREAM, Input)

  -- "Wild RATTATA appeared!" goes up on the step that drains the queue, and
  -- the DUDE is handed the prompt on the first step that waits on it.
  screen:update(1 / 60)
  eq(screen.message, "Wild RATTATA appeared!", "the intro line is the cart's")
  screen:update(1 / 60)
  eq(ring.bytes, AutoInput.STREAMS.DUDE_A,
    "and DudeAutoInput_A is armed to answer it")
  local before = ring.pos
  screen:update(1 / 60)
  eq(ring.pos, before,
    "a wait that spans many steps arms the stream once, not once a step")
  check(screen.messageTimer > 0,
    "and the line does NOT time out: PromptButton waits for the button")
end

do
  -- The whole demo, driven by nothing but the ring: enough steps for the
  -- prompt beat on each line plus the menu and pack presses.
  local screen, ring, save, outcomeOf, pushed = tutorialScreen()
  ring:start(CatchTutorial.BATTLE_STREAM, Input)
  local sawPack, sawBallPocket, chosen = false, false, nil
  for _ = 1, 600 do
    ring:step(Input)
    Input:step()
    local top = pushed[#pushed]
    if top and getmetatable(top) == PackMenu then
      sawPack = true
      top:update(1 / 60)
      -- DudeAutoInput_RightA's RIGHT is the pocket cross; its A picks the row
      -- the cursor is sitting on, which in the BALL pocket is the POKE BALL.
      if top:pocket().id == "BALL" then
        sawBallPocket = true
        chosen = top.rows[top.index] and top.rows[top.index].id
      end
    else
      screen:update(1 / 60)
    end
    if outcomeOf() then break end
  end
  check(sawPack, "the DUDE opens his own pack, as BattleMenu_Pack .tutorial does")
  check(sawBallPocket, "crosses to the BALL pocket")
  eq(chosen, "POKE_BALL", "and lands on the POKE BALL")
  eq(outcomeOf(), "caught", "and the ball catches")
  eq(screen.message, "Gotcha! RATTATA was caught!", "with the cart's line")
  eq(#save.party, 1, "nothing is added to the party")
  eq(save.pokedex.caught.RATTATA, nil, "nothing is written to the Pokedex")
  eq(save.inventory.POKE_BALL, 3, "and no ball leaves the player's bag")
end

-- ---- the call sites -------------------------------------------------------
-- World needs a map, a stack and a VM to construct, so the wiring that reaches
-- all of the above is asserted by reading it: a call site that is not spelled
-- out in the file is not there at all.
local function sourceOf(path)
  local f = io.open(path, "r")
  if not f then return nil end
  local body = f:read("*a")
  f:close()
  return body
end

do
  local world = sourceOf("src/world/gen2/World.lua")
  check(world ~= nil, "World's source is readable")
  for _, wanted in ipairs({
      "catchTutorial = function(wild, battleType, onDone)",
      "self:startCatchTutorial(wild, battleType, onDone)",
      "function World:startCatchTutorial",
      "CatchTutorial.begin(save, game and game.options)",
      "CatchTutorial.finish(save, game and game.options, state)",
      "tutorial = true,",
      "tutorial = opts.tutorial,",
    }) do
    check(world:find(wanted, 1, true) ~= nil, "World has " .. wanted)
  end

  local vmSource = sourceOf("src/script/gen2/Vm.lua")
  check(vmSource ~= nil, "the VM's source is readable")
  for _, wanted in ipairs({
      "catchTutorialFn = hooks.catchTutorial,",
      'req.kind == "catchtutorial"',
    }) do
    check(vmSource:find(wanted, 1, true) ~= nil, "the VM has " .. wanted)
  end

  -- GetTrainerBackpic's "Special exception for Dude".
  local extractor = sourceOf("src/import/RomExtractorGen2.lua")
  check(extractor ~= nil, "the extractor's source is readable")
  check(extractor:find('self.symbols["DudeBackpic"]', 1, true) ~= nil,
    "the extractor rips DudeBackpic")
  check(extractor:find('hud.dudeBack = "assets/generated/battle/dude_back.png"',
    1, true) ~= nil, "and the battle screen has a path to look it up by")
end

S.finish()