DramaticShapeVoxelMod/lib/CatchThrow.lua

-- LET'S GO capture mode: the throw itself.
--
-- The player sees the wild Pokemon from the staged battle's own
-- over-the-shoulder seat -- held perfectly still for the duration, with
-- their own Pokemon nowhere in the shot -- a Poke Ball hanging in the
-- foreground, and a timing ring pulsing on the foe. A flick of the mouse,
-- a finger, or the right stick throws the ball along a solved arc; spin
-- the ball first and it flies with a visible curve. Where the ball crosses
-- the foe's plane is judged in SCREEN space against the ring -- the player
-- aimed at pixels, so pixels are what they are graded on -- and a throw
-- inside the shrinking ring earns NICE / GREAT / EXCELLENT, which
-- multiplies the Gen 1 catch roll the engine then makes. The ball opens,
-- drinks the Pokemon in, drops, rocks once per engine shake, and either
-- clicks with stars or bursts the Pokemon back out.
--
-- ------- what this file owns, and what it borrows
--
-- It owns the SESSION: input sampling, the flick estimate, the arc, the
-- ring, the grading, and the choreography of the Pokeball prop. Everything
-- consequential is borrowed from the engine so the outcome is exactly a
-- Gen 1 ball throw: the roll is battle:catchAttempt (status, HP and ball
-- factors intact, our throw grade folded into the rate), the outcome texts
-- and the enemy's revenge turn are the same queue throwBall builds, and a
-- catch lands in storeCaughtMon -- dex page, nickname, box overflow and
-- the pokemon.caught event all included. While the session runs the battle
-- is FROZEN by parking battle.phase on a value the engine's update has no
-- branch for; the resolution puts "messages" back and the engine finishes
-- the fight believing it threw the ball itself.
--
-- ------- the input model (design: flick-to-throw)
--
-- All pointer samples are kept in GB-frame pixels (160x144), the same
-- space the ring is drawn in. The flick velocity is a least-squares slope
-- over the last 110 ms -- never last-minus-previous, which one frame of
-- jitter destroys. Strength comes from speed, direction from the fit, and
-- the landing point is "the spot the flick pointed at": release position
-- plus direction times a reach that grows with strength. Short flicks land
-- short, wild flicks sail long, and a ±30% speed error still lands inside
-- the outer ring, which is what keeps the mechanic hard rather than broken.
-- The right stick plays the same game with a virtual finger standing at
-- centre + stick * radius, so pad players flick by flicking the stick.
--
-- Spin is a circular gesture around the held ball: accumulated signed
-- angle arms the curve past 1.25 turns, and once armed it latches. A
-- curved ball hooks late in flight (the ramp is what forces aiming off to
-- the opposite side) with a 40% assist folded into the solve, so the curve
-- is a flourish first and a skill test second.

-- the mod namespace (see main.lua): V.require loads a sibling module
local V = ...

local Mat4 = V.require("Mat4")
local Voxel3D = V.require("Voxel3D")
local Pokeball = V.require("Pokeball")
local BattleScene = V.require("BattleScene")
local BattleCam = V.require("BattleCam")

local CatchThrow = {}

-- the parked phase: any value BattleState:update has no branch for freezes
-- the fight; namespaced so no future engine phase can collide with it
CatchThrow.PHASE = "dramaticShapeCapture"

-- ------- tuning
--
-- Screen quantities are GB pixels (the battle frame is 160x144); world
-- quantities are world pixels (a map cell is 16); times are seconds.

local WINDOW = 0.11          -- flick fit window
local S_MIN = 55             -- below this the release is a hesitation
-- a throw must point up-screen at least this much. LENIENT on purpose:
-- the gate only has to reject a plainly downward drag
local MIN_UP = 0.08

-- ------- the throw is the SWIPE'S OWN VELOCITY
--
-- The reference model (and the one that finally felt right): the ball is
-- dragged under the finger, and releasing LAUNCHES IT with the swipe's
-- velocity -- forward speed from how hard the swipe was, height from its
-- vertical, side from its horizontal, each clamped to a sane range like a
-- rigidbody throw. No aim point is picked and no arc is solved: gravity
-- and the collision decide what the throw earns. A soft flick drops
-- short, a wild one sails over, and the assist below is the only mercy.
--
-- CALIBRATED against the staging rather than picked: the throw is 48
-- world pixels (three cells) to a body about ten pixels up, so the
-- vertical speed that actually ARRIVES is somewhere in the 65-95 range
-- across every forward speed worth throwing at. The first cut had gains
-- of 3.0 and a 150/110 ceiling, which meant an ordinary ~190 GB px/s
-- swipe already saturated both clamps -- every throw left at maximum,
-- and maximum was well above anything that lands, so the ball sailed
-- over the Pokemon no matter how it was flicked. These put a
-- comfortable swipe in the middle of the band and leave the ceilings
-- where a genuinely hard throw still reaches them.
local K_FWD, K_UP, K_LAT = 2.4, 1.6, 1.0  -- swipe (world px/s) -> velocity
local F_MIN, F_MAX = 48, 140 -- forward speed clamp, world px/s
local U_MIN, U_MAX = 34, 92  -- upward
local L_MAX = 38             -- sideways
-- ------- and the ceiling that ends overthrowing
--
-- The launch height is never allowed to exceed what THIS throw's own
-- forward speed needs to arrive, by more than a margin. That is the
-- direct cure for the failure the gains alone could not fix: on a fixed
-- camera there is no depth cue for "too high", so a firm flick would
-- sail the ball clean over the Pokemon every time and the player had no
-- way to read why. Under the cap a throw can still fall SHORT (too
-- weak) or go WIDE (bad bearing) -- both of which are legible, because
-- you watch the ball land -- but it can no longer be lost over the top.
local OVER_CAP = 1.12
-- directional assist: the HORIZONTAL launch direction leans this fraction
-- toward the Pokemon. Speed, height and the short/long answer stay the
-- player's; the assist only trims the bearing, so an honest throw at the
-- creature connects instead of clipping past its ear.
local MAGNET = 0.3
-- range assist: the launch's HEIGHT leans this fraction toward what its
-- own forward speed would need to arrive at the foe's body. Pure velocity
-- throws punish the lob's shape as hard as its speed; this keeps speed as
-- the skill and stops a good read from sailing a ball-width over. Half,
-- not a third: the arc's SHAPE is the least legible thing about a throw
-- on a fixed camera -- there is no depth cue for how high is too high --
-- so it is the part worth forgiving, while distance and bearing stay the
-- player's to get right.
local V_ASSIST = 0.5
local T_REF = 0.6            -- the tap-throw / Master Ball solve time

local GRAVITY = 300          -- world px/s^2 -- ~2x earth at 16 px/metre,
                             -- the platformer exaggeration the arc needs
local H_STEP = 1 / 120       -- fixed integration step

-- ------- spin
--
-- The wind-up is a METER now, not a switch: every turn of the gesture adds
-- to it and it bleeds away when the hand stops, so the ball visibly spins
-- up with the player -- faster the more they wind -- to a cap. Only a ball
-- AT the cap curves when thrown; anything less is style.
local SPIN_FULL = 32         -- radians of gesture from still to the cap
local ROLL_MAX = 24          -- the cap's visible spin, rad/s
local SPIN_DECAY = 0.45      -- meter per second, once the hand pauses
local SPIN_IDLE = 0.2        -- how long a pause before the bleed starts
local ARM_AT, DISARM_AT = 0.99, 0.80  -- hysteresis on "at the cap"

local CURVE_GAIN = 120       -- lateral pull at full spin, world px/s^2
local CURVE_RAMP0, CURVE_RAMP1 = 0.25, 0.70   -- the hook bites late
local ASSIST = 0.4           -- how much of the curve the solve pre-corrects
local K_RAMP = 0.14          -- integral of the ramp, for the assist

local RING_PERIOD = 2.2      -- shrink cycle
local RING_HOLD = 0.15       -- pause at the smallest
local RING_MIN = 0.12        -- the Excellent floor
local CHEST = 9              -- ring/beam height over the foe's feet, world px

local SUCK_T = 0.6           -- the Pokemon drinking into the ball
local DROP_T = 0.45          -- fall to the ground
local SHAKE_GAP = 0.42       -- pause between rocks
local STICK_R = 34           -- the virtual finger's orbit, GB px

-- stick flick thresholds, in stick units (full deflection = 1) per second
local STICK_VEL = 5.5
local STICK_GRAB = 0.30

-- the Let's Go throw-grade multipliers, applied to the Gen 1 catch rate
-- and to the capture-experience stack (Bulbapedia's Let's Go tables)
local TIER_MULT = { EXCELLENT = 2.0, GREAT = 1.5, NICE = 1.1 }

