local SKILLS = require("game/enso_skills")
local STAGES = require("game/enso_stages")
local INTERCEPTS = require("game/enso_intercepts")

EnsoBattleOverlay = {}
EnsoBattleOverlay.__index = EnsoBattleOverlay

local function folder_of(key)
    return key:sub(1, 6) == "stage_" and "battle_stage" or "enso_battle"
end
local S = tex.get_screen_scale()

local FIELD = { x0 = 660, x1 = 1220, y0 = 470, y1 = 660, near = 0.7, far = 0.5 }
local POP_STAGGER_MS = 120

local POP_MS, DEAD_MS, ESCAPE_MS = 550, 450, 500
local HIT_TILT_MS, HIT_SHAKE_MS, SPARK_MS = 67, 200, 200
local LANE_HIT_MS = 250
local NUMBER = { x = 414, y = 168, drop_from = -10, drop_to = 12, drop_ms = 67, life_ms = 300 }
local KILL_TICK_MS, KILL_TICK_CATCHUP = 250, 20
local KILL_ADD = { x = 450, cy = 92, gap = -8 }
local DIGIT_POP_MS = 67
local SPARK = { per_kill = 3, delay_ms = 250, fly_ms = 650, x = 470, y = 92, field_x0 = 480, field_x1 = 1100 }
local ROLL = { x = 425, y = 140, spread_x = 85, spread_y = 45, s = 0.6, bg_ms = 550, number_ms = 483, max = 14 }
local CUTIN_MS, CUTIN_IN, SLASH_AT, CUTIN_OUT = 2420, 450, 1167, 2117
local FRAME_MS = 1000 / 60
local SLASH = { x = -314, y = -75, s = 0.873, cx = 186, cy = 323 }
local CHEST_MS = 1900
local CHEST_COUNT = { x = 171.5, y = 260.4, badge_x = 192.5, badge_y = 234.4, orb_y = 266.4, delay = 1133 }

local BOSS_DMG_MS = 117
local BEST_BANNER = { x = 72, y = 163, x_off = -86, slide = 14, out = 136, len = 149 }
local BOSS_HIT = { x0 = 650, x1 = 1000, y0 = 380, y1 = 600, ms = 300, max = 6 }
local BOSS_KNOCK = { at = 1300, out_ms = 350, back = 767, land = 1183, settle = 1317, done = 1500 }
local FINISH = { delay = 1000, boss_dead = 0, x = 804, y = 260, seal_x = 1040, seal_y = 260, slash_dx = -285,
    slash_dy = 15, shatter = 1517, shard_ms = 383, banner = 1833 }
local FC = { dx = -4, dy = -6.6, loop_from = 44, loop_len = 95, band_from = 39, band_period = 90 }
local SHARDS = {
    { -15, -139, -1, -244, 1.765 }, { -159, -49, -318, -158, 1.618 },
    { -105, 65, -148, 149, 1.618 }, { 67, -18, 241, -41, 1.882 },
}
local BOSS_GAUGE = { w = 440, warn = 1 / 3, critical = 0.1, warn_ms = 850, critical_ms = 583, bump_ms = 33 }

local KILL_DIGITS = { right = 440, cy = 90, gap = -6 }
local POWER_DIGITS = { right = 106, cy = 208, gap = -2 }
local GAUGE_FILL_WIDTH = 200

local function clamp01(v)
    return math.max(0, math.min(1, v))
end

local function lerp(a, b, q)
    return a + (b - a) * clamp01(q)
end

local function ease_out(t)
    return 1 - (1 - t) * (1 - t)
end

-- 0 -> 1 over [a, b] ms, then 1 -> 0 over [c, d]
local function window(t, a, b, c, d)
    if t < a or t >= d then return 0 end
    if t < b then return (t - a) / (b - a) end
    if t < c then return 1 end
    return 1 - (t - c) / (d - c)
end

function EnsoBattleOverlay.new()
    local self = setmetatable({}, EnsoBattleOverlay)
    self.ids = {}
    self.sizes = {}
    self:reset(414 * S, 256 * S)
    return self
end

function EnsoBattleOverlay:id(key)
    self.ids[key] = self.ids[key] or tex.get_texture(folder_of(key) .. "/" .. key)
    return self.ids[key]
end

function EnsoBattleOverlay:size(key)
    local info = self.sizes[key]
    if not info then
        info = tex.get_texture_info(folder_of(key), key)
        self.sizes[key] = info
    end
    return info.width * S, info.height * S
end

function EnsoBattleOverlay:spr(key, x, y, o)
    o = o or {}
    local w, h = self:size(key)
    local sx, sy = o.sx or o.s or 1, o.sy or o.s or 1
    tex.draw_texture(self:id(key), {
        x = x * S, y = y * S,
        x2 = w * (sx - 1), y2 = h * (sy - 1),
        origin = { w * sx * (o.ax or 0.5), h * sy * (o.ay or 0.5) },
        rotation = o.rot or 0,
        fade = o.fade or 1,
        frame = o.frame or 0,
        blend = o.add and "additive" or nil,
    })
end

local function play(name, preset)
    name = "enso_battle_" .. name
    if audio.has_sound(name) then audio.play_sound(name, preset or "sound") end
end

function EnsoBattleOverlay:reset(judge_x, judge_y, stage, orbs, best_power)
    self.judge = { x = judge_x / S, y = judge_y / S }
    self.chest_count = { orbs = orbs, counts = {}, bumps = {} }
    stage = STAGES[stage] and stage or 1
    -- the EX stage (11) fields stage 9's enemies once its boss is gone
    self.stage, self.enemy_stage = STAGES[stage], STAGES[math.min(stage - 1 + stage % 2, 9)]
    self.intercept_def = INTERCEPTS[stage]
    self.intercept = nil
    self.enemies = {}
    self.next_pop = 0
    self.fallen = {}
    self.number = nil
    self.kill_add = nil
    self.skill_add = nil
    self.kill_count = { target = 0, shown = 0, next_tick = 0, pops = {}, incoming = {} }
    self.sparks = {}
    self.puff = nil
    self.rolls = {}
    self.power_count = { shown = 0, pops = {} }
    self.lane_hits = {}
    self.chests = {}
    self.skill = nil
    self.ended = nil
    self.end_banner = nil
    self.fight = nil
    self.power, self.fill = 0, 0
    self.best_power = best_power and best_power >= 0 and best_power or nil
    self.best_banner = nil
end

function EnsoBattleOverlay:boss(ms, hp, max)
    self.fight = { start = ms, hp = hp, shown = hp, from = hp, max = max, hits = {} }
    self.fight.def = self.stage.boss or STAGES[2].boss
    if self.intercept_def then
        self.intercept = { start = ms, last = ms, gogo = false, active = {},
            normal = { t = 0, i = 1 }, gogo_mode = { t = 0, i = 1 } }
    end
end

