forked from Yonokid/PyTaikoGreen
471 lines
18 KiB
Lua
471 lines
18 KiB
Lua
AISectionBoard = {}
|
|
AISectionBoard.__index = AISectionBoard
|
|
|
|
local S = tex.get_screen_scale()
|
|
local FRAME_MS = 1000 / 60
|
|
|
|
local SECTION_END_WAIT, TOTAL_WAIT = 60, 60
|
|
local PLAYER_WAIT, DETAIL_WAIT = 600, 1200
|
|
local BADGE_FIRST_WAIT, BADGE_CHALLENGE_WAIT, BADGE_UNMET_WAIT = 60, 90, 60
|
|
local VOICE_WAIT, TOKEN_WAIT, WIN_WAIT = 60, 120, 210
|
|
local TOKEN_STEP, COUNT_FRAMES = 15, 30
|
|
local BOARD_FADE = 10
|
|
|
|
local RANK_MAX = 11
|
|
local LOGO_X, LOGO_DETAIL_X, LOGO_Y = 889, 1089, 502
|
|
|
|
local SIMPLE = {
|
|
[3] = { x = { 300, 428, 556 }, y = { 485, 539, 485 } },
|
|
[5] = { x = { 116, 244, 372, 500, 628 }, y = { 485, 539, 485, 539, 485 } },
|
|
}
|
|
local DETAIL = {
|
|
[3] = { x = { 322, 510.5, 699 }, y = { 510, 528, 510 } },
|
|
[5] = { x = { 168, 328, 488, 648, 808 }, y = { 510, 536, 510, 536, 510 } },
|
|
}
|
|
local ROW_COUNT_Y = { -1, 32, 65, 99 }
|
|
local ROW_DIFF_Y = { 0, 33, 66, 99 }
|
|
local ROW_KEYS = { "good", "ok", "bad", "drumroll" }
|
|
|
|
local function clamp01(v) return math.max(0, math.min(1, v)) end
|
|
local function ramp(t, at, len) return clamp01((t - at) / len) end
|
|
local function lerp(a, b, u) return a + (b - a) * u end
|
|
|
|
local function play(name)
|
|
if audio.has_sound(name) then audio.play_sound(name, name:find("^vo_") and "voice" or "sound") end
|
|
end
|
|
|
|
local function beats_best(now, best)
|
|
if now.good ~= best.good then return now.good > best.good end
|
|
if now.ok ~= best.ok then return now.ok > best.ok end
|
|
if now.bad ~= best.bad then return now.bad < best.bad end
|
|
return now.drumroll > best.drumroll
|
|
end
|
|
local function no_best(best)
|
|
return not best or (best.good == 0 and best.ok == 0 and best.bad == 0 and best.drumroll == 0)
|
|
end
|
|
|
|
function AISectionBoard.new(data)
|
|
local self = setmetatable({}, AISectionBoard)
|
|
self.sizes, self.ids = {}, {}
|
|
self.sections = data.sections
|
|
self.count = #data.sections
|
|
self.won = data.won
|
|
self.f = 0
|
|
self.started = false
|
|
tex.load_folder("ai_section_result", "ai_background")
|
|
tex.load_folder("ai_section_result", "ai_board")
|
|
if audio.has_sound("ai_bgm") then audio.play_sound("ai_bgm", "music") end
|
|
return self
|
|
end
|
|
|
|
function AISectionBoard:begin(progress)
|
|
self.progress = progress
|
|
self.first_play = progress == nil
|
|
if progress then
|
|
for i, section in ipairs(self.sections) do
|
|
section.best = progress.bests[i]
|
|
self.first_play = self.first_play or no_best(section.best)
|
|
end
|
|
end
|
|
self.best_updated = {}
|
|
for i, section in ipairs(self.sections) do
|
|
self.best_updated[i] = not self.first_play and beats_best(section, section.best)
|
|
end
|
|
self.start_ms = nil
|
|
self.f = 0
|
|
self.played = {}
|
|
self.total_at = self:simple_end()
|
|
self.rank_at = self.total_at + TOTAL_WAIT
|
|
self.rank_events = self:rank_schedule()
|
|
self.wait_at = self.rank_at + self.rank_events.finish
|
|
self.mode = "simple"
|
|
self.mode_at = 0
|
|
self.leaving = false
|
|
self.detail_seen_at = nil
|
|
self.deadline = self.wait_at + PLAYER_WAIT
|
|
self.started = true
|
|
play("vo_call")
|
|
end
|
|
|
|
function AISectionBoard:simple_end()
|
|
return 15 + SECTION_END_WAIT
|
|
end
|
|
|
|
function AISectionBoard:rank_schedule()
|
|
local p = self.progress
|
|
local events = { finish = 0 }
|
|
if not p or not self.won then return events end
|
|
local t = 0
|
|
if p.tokens_after ~= p.tokens_before and p.rank_before < RANK_MAX then
|
|
if p.challenge then
|
|
t = t + BADGE_CHALLENGE_WAIT
|
|
events.challenge = t
|
|
end
|
|
if p.first then
|
|
t = t + BADGE_FIRST_WAIT
|
|
events.first = t
|
|
end
|
|
t = t + VOICE_WAIT
|
|
if p.first or p.challenge then events.voice = t end
|
|
t = t + TOKEN_WAIT
|
|
events.tokens = t
|
|
t = t + (p.tokens_after - p.tokens_before) * TOKEN_STEP
|
|
events.tokens_end = t
|
|
elseif not p.fulfilled and p.rank_before < RANK_MAX then
|
|
t = t + BADGE_UNMET_WAIT
|
|
events.unmet = t
|
|
end
|
|
t = t + WIN_WAIT
|
|
events.wins = t
|
|
events.finish = t + COUNT_FRAMES
|
|
return events
|
|
end
|
|
|
|
function AISectionBoard:skip_reveal()
|
|
if self.f < self.wait_at then
|
|
self.f = self.wait_at
|
|
self.start_ms = self.now_ms - self.f * FRAME_MS
|
|
for _, key in ipairs({ "popup", "marks", "logo", "challenge", "first", "unmet", "voice" }) do
|
|
self.played[key] = true
|
|
end
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function AISectionBoard:decide()
|
|
if self.leaving then return false end
|
|
if self:skip_reveal() then return true end
|
|
if self.mode == "detail" and self.f < self.mode_at + self:detail_length() then
|
|
self.mode_at = self.f - self:detail_length()
|
|
return true
|
|
end
|
|
self.leaving = true
|
|
return true
|
|
end
|
|
|
|
function AISectionBoard:toggle()
|
|
if self.leaving or self.f < self.wait_at then return false end
|
|
self.mode = self.mode == "simple" and "detail" or "simple"
|
|
self.mode_at = self.f
|
|
self.deadline = self.f + DETAIL_WAIT
|
|
return true
|
|
end
|
|
|
|
function AISectionBoard:detail_length()
|
|
return BOARD_FADE + 2 * COUNT_FRAMES + 20
|
|
end
|
|
|
|
function AISectionBoard:once(key, at)
|
|
if not self.played[key] and self.f >= at then
|
|
self.played[key] = true
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
function AISectionBoard:update(ms)
|
|
self.now_ms = ms
|
|
if not self.started then return end
|
|
self.start_ms = self.start_ms or ms
|
|
self.f = (ms - self.start_ms) / FRAME_MS
|
|
if self:once("popup", 5) then play("se_popup") end
|
|
if self:once("marks", 7) then play("se_section_mark") end
|
|
if self:once("logo", self.total_at) then play(self.won and "se_logo_win" or "se_logo_lose") end
|
|
|
|
local e, rank_t = self.rank_events, self.rank_at
|
|
if e.challenge and self:once("challenge", rank_t + e.challenge) then play("se_badge") end
|
|
if e.first and self:once("first", rank_t + e.first) then
|
|
play("se_badge")
|
|
if e.challenge then play("se_badge_add") end
|
|
end
|
|
if e.unmet and self:once("unmet", rank_t + e.unmet) then play("se_badge") end
|
|
if e.voice and self:once("voice", rank_t + e.voice) then play("vo_bonus") end
|
|
if e.tokens then
|
|
local steps = math.floor((self.f - rank_t - e.tokens) / TOKEN_STEP)
|
|
if steps >= 0 and steps < self.progress.tokens_after - self.progress.tokens_before
|
|
and self:once("token" .. steps, rank_t + e.tokens + steps * TOKEN_STEP) then
|
|
play("se_count")
|
|
end
|
|
end
|
|
if self:rankup() and e.tokens_end then
|
|
if self:once("rankup", rank_t + e.tokens_end) then play("se_rankup_panel") end
|
|
if self:once("rankup_shine", rank_t + e.tokens_end + 65) then play("se_rankup_shine") end
|
|
end
|
|
if e.wins and self:once("wins", rank_t + e.wins) then play("se_win_count") end
|
|
|
|
if self.mode == "detail" and not self.detail_seen_at then self.detail_seen_at = self.mode_at end
|
|
if self.mode == "detail" then
|
|
local t = self.f - self.mode_at
|
|
if t >= BOARD_FADE and t < BOARD_FADE + COUNT_FRAMES and self:once("detail_count", self.mode_at + BOARD_FADE) then
|
|
play("se_count")
|
|
end
|
|
if not self.first_play then
|
|
for _, updated in ipairs(self.best_updated) do
|
|
if updated and self:once("best", self.mode_at + BOARD_FADE + 2 * COUNT_FRAMES) then play("se_best") end
|
|
end
|
|
end
|
|
end
|
|
if self.f >= self.deadline then self.leaving = true end
|
|
end
|
|
|
|
function AISectionBoard:rankup()
|
|
local p = self.progress
|
|
return p and p.next_rank_tokens >= 0 and p.tokens_after >= p.next_rank_tokens
|
|
end
|
|
|
|
function AISectionBoard:is_done()
|
|
return self.leaving
|
|
end
|
|
|
|
function AISectionBoard:put(folder, key, cx, cy, o)
|
|
o = o or {}
|
|
local path = folder .. "/" .. key
|
|
local id = self.ids[path]
|
|
if id == nil then
|
|
id = tex.get_texture("ai_section_result/" .. path)
|
|
self.ids[path] = id
|
|
self.sizes[path] = tex.get_texture_info(folder, key)
|
|
end
|
|
local info = self.sizes[path]
|
|
if not info then return end
|
|
local sx, sy = o.sx or o.s or 1, o.sy or o.s or 1
|
|
local w, h = info.width * S, info.height * S
|
|
tex.draw_texture(id, {
|
|
x = cx * S, y = cy * S,
|
|
x2 = w * (sx - 1), y2 = h * (sy - 1),
|
|
origin = { w * sx * 0.5, h * sy * 0.5 },
|
|
rotation = o.rot or 0,
|
|
fade = o.fade or 1,
|
|
frame = o.frame or 0,
|
|
mirror = o.mirror,
|
|
blend = o.add and "additive" or nil,
|
|
})
|
|
end
|
|
|
|
function AISectionBoard:board(key, cx, cy, o)
|
|
self:put("ai_board", key, cx, cy, o)
|
|
end
|
|
|
|
function AISectionBoard:draw_background()
|
|
self.bg_start = self.bg_start or self.now_ms or 0
|
|
local f = ((self.now_ms or 0) - self.bg_start) / FRAME_MS
|
|
local bg = "ai_background"
|
|
if self.won then
|
|
self:put(bg, "gradient_win", 640, 360, { sx = 160 })
|
|
for k = 0, 1 do
|
|
local u = ((f * 1.35 + k * 425) % 850) / 850
|
|
self:put(bg, "pattern", 640, 844 - u * 850, {
|
|
fade = 0.13 * math.sin(math.pi * u), add = true, mirror = k == 0 and "horizontal" or nil,
|
|
})
|
|
end
|
|
for k = 0, 2 do
|
|
local u = ((f * 0.5 + k * 280) % 840) / 840
|
|
self:put(bg, "triangle", 300 + k * 340, 800 - u * 880, { rot = f * 1.7 + k * 120, fade = 0.4 })
|
|
end
|
|
else
|
|
self:put(bg, "gradient_lose", 640, 360, { sx = 160 })
|
|
for k = 0, 2 do
|
|
local u = ((f * 1.55 + k * 640) % 1920) / 1920
|
|
self:put(bg, "pattern", -320 + u * 1920, 364, { fade = 0.13 * math.sin(math.pi * u), add = true })
|
|
end
|
|
end
|
|
end
|
|
|
|
function AISectionBoard:draw_simple(fade)
|
|
local layout = SIMPLE[self.count]
|
|
if not layout or fade <= 0 then return end
|
|
local t = self.f
|
|
for i, section in ipairs(self.sections) do
|
|
local x, y = layout.x[i], layout.y[i]
|
|
self:board("section_back", x, y, { fade = fade })
|
|
self:board("section_back_top", x, y, { fade = fade })
|
|
if section.won then
|
|
local s = t < 7 and 1 or t < 10 and lerp(0.95, 1.05, ramp(t, 7, 3)) or t < 13 and lerp(1.05, 1, ramp(t, 10, 3)) or 1
|
|
self:board("section_win", x, y, { s = s, fade = fade * ramp(t, 5, 1) })
|
|
if t >= 7 and t < 17 then
|
|
self:board("section_flash", x, y, { s = lerp(1, 1.5, ramp(t, 7, 10)), fade = fade * (1 - ramp(t, 7, 10)) })
|
|
end
|
|
else
|
|
self:board("section_lose", x, y, { fade = fade * ramp(t, 5, 8) })
|
|
end
|
|
self:board("section_name", x - 2, y - 73, { frame = i - 1, fade = fade * ramp(t, 5, 1) })
|
|
end
|
|
end
|
|
|
|
-- Right aligned digits; slots step left from the anchor.
|
|
function AISectionBoard:draw_number(key, value, right_x, y, step, fade)
|
|
value = math.max(0, math.floor(value))
|
|
local x = right_x
|
|
repeat
|
|
self:board(key, x, y, { frame = value % 10, fade = fade })
|
|
value = value // 10
|
|
x = x - step
|
|
until value == 0
|
|
end
|
|
|
|
function AISectionBoard:draw_detail(fade)
|
|
local layout = DETAIL[self.count]
|
|
if not layout or fade <= 0 then return end
|
|
local t = self.f - self.mode_at - BOARD_FADE
|
|
local count_u = ramp(t, 0, COUNT_FRAMES)
|
|
local diff_u = ramp(t, COUNT_FRAMES, COUNT_FRAMES)
|
|
for i, section in ipairs(self.sections) do
|
|
local x, y = layout.x[i], layout.y[i]
|
|
self:board("detail_panel", x, y, { fade = fade })
|
|
self:board(section.won and "detail_win" or "detail_lose", x + 37, y - 76, { fade = fade })
|
|
self:board("section_name", x - 38, y - 76, { frame = i - 1, fade = fade })
|
|
for row, key in ipairs(ROW_KEYS) do
|
|
self:draw_number("digits_count", section[key] * count_u, x + 20, y - 2 + ROW_COUNT_Y[row], 17, fade)
|
|
if not self.first_play and diff_u > 0 then
|
|
local diff = section[key] - section.best[key]
|
|
local sign = diff > 0 and "sign_plus" or diff < 0 and "sign_minus" or "sign_even"
|
|
self:board(sign, x + 36, y - 2 + ROW_DIFF_Y[row], { fade = fade * diff_u })
|
|
self:draw_number("digits_diff", math.abs(diff) * diff_u, x + 65, y - 2 + ROW_DIFF_Y[row], 10, fade * diff_u)
|
|
end
|
|
end
|
|
if self.best_updated[i] then
|
|
local best_fade = ramp(t, 2 * COUNT_FRAMES, 10)
|
|
if best_fade > 0 then self:board("best_updated", x, y - 33, { fade = fade * best_fade }) end
|
|
end
|
|
end
|
|
end
|
|
|
|
function AISectionBoard:draw_logo(x, fade)
|
|
if fade <= 0 then return end
|
|
local t = self.f - self.total_at
|
|
local y = LOGO_Y
|
|
if self.won then
|
|
local pulse = t < 14 and 1.087 or lerp(1.087, 0.725, math.abs(((t - 14) % 118) / 59 - 1))
|
|
self:board("win_glow", x, y, { s = pulse, fade = fade * ramp(t, 2, 12) })
|
|
if t >= 14 then
|
|
self:board("win_ring_glow", x, y, { add = true, fade = fade * lerp(0.2, 1, math.abs(((t - 14) % 118) / 59 - 1)) })
|
|
end
|
|
if t >= 9 then
|
|
self:board("win_laurel", x, y, { s = lerp(1.268, 1, ramp(t, 9, 5)), fade = fade * ramp(t, 9, 5) })
|
|
self:board("win_rays", x, y, { s = 0.85, rot = t * 3, add = true, fade = fade * 0.3 * ramp(t, 9, 5) })
|
|
end
|
|
if t >= 9 and t < 14 then
|
|
self:board("win_flash", x, y, { s = lerp(1.087, 1.812, ramp(t, 9, 5)), fade = fade * (1 - ramp(t, 9, 5)) })
|
|
end
|
|
for k, key in ipairs({ "triangle_yellow", "triangle_pale", "triangle_purple", "triangle_pink", "triangle_white" }) do
|
|
local u = ramp(t, 23 + k * 2, 22)
|
|
if u > 0 and u < 1 then
|
|
local a = (k * 72) * math.pi / 180
|
|
self:board(key, x + math.cos(a) * 170 * u, y + math.sin(a) * 170 * u, { rot = t * 8, fade = fade * (1 - u) })
|
|
end
|
|
end
|
|
local logo_s = t < 6 and lerp(1, 2, ramp(t, 0, 6)) or lerp(1.772, 1, ramp(t, 6, 8))
|
|
self:board("logo_win", x, y, { s = logo_s, fade = fade * ramp(t, 0, 5) })
|
|
for k, spot in ipairs({ { 156, -107 }, { -167, 121 }, { -11, -159 }, { 140, 136 } }) do
|
|
local at = 29 + (k - 1) * 15
|
|
if t >= at then
|
|
local u = ((t - at) % 170) / 60
|
|
if u < 1 then self:board("sparkle", x + spot[1], y + spot[2], { fade = fade * math.sin(math.pi * u) }) end
|
|
end
|
|
end
|
|
else
|
|
if t < 13 then
|
|
self:board("lose_burst", x, y, { s = lerp(0.145, 1.8, ramp(t, 0, 12)), fade = fade * (1 - ramp(t, 6, 6)) })
|
|
end
|
|
local show = fade * ramp(t, 6, 7)
|
|
self:board("lose_disc", x, y, { fade = show })
|
|
self:board("lose_ring", x, y, { rot = -t * 0.75, fade = show })
|
|
self:board("lose_ring_thin", x, y, { rot = t * 0.75, fade = show })
|
|
self:board("logo_lose", x, y, { fade = show })
|
|
end
|
|
end
|
|
|
|
function AISectionBoard:draw_rank(fade)
|
|
local p = self.progress
|
|
if not p or fade <= 0 then return end
|
|
local e, t = self.rank_events, self.f - self.rank_at
|
|
local rankup = self:rankup() and e.tokens_end and t >= e.tokens_end
|
|
local rank = rankup and p.rank_after or p.rank_before
|
|
|
|
if rank >= RANK_MAX then
|
|
self:board("rank_panel_max", 1159, 440, { fade = fade })
|
|
else
|
|
self:board("rank_panel", 1159, 440, { fade = fade })
|
|
self:draw_number("digits_rank", rank, 1214 + (rank >= 10 and 17 or 0), 424, 35, fade)
|
|
if p.next_rank_tokens >= 0 then
|
|
local tokens = p.tokens_before
|
|
if e.tokens and t >= e.tokens then
|
|
tokens = math.min(p.tokens_after, p.tokens_before + math.floor((t - e.tokens) / TOKEN_STEP) + 1)
|
|
end
|
|
self:draw_number("digits_count", math.max(0, p.next_rank_tokens - tokens), 1201, 459, 17, fade)
|
|
end
|
|
end
|
|
|
|
local wins = p.wins_before
|
|
if e.wins and t >= e.wins then wins = lerp(p.wins_before, p.wins_after, ramp(t, e.wins, COUNT_FRAMES)) end
|
|
local to_next = p.next_reward_wins >= 0 and p.next_reward_wins - math.floor(wins) or nil
|
|
self:board(to_next and "wins_panel_next" or "wins_panel", 1160, 522, { fade = fade })
|
|
self:draw_number("digits_wins", wins, 1244, 508, 17, fade)
|
|
if to_next then self:draw_number("digits_count", to_next, 1218, 543, 17, fade) end
|
|
if e.wins and p.reward_kind ~= "" and t >= e.wins + COUNT_FRAMES then
|
|
local r = t - e.wins - COUNT_FRAMES
|
|
self:board("reward_text", 1160, 522, { s = r < 10 and lerp(1.5, 1, ramp(r, 0, 10)) or 1, fade = fade * ramp(r, 0, 10) })
|
|
end
|
|
|
|
local slide = function(at) return lerp(225, 0, ramp(t, at + 1, 6)), lerp(0.5, 1, ramp(t, at + 1, 6)) end
|
|
if e.challenge and t >= e.challenge then
|
|
local dx, a = slide(e.challenge)
|
|
self:board("badge_challenge", 1150 + dx, 379, { fade = fade * a })
|
|
end
|
|
if e.unmet and t >= e.unmet then
|
|
local dx, a = slide(e.unmet)
|
|
self:board("badge_unmet", 1150 + dx, 379, { fade = fade * a })
|
|
end
|
|
if e.first and t >= e.first then
|
|
local dx, a = slide(e.first)
|
|
self:board("badge_first", 1171 + dx, p.challenge and 345 or 383, { fade = fade * a })
|
|
end
|
|
if rankup then
|
|
local r = t - e.tokens_end - 65
|
|
if r >= 0 then
|
|
local s = r < 10 and lerp(1, 1.5, ramp(r, 0, 10)) or r < 14 and lerp(1.375, 1, ramp(r, 10, 4)) or 1
|
|
local a = ramp(r, 0, 10) * fade
|
|
self:board("rankup_glow", 1160, 440, { s = s + (r >= 14 and 0.02 * math.sin(r / 11) or 0), fade = a })
|
|
self:board("rankup_text", 1160, 440, { s = s, fade = a })
|
|
end
|
|
end
|
|
end
|
|
|
|
function AISectionBoard:draw_hints()
|
|
local t = self.f % 120
|
|
local simple = self.mode == "simple"
|
|
self:board("hint_end", 1169, 687)
|
|
self:board(simple and "hint_detail" or "hint_back", 930, 687)
|
|
self:board("drum", 810, 688)
|
|
self:board("drum", 1053, 688)
|
|
local rim = t < 60 and 1 - math.abs(t / 30 - 1) or 0
|
|
self:board("drum_rim", 798, 688, { fade = rim })
|
|
self:board("drum_rim", 822, 688, { fade = rim, mirror = "horizontal" })
|
|
local arrow = t < 60 and 1 - t / 60 or 0
|
|
self:board("drum_arrow", 783 - 7 * (1 - arrow), 688, { fade = arrow })
|
|
self:board("drum_arrow", 837 + 7 * (1 - arrow), 688, { fade = arrow, mirror = "horizontal" })
|
|
self:board("drum_center", 1053, 688, { fade = rim })
|
|
end
|
|
|
|
function AISectionBoard:draw()
|
|
if not self.started then return end
|
|
local since = self.f - self.mode_at
|
|
local detail = self.mode == "detail"
|
|
local logo_u = ramp(self.f - self.total_at, 1, 8)
|
|
if detail then
|
|
local out = 1 - ramp(since, 0, 4)
|
|
self:draw_simple(out)
|
|
self:draw_rank(out)
|
|
self:draw_logo(LOGO_X, logo_u * out)
|
|
self:draw_logo(LOGO_DETAIL_X, ramp(since, 2, 7))
|
|
self:draw_detail(ramp(since, 1, BOARD_FADE))
|
|
else
|
|
local back = self.detail_seen_at and ramp(since, 0, 4) or 1
|
|
self:draw_simple(back)
|
|
self:draw_rank(back)
|
|
self:draw_logo(LOGO_X, math.min(logo_u, back))
|
|
end
|
|
if self.f >= self.wait_at then self:draw_hints() end
|
|
end
|