-- ------- session state

local S = nil

local function game() return require("src.core.Game") end

local function sound(name)
  pcall(function()
    require("src.core.Sound").play(game().data, name)
  end)
end

local function emit(name, payload)
  pcall(function() require("src.mods.Runtime").emit(name, payload) end)
end

local function OB() return V.require("OverworldBattle") end

function CatchThrow.active()
  return S ~= nil and S.phase ~= "epilogue"
end

function CatchThrow.session()
  return S
end

-- ------- geometry helpers
--
-- The shot BattleScene hands back carries the camera (eye/focus), the
-- combined matrix (vp) and the letterbox, which together answer every
-- space question the session has: world -> GB via BattleScene.toGB, and
-- the camera's flat forward/right for aiming errors.

local function camBasis(shot)
  local e, f = shot.eye, shot.focus
  local fx, fz = f[1] - e[1], f[3] - e[3]
  local l = math.sqrt(fx * fx + fz * fz)
  if l < 1e-6 then fx, fz = 0, -1 else fx, fz = fx / l, fz / l end
  -- right-handed about +Y up: right = fwd x up
  return fx, fz, -fz, fx
end

local function toGB(shot, wx, wy, wz)
  return BattleScene.toGB(shot.vp, wx, wy, wz,
                          shot.lx, shot.ly, shot.scale, shot.pw, shot.ph)
end

-- the yaw that turns a thing at (x, z) to face this shot's eye
local function eyeYaw(x, z)
  local e = S.shot and S.shot.eye
  if not e then return 0 end
  return math.atan2(e[1] - x, e[3] - z)
end

-- ------- the capture seat's measurements
--
-- HEAD ON: the eye stands on the arena's own axis, behind the player's
-- cell, looking straight at the foe -- the GO framing, not the battle's
-- over-the-shoulder rig. Declared here rather than beside captureRig
-- below because the ray reconstruction underneath needs the lens.
local SEAT_BACK = 46         -- eye behind the player's cell, world px
local SEAT_UP = 13           -- and above the floor
local SEAT_FOV = math.rad(26)
local SEAT_FRAME = 44        -- world height the sun's box is fitted to

-- ------- the ray a GB-frame point looks along
--
-- The drag's whole job is "the ball is under the finger", and only the
-- real projection answers that: an offset scaled by some world-per-pixel
-- estimate is right at one depth and wrong everywhere else, and it has
-- no way to say what the bottom of the screen even means. This is the
-- ordinary pinhole reconstruction from the seat's own basis -- the
-- vertical field covers the GB's 144 rows, and the horizontal falls out
-- of square pixels (which is why both axes divide by the same half
-- height).
--
-- Keyed to SEAT_FOV rather than to the shot, deliberately: the shot's
-- fov has been widened to the window (BattleScene.letterboxFov) and what
-- is wanted here is the lens the GB frame was framed with, which is the
-- capture rig's own and nobody else's.
local function rayThrough(gx, gy)
  local shot = S and S.shot
  if not shot then return nil end
  local e, f = shot.eye, shot.focus
  local dx, dy, dz = f[1] - e[1], f[2] - e[2], f[3] - e[3]
  local l = math.sqrt(dx * dx + dy * dy + dz * dz)
  if l < 1e-6 then return nil end
  dx, dy, dz = dx / l, dy / l, dz / l
  -- right = forward x worldUp; camUp = right x forward
  local rx, rz = -dz, dx
  local rl = math.sqrt(rx * rx + rz * rz)
  if rl < 1e-6 then return nil end
  rx, rz = rx / rl, rz / rl
  local ux, uy, uz = -rz * dy, rz * dx - rx * dz, rx * dy
  local half = BattleScene.GB_H / 2
  local t = math.tan(SEAT_FOV / 2)
  local ax = (gx - BattleScene.GB_W / 2) / half * t
  local ay = (gy - half) / half * t
  local vx = dx + rx * ax - ux * ay
  local vy = dy - uy * ay
  local vz = dz + rz * ax - uz * ay
  local vl = math.sqrt(vx * vx + vy * vy + vz * vz)
  if vl < 1e-6 then return nil end
  return vx / vl, vy / vl, vz / vl
end

-- Where the held ball hangs: over the PLAYER'S OWN CELL, which capture
-- mode has just emptied. Not in front of the camera -- the default battle
-- rig is a long lens standing five blocks back, and anything a hand's
-- reach from THAT eye is a blimp filling the frame. The player's cell is
-- where the trainer stands, it sits bottom-centre of the head-on seat
-- below, and it makes the throw a real three-cell lob at 16 pixels a
-- metre instead of an eleven-metre crane shot from the sky.
local HAND_HOVER = 6.5       -- the held ball's height over the floor
local function handPos()
  local p = S.playerPos
  return { p[1], p[2] + HAND_HOVER, p[3] }
end

-- The seat itself, from the measurements above: the foe centred, the held
-- ball at the bottom of the frame, the throw a straight shot up the
-- middle. Handed to BattleScene.render through the capture table's `rig`;
-- everything downstream (pins, cards, sun, fov) is camera-generic.
local function captureRig(arena, groundY)
  local ex, ez = arena.enemy[1], arena.enemy[2]
  local px, pz = arena.player[1], arena.player[2]
  local ax, az = ex - px, ez - pz
  local l = math.sqrt(ax * ax + az * az)
  if l < 1e-6 then ax, az = 0, -1 else ax, az = ax / l, az / l end
  local cam = {
    eye = { px - ax * SEAT_BACK, groundY + SEAT_UP, pz - az * SEAT_BACK },
    focus = { ex, groundY + 8, ez },
    fov = SEAT_FOV,
  }
  -- the pitch VoxelScene.pull wants: how far below level the seat looks
  local pitch = math.atan2(SEAT_UP - 8, SEAT_BACK + l)
  return cam, math.max(pitch, 0.05), SEAT_FRAME
end

-- The ring in GB space, centred on the CREATURE. The pinned mark is the
-- cell's ground point, but a species' art sits wherever the artist put it
-- in the frame -- a bird hovers half a slot over its own feet row -- so
-- the session measures the foe's rendered pic once (measureArt below) and
-- centres on the art's opaque box. The conversion is the card's own
-- arithmetic: one pic pixel is FULL_W/FULL_PIC world pixels, and a cell
-- is enemySpan GB pixels, so a pic pixel is span/56 GB pixels on screen.
-- The heuristic fallback (no pic: a STADIUM model, or a readback that
-- failed) is a chest height over the mark. The outer clamp is the
-- design's 0.06..0.18 screen heights, in GB pixels.
local function ringGeometry(shot)
  local span = shot.enemySpan or 16
  local b = S and S.artBox
  if b then
    local k = span / 56
    local cx = shot.enemy[1] + ((b.x0 + b.x1) / 2 - b.ax) * k
    local cy = shot.enemy[2] - (b.ay - (b.y0 + b.y1) / 2) * k
    local r = math.max(b.x1 - b.x0, b.y1 - b.y0) * 0.55 * k
    return cx, cy, math.max(9, math.min(26, r))
  end
  -- no pic to measure (a Stadium model, or a readback still pending):
  -- the collision body doubles as the ring's anchor, in the same
  -- world-to-screen scale a cell provides
  local body = (S and S.body) or { r = 8, yOff = 8 }
  local outer = math.max(9, math.min(26, body.r * 1.25 * span / 16))
  return shot.enemy[1], shot.enemy[2] - body.yOff * span / 16, outer
end

-- read the foe's pic back once and box its opaque pixels. A few thousand
-- getPixel calls on a 160x144 canvas, paid once per session -- the ring
-- then sits on the Pokemon for every species without a per-species table.
local function measureArt()
  local ok, box = pcall(function()
    local tex = OB().enemyTexture()
    if not (tex and tex.canvas and tex.canvas.newImageData) then return nil end
    local data = tex.canvas:newImageData()
    local w, h = data:getWidth(), data:getHeight()
    local x0, y0, x1, y1
    for y = 0, h - 1, 2 do
      for x = 0, w - 1, 2 do
        local _, _, _, a = data:getPixel(x, y)
        if a > 0.1 then
          if not x0 or x < x0 then x0 = x end
          if not x1 or x > x1 then x1 = x end
          if not y0 or y < y0 then y0 = y end
          if not y1 or y > y1 then y1 = y end
        end
      end
    end
    if not x0 then
      if data.release then data:release() end
      return nil
    end
    -- the ImageData is KEPT: it is the foe's collision geometry -- the
    -- flight samples it per plane crossing -- and it is released when the
    -- session is swept (endSession / battle.ended)
    return { ax = tex.ax, ay = tex.ay, x0 = x0, y0 = y0, x1 = x1, y1 = y1,
             data = data }
  end)
  return (ok and box) or nil