function EnsoBattleOverlay:set_gogo(ms, on)
    local ic = self.intercept
    if not ic or ic.gogo == on then return end
    ic.gogo = on
    for _, a in ipairs(ic.active) do
        if a.gogo ~= on and not a.out then a.out = ms end
    end
end

function EnsoBattleOverlay:cue_once(key, name)
    local played = self.intercept_played
    if played and not played[key] then
        played[key] = true
        play(name)
    end
end

function EnsoBattleOverlay:draw_intercept(ms)
    local ic = self.intercept
    if not ic then return end
    if self.ended and not ic.over then
        ic.over = true
        for _, a in ipairs(ic.active) do a.out = a.out or ms end
    end
    if not ic.over then
        local mode = ic.gogo and ic.gogo_mode or ic.normal
        local def = ic.gogo and self.intercept_def.gogo or self.intercept_def.normal
        mode.t = mode.t + (ms - ic.last) / FRAME_MS
        local ev = def.events[mode.i]
        if mode.t >= ev[1] then
            if ev[2] > 0 then
                ic.active[#ic.active + 1] = {
                    start = ms, gogo = ic.gogo, pat = def.pats[ev[2]], def = def, played = {},
                }
            end
            for _, name in ipairs(def.sounds[mode.i] or {}) do
                play(name, name:sub(1, 3) == "vo_" and "voice" or nil)
            end
            mode.i = mode.i + 1
            if mode.i > #def.events then mode.t, mode.i = 0, 1 end
        end
    end
    ic.last = ms
    local always = self.intercept_def.always
    if always then
        local fade = ic.over and math.max(0, 1 - (ms - (ic.over_ms or ms)) / FRAME_MS / 25) or 1
        ic.over_ms = ic.over and (ic.over_ms or ms) or nil
        if fade > 0 then always.draw(self, (ms - ic.start) / FRAME_MS % always.len, fade) end
    end
    for i = #ic.active, 1, -1 do
        local a = ic.active[i]
        local f = (ms - a.start) / FRAME_MS
        local fade = 1
        if a.out then
            local q = (ms - a.out) / FRAME_MS / a.def.fade
            fade = a.gogo and (1 - q) * (1 - q) or 1 - q
        end
        if f >= a.pat.len or fade <= 0 then
            table.remove(ic.active, i)
        else
            self.intercept_played = a.played
            a.pat.draw(self, f, math.min(fade, 1))
        end
    end
    self.intercept_played = nil
end

function EnsoBattleOverlay:boss_hit(ms)
    local b = self.fight
    b.hit = ms
    if #b.hits >= BOSS_HIT.max then table.remove(b.hits, 1) end
    b.hits[#b.hits + 1] = {
        start = ms,
        x = BOSS_HIT.x0 + math.random() * (BOSS_HIT.x1 - BOSS_HIT.x0),
        y = BOSS_HIT.y0 + math.random() * (BOSS_HIT.y1 - BOSS_HIT.y0),
    }
end

function EnsoBattleOverlay:draw_spark_hit(x, y, f)
    if f >= 2 and f < 15 then
        local u = (f - 2) / 13
        self:spr("boss_hit_ring", x, y, { s = 0.3 + 1.02 * ease_out(u), fade = 1 - u })
    end
    if f < 4 then
        self:spr("boss_hit_spark", x, y, { s = lerp(0.5, 1, f / 2) })
    elseif f < 12 then
        self:spr("boss_hit_spark", x, y, { frame = f < 8 and 1 or 2 })
    elseif f < 16 then
        self:spr("boss_hit_spark", x, y, { frame = 3, s = lerp(1, 1.2, (f - 12) / 4), fade = 0.852 })
    end
end

function EnsoBattleOverlay:free_spot()
    local best, best_gap = nil, -1
    for _ = 1, 6 do
        local x = FIELD.x0 + math.random() * (FIELD.x1 - FIELD.x0)
        local y = FIELD.y0 + math.random() * (FIELD.y1 - FIELD.y0)
        local gap = math.huge
        for _, e in ipairs(self.enemies) do
            gap = math.min(gap, (e.x - x) ^ 2 + ((e.y - y) * 2) ^ 2)
        end
        if gap > best_gap then best, best_gap = { x = x, y = y }, gap end
    end
    return best
end

function EnsoBattleOverlay:pop_enemy(ms, kind)
    local spot = self:free_spot()
    local enemies = self.enemy_stage.enemies
    self.next_pop = math.max(ms, self.next_pop + POP_STAGGER_MS)
    self.enemies[#self.enemies + 1] = {
        key = enemies[kind + 1] or enemies[1], start = self.next_pop, x = spot.x, y = spot.y,
        s = FIELD.far + (FIELD.near - FIELD.far) * (spot.y - FIELD.y0) / (FIELD.y1 - FIELD.y0),
    }
end