end

-- is there sprite under this pic pixel, within `r` pixels? Nine taps --
-- centre and a ring -- which at the dilation radii in play reads a hit
-- anywhere the ball's silhouette overlaps the art's.
local function maskHit(data, x, y, r)
  local ok, hit = pcall(function()
    local w, h = data:getWidth(), data:getHeight()
    local function tap(px, py)
      px, py = math.floor(px + 0.5), math.floor(py + 0.5)
      if px < 0 or py < 0 or px >= w or py >= h then return false end
      local _, _, _, a = data:getPixel(px, py)
      return a > 0.1
    end
    if tap(x, y) then return true end
    for i = 0, 7 do
      local a = i * math.pi / 4
      if tap(x + math.cos(a) * r, y + math.sin(a) * r) then return true end
    end
    return false
  end)
  return ok and hit or false
end

-- The foe's BODY -- where the ball has to physically arrive, and what the
-- ring is sized on. Measured from whichever the foe actually is: the pic's
-- opaque box (a hovering bird is hit where the bird is drawn, not where
-- its shadow falls), or the Stadium model's own height and footprint. A
-- default torso stands in until one of them answers; measured=false says
-- keep trying.
local function measureBody()
  local box = measureArt()
  if box then
    S.artBox = box
    local k = 16 / 56
    S.body = {
      r = math.max(5, math.min(14,
            math.max(box.x1 - box.x0, box.y1 - box.y0) * k * 0.5)),
      yOff = math.max(4, (box.ay - (box.y0 + box.y1) / 2) * k),
      hh = math.max(4, (box.y1 - box.y0) * k * 0.55),
    }
    S.bodyMeasured = true
    return
  end
  local ok, body = pcall(function()
    return V.require("Stadium").captureBody()
  end)
  if ok and body then
    S.body = body
    S.bodyMeasured = true
  end
end

-- named for the drivers: where the ball hangs and where the ring sits, in
-- GB pixels plus the live letterbox -- everything a scripted flick needs
-- to aim like a hand would
function CatchThrow._aimInfo()
  if not (S and S.shot) then return nil end
  local cx, cy, outer = ringGeometry(S.shot)
  return { hand = { S.handGB[1], S.handGB[2] },
           ring = { cx, cy }, outer = outer,
           lx = S.shot.lx, ly = S.shot.ly, scale = S.shot.scale,
           pw = S.shot.pw, ph = S.shot.ph }
end

-- the ring's inner fraction right now: 1 -> RING_MIN, hold, snap back
local function ringRho(t)
  local cycle = RING_PERIOD + RING_HOLD
  local u = t % cycle
  if u >= RING_PERIOD then return RING_MIN end
  return 1 - (1 - RING_MIN) * (u / RING_PERIOD)
end

-- ------- flick estimation

local function pushSample(x, y)
  local n = S.samples
  n[#n + 1] = { x = x, y = y, t = S.clock }
  if #n > 32 then table.remove(n, 1) end
end

-- least-squares velocity over the window before `at`; also answers the
-- window's peak two-sample speed and the mean speed of the last 40 ms,
-- which the dead-flick gate reads
local function flickFit(at)
  local xs, n = S.samples, 0
  local sx, sy, st = 0, 0, 0
  local first = at - WINDOW
  local pts = {}
  for _, p in ipairs(xs) do
    if p.t >= first and p.t <= at then
      pts[#pts + 1] = p
      sx, sy, st = sx + p.x, sy + p.y, st + p.t
      n = n + 1
    end
  end
  if n < 3 then return nil, nil, n end
  local mt, mx, my = st / n, sx / n, sy / n
  local num_x, num_y, den = 0, 0, 0
  for _, p in ipairs(pts) do
    local d = p.t - mt
    num_x = num_x + d * (p.x - mx)
    num_y = num_y + d * (p.y - my)
    den = den + d * d
  end
  if den < 1e-9 then return nil, nil, n end
  local vx, vy = num_x / den, num_y / den
  local peak, tailSum, tailN = 0, 0, 0
  for i = 2, #pts do
    local a, b = pts[i - 1], pts[i]
    local dt = b.t - a.t
    if dt > 1e-5 then
      local sp = math.sqrt((b.x - a.x) ^ 2 + (b.y - a.y) ^ 2) / dt
      if sp > peak then peak = sp end
      if b.t > at - 0.04 then tailSum, tailN = tailSum + sp, tailN + 1 end
    end
  end
  local tail = tailN > 0 and tailSum / tailN or 0
  return vx, vy, n, peak, tail
end

-- ------- spin gesture
--
-- A METER, not a switch. Circling the held ball winds it: every radian of
-- gesture adds to the meter and the ball's screen-plane roll follows it,
-- so the ball visibly spins faster the more it is wound, to a cap. Pause
-- and it bleeds back down (the decay lives in the aim tick). Winding the
-- OTHER way unwinds first. Only a ball at the cap curves when thrown.
local function feedSpin(x, y)
  -- About the CENTROID of the recent gesture, not about any fixed point:
  -- the ball rides under the finger, so the finger is never orbiting the
  -- ball -- it is orbiting the middle of the loop it is drawing, and that
  -- is what the centroid of the last few samples is. It also gives the
  -- straight-drag rejection for free: on a straight swipe the centroid
  -- trails along the line, so both spokes point the same way and the
  -- accumulated angle stays at nothing.
  local n = #S.samples
  if n < 4 then return end
  local sx, sy, count = 0, 0, 0
  for i = math.max(1, n - 11), n do
    sx, sy, count = sx + S.samples[i].x, sy + S.samples[i].y, count + 1
  end
  local cx, cy = sx / count, sy / count
  local px, py = S.spinPrev and S.spinPrev[1], S.spinPrev and S.spinPrev[2]
  S.spinPrev = { x, y }
  if not px then return end
  local ax, ay = px - cx, py - cy
  local bx, by = x - cx, y - cy
  local ra = math.sqrt(ax * ax + ay * ay)
  local rb = math.sqrt(bx * bx + by * by)
  if ra < 4 or rb < 4 then return end        -- thumb jitter, not an orbit
  local d = math.atan2(ax * by - ay * bx, ax * bx + ay * by)
  if d == 0 then return end
  local sign = d > 0 and 1 or -1
  if sign ~= S.spinSign and S.spinLevel > 0 then
    -- winding against the charge unwinds it, twice as fast as it built
    S.spinLevel = math.max(0, S.spinLevel - math.abs(d) * 2 / SPIN_FULL)
    if S.spinLevel == 0 then S.spinSign = sign end
  else
    S.spinSign = sign
    S.spinLevel = math.min(1, S.spinLevel + math.abs(d) / SPIN_FULL)
  end
  S.spinT = S.clock
  if not S.spinArmed and S.spinLevel >= ARM_AT then
    S.spinArmed = true
    sound("Press_AB")
  end
end

-- ------- the throw

local function smoothstep(a, b, t)
  local u = math.max(0, math.min(1, (t - a) / (b - a)))
  return u * u * (3 - 2 * u)
end

-- the moment the ball leaves the hand: pay for it, count it, sound it
local function paidAndAway()
  if not S.consumed then
    if S.safari then
      local st = S.battle.safari
      if st then st.balls = math.max(0, st.balls - 1) end
    else
      pcall(function()
        require("src.inventory.Bag").remove(game().save, S.ballId, 1)
      end)
    end
    S.consumed = true
  end
  S.battle.dramaticShapeThrows = (S.battle.dramaticShapeThrows or 0) + 1
  S.phase = "flight"
  S.tFly, S.acc = 0, 0
  -- a charged ball keeps its screen-plane roll all the way in; a plain
  -- throw tumbles end over end, harder the less it was wound
  S.ballInst.tumble = S.spinArmed and 0 or 15 * (1 - S.spinLevel)
  sound("Ball_Toss")
end

-- estimate how long the flight will take to reach the foe, for the curve
-- ramp and the give-up timer -- with a thrown VELOCITY there is no solved
-- T any more, only this
local function estimateT()
  local p, E = S.ballInst.pos, S.enemyPos
  local dx, dz = E[1] - p[1], E[3] - p[3]
  local horiz = math.sqrt(dx * dx + dz * dz)
  local hs = math.sqrt(S.vel[1] ^ 2 + S.vel[3] ^ 2)
  S.T = math.max(0.35, math.min(1.0, horiz / math.max(20, hs)))
end

-- launch with the swipe's own velocity (GB px/s in, world velocity out)
local function launchVelocity(vgx, vgy)
  local shot = S.shot
  local fx, fz, rx, rz = camBasis(shot)
  -- what a GB pixel is worth at the BALL's own depth: the swipe moved the
  -- ball, so the ball's speed is the swipe's speed in its own plane
  local wpg = 16 / math.max(6, shot.playerSpan or 16)
  local speed = math.sqrt(vgx * vgx + vgy * vgy) * wpg
  local fwd = math.max(F_MIN, math.min(F_MAX, speed * K_FWD))
  local up = math.max(U_MIN, math.min(U_MAX, (-vgy) * wpg * K_UP))
  local lat = math.max(-L_MAX, math.min(L_MAX, vgx * wpg * K_LAT))
  -- the horizontal launch, leaned MAGNET of the way toward the Pokemon
  local hx, hz = fx * fwd + rx * lat, fz * fwd + rz * lat
  local hmag = math.sqrt(hx * hx + hz * hz)
  local p, E = S.ballInst.pos, S.enemyPos
  local tx, tz = E[1] - p[1], E[3] - p[3]
  local tl = math.sqrt(tx * tx + tz * tz)
  if hmag > 1e-6 and tl > 1e-6 then
    local nx = hx / hmag * (1 - MAGNET) + tx / tl * MAGNET
    local nz = hz / hmag * (1 - MAGNET) + tz / tl * MAGNET
    local nl = math.sqrt(nx * nx + nz * nz)
    hx, hz = nx / nl * hmag, nz / nl * hmag
  end
  -- the range assist: what height would land THIS forward speed on the
  -- body, and lean toward it
  if hmag > 1 then
    local body = S.body or { yOff = 8 }
    local tt = tl / hmag
    local need = (S.groundY + body.yOff - p[2] + 0.5 * GRAVITY * tt * tt) / tt
    up = up + (need - up) * V_ASSIST
    -- and never more than a margin over what this throw needs (OVER_CAP)
    if need > 0 then up = math.min(up, need * OVER_CAP) end
    up = math.max(U_MIN * 0.6, math.min(U_MAX, up))
  end
  S.vel = { hx, up, hz }
  estimateT()
  paidAndAway()
end

-- the solved arc, kept for exactly two throwers: the Master Ball (which
-- must not miss) and the pad's A tap (full participation without the
-- dexterity requirement). Flies to the foe's own body centre.
local function launchSolve()
  local body = S.body or { r = 10, yOff = 8 }
  local E, p = S.enemyPos, S.ballInst.pos
  local T = T_REF
  S.vel = { (E[1] - p[1]) / T,
            (S.groundY + body.yOff - p[2]) / T + 0.5 * GRAVITY * T,
            (E[3] - p[3]) / T }
  S.T = T
  paidAndAway()
end

local function tapThrow()
  if S.shot then launchSolve() end
end

local function pointerRelease(at)
  if not S.grab then return end
  S.grab = nil
  local vx, vy, n, peak, tail = flickFit(at or S.clock)
  if not vx or n < 3 then return end          -- a tap, not a throw
  local speed = math.sqrt(vx * vx + vy * vy)
  -- dead flick: the finger braked before lifting -- the player changed
  -- their mind, and the ball drifts back to the hand
  if peak and peak > 0 and tail / peak < 0.10 then return end
  if speed < S_MIN then return end
  if vy / speed > -MIN_UP then return end     -- throws point up the screen
  local def = S.battle:ballDef(S.ballId)
  if def and def.autoCatch then return launchSolve() end
  launchVelocity(vx, vy)
end

-- ------- contact

local function tierFor(rho, inside)
  if not inside then return nil end
  if rho <= 0.30 then return "EXCELLENT" end
  if rho <= 0.70 then return "GREAT" end
  return "NICE"
end

local function beginSuck(cross)
  S.phase = "suck"
  S.t = 0
  S.ballInst.pos = cross
  S.ballInst.tumble, S.ballInst.tumbleAngle = 0, 0
  S.ballInst.spin, S.ballInst.spinAngle = 0, 0
  S.ballInst.roll, S.ballInst.rollAngle = 0, 0
  -- face the foe: the hinge is at the back, so the mouth gapes at it
  local E = S.enemyPos
  S.ballInst.yaw = math.atan2(E[1] - cross[1], E[3] - cross[3]) + math.pi
  S.ballInst:open()
  sound("Ball_Poof")
end

-- The ball has TOUCHED the Pokemon -- contact is a real collision in
-- world space (see the flight step), so any touch opens the ball; the
-- ring's only job is the GRADE, judged in screen space at this instant:
-- inside the shrinking ring earns the tier, outside is a plain hit.
local function resolveContact(cross)
  local shot = S.shot
  local cx, cy, outer = ringGeometry(shot)
  local rho = ringRho(S.ringT)
  local inside = false
  local gx, gy = toGB(shot, cross[1], cross[2], cross[3])
  if gx then
    local dist = math.sqrt((gx - cx) ^ 2 + (gy - cy) ^ 2)
    inside = dist <= rho * outer + 1
  end
  S.tier = tierFor(rho, inside)
  S.rho = rho
  S.hit = true
  -- hang the ball where it struck
  beginSuck({ cross[1], math.max(S.groundY + Pokeball.R, cross[2]),
              cross[3] })
  return true
end

-- ------- the engine roll, and the queue that finishes the fight

local function throwMult()
  return (S.tier and TIER_MULT[S.tier]) or 1.0
end

local function rollCatch()
  local b = S.battle
  local base = S.safari and (b.safariCatchRate or b.enemy.def.catchRate)
               or b.enemy.def.catchRate
  local rate = math.min(255, math.floor(base * throwMult()))
  local caught, shakes = b:catchAttempt(S.ballId, rate)
  S.caught = caught
  S.shakes = caught and 3 or (shakes or 0)
  emit("battle.ball_thrown", { battle = b, ball = S.ballId,
                               caught = caught, shakes = shakes })
end

-- the camera hold's previous value, owned by whoever engaged first -- the
-- battle-long veil under FULL, or a lone session under CATCH ONLY
local heldStill = nil

local function releaseMask()
  if S and S.artBox and S.artBox.data then
    pcall(function() S.artBox.data:release() end)
    S.artBox.data = nil
  end
end

local function endSession(keepScene)
  if not S then return end
  if not keepScene then
    BattleCam.still = heldStill or false
    heldStill = nil
    BattleScene.capture = nil
    releaseMask()
    S = nil
  end
end

-- the catch: the engine's own captured flow, with the fanfare the anim
-- chain would have supplied. The session stays alive as an epilogue so the
-- ball and the stars remain in shot under the caught text; battle.ended
-- sweeps it away.
local function resolveCaught()
  local b = S.battle
  b.lastBall = S.ballId
  -- the experience context has to exist before storeCaughtMon fires the
  -- catch-exp hooks; LetsGo owns the arithmetic
  pcall(function()
    V.require("LetsGo").noteCatch(b, {
      tier = S.tier,
      mult = throwMult(),
      firstThrow = (b.dramaticShapeThrows or 1) == 1,
      safari = S.safari,
    })
  end)
  b.phase = "messages"
  b.afterQueue = "menu"
  b:act(function() sound("Caught_Mon") end)
  b:say(require("src.core.Strings")("All right!\n%s was\ncaught!",
                                    b.enemy.name))
  b:act(function() b:storeCaughtMon() end)
  S.phase = "epilogue"
end

-- a failed throw -- broke out, or never touched the Pokemon at all. The
-- engine's own miss line for the shake count, then the foe's turn, exactly
-- as throwBall's failure path builds it.
--
-- Except under FULL, where a wild encounter IS the catch: the foe never
-- takes a turn, and the session stays alive as "await" -- the moment the
-- miss text clears, the next ball is in the hand. Let's Go wilds do not
-- fight back, and the player is never dropped out of throwing mode.
local function resolveFail(shakes)
  local b = S.battle
  b.lastBall = S.ballId
  b.phase = "messages"
  b.afterQueue = "menu"
  b:say(b:ballMissMessage(shakes))
  if S.fullWild then
    S.phase = "await"
    S.ballInst.visible = false
    S.hit, S.tier, S.planeD = nil, nil, nil
    if BattleScene.capture then BattleScene.capture.shrink = nil end
    return
  end
  if S.safari then
    b:act(function() b:safariEnemyTurn() end)
  else
    b:act(function() b:executeAction(b.enemy, b.player, b:enemyAction()) end)
    b:act(function() b:endOfTurn() end)
  end
  endSession()
end

-- B during the aim. Under FULL it is the encounter's RUN: a Let's Go wild
-- is a catch encounter, so leaving it always works -- the safari's own
-- farewell. Everywhere else it backs out to whatever the session was
-- opened over, refunding a ball the bag menu already consumed.
function CatchThrow.cancel(declined)
  if not (S and S.phase == "aim") then return false end
  local b = S.battle
  if S.fullWild then
    sound("Run")
    b:say(require("src.core.Strings")("Got away safely!"))
    b.result = "run"
    b.phase = "messages"
    b.afterQueue = "finish"
    S.phase = "epilogue"      -- the veil holds until battle.ended sweeps
    return true
  end
  if S.consumed and not S.safari then
    pcall(function()
      require("src.inventory.Bag").add(game().save, S.ballId, 1, game().data)
    end)
  end
  if declined then b.dramaticShapeDeclined = true end
  b.phase = "menu"
  endSession()
  sound("Press_AB")
  return true
end

-- ------- the scene hooks BattleScene consults
--
-- One table on BattleScene while a session runs: the ball's draw and
-- shadow, the foe's shrink, the hidden player side, and the GB overlay.

local function sceneDraw(pull)
  if not S then return end
  S.ballInst:draw(pull)
  if S.phase == "suck" then
    local E = S.enemyPos
    local k = 1 - smoothstep(0, 1, S.t / SUCK_T)
    S.ballInst:drawBeam(E[1], S.groundY + CHEST * 0.8, E[3],
                        3.2 * k + 0.6, 1, pull)
  end
end

local function sceneCast(shadowMap)
  if S then S.ballInst:cast(shadowMap) end
end

local function sceneSig()
  if not S then return "" end
  return S.ballInst:signature() .. "," .. S.phase
end

-- ------- the GB overlay (rings, labels, ball readout)
--
-- Drawn inside the battle's own 160x144 UI canvas, from the BattleState
-- draw wrap, so it composites exactly where the engine's HUD does and
-- comes out with the same chunky letterboxed pixels.

local Font = nil
local function font()
  if Font ~= nil then return Font or nil end
  local ok, F = pcall(require, "src.render.Font")
  Font = ok and F or false
  return Font or nil
end

local function label(str, x, y, align)
  local F = font()
  if not F then return end
  local g = love.graphics
  local w = F.width(str) + 4
  local px = align == "right" and (x - w) or
             align == "center" and math.floor(x - w / 2) or x
  g.setColor(0.06, 0.05, 0.09, 0.75)
  g.rectangle("fill", px, y, w, 11)
  g.setColor(0.93, 0.94, 0.90, 1)
  g.rectangle("fill", px + 1, y + 1, w - 2, 9)
  g.setColor(0, 0, 0, 1)
  F.draw(str, px + 2, y + 2)
  g.setColor(1, 1, 1, 1)
end

-- a tiny ball glyph for the readout
local BALL_TOP = {
  POKE_BALL = { 0.86, 0.16, 0.16 }, GREAT_BALL = { 0.25, 0.45, 0.88 },
  ULTRA_BALL = { 0.22, 0.22, 0.26 }, MASTER_BALL = { 0.48, 0.22, 0.66 },
  SAFARI_BALL = { 0.47, 0.52, 0.26 },
}

local function ballGlyph(x, y, id)
  local g = love.graphics
  local top = BALL_TOP[id] or BALL_TOP.POKE_BALL
  g.setColor(0.93, 0.94, 0.90, 1)
  g.circle("fill", x, y, 4)
  g.setColor(top[1], top[2], top[3], 1)
  g.arc("fill", x, y, 4, math.pi, 2 * math.pi)
  g.setColor(0.08, 0.08, 0.09, 1)
  g.setLineWidth(1)
  g.line(x - 4, y, x + 4, y)
  g.circle("line", x, y, 4)
  g.setColor(1, 1, 1, 1)
end

-- how sure the ring should look: the Gen 1 odds, ball and status included,
-- but never the throw -- a colour that jittered with your own inputs would
-- be unreadable (and is why the reference game excludes it too)
local function ringColor()
  local b = S.battle
  local ok, p = pcall(function()
    local def = b:ballDef(S.ballId)
    if def and def.autoCatch then return 1 end
    local rate = S.safari and (b.safariCatchRate or 0) or b.enemy.def.catchRate
    local randMax = (def and def.randMax) or 255
    return math.max(0.05, math.min(1, (rate + 1) / (randMax + 1)))
  end)
  if not ok then p = 0.5 end
  return 1 - p * 0.75, 0.25 + p * 0.7, 0.28, p
end

local function drawGB(battle)
  if not S or S.battle ~= battle then return end
  local shot = OB().shot()
  if not shot then return end
  S.shot = shot
  local g = love.graphics
  g.push("all")

  -- The empty hand: no ring (nothing will be graded) and no ball readout
  -- (there is no ball) -- just what happened and the way out. On the two
  -- rows the aim HUD already uses, NOT side by side on one: at the GB font
  -- these two strings are ~110 and ~56 pixels wide in a 160 pixel frame,
  -- so a single row draws the second plate straight over the end of the
  -- first ("OUT OF BALL|A/B:RUN").
  if S.phase == "aim" and S.empty then
    label("NO BALLS LEFT", 8, 119)
    label("A/B:RUN", 158, 131, "right")
    g.pop()
    return
  end

  if S.phase == "aim" or S.phase == "flight" then
    local cx, cy, outer = ringGeometry(shot)
    local rho = ringRho(S.ringT)
    g.setLineWidth(1)
    -- outer: fixed, white, the hit area
    g.setColor(1, 1, 1, 0.85)
    g.circle("line", cx, cy, outer)
    -- inner: the timing ring, coloured by the odds
    local r, gr, bl = ringColor()
    g.setColor(r, gr, bl, 0.95)
    g.circle("line", cx, cy, math.max(1.5, rho * outer))
  end

  if S.phase == "aim" then
    -- the ball readout: which ball, how many left
    local count
    if S.safari then
      count = battle.safari and battle.safari.balls or 0
    else
      count = (game().save.inventory[S.ballId] or 0)
             + ((S.consumed and not S.safari) and 1 or 0)
    end
    local name = (game().data.items[S.ballId]
                  and game().data.items[S.ballId].name) or S.ballId
    -- along the bottom edge, out of the throwing lane: with the empty
    -- text box gone the whole middle of the frame is the wind-up, and
    -- chrome parked in it would be something to drag around
    -- " BALL" is dropped from the name: the glyph beside it is already a
    -- ball, in that tier's own colours, and the full string is wide
    -- enough at the GB font to run under the B:BACK plate opposite
    ballGlyph(8, 137, S.ballId)
    label(("%s x%d"):format(name:gsub("%s*BALL%s*", ""), count), 15, 131)
    -- and what B does, which is not the same thing in both modes: under
    -- FULL there is no classic menu behind the throw to back out TO, so B
    -- is the encounter's RUN and the label has to say so
    label(S.fullWild and "B:RUN" or "B:BACK", 158, 131, "right")
    if S.canSwitch then label("L/R:BALL", 15, 119) end

    -- the wind-up readout: sparks orbit the ball as it charges, dim and
    -- slow at a quarter wind, bright gold and quick at the cap -- the cap
    -- is the only wind that curves, so it has to be unmistakable
    if S.spinLevel > 0.12 then
      local bx, by = S.handGB[1], S.handGB[2]
      local orbit = math.max(6, (shot.playerSpan or 16) * 0.2)
      local lvl = S.spinLevel
      if S.spinArmed then
        g.setColor(1, 0.9, 0.35, 1)
      else
        g.setColor(1, 1, 0.75, 0.25 + lvl * 0.55)
      end
      for i = 0, 2 do
        local a = S.clock * (3 + 8 * lvl) * S.spinSign + i * (2 * math.pi / 3)
        g.circle("fill", bx + math.cos(a) * orbit,
                 by + math.sin(a) * orbit * 0.45, S.spinArmed and 1.5 or 1)
      end
    end
  end

  -- the grade, splashed at the ring for a beat after contact
  if S.tier and S.tierSplash and S.tierSplash > 0 then
    local cx, cy = ringGeometry(shot)
    label(S.tier .. "!", cx, math.max(8, cy - 20), "center")
  end

  g.pop()
end

-- ------- ball switching (the FULL entry owns its ball choice)

local SWITCHABLE = { "POKE_BALL", "GREAT_BALL", "ULTRA_BALL", "MASTER_BALL" }

local function ownedBalls()
  local inv = game().save.inventory
  local out = {}
  for _, id in ipairs(SWITCHABLE) do
    if (inv[id] or 0) > 0 then out[#out + 1] = id end
  end
  return out
end

local function switchBall(dir)
  if not (S and S.canSwitch and S.phase == "aim") then return end
  local owned = ownedBalls()
  if #owned == 0 then return end
  local at = 1
  for i, id in ipairs(owned) do
    if id == S.ballId then at = i break end
  end
  S.ballId = owned[((at - 1 + dir) % #owned) + 1]
  S.ballInst.ball = S.ballId
  sound("Press_AB")
end

CatchThrow.pickBall = function()
  local owned = ownedBalls()
  for _, id in ipairs(owned) do
    if id == CatchThrow.lastBall then return id end
  end
  return owned[1]
end

-- ------- session lifecycle

-- The capture table BattleScene consults: one shape, installed by the
-- session OR by the battle-long veil below.
local function installScene()
  if not BattleScene.capture then
    if heldStill == nil then heldStill = BattleCam.still end
    BattleCam.still = true
  end
  BattleScene.capture = {
    hidePlayer = true,
    rig = captureRig,
    draw = sceneDraw,
    cast = sceneCast,
    sig = sceneSig,
    drawGB = drawGB,
    shrink = nil,
  }
end

-- The FULL veil: installed at battle.started for a Let's Go wild, before
-- any session exists, so the whole encounter -- the wipe, the "Wild X
-- appeared!" line, every beat between throws -- plays from the head-on
-- seat with the player's side out of the shot. The player's Pokemon is
-- NEVER shown; the encounter IS the catch.
function CatchThrow.veil(battle)
  installScene()
end

-- opts: consumed (the bag already took the ball), safari (safari flow),
-- canSwitch (aim-time ball cycling), declinable (B backs out / runs),
-- fullWild (Let's Go rules: no foe turns, stay in throw mode, B flees),
-- empty (ballId is nil -- the out-of-balls hand, see rearm below)
function CatchThrow.begin(battle, ballId, opts)
  if S then return false end
  opts = opts or {}
  local empty = opts.empty or ballId == nil
  local ok = pcall(function()
    local arena, groundY = OB().arenaInfo()
    local shot = OB().shot()
    assert(arena and shot and shot.eye, "no staged shot to capture in")
    local ball = Pokeball.new(ballId)
    S = {
      battle = battle,
      ballId = ballId,
      safari = opts.safari or false,
      fullWild = opts.fullWild or false,
      empty = empty,
      consumed = opts.consumed or false,
      canSwitch = (opts.canSwitch and not empty) or false,
      declinable = opts.declinable ~= false,
      phase = "aim",
      clock = 0, t = 0, ringT = 0,
      samples = {}, grab = nil,
      spinLevel = 0, spinArmed = false, spinSign = 1,
      stickHeld = false, stickSamples = {},
      ballInst = ball,
      enemyPos = { arena.enemy[1], groundY, arena.enemy[2] },
      playerPos = { arena.player[1], groundY, arena.player[2] },
      groundY = groundY,
      shot = shot,
      handGB = { 80, 110 },
    }
    ball.pos = handPos()
    ball.visible = not empty
    S.body = { r = 10, yOff = 8, hh = 8 }  -- until a measurement lands
    measureBody()
  end)
  if not ok or not S then
    S = nil
    return false
  end
  battle.phase = CatchThrow.PHASE
  if ballId then CatchThrow.lastBall = ballId end
  -- the capture seat, HELD: still drops the drift, the steer and the lift
  -- inside the rig itself, and OverworldBattle's per-frame steerable gate
  -- closes every input that could move it. The player's own steered angle
  -- and lens come back when the hold releases.
  installScene()
  return true
end

-- The next ball into the hand, without tearing the seat down: FULL's
-- "always in throw mode" between one throw and the next.
--
-- A NIL ball is not a failure to rearm -- it is the empty hand, and it is
-- still capture mode. Running out mid-encounter does not hand the fight
-- back to the classic menu (there is no fight: a Let's Go wild has no
-- player Pokemon in it and the foe never takes a turn, so the menu would
-- offer a FIGHT that cannot happen against a foe that cannot answer).
-- The seat holds, the Pokemon stands there, and the readout says so with
-- the one move that is left.
local function rearm(ballId)
  S.ballId = ballId
  S.empty = ballId == nil
  if ballId then
    CatchThrow.lastBall = ballId
    S.ballInst = Pokeball.new(ballId)
    S.ballInst.pos = handPos()
  else
    S.ballInst.visible = false
    S.canSwitch = false
  end
  S.battle.phase = CatchThrow.PHASE   -- park the engine's menu again
  S.phase = "aim"
  S.clock = 0
  S.samples, S.grab, S.spinPrev = {}, nil, nil
  S.spinLevel, S.spinArmed, S.spinSign = 0, false, 1
  S.stickHeld, S.stickSamples = false, {}
  S.consumed = false
  S.hit, S.tier, S.rho, S.caught, S.shakes, S.planeD = nil, nil, nil, nil,
                                                      nil, nil
  S.tFly, S.tierSplash = 0, nil
end

-- battle.ended sweeps the epilogue, the veil, and any half-open session:
-- a battle torn down by a script must never leave the camera held
function CatchThrow.onBattleEnded()
  releaseMask()
  if heldStill ~= nil or S ~= nil or BattleScene.capture ~= nil then
    BattleCam.still = heldStill or false
  end
  heldStill = nil
  BattleScene.capture = nil
  S = nil
end

-- ------- input entry points (installed once, from LetsGo.install)

local installed = false

-- window coordinates (LOVE units) -> GB frame pixels
local function winToGB(x, y)
  local shot = S and S.shot
  if not shot then return nil end
  local uw, uh = love.graphics.getDimensions()
  if not (uw > 0 and uh > 0) then return nil end
  local px = x * shot.pw / uw
  local py = y * shot.ph / uh
  return (px - shot.lx) / shot.scale, (py - shot.ly) / shot.scale
end

-- An EMPTY hand is not aimable: with no ball there is nothing to drag, so
-- the pointer seams stand down entirely and the mouse/finger goes back to
-- whatever owned it -- rather than the player wrestling an invisible ball
-- around a screen that can never throw it.
local function aiming()
  return S ~= nil and S.phase == "aim" and not S.empty
end

local function pointer(kind, x, y, id)
  local gx, gy = winToGB(x, y)
  if not gx then return end
  if kind == "press" and not S.grab then
    S.grab = { id = id }
    S.samples = {}
    S.spinPrev = nil
    pushSample(gx, gy)
  elseif S.grab and S.grab.id == id then
    pushSample(gx, gy)
    feedSpin(gx, gy)
    if kind == "release" then pointerRelease(S.clock) end
  end
end

-- ------- the BUTTONS, read on the LOGIC STEP rather than the frame
--
-- Everything else in this file is presentational and rides the render
-- frame (Pipelines.update). Button EDGES cannot: Input:step rebuilds
-- `pressed` from scratch once per FIXED step, and Game:update runs the
-- fixed steps for the frame FIRST and Pipelines.update after -- so a
-- frame that runs two steps has already thrown the first step's edges
-- away by the time anything on the render clock looks at them.
--
-- Which is not a rare race. It is every frame below 60fps: the key is
-- queued between frames, the frame's FIRST step promotes it, the SECOND
-- wipes it, and the poll never sees it at all. A 3D battle is exactly
-- where the frame rate goes under, so B-to-run, A-to-throw and the L/R
-- ball switch were all reliably dead on the machines that most needed
-- them and fine on a 144Hz one (where most frames run no step at all and
-- the edge lingers). Read from the pressQueue on the engine's own
-- input.step seam instead: it fires once per logic step, never skipped,
-- with this step's presses still in the queue.
--
-- Taken rather than peeked, so a press the capture consumed does not also
-- page the message it just queued.
local function take(g, btn)
  local q = g and g.input and g.input.pressQueue
  if not q then return false end
  local hit = false
  for i = #q, 1, -1 do
    if q[i] == btn then
      table.remove(q, i)
      hit = true
    end
  end
  return hit
end

function CatchThrow.buttons(g)
  if not (S and S.phase == "aim") then return end
  -- the same beat of deafness the drag has: the A that picked the ball out
  -- of the bag menu is still this step's edge, and must not become a throw
  if S.clock < 0.25 then return end
  if S.empty then
    -- A as well as B: nothing here can be confirmed, so the confirm button
    -- should get the player out rather than do nothing at all
    local b, a = take(g, "b"), take(g, "a")
    if b or a then CatchThrow.cancel(true) end
    return
  end
  if S.declinable and take(g, "b") then
    CatchThrow.cancel(true)
    return
  end
  if take(g, "a") then tapThrow() end
  if take(g, "left") then switchBall(-1) end
  if take(g, "right") then switchBall(1) end
end

function CatchThrow.installInput()
  if installed then return end
  installed = true

  local Game = require("src.core.Game")

  -- the logic-step seam for the buttons (see above). next_ first, so a
  -- tool mod injecting presses on this hook is read like a controller.
  local mod = V.mod
  if mod and mod.hooks then
    mod.hooks:wrap("input.step", function(next_, g, dt)
      local r = next_(g, dt)
      pcall(CatchThrow.buttons, g)
      return r
    end)
  end

  -- ------- mouse
  --
  -- Installed after CamControl's wraps (see main.lua's install order), so
  -- these are the OUTER ones and the aim owns the button first. Bare
  -- motion is not claimed -- CamControl's battle steer already stands
  -- down while the capture holds the camera (BattleCam.steerable).
  do
    local inner = love.mousepressed
    love.mousepressed = function(x, y, button, istouch, presses)
      if aiming() and not istouch and button == 1 then
        pointer("press", x, y, "mouse")
        return
      end
      if inner then return inner(x, y, button, istouch, presses) end
    end
  end
  do
    local inner = love.mousemoved
    love.mousemoved = function(x, y, dx, dy, istouch)
      if aiming() and not istouch and S.grab and S.grab.id == "mouse" then
        pointer("move", x, y, "mouse")
        return
      end
      if inner then return inner(x, y, dx, dy, istouch) end
    end
  end
  do
    local inner = love.mousereleased
    love.mousereleased = function(x, y, button, istouch, presses)
      if aiming() and not istouch and button == 1
         and S.grab and S.grab.id == "mouse" then
        pointer("release", x, y, "mouse")
        return
      end
      if inner then return inner(x, y, button, istouch, presses) end
    end
  end

  -- ------- touch
  --
  -- A finger on open screen is the throw; fingers on the overlay's d-pad
  -- and buttons flow to TouchControls untouched, so B still backs out on
  -- a phone. One finger owns the ball at a time, the FirstPerson rule.
  local TouchControls = require("src.core.TouchControls")
  do
    local inner = Game.touchpressed
    function Game:touchpressed(id, x, y)
      if aiming() then
        local onControl = nil
        pcall(function() onControl = TouchControls:hitTest(x, y) end)
        if not onControl and not S.grab then
          pointer("press", x, y, id)
          return
        end
      end
      return inner(self, id, x, y)
    end
  end
  do
    local inner = Game.touchmoved
    function Game:touchmoved(id, x, y)
      if aiming() and S.grab and S.grab.id == id then
        pointer("move", x, y, id)
        return
      end
      return inner(self, id, x, y)
    end
  end
  do
    local inner = Game.touchreleased
    function Game:touchreleased(id, x, y)
      if aiming() and S.grab and S.grab.id == id then
        pointer("release", x, y, id)
        return
      end
      return inner(self, id, x, y)
    end
  end
end

-- ------- the stick, polled
--
-- FirstPerson's always-on wrap records the right stick whatever the mode,
-- so the session reads it rather than claiming a seam of its own. The
-- stick plays "virtual finger": deflection stands a finger at centre +
-- stick * STICK_R, circling winds the spin, and a hard upward flick of
-- the stick is the throw -- strength from the flick's own velocity.
local function stickInput(dt)
  local FirstPerson = V.require("FirstPerson")
  local sx = FirstPerson.stickX and FirstPerson.stickX() or 0
  local sy = FirstPerson.stickY and FirstPerson.stickY() or 0
  local mag = math.sqrt(sx * sx + sy * sy)

  local st = S.stickSamples
  st[#st + 1] = { x = sx, y = sy, t = S.clock }
  if #st > 16 then table.remove(st, 1) end

  if mag > STICK_GRAB then
    if not S.stickHeld then
      S.stickHeld = true
      if not S.grab then
        S.grab = { id = "stick" }
        S.samples = {}
        S.spinPrev = nil
      end
    end
    if S.grab and S.grab.id == "stick" then
      local gx = S.handGB[1] + sx * STICK_R
      local gy = S.handGB[2] + sy * STICK_R
      pushSample(gx, gy)
      feedSpin(gx, gy)
      -- the flick: stick velocity over the last few samples, upward and
      -- fast. Measured in stick units so a worn pad and a fresh one
      -- answer alike after their deadzones.
      local n = #st
      if n >= 3 then
        local a, b = st[n - 2], st[n]
        local dt2 = b.t - a.t
        if dt2 > 1e-4 then
          local vy = (b.y - a.y) / dt2
          if vy < -STICK_VEL and sy < -0.45 then
            -- hand the same release path the pointer takes; the samples
            -- already trace the gesture in GB pixels
            pointerRelease(S.clock)
            S.stickHeld = false
          end
        end
      end
    end
  elseif S.stickHeld then
    S.stickHeld = false
    if S.grab and S.grab.id == "stick" then
      -- stick returned to centre without the flick: let the fit decide
      -- whether the travel back was itself a throw (it usually is not)
      pointerRelease(S.clock)
    end
  end
end

-- ------- per-frame drive (called from LetsGo.update, before the battle
-- scene renders, so the ball this frame draws is the ball this frame)

function CatchThrow.update(dt)
  if not S then return end
  local b = S.battle
  S.clock = S.clock + dt
  S.ringT = S.ringT + dt
  S.ballInst:update(dt)
  if S.tierSplash then S.tierSplash = S.tierSplash - dt end
  -- the box is back by default and taken away only by the aim branch, so
  -- the first frame with something to say has somewhere to say it
  if BattleScene.capture then BattleScene.capture.hideTextBox = false end

  -- the battle went away under us (forced finish, a script): stand down
  if S.phase ~= "epilogue" then
    local ok, gone = pcall(function()
      return b.result ~= nil and b.result ~= false
    end)
    if ok and gone then
      CatchThrow.onBattleEnded()
      return
    end
  end

  -- the staged shot for this frame's reasoning: last frame's render.
  -- Losing it (a lost context, a broken arena) abandons the session
  -- rather than playing blind.
  local shot = OB().shot()
  if shot then
    S.shot = shot
    S.lostShot = 0
  else
    S.lostShot = (S.lostShot or 0) + dt
    if S.lostShot > 1.0 and S.phase == "aim" then
      CatchThrow.cancel(true)
      return
    end
  end

  if S.phase == "aim" then
    -- ------- the empty hand
    --
    -- No ball, so no drag, no wind-up, no throw and no ring: the seat and
    -- the Pokemon are all that is left, and the only input that means
    -- anything is leaving. A runs as well as B on purpose -- there is no
    -- second choice for it to be confused with, and a player mashing the
    -- confirm button at a screen that cannot confirm anything should get
    -- out rather than get stuck.
    if S.empty then
      if BattleScene.capture then BattleScene.capture.hideTextBox = true end
      return                      -- A/B are read on the logic step, below
    end
    -- the foe's body, if no measurement landed at begin (the texture pass
    -- and the session race on the entry frame; a model needs its pack
    -- warm): retried while aiming, briefly -- the default torso covers a
    -- foe that never answers
    if not S.bodyMeasured and (S.artTries or 0) < 30 then
      S.artTries = (S.artTries or 0) + 1
      measureBody()
    end
    -- The held ball is DRAGGED, riding directly under the finger with no
    -- fence around it (the reference model: the ball follows the hand,
    -- and the throw will be the hand's own velocity). It moves in the
    -- CAMERA-FACING PLANE through its hover -- screen right is the eye's
    -- right, screen up is the eye's own tilted up -- so every part of
    -- the frame maps to somewhere the ball can be: dragging low brings
    -- it down and toward the seat rather than jamming it into the floor.
    -- The floor is the one true limit, and it is the world's, not a box.
    local home = handPos()
    local bob = math.sin(S.clock * 2.2) * 0.35
    local target = { home[1], home[2] + bob, home[3] }
    if S.grab and #S.samples > 0 then
      -- straight down the finger's own ray, at the hand's reach: the ball
      -- is wherever the pointer is, over the WHOLE frame, with no plane
      -- and no box to run into.
      --
      -- The one limit is the world's own floor, and it is not a clamp:
      -- drag low enough that the ray would put the ball underground and
      -- the ball is pulled IN toward the eye instead, which is how a
      -- hand holding it low actually looks. So the bottom of the screen
      -- is reachable everywhere -- the ball simply comes nearer as it
      -- goes down, rather than stopping dead at the grass.
      local last = S.samples[#S.samples]
      local e = S.shot.eye
      local dx, dy, dz = rayThrough(last.x, last.y)
      if dx then
        local reach = math.sqrt((home[1] - e[1]) ^ 2 + (home[2] - e[2]) ^ 2
                                + (home[3] - e[3]) ^ 2)
        if dy < -1e-6 then
          local floor = (e[2] - (S.groundY + Pokeball.R * 1.4)) / -dy
          reach = math.min(reach, math.max(Pokeball.R * 3, floor))
        end
        target = { e[1] + dx * reach, e[2] + dy * reach, e[3] + dz * reach }
      end
    end
    -- direct under the finger, a soft drift when coming home
    local ease = S.grab and math.min(1, dt * 30) or math.min(1, dt * 9)
    local bp = S.ballInst.pos
    bp[1] = bp[1] + (target[1] - bp[1]) * ease
    bp[2] = bp[2] + (target[2] - bp[2]) * ease
    bp[3] = bp[3] + (target[3] - bp[3]) * ease
    -- face the seat, so the wind-up's roll reads as the ball turning
    -- clockwise/counter-clockwise to the player watching it
    S.ballInst.yaw = eyeYaw(bp[1], bp[3])
    local gx, gy = toGB(S.shot, bp[1], bp[2], bp[3])
    if gx then S.handGB = { gx, gy } end

    -- the wind-up meter: bleeds once the hand pauses, and the ball's
    -- visible roll IS the meter -- faster the more it is wound
    if S.spinLevel > 0 and S.clock - (S.spinT or 0) > SPIN_IDLE then
      S.spinLevel = math.max(0, S.spinLevel - SPIN_DECAY * dt)
    end
    if S.spinArmed and S.spinLevel < DISARM_AT then S.spinArmed = false end
    S.ballInst.roll = -S.spinSign * S.spinLevel * ROLL_MAX
    -- the empty text box is off the frame while aiming, which is what
    -- gives the drag the bottom third of the screen to wind up in
    if BattleScene.capture then BattleScene.capture.hideTextBox = true end

    stickInput(dt)
    -- B, A and the L/R ball switch are NOT read here: button edges do not
    -- survive the render clock (CatchThrow.buttons, on the logic step)
    return
  end

  -- FULL, between throws: the miss text is playing, the seat is held, and
  -- the moment the engine offers the menu the next ball is in the hand
  -- instead -- or, when that was the last ball, the empty hand is (rearm
  -- takes nil for exactly this). Either way the capture screen stays up.
  if S.phase == "await" then
    if S.battle.phase == "menu" then rearm(CatchThrow.pickBall()) end
    return
  end

  if S.phase == "flight" then
    S.acc = S.acc + dt
    local E = S.enemyPos
    -- The foe's GEOMETRY, not a blob. A pic foe is judged against its own
    -- art: crossing the card's plane samples the sprite's opaque pixels
    -- (dilated by the ball's radius and a mercy margin), so a ball through
    -- the gap under a wing flies on and one that clips the wing connects.
    -- A model foe is an ellipsoid at its measured height and footprint;
    -- the default torso covers a foe that never answered.
    local body = S.body or { r = 10, yOff = 8, hh = 8 }
    local box = S.artBox
    local fx, fz, rx, rz = camBasis(S.shot)
    local kPic = 16 / 56                       -- world px per pic px
    local dilate = (Pokeball.R * 1.6 + 2) / kPic
    local sr = body.r * 1.3 + Pokeball.R + 1.5 -- ellipsoid semi-axes
    local sh = (body.hh or body.r) + Pokeball.R + 1
    while S.acc >= H_STEP do
      S.acc = S.acc - H_STEP
      local p, v = S.ballInst.pos, S.vel
      local ax, ay, az = 0, -GRAVITY, 0
      if S.spinArmed then
        local w = smoothstep(CURVE_RAMP0, CURVE_RAMP1, S.tFly / S.T)
        ax = ax + rx * CURVE_GAIN * S.spinSign * w
        az = az + rz * CURVE_GAIN * S.spinSign * w
      end
      v[1], v[2], v[3] = v[1] + ax * H_STEP, v[2] + ay * H_STEP,
                         v[3] + az * H_STEP
      p[1] = p[1] + v[1] * H_STEP
      p[2] = p[2] + v[2] * H_STEP
      p[3] = p[3] + v[3] * H_STEP
      S.tFly = S.tFly + H_STEP

      if not S.hit then
        local contact = false
        if box and box.data then
          -- the card's plane through the foe's cell, crossed this step?
          local d1 = (p[1] - E[1]) * fx + (p[3] - E[3]) * fz
          if (S.planeD or -1) < 0 and d1 >= 0 then
            -- where the ball stands ON the art, in pic pixels
            local ux = (p[1] - E[1]) * rx + (p[3] - E[3]) * rz
            local px = box.ax + ux / kPic
            local py = box.ay - (p[2] - S.groundY) / kPic
            contact = maskHit(box.data, px, py, dilate)
          end
          S.planeD = d1
        else
          local dx = (p[1] - E[1]) / sr
          local dy = (p[2] - (S.groundY + body.yOff)) / sh
          local dz = (p[3] - E[3]) / sr
          contact = dx * dx + dy * dy + dz * dz <= 1
        end
        if contact then
          resolveContact({ p[1], p[2], p[3] })
          S.tierSplash = S.tier and 1.0 or nil
          return
        end
      end

      -- short or wide: the ground takes it, with a couple of tired hops
      if p[2] <= S.groundY + Pokeball.R and v[2] < 0 then
        p[2] = S.groundY + Pokeball.R
        v[2] = -v[2] * 0.35
        v[1], v[3] = v[1] * 0.55, v[3] * 0.55
        S.ballInst.tumble = S.ballInst.tumble * 0.5
        if math.abs(v[2]) < 12 then v[2] = 0 end
      end
    end
    if S.tFly > S.T + 1.2 then
      S.ballInst.visible = false
      resolveFail(0)                          -- "You missed the POKéMON!"
    end
    return
  end

  if S.phase == "suck" then
    S.t = S.t + dt
    local k = 1 - smoothstep(0, 1, S.t / SUCK_T)
    BattleScene.capture.shrink = math.max(0.02, k)
    if S.t >= SUCK_T then
      S.ballInst:close()
      S.phase = "drop"
      S.t = 0
      -- the roll happens NOW, so the wobble count is honest
      rollCatch()
      local p = S.ballInst.pos
      S.dropFrom = { p[1], p[2], p[3] }
      -- land a step toward the camera from the foe's feet
      local fx, fz = camBasis(S.shot)
      S.dropTo = { S.enemyPos[1] - fx * 5, S.groundY + Pokeball.R,
                   S.enemyPos[3] - fz * 5 }
    end
    return
  end

  if S.phase == "drop" then
    S.t = S.t + dt
    local u = math.min(1, S.t / DROP_T)
    local p0, p1 = S.dropFrom, S.dropTo
    -- a dropped arc: linear across, gravity-shaped down, one bounce
    local h = (1 - u) * (p0[2] - p1[2])
    local bounce = 0
    if u > 0.82 then
      bounce = math.abs(math.sin((u - 0.82) / 0.18 * math.pi)) * 1.2 * (1 - u)
    end
    S.ballInst.pos = { p0[1] + (p1[1] - p0[1]) * u,
                       p1[2] + h * (1 - u * 0.4) + bounce,
                       p0[3] + (p1[3] - p0[3]) * u }
    if u >= 1 then
      S.ballInst.pos = { p1[1], p1[2], p1[3] }
      S.phase = "wobble"
      S.t = -0.35                             -- a beat before the first rock
      S.shakeIx = 0
      sound("Tink")
    end
    return
  end

  if S.phase == "wobble" then
    S.t = S.t + dt
    if S.ballInst:busy() then return end
    if S.t < SHAKE_GAP then return end
    if S.shakeIx < S.shakes then
      S.shakeIx = S.shakeIx + 1
      S.t = 0
      S.ballInst:rock(S.shakeIx % 2 == 0 and 1 or -1)
      sound("Tink")
    elseif S.caught then
      S.phase = "clicked"
      S.t = 0
      S.ballInst:catchClick()
    else
      -- the breakout: the ball bursts, the foe pours back out
      S.phase = "burst"
      S.t = 0
      S.ballInst:burst()
      sound("Ball_Poof")
    end
    return
  end

  if S.phase == "clicked" then
    S.t = S.t + dt
    if S.t >= 0.9 then resolveCaught() end
    return
  end

  if S.phase == "burst" then
    S.t = S.t + dt
    local k = smoothstep(0, 1, S.t / 0.3)
    BattleScene.capture.shrink = k >= 0.98 and nil or math.max(0.02, k)
    if S.t >= 0.55 then
      BattleScene.capture.shrink = nil
      S.ballInst.visible = false
      resolveFail(S.shakes)
    end
    return
  end

  -- epilogue: the ball rests in shot while the caught text plays; the
  -- stars fade on their own, and battle.ended clears the table
end

return CatchThrow