function EnsoBattleOverlay:hit(ms, damage, good, critical, kat, big)
    local target = self.enemies[1]
    if target then target.hit = ms end
    if self.fight then self:boss_hit(ms) end
    local key = critical and "critical_digits" or good and "good_digits" or "ok_digits"
    self.number = { value = damage, start = ms, key = key }
    local face = critical and ("critical_" .. (kat and "kat" or "don")) or good and "good" or "ok"
    local key = "hit_" .. face .. (big and "_big" or "")
    self.lane_hits[#self.lane_hits + 1] = { key = key, start = ms, critical = critical }
    if critical then play("se_critical") end
end

function EnsoBattleOverlay:roll_hit(ms, damage)
    local target = self.enemies[1]
    if target then target.hit = ms end
    if self.fight then self:boss_hit(ms) end
    if #self.rolls >= ROLL.max then table.remove(self.rolls, 1) end
    self.rolls[#self.rolls + 1] = {
        value = damage, start = ms, rise = math.random() < 0.5,
        x = ROLL.x + (math.random() * 2 - 1) * ROLL.spread_x,
        y = ROLL.y + (math.random() * 2 - 1) * ROLL.spread_y,
    }
end

function EnsoBattleOverlay:kill(ms, skill)
    local e = table.remove(self.enemies, 1)
    local count = self.kill_count
    if e and e.start <= ms then
        e.start = ms
        self.fallen[#self.fallen + 1] = e
    end
    if not skill then
        count.target = count.target + 1
        play("se_defeat")
        return
    end
    local arrive = ms + SPARK.delay_ms + SPARK.fly_ms
    local last = count.incoming[#count.incoming]
    if last and last.at == arrive then
        last.n = last.n + 1
    else
        count.incoming[#count.incoming + 1] = { at = arrive, n = 1 }
    end
    local from_x = e and e.x or SPARK.field_x0 + math.random() * (SPARK.field_x1 - SPARK.field_x0)
    local from_y = e and e.y - 40 or 560
    for _ = 1, SPARK.per_kill do
        self.sparks[#self.sparks + 1] = {
            start = ms + math.random() * SPARK.delay_ms,
            x = from_x + (math.random() - 0.5) * 80, y = from_y + (math.random() - 0.5) * 60,
            lift = 80 + math.random() * 160, small = math.random() < 0.5, spin = math.random() * 360,
        }
    end
end

function EnsoBattleOverlay:start_skill(ms, skill)
    self.skill = { start = ms, skill = skill, move = SKILLS[skill] or {}, played = {} }
    if self.fight then self.fight.knock, self.fight.knock_played = ms + BOSS_KNOCK.at, {} end
    play(self.skill.move.cutin_sound or "se_cutin")
    play("vo_skill", "voice")
end

function EnsoBattleOverlay:drop_chest(ms, orbs)
    self.chests[#self.chests + 1] = { start = ms + SLASH_AT, x = 620 + math.random() * 120, y = 660,
        kind = orbs and "orb_chest" or "chest" }
    local cc = self.chest_count
    cc.bumps[#cc.bumps + 1] = { at = ms + SLASH_AT + CHEST_COUNT.delay, orbs = orbs and true or false }
end

function EnsoBattleOverlay:song_end(ms, full_combo)
    self.ended = ms
    self.full_combo = full_combo
    local b = self.fight
    if b and b.hp <= 0 then
        b.finish, b.finish_played = ms + FINISH.delay, {}
        b.dead, b.dead_played = b.finish + FINISH.boss_dead, {}
    else
        self.end_banner, self.end_played = ms + FINISH.delay, {}
    end
end

function EnsoBattleOverlay:set_status(power, fill, boss_hp)
    self.power, self.fill = power, fill
    if self.fight and boss_hp then self.fight.hp = boss_hp end
end

-- Marks the digits that differ between two numbers (counted from the right) to pop.
local function pop_changed(pops, old, new, ms)
    old, new = tostring(old), tostring(new)
    for i = 1, #new do
        if old:sub(-i, -i) ~= new:sub(-i, -i) then pops[i] = ms end
    end
end

function EnsoBattleOverlay:tick_counters(ms)
    local count = self.kill_count
    while count.incoming[1] and ms >= count.incoming[1].at do
        local batch = table.remove(count.incoming, 1)
        count.target = count.target + batch.n
        local add = self.skill_add
        if add and not add.leaving then
            add.count, add.until_kills = add.count + batch.n, count.target
        else
            self.skill_add = { count = batch.n, start = ms, until_kills = count.target }
        end
        self.puff = { start = ms }
    end
    local gap = count.target - count.shown
    if gap > 0 and ms >= count.next_tick then
        local step = math.max(1, math.ceil(gap / KILL_TICK_CATCHUP))
        pop_changed(count.pops, count.shown, count.shown + step, ms)
        count.shown = count.shown + step
        count.next_tick = ms + KILL_TICK_MS
        if not self.skill_add then self.kill_add = { count = step, start = ms } end
    end
    local add = self.skill_add
    if add and not add.leaving and count.shown >= add.until_kills then add.leaving = ms end
    local power = self.power_count
    if power.shown ~= self.power then
        pop_changed(power.pops, power.shown, self.power, ms)
        power.shown = self.power
    end
end

function EnsoBattleOverlay:draw_enemy(e, ms)
    local t = ms - e.start
    if t < 0 then return end
    local x, y, sx, sy, rot, fade = e.x, e.y, e.s, e.s, 0, 1
    if t < POP_MS then
        local p = t / POP_MS
        if p < 0.33 then
            local q = p / 0.33
            x, y, fade = x + 56 * (1 - q), y - 27 * (1 - q), q
        else
            local q = (p - 0.33) / 0.67
            y = y - 26 * math.sin(q * math.pi)
            sy = e.s * (1 - 0.16 * math.max(0, math.sin((q - 0.5) * 2 * math.pi)))
        end
    else
        sy = e.s * (1 - 0.045 * (1 - math.cos((t - POP_MS) / 650 * math.pi)))
    end
    if e.hit then
        local h = ms - e.hit
        if h < HIT_TILT_MS then
            x, rot = x + 10, 30
        elseif h < HIT_SHAKE_MS then
            x = x + (math.random() - 0.5) * 2
        end
    end
    if self.ended then
        local q = clamp01((ms - self.ended) / ESCAPE_MS)
        x, fade = x + 50 * q, fade * (1 - q)
    end
    self:spr(e.key, x, y, { ax = 0.5, ay = 1, sx = sx, sy = sy, rot = rot, fade = fade })
    if e.hit and ms - e.hit < SPARK_MS then
        local q = (ms - e.hit) / SPARK_MS
        local _, h = self:size(e.key)
        self:spr("defeat_flash", e.x, e.y - h * e.s / S / 2, { s = 0.4 + 0.3 * q, fade = 1 - q, add = true })
    end
end

function EnsoBattleOverlay:draw_fallen(e, ms)
    local q = (ms - e.start) / DEAD_MS
    if q >= 1 then return true end
    local _, h = self:size(e.key)
    local mid = e.y - h * e.s / S / 2
    self:spr(e.key, e.x + 570 * q, mid - 190 * ease_out(q), { s = e.s, rot = 30 + 105 * q, fade = 1 - q })
    self:spr("defeat_flash", e.x, mid, { s = 0.6 + 0.8 * q, fade = 1 - q, add = true })
    return false
end

function EnsoBattleOverlay:draw_amitie(ms)
    local frame, bob = 0, math.sin(ms / 400) * 2
    if self.skill then
        local t = ms - self.skill.start
        frame = t < SLASH_AT and 2 or 3
    end
    tex.draw_texture(self:id("amitie"), { y = bob * S, frame = frame })
end

function EnsoBattleOverlay:draw_chest(c, ms)
    local t = ms - c.start
    if t < 0 then return false end
    if t >= CHEST_MS then return true end
    local drop = clamp01(t / 300)
    local y = c.y - 220 * (1 - ease_out(drop))
    local fade = clamp01((CHEST_MS - t) / 300)
    if t < 600 then
        self:spr("chest_beam", c.x, c.y, { ay = 1, fade = 1 - t / 600, add = true })
    end
    self:spr("chest_halo", c.x, c.y - 20, { fade = fade * 0.8, add = true })
    self:spr(c.kind, c.x, y, { ay = 1, fade = fade })
    if drop >= 1 then
        local q = clamp01((t - 300) / 400)
        self:spr(c.kind .. "_ring", c.x, c.y - 72, { s = 0.5 + q, fade = (1 - q) * fade, add = true })
    end
    return false
end

-- plays `name` once, the first frame `ready` holds
local function cue(played, ready, name, preset)
    if ready and not played[name] then
        played[name] = true
        play(name, preset)
    end
end

-- offset, squash and visibility while the special move throws the boss away and it falls back
function EnsoBattleOverlay:boss_knock(b, ms)
    local k = ms - b.knock
    if k < 0 then return nil end
    local K = BOSS_KNOCK
    cue(b.knock_played, true, "se_boss_knock")
    cue(b.knock_played, k >= K.back, "se_boss_fall")
    cue(b.knock_played, k >= K.land, "se_boss_land")
    if k < K.out_ms then
        local q = k / K.out_ms
        return { dx = lerp(44, 919, q), dy = lerp(-23, -487, q) }
    elseif k < K.back then
        return { hidden = true }
    elseif k < K.land then
        local q = (k - K.back) / (K.land - K.back)
        return { dx = lerp(117, 0, q), dy = lerp(-1007, 0, q), back = true }
    elseif k < K.settle then
        return { sy = lerp(0.99, 0.918, (k - K.land) / (K.settle - K.land)), back = true }
    elseif k < K.done then
        return { sy = lerp(0.926, 1, (k - K.settle) / (K.done - K.settle)), back = true }
    end
    b.knock = nil
    return nil
end

function EnsoBattleOverlay:draw_boss_dead(b, ms)
    local k, B = ms - b.dead, b.def
    local D = B.dead
    cue(b.dead_played, k >= D.hold, "se_boss_shake")
    cue(b.dead_played, k >= D.burst, "se_boss_vanish")
    if k < D.burst then
        local dx = k < D.hold and 0 or math.floor((k - D.hold) / 50) % 2 == 0 and 10 or -10
        local dying = D.hold > 0 and clamp01(k / D.hold) or 1
        B.draw(self, { t = math.huge, idle = 0, dx = dx, dy = 0, sy = 1, dying = dying })
        return
    end
    -- a boss without a single burst picture draws its dying pose scaled
    local function burst(s, fade, add)
        if D.key then return self:spr(D.key, D.x, D.y, { s = s, fade = fade, add = add }) end
        B.draw(self, { t = math.huge, idle = 0, dx = 0, dy = 0, sy = 1, dying = 1, s = s, fade = fade, add = add })
    end
    local q = (k - D.burst) / D.fade_ms
    if q < 1 then burst(lerp(D.s or 1, D.grow or D.s or 1, q), 1 - q) end
    if D.glow then
        local g = ease_out(clamp01((k - D.burst) / D.glow_ms))
        burst(lerp(D.s or 1, D.glow, g), 1 - g, true)
    end
end

function EnsoBattleOverlay:draw_boss(ms)
    local b = self.fight
    if b.dead and ms >= b.dead then return self:draw_boss_dead(b, ms) end
    local t = ms - b.start
    local p = { t = t, idle = t >= b.def.pop_ms and t - b.def.pop_ms or nil, dx = 0, dy = 0, sy = 1 }
    if b.hit and ms - b.hit < BOSS_DMG_MS then p.hurt = (ms - b.hit) / BOSS_DMG_MS end
    local knock = b.knock and self:boss_knock(b, ms)
    if knock then
        if knock.hidden then return end
        p.knock, p.dx, p.dy, p.sy = knock, knock.dx or 0, knock.dy or 0, knock.sy or 1
    end
    b.def.draw(self, p)
    for i = #b.hits, 1, -1 do
        local h = b.hits[i]
        local k = ms - h.start
        if k >= BOSS_HIT.ms then
            table.remove(b.hits, i)
        elseif not knock and b.def.spark_hit then
            self:draw_spark_hit(h.x, h.y, k / FRAME_MS)
        elseif not knock then
            local hit_fade = k < 83 and lerp(0.89, 1, k / 83) or lerp(0.91, 0, (k - 100) / 167)
            self:spr("boss_hit", h.x, h.y, { fade = hit_fade })
        end
    end
end

function EnsoBattleOverlay:draw_win_banner(t)
    local F = FINISH
    local band_sx, band_x, band_sy, band_fade = 15.35, 0, 1, 1
    if t < 100 then
        local q = t / 100
        band_sx, band_x, band_sy, band_fade = lerp(1.8, 15.35, q), lerp(-881, 0, q), lerp(1, 1.155, q), q
    elseif t < 333 then
        band_sy = lerp(1.155, 1, (t - 100) / 233)
    elseif t < 1167 then
        band_sy = lerp(1, 0.904, (t - 333) / 834)
    else
        band_sy = 1.013 - 0.111 * math.cos((t - 1167) / 1833 * 2 * math.pi)
    end
    for _ = 1, 2 do
        self:spr("boss_win_band", F.x + band_x, F.y, { sx = band_sx, sy = band_sy, fade = band_fade })
    end
    if t < 650 then
        local sx, sy, x, fade = 1, 0.167, 0, 1
        if t < 167 then
            local q = t / 167
            sx, sy, x, fade = lerp(0.126, 1, q), lerp(2.53, 0.167, q), lerp(-877, 0, q), q
        elseif t >= 333 then
            local q = clamp01((t - 333) / 167)
            sy, fade = lerp(0.417, 3.33, q * q), lerp(0.89, 0, (t - 500) / 150)
            if t < 500 then fade = 1 end
        end
        self:spr("boss_win_line", F.x + x, F.y + 2, { sx = sx, sy = sy, fade = fade })
    end
    if self.full_combo then
        self:draw_fc_text(t)
        return
    end
    if t >= 500 then
        local s, fade = 2, 0.77
        if t < 667 then
            s, fade = lerp(1.68, 2, (t - 500) / 167), (t - 500) / 167
        elseif t < 1167 then
            fade = lerp(0.965, 0.77, (t - 667) / 500)
        else
            s = 1.833 + 0.167 * math.cos((t - 1167) / 1833 * 2 * math.pi)
        end
        self:spr("boss_win_glow", F.x, F.y, { s = s, fade = fade, add = true })
    end
    local x, fade = 0, 1
    if t < 283 then
        x, fade = lerp(-776, 256, t / 283), lerp(0.06, 1, t / 283)
    elseif t < 333 then
        x = lerp(170, 0, (t - 283) / 50)
    end
    local pop = (t >= 433 and t < 567) and math.sin((t - 433) / 133 * math.pi) or 0
    self:spr("boss_win_banner", F.x + x, F.y + 5, { s = 1 + 0.167 * pop, fade = fade })
    if pop > 0 then
        self:spr("boss_win_banner", F.x, F.y + 5, { s = 1 + 0.167 * pop, fade = 1 - (t - 433) / 133, add = true })
    end
end

function EnsoBattleOverlay:draw_fc_text(t)
    local F = FINISH
    local f = t / FRAME_MS
    local x, y = F.x + FC.dx, F.y + FC.dy

    if f >= FC.band_from then
        local b = f - FC.band_from
        local sx, sy, fade = 15.32, 1, 0.8
        if b < 4 then
            local q = b / 4
            sx, sy, fade = lerp(3.23, 15.32, q), lerp(1, 1.88, q), lerp(0, 0.8, q)
        else
            local c = math.cos((b - 4) / FC.band_period * 2 * math.pi)
            sy, fade = 1.555 + 0.325 * c, 0.895 - 0.095 * c
        end
        self:spr("fc_band_flash", F.x, F.y, { sx = sx, sy = sy, fade = fade, add = true })
    end

    local p = f < FC.loop_from and f or FC.loop_from + (f - FC.loop_from) % FC.loop_len
    local pulse, flash = 1, window(p, 82, 88, 88, 95)
    if p >= 82 and p < 89 then
        pulse = lerp(1.014, 1.097, (p - 82) / 7)
    elseif p >= 89 and p < 96 then
        pulse = lerp(1.083, 1, (p - 89) / 7)
    end

    if f < 44 then
        local rise, white, glow = -15, 1, 1
        if f < 15 then
            local q = f / 15
            rise, white, glow = -15 * ease_out(q), q, q
        elseif f >= 25 and f < 38 then
            local q = (f - 25) / 12
            rise, white, glow = -15 * (1 - q * q), 1 - q, lerp(1, 0.5, q)
        elseif f >= 38 then
            rise, white, glow = 0, 0, lerp(0.42, 0, (f - 38) / 6)
        end
        self:spr("fc_text_flash", x, y + rise, { fade = clamp01(white) })
        self:spr("fc_text_glow", x, y + rise, { fade = clamp01(glow), add = true })
    elseif flash > 0 then
        self:spr("fc_text_flash", x, y, { s = pulse, fade = 0.32 * flash })
        self:spr("fc_text_glow", x, y, { s = pulse, fade = flash, add = true })
    end

    if f < 24 then return end
    local dy, sy = 0, 1
    if f < 38 then
        local q = (f - 24) / 13
        dy = -15 * (1 - q * q)
    elseif f < 41 then
        sy, dy = lerp(0.939, 0.818, (f - 38) / 2), lerp(2.35, 7, (f - 38) / 2)
    elseif f < 44 then
        sy, dy = lerp(0.879, 1, (f - 41) / 2), lerp(4.7, 0, (f - 41) / 2)
    end
    local flicker = 0.8 + 0.2 * (1 - math.abs(2 * (f % 20) / 20 - 1))
    self:spr("fc_text_glow", x, y + dy, { sx = pulse, sy = sy * pulse, fade = flicker, add = true })
    self:spr("fc_text", x, y + dy, { sx = pulse, sy = sy * pulse })
end

function EnsoBattleOverlay:draw_end_banner(ms)
    local t = ms - self.end_banner
    if t < 0 then return end
    local F = FINISH
    local fc = self.full_combo
    cue(self.end_played, true, fc and "se_fc_start" or "se_battle_end")
    cue(self.end_played, t >= 333, fc and "se_fc_banner" or "se_battle_end_banner")
    if fc then cue(self.end_played, t >= 333, "vo_fullcombo", "voice") end
    local copies, band_sx, band_x, band_sy, band_fade = 2, 15.35, 0, 1, 1
    if t < 167 then
        band_sx, band_x, band_fade = lerp(0.108, 15.35, t / 167), lerp(-473, 0, t / 167), t / 167
    elseif t < 1317 then
        band_sy, band_fade = lerp(1, 1.126, (t - 167) / 1150), lerp(1, 0, (t - 167) / 1150)
    elseif t < 1483 then
        copies, band_sy, band_fade = 1, 1.128, lerp(0, 0.9, (t - 1317) / 166)
    else
        band_fade = (1 + math.cos((t - 1483) / 2017 * 2 * math.pi)) / 2
        band_sy = 0.902 + 0.226 * band_fade
    end
    for _ = 1, copies do
        self:spr("boss_win_band", F.x + band_x, F.y, { sx = band_sx, sy = band_sy, fade = band_fade })
    end
    if t >= 83 and t < 733 then
        local sx, sy, x, fade = 1, 0.017, 0, window(t, 83, 167, 517, 733)
        if t < 167 then
            local q = (t - 83) / 84
            sx, sy, x = lerp(0.187, 1, q), lerp(2.533, 0.167, q), lerp(-386, 0, q)
        elseif t < 267 then
            sy = lerp(0.137, 0.017, (t - 183) / 67)
        else
            local q = clamp01((t - 267) / 250)
            sy = lerp(0.047, 3.332, q * q)
        end
        self:spr("boss_win_line", F.x + x, F.y + 2, { sx = sx, sy = sy, fade = fade })
    end
    if t < 333 then return end
    if fc then
        self:draw_fc_text(t - 333)
        return
    end
    local sy = 1
    if t < 517 then
        sy = lerp(0.08, 1.8, (t - 333) / 184)
    elseif t < 683 then
        sy = lerp(1.8, 0.4, (t - 517) / 166)
    elseif t < 733 then
        sy = lerp(0.6, 0.8, (t - 700) / 17)
    end
    self:spr("battle_end_banner", F.x, F.y, { sy = sy, fade = clamp01((t - 333) / 184) })
    local glow = window(t, 333, 517, 517, 733)
    if glow > 0 then self:spr("battle_end_banner", F.x, F.y, { sy = sy, fade = glow, add = true }) end
end

function EnsoBattleOverlay:draw_finish(b, ms)
    local t = ms - b.finish
    if t < 0 then return end
    local F = FINISH
    local fc = self.full_combo
    if fc then cue(b.finish_played, true, "se_boss_fc_start") end
    cue(b.finish_played, t >= 300, "se_boss_sword")
    cue(b.finish_played, t >= F.shatter, "se_boss_break")
    if fc then
        cue(b.finish_played, t >= F.banner, "se_boss_fc_banner")
        cue(b.finish_played, t >= F.banner, "vo_fullcombo", "voice")
    else
        cue(b.finish_played, t >= F.banner + 433, "vo_boss_win", "voice")
    end
    if t >= F.banner then self:draw_win_banner(t - F.banner) end
    if t < 1183 then
        local dx = t < 583 and lerp(-5, 5, t / 583) or (math.floor((t - 583) / 33) % 2 == 0 and -4 or 5)
        self:spr("boss_seal", F.seal_x + dx, F.seal_y, { fade = clamp01(t / 583) })
    elseif t >= F.shatter and t < F.shatter + F.shard_ms then
        local q = (t - F.shatter) / F.shard_ms
        for i, s in ipairs(SHARDS) do
            self:spr("boss_seal_shards", F.seal_x + lerp(s[1], s[3], q), F.seal_y + lerp(s[2], s[4], q), {
                frame = i - 1, s = lerp(1, s[5], q), fade = 1 - q,
            })
        end
    end
    local slash_x, slash_y = F.seal_x + F.slash_dx, F.seal_y + F.slash_dy
    if t >= 300 and t < 517 then
        local fade = t < 333 and (t - 300) / 33 or t < 450 and 0.95 or lerp(0.89, 0, (t - 450) / 67)
        self:spr("boss_seal_slash", slash_x + 10 * (t - 300) / 217, slash_y, { s = 0.732, fade = fade })
    elseif t >= 500 and t < 717 then
        local fade = t < 517 and (t - 500) / 17 or t < 667 and 0.93 or lerp(0.67, 0, (t - 667) / 50)
        self:spr("boss_seal_slash", slash_x, slash_y, { s = 0.74, rot = 45, fade = fade })
    end
end

function EnsoBattleOverlay:draw_bar(key, frac, dy)
    local w, h = self:size(key)
    tex.draw_texture(self:id(key), {
        src = { x = w / S * (1 - frac), y = 0, width = w / S * frac, height = h / S },
        x = w * (1 - frac), y = dy * S, x2 = w * frac - w,
    })
end

function EnsoBattleOverlay:draw_boss_gauge(ms)
    local b, G = self.fight, BOSS_GAUGE
    if b.hp < b.shown then b.bump = ms end
    b.shown = b.hp
    local dy = b.bump and ms - b.bump < G.bump_ms and -2 or 0
    local r, from = b.hp / b.max, b.from / b.max
    tex.draw_texture(self:id("boss_gauge_back"), { y = dy * S })
    self:draw_bar("boss_gauge_lost", from, dy)
    if r > 0 then
        self:draw_bar(r > 2 / 3 and "boss_gauge_high" or r > G.warn and "boss_gauge_mid" or "boss_gauge_low", r, dy)
    end
    tex.draw_texture(self:id("boss_gauge_frame"), { y = dy * S })
    if r < G.critical then
        tex.draw_texture(self:id("boss_gauge_warn"), { y = dy * S })
        local pulse = 0.5 + 0.5 * math.cos(ms / G.critical_ms * 2 * math.pi)
        tex.draw_texture(self:id("boss_gauge_warn_glow"), { y = dy * S, fade = pulse })
    elseif r < G.warn then
        local pulse = 0.5 + 0.5 * math.cos(ms / G.warn_ms * 2 * math.pi)
        tex.draw_texture(self:id("boss_gauge_warn"), { y = dy * S, fade = pulse })
    end
    if from < 1 then
        tex.draw_texture(self:id("boss_gauge_needle"), { x = G.w * (1 - from) * S, y = dy * S })
    end
end

function EnsoBattleOverlay:draw_back(ms)
    local zone = self.fight and self.stage or self.enemy_stage
    tex.draw_texture(self:id(zone.bg), {})
    if self.fight and zone.scenery then
        local sc = zone.scenery
        self:spr(sc[1], sc[2], sc[3], { ax = 0, ay = 0 })
    end
    self:draw_amitie(ms)
    if self.fight then self:draw_boss(ms) end
    for i = #self.fallen, 1, -1 do
        if self:draw_fallen(self.fallen[i], ms) then table.remove(self.fallen, i) end
    end
    local order = {}
    for i, e in ipairs(self.enemies) do order[i] = e end
    table.sort(order, function(a, b) return a.y < b.y end)
    for _, e in ipairs(order) do self:draw_enemy(e, ms) end
    for i = #self.chests, 1, -1 do
        if self:draw_chest(self.chests[i], ms) then table.remove(self.chests, i) end
    end
end

function EnsoBattleOverlay:draw_number(key, value, right, cy, gap, o)
    o = o or {}
    local s = o.s or 1
    local digits = tostring(math.floor(value))
    local step = (self:size(key) / S + gap) * s
    local x = right - step * #digits + step / 2
    for i = 1, #digits do
        local pop = o.pops and o.pops[#digits - i + 1]
        local ds = s
        if pop then ds = s * (1 + 0.4 * (1 - clamp01((o.ms - pop) / DIGIT_POP_MS))) end
        self:spr(key, x, cy, { frame = tonumber(digits:sub(i, i)), s = ds, fade = o.fade })
        x = x + step
    end
end

function EnsoBattleOverlay:draw_damage(ms)
    local n = self.number
    if not n then return end
    local t = ms - n.start
    if t >= NUMBER.life_ms then
        self.number = nil
        return
    end
    local q = clamp01(t / NUMBER.drop_ms)
    local y = NUMBER.y + NUMBER.drop_from + (NUMBER.drop_to - NUMBER.drop_from) * q
    local fade = 0.5 + 0.5 * q
    if t > NUMBER.life_ms - 67 then fade = (NUMBER.life_ms - t) / 67 end
    local half = (self:size(n.key) / S - 4) * #tostring(n.value) / 2
    self:draw_number(n.key, n.value, NUMBER.x + half, y, -4, { fade = fade })
end

function EnsoBattleOverlay:draw_rolls(ms)
    for i = #self.rolls, 1, -1 do
        local r = self.rolls[i]
        local t = ms - r.start
        if t >= ROLL.bg_ms then
            table.remove(self.rolls, i)
        else
            local bg = t < 83 and lerp(0.6, 0.8, t / 83) or t < 417 and 0.8 or lerp(0.71, 0, (t - 417) / 133)
            self:spr("roll_burst", r.x, r.y, { s = ROLL.s, fade = bg })
            if t < ROLL.number_ms then
                local fade = t < 100 and lerp(0.6, 1, t / 100) or t < 350 and 1 or lerp(0.89, 0, (t - 350) / 133)
                local y = r.y
                if r.rise then
                    y = y - (t < 100 and lerp(0, 20.6, t / 100) or t < 350 and 20.6 or lerp(22, 35.6, (t - 350) / 133))
                end
                local half = (self:size("ok_digits") / S - 4) * ROLL.s * #tostring(r.value) / 2
                self:draw_number("ok_digits", r.value, r.x + half, y, -4, { s = ROLL.s, fade = fade })
            end
        end
    end
end

function EnsoBattleOverlay:draw_sparks(ms)
    for i = #self.sparks, 1, -1 do
        local p = self.sparks[i]
        local t = ms - p.start
        if t >= SPARK.fly_ms then
            table.remove(self.sparks, i)
        elseif t >= 0 then
            local q = t / SPARK.fly_ms
            local e = q * q
            local x = p.x + (SPARK.x - p.x) * e
            local y = p.y + (SPARK.y - p.y) * e - p.lift * math.sin(q * math.pi)
            local twinkle = 0.75 + 0.25 * math.sin((ms + p.spin) / 40)
            self:spr(p.small and "kill_sparkle_small" or "kill_sparkle", x, y, {
                s = lerp(1.4, 0.8, q) * twinkle, rot = p.spin + q * 90, fade = math.min(1, t / 80), add = true,
            })
        end
    end
    local puff = self.puff
    if puff then
        local q = (ms - puff.start) / 500
        if q >= 1 then
            self.puff = nil
        else
            self:spr("kill_puff", SPARK.x + 40, SPARK.y, { s = lerp(0.6, 1.2, q), fade = (1 - q) * 0.9, add = true })
        end
    end
end

-- "+N" with its sign: frame 10 of the digit sheet
function EnsoBattleOverlay:draw_add(key, count, x, y, fade, s)
    local w = (self:size(key) / S + KILL_ADD.gap) * s
    self:spr(key, x + w / 2, y, { frame = 10, fade = fade, s = s })
    self:draw_number(key, count, x + w * (1 + #tostring(count)), y, KILL_ADD.gap, { fade = fade, s = s })
end

function EnsoBattleOverlay:draw_best_banner(ms)
    local f = (ms - self.best_banner) / FRAME_MS
    if f >= BEST_BANNER.len then return end
    local x, y = BEST_BANNER.x, BEST_BANNER.y
    if f < BEST_BANNER.slide then
        local q = f / BEST_BANNER.slide
        x, y = lerp(BEST_BANNER.x_off, x, q), lerp(y - 6, y, q)
    elseif f >= BEST_BANNER.out then
        x = lerp(x - 13, BEST_BANNER.x_off - 15, (f - BEST_BANNER.out) / 12)
    end
    local glow = f >= BEST_BANNER.slide and f < BEST_BANNER.out
    local loop = f - BEST_BANNER.slide
    local pulse = 0.5 + 0.5 * math.cos(2 * math.pi * loop / 60)
    if glow then self:spr("kill_puff", BEST_BANNER.x + 2, y - 0.5, { fade = pulse }) end
    local breathe = glow and 1 - 0.055 * (1 - math.cos(2 * math.pi * (loop - 1) / 60)) / 2 or 1
    self:spr("best_banner_cloud", x, y, { s = breathe })
    if glow then
        local drift = loop >= 61 and 5.8 * (1 - math.abs(loop - 91) / 30) or 0
        self:spr("best_banner_glow", BEST_BANNER.x, y - 1 - drift, { fade = pulse })
    end
    self:spr("best_banner_text", x, y)
    if glow then
        local p = loop % 60
        local q = p % 30
        local fade = q < 15 and q / 15 or 0.93 * (1 - (q - 15) / 14)
        self:spr(p < 30 and "kill_sparkle_small" or "kill_sparkle", BEST_BANNER.x + 2, y, { fade = fade })
    end
end

function EnsoBattleOverlay:draw_kill_add(ms)
    local a = self.kill_add
    if not a then return end
    local t = ms - a.start
    if t >= 600 then
        self.kill_add = nil
        return
    end
    local dx, dy, fade = 0, 0, 1
    if t < 83 then
        local q = t / 83
        dx, dy, fade = 10 * (1 - q), 10 * (1 - q), 0.5 + 0.5 * q
    elseif t >= 500 then
        local q = (t - 500) / 100
        dx, dy, fade = -10 * q, 10 * q, 1 - q
    end
    self:draw_add("kill_add_digits", a.count, KILL_ADD.x + dx, KILL_ADD.cy + dy, fade, 1)
end

function EnsoBattleOverlay:draw_skill_add(ms)
    local a = self.skill_add
    if not a then return end
    local t = ms - a.start
    local dx, dy, fade, s = 0, 0, 1, 1
    if t < 117 then
        dx = 30 * (1 - t / 117)
    elseif t < 467 then
        dy = -math.sin((t - 117) / 350 * math.pi) * 1.5
    end
    if a.leaving then
        local q = (ms - a.leaving) / 150
        if q >= 1 then
            self.skill_add = nil
            return
        end
        dx, s, fade = -46 * q, 0.94 - 0.52 * q, 1 - q
    end
    self:draw_add("kill_skill_digits", a.count, KILL_ADD.x + dx, KILL_ADD.cy + dy, fade, s)
end

function EnsoBattleOverlay:draw_lane_hit(h, ms)
    local q = (ms - h.start) / LANE_HIT_MS
    if q >= 1 then return true end
    self:spr(h.key, self.judge.x, self.judge.y, { s = 0.8 + 0.4 * q, fade = 1 - q, add = true })
    if h.critical then
        self:spr("hit_critical_rays", self.judge.x, self.judge.y, {
            s = 0.9 + 0.5 * q, rot = 20 * q, fade = 1 - q, add = true,
        })
    end
    return false
end

function EnsoBattleOverlay:draw_gauge(ms)
    tex.draw_texture(self:id("skill_gauge_bubble"), {})
    local w = GAUGE_FILL_WIDTH * S
    if self.fill > 0 then
        tex.draw_texture(self:id("skill_gauge_fill"), { x2 = w * (self.fill - 1) })
    end
    tex.draw_texture(self:id("skill_gauge_frame"), {})
    if self.fill >= 1 then
        local pulse = 0.5 + 0.5 * math.sin(ms / 120)
        tex.draw_texture(self:id("skill_gauge_full"), { fade = pulse, blend = "additive" })
        tex.draw_texture(self:id("skill_gauge_glow"), { frame = math.floor(ms / 50) % 5, blend = "additive" })
    end
end

local SPIRIT_SABER = { start = "slash_start", main = "slash", glow = "slash_glow", delay = 0, dx = 0 }

function EnsoBattleOverlay:draw_slash(t, keys)
    local f = (t - SLASH_AT) / FRAME_MS - keys.delay
    if f < 0 then return end
    local drift = 36 * clamp01((f - 4) / 56)
    local master = clamp01(f / 3) * lerp(1, 0.8, (f - 4) / 56) * (1 - clamp01((f - 57) / 17))
    local x, cx = SLASH.x + drift, SLASH.cx + drift + keys.dx
    if f < 6 then
        self:spr("slash_blur", cx - 179, SLASH.cy - 72, { s = 1.746, rot = -4, fade = 0.91 * (1 - f / 6), add = true })
    end
    if f < 8 then
        self:spr(keys.start, x, SLASH.y, { ax = 0, ay = 0, s = SLASH.s, fade = master * lerp(0, 0.75, f / 3) })
    end
    if f >= 4 and f < 26 then
        local q = (f - 4) / 22
        self:spr(keys.glow, cx, SLASH.cy, {
            s = SLASH.s * lerp(1, 1.134, q), fade = master * 0.5 * (1 - q), add = true,
        })
    end
    if f >= 8 and f < 30 then
        local q = (f - 8) / 22
        self:spr(keys.glow, cx, SLASH.cy, {
            s = SLASH.s * lerp(1, 1.223, q), fade = master * 0.2 * (1 - q), add = true,
        })
    end
    if f >= 4 and f < 68 then
        local fade = f < 50 and 1 or lerp(0.97, 0.34, (f - 50) / 18)
        self:spr(keys.main, x, SLASH.y, { ax = 0, ay = 0, s = SLASH.s, fade = master * fade })
    end
end

function EnsoBattleOverlay:draw_cutin(ms)
    if not self.skill then return end
    local t = ms - self.skill.start
    if t >= CUTIN_MS then
        self.skill = nil
        return
    end
    local sk = self.skill
    local move = sk.move
    local f = t / FRAME_MS + 4
    if sk.skill == 1 then
        if t >= CUTIN_IN and not sk.swung then
            sk.swung = true
            play("se_slash")
        end
        if t >= SLASH_AT and not sk.slashed then
            sk.slashed = true
            play("se_slash_hit")
        end
    end
    for i, cue in ipairs(move.sounds or {}) do
        if f >= cue[1] and not sk.played[i] then
            sk.played[i] = true
            play(cue[2])
        end
    end
    if t < CUTIN_IN + 100 then
        local veil = math.min(t / 300, 1) * (1 - clamp01((t - CUTIN_IN) / 100))
        tex.draw_rect(0, 360 * S, 1280 * S, 360 * S, 255, 255, 255, math.floor(90 * veil))
        self:spr("cutin_band", 0, 350, { ax = 0, ay = 0, sx = lerp(0.05, 0.2, t / CUTIN_IN), fade = veil, add = true })
    end
    local out = clamp01((t - CUTIN_OUT) / 300)
    local fade = 1 - out
    if move.back then move.back(self, f) end
    if t < CUTIN_IN then return end
    local band = sk.skill - 1
    local band_x = lerp(-1021, -279, (t - CUTIN_IN) / 100)
    local band_sx = lerp(0.859, 1, out)
    local swap = 0.5 + 0.5 * math.sin(t / 1200 * 2 * math.pi)
    self:spr("cutin_band", band_x, 350, { ax = 0, ay = 0, sx = band_sx, frame = band, fade = fade })
    self:spr("cutin_band", band_x, 350, { ax = 0, ay = 0, sx = band_sx, frame = band, fade = fade * (1 - swap) })
    self:spr("cutin_band_alt", band_x, 350, { ax = 0, ay = 0, sx = band_sx, frame = band, fade = fade * swap })

    local lines_x = t < CUTIN_OUT and lerp(-651, -241, (t - 517) / 67) or lerp(-241, -172, out)
    local lines_fade = window(t, 517, 583, CUTIN_OUT, CUTIN_MS) * 0.5
    local alt = math.floor(t / (3 * FRAME_MS)) % 2 == 0
    self:spr(alt and "cutin_lines" or "cutin_lines_alt", lines_x, 350, { ax = 0, ay = 0, fade = lines_fade })

    local p = t - CUTIN_IN
    local amitie_x = -289 - 15 * (1 - clamp01(p / 1617)) - 797 * math.exp(-p / 68)
    if move.mid then move.mid(self, f) end
    if move.portrait then
        move.portrait(self, f, amitie_x, fade)
    else
        self:spr("cutin_amitie", amitie_x, 350, { ax = 0, ay = 0, fade = fade })
    end
    if sk.skill == 1 or move.slash then self:draw_slash(t, move.slash or SPIRIT_SABER) end
    if move.front then move.front(self, f) end
end

-- the counter's glows: in, dip, back up, out over 100 frames
local function count_glow(t)
    local g = t < 11 and t / 10 or t < 32 and lerp(0.98, 0.65, (t - 11) / 20)
        or t < 52 and lerp(0.67, 1, (t - 32) / 19) or lerp(0.98, 0, (t - 52) / 47)
    return clamp01(g)
end

-- one badge: the count, popping 1.5 -> 1 with a fading glow and a widening ring when it goes up
function EnsoBattleOverlay:draw_chest_badge(key, n, y, bump, ms)
    local C = CHEST_COUNT
    local t = bump and (ms - bump) / FRAME_MS
    local s = 1
    if t and t < 9 then s = t < 5 and lerp(1, 1.5, t / 4) or lerp(1.375, 1, (t - 5) / 3) end
    if t and t < 110 then
        self:spr("chest_count_glow", C.badge_x, y, { fade = count_glow(t) })
    end
    self:spr(key, C.badge_x, y, { s = s })
    self:spr("chest_count_digits", C.badge_x, y, { s = s, frame = math.min(n, 6) })
    if t and t < 9 then self:spr("chest_count_ring", C.badge_x, y, { s = lerp(1, 2.083, t / 8), fade = 1 - t / 8 }) end
end

function EnsoBattleOverlay:draw_chest_count(ms)
    local C, cc = CHEST_COUNT, self.chest_count
    local n, orbs, last, last_orb = 0, 0, nil, nil
    for _, b in ipairs(cc.bumps) do
        if ms >= b.at then
            if b.orbs then orbs, last_orb = orbs + 1, b.at else n, last = n + 1, b.at end
        end
    end
    local latest = math.max(last or -1e9, last_orb or -1e9)
    local t = (ms - latest) / FRAME_MS
    local s = 1
    if t >= 0 and t < 11 then s = t < 4 and lerp(1.034, 1.136, t / 3) or lerp(1.114, 1, (t - 4) / 6) end
    if t >= 0 and t < 100 then
        self:spr("chest_count_icon_glow", C.x, C.y, { fade = count_glow(t) })
    end
    self:spr("chest_count_icon", C.x, C.y, { s = s })
    if t >= 0 and t < 14 then
        local k = t < 4 and lerp(0.364, 1, t / 3) or lerp(1.036, 1.364, (t - 4) / 9)
        local fade = t < 4 and t / 3 or 0.9 * (1 - (t - 4) / 9)
        self:spr("chest_count_sparkle", C.badge_x, C.badge_y - 2, { s = k, fade = fade })
    end
    self:draw_chest_badge("chest_count_badge", n, C.badge_y, last, ms)
    if cc.orbs then self:draw_chest_badge("chest_count_orb_badge", orbs, C.orb_y, last_orb, ms) end
end

function EnsoBattleOverlay:draw_front(ms)
    self:draw_intercept(ms)
    self:draw_chest_count(ms)
    for i = #self.lane_hits, 1, -1 do
        if self:draw_lane_hit(self.lane_hits[i], ms) then table.remove(self.lane_hits, i) end
    end
    self:draw_damage(ms)
    self:draw_rolls(ms)
    self:tick_counters(ms)
    if self.fight then
        self:draw_boss_gauge(ms)
    else
        tex.draw_texture(self:id("kill_panel"), {})
        local kills = self.kill_count
        self:draw_number("kill_digits", kills.shown, KILL_DIGITS.right, KILL_DIGITS.cy, KILL_DIGITS.gap,
            { pops = kills.pops, ms = ms })
        if self.skill_add then self:draw_skill_add(ms) else self:draw_kill_add(ms) end
        self:draw_sparks(ms)
    end
    if self.fight and self.fight.finish then self:draw_finish(self.fight, ms) end
    if self.end_banner then self:draw_end_banner(ms) end
    tex.draw_texture(self:id("power_panel"), {})
    self:draw_number("power_digits", self.power, POWER_DIGITS.right, POWER_DIGITS.cy, POWER_DIGITS.gap,
        { pops = self.power_count.pops, ms = ms })
    if self.best_power and not self.best_banner and self.power > self.best_power then self.best_banner = ms end
    if self.best_banner then self:draw_best_banner(ms) end
    self:draw_gauge(ms)
end