276 lines
10 KiB
Lua
276 lines
10 KiB
Lua
Entry = {}
|
|
Entry.__index = Entry
|
|
|
|
function Entry.new()
|
|
local self = setmetatable({}, Entry)
|
|
__hss_entry_reset = true
|
|
|
|
self.bg_flicker = tex.get_animation(1, "entry")
|
|
self.side_select_fade = tex.get_animation(0, "entry")
|
|
self.bg_flicker:start()
|
|
|
|
self.text_cancel = text.create_text("entry_cancel", { 255, 255, 255, 255 }, { 40, 24, 12, 255 }, false, 3, 0)
|
|
self.text_credit_p = {
|
|
text.create_text("entry_credit_1p", { 0, 0, 0, 255 }, { 255, 255, 255, 255 }, false, 7.0 / tex.get_screen_scale(), 0),
|
|
text.create_text("entry_credit_2p", { 0, 0, 0, 255 }, { 255, 255, 255, 255 }, false, 7.0 / tex.get_screen_scale(), 0),
|
|
}
|
|
local CREDIT_BORDER = 7.0 / tex.get_screen_scale()
|
|
self.text_credit_msg = text.create_text("entry_credit_start", { 255, 255, 255, 255 }, { 0, 0, 0, 255 }, false, CREDIT_BORDER, 0)
|
|
self.text_credit_msg_hl = text.create_text("entry_credit_start", { 255, 255, 255, 255 }, { 255, 236, 67, 255 }, false, CREDIT_BORDER, 0)
|
|
|
|
self.bg_bg = tex.get_texture("entry/background/bg")
|
|
self.bg_tower = tex.get_texture("entry/background/tower")
|
|
self.bg_shops_center = tex.get_texture("entry/background/shops_center")
|
|
self.bg_people = tex.get_texture("entry/background/people")
|
|
self.bg_shops_left = tex.get_texture("entry/background/shops_left")
|
|
self.bg_shops_right = tex.get_texture("entry/background/shops_right")
|
|
self.bg_lights = tex.get_texture("entry/background/lights")
|
|
|
|
self.bg_street_lit = tex.get_texture("entry/background/street_lit")
|
|
self.bg_glow = tex.get_texture("entry/background/glow")
|
|
self.bg_twinkle = tex.get_texture("entry/background/twinkle")
|
|
self.bg_t0 = tex.get_current_ms()
|
|
|
|
self.cr_pill = tex.get_texture("entry/side_select/credit_pill")
|
|
self.cr_flash = tex.get_texture("entry/side_select/credit_flash")
|
|
self.cr_t0 = tex.get_current_ms()
|
|
self.cr_blink_t0 = self.cr_t0
|
|
self.cr_side = 1
|
|
self.cr_frame = 0
|
|
self.cr_seen_frame = nil
|
|
self.cr_decide_t0 = nil
|
|
self.cr_decide_row = nil
|
|
|
|
local arcade_cfg = tex.get_skin_config("entry_credit_arcade")
|
|
self.cr_arcade = (arcade_cfg ~= nil and (arcade_cfg.x or 0) >= 1)
|
|
self.cr_pending_decide = nil
|
|
|
|
self.guide = tex.get_texture("global/indicator/background")
|
|
self.guide_t0 = self.cr_t0
|
|
self.any_joined = false
|
|
|
|
return self
|
|
end
|
|
|
|
local GUIDE_STEP = 2
|
|
local GUIDE_SPLIT = math.floor(420 / GUIDE_STEP)
|
|
local GUIDE_END = math.floor(650 / GUIDE_STEP)
|
|
|
|
function Entry:draw_control_guide()
|
|
if not self.guide then return end
|
|
if self.any_joined then return end
|
|
local n = GUIDE_END - GUIDE_SPLIT
|
|
local f = GUIDE_SPLIT + math.floor((tex.get_current_ms() - self.guide_t0) * 0.06 / GUIDE_STEP) % n
|
|
tex.draw_texture(self.guide, { frame = f, x = 0, y = 0 })
|
|
end
|
|
|
|
function Entry:update(current_ms)
|
|
self.bg_flicker:update(current_ms)
|
|
self.side_select_fade:update(current_ms)
|
|
self.cr_frame = (self.cr_frame or 0) + 1
|
|
end
|
|
|
|
function Entry:start_side_select()
|
|
self.side_select_fade:start()
|
|
self:restart_credit()
|
|
end
|
|
|
|
function Entry:restart_side_select()
|
|
self.side_select_fade:restart()
|
|
self:restart_credit()
|
|
end
|
|
|
|
function Entry:restart_credit()
|
|
local now = tex.get_current_ms()
|
|
self.cr_t0 = now
|
|
self.cr_blink_t0 = now
|
|
self.cr_side = 1
|
|
self.cr_decide_t0 = nil
|
|
self.cr_decide_row = nil
|
|
self.cr_seen_frame = nil
|
|
self.cr_pending_decide = nil
|
|
end
|
|
|
|
function Entry:get_side_select_fade()
|
|
return self.side_select_fade.attribute
|
|
end
|
|
|
|
local ea_ok, entry_anim = pcall(require, "anim/sampler")
|
|
if not ea_ok then entry_anim = { safe = function()
|
|
local n = {}
|
|
n.at = function() return nil end; n.get = function() return nil end
|
|
n.label = function() return nil end; n.has = function() return false end
|
|
n.first = function() return 0 end; n.last = function() return 0 end
|
|
return n
|
|
end } end
|
|
local entry_bg = entry_anim.safe("anim/entry_bg")
|
|
local credit_row = entry_anim.safe("anim/credit_row")
|
|
local credit_fade = entry_anim.safe("anim/credit_fade")
|
|
|
|
local CREDIT_CX = 960
|
|
local ROW_CY = { 432 + 72, 432 + 248 }
|
|
local LABEL_INK_X = CREDIT_CX - 443
|
|
local MSG_INK_X = CREDIT_CX + 190
|
|
local TEXT_INK_DY = 0.5
|
|
local PAD5 = 9
|
|
local PAD_LABEL = 2
|
|
local CANCEL_CX, CANCEL_CY = 960, 838
|
|
local ROW_LOOP_F0, ROW_LOOP_LEN = 5, 120
|
|
local DIM_UNSELECTED = 0.72
|
|
local DECIDE_FLASH_F = 24
|
|
local entry_bg_len = math.max(1, entry_bg:last() - entry_bg:first() + 1)
|
|
local BG_LIT_END = 19
|
|
local ENTRY_TWINKLES = {
|
|
{ 0, 0, "#11@1/#5@0/#3@0" },
|
|
{ 1, 0, "#11@1/#9@2/#3@0" },
|
|
{ 2, 1, "#11@1/#8@1/#6@0" },
|
|
{ 3, 1, "#11@1/#10@3/#6@0" },
|
|
}
|
|
|
|
function Entry:draw_background()
|
|
local f = ((tex.get_current_ms() - self.bg_t0) * 0.06) % entry_bg_len -- arcade frames @ 60 fps
|
|
|
|
tex.draw_texture(self.bg_bg)
|
|
|
|
if self.bg_twinkle then
|
|
for i = 1, #ENTRY_TWINKLES do
|
|
local tw = ENTRY_TWINKLES[i]
|
|
local s, a = entry_bg:at(tw[3], f)
|
|
if a and a > 0.002 then
|
|
tex.draw_texture(self.bg_twinkle,
|
|
{ index = tw[1], frame = tw[2], center = true, scale = s, fade = a })
|
|
end
|
|
end
|
|
end
|
|
|
|
if self.bg_glow then
|
|
local ga = entry_bg:get("#16@3/#14@0", f, "a") or 1.0
|
|
for i = 0, 1 do
|
|
tex.draw_texture(self.bg_glow, { index = i, frame = i, fade = ga })
|
|
end
|
|
end
|
|
|
|
if self.bg_street_lit then
|
|
local lf = (tex.get_current_ms() - self.bg_t0) * 0.06 -- monotonic, NOT wrapped
|
|
if lf < BG_LIT_END then
|
|
local la = entry_bg:get("#17@7", lf, "a") or 0.0
|
|
if la > 0.002 then tex.draw_texture(self.bg_street_lit, { fade = la }) end
|
|
end
|
|
end
|
|
end
|
|
|
|
function Entry:draw_side_select()
|
|
end
|
|
|
|
-- One player row. `row` is 1 (upper, 1P) or 2 (lower, 2P); `f` is the row timeline frame.
|
|
function Entry:draw_credit_row(row, f, a)
|
|
if a <= 0.002 then return end
|
|
tex.draw_texture(self.cr_pill, { index = row - 1, fade = a })
|
|
|
|
local cy = ROW_CY[row]
|
|
local lbl = self.text_credit_p[row]
|
|
if lbl then
|
|
lbl:draw({ x = LABEL_INK_X - PAD_LABEL, y = cy + TEXT_INK_DY - lbl.height / 2, fade = a })
|
|
end
|
|
|
|
-- fill alpha and the outline copy colour multiply, both read from the export
|
|
local ma = credit_row:get("text_message_instance", f, "a") or 1
|
|
local _, cr = credit_row:at("text_message_instance_2", f)
|
|
local yellow = (cr and cr / 256.0) or 0.0 -- 0 = black outline, 1 = (256,236,67)
|
|
local msg = self.text_credit_msg
|
|
if msg and ma > 0.002 then
|
|
local x = MSG_INK_X - msg.width / 2
|
|
local y = cy + TEXT_INK_DY - msg.height / 2
|
|
msg:draw({ x = x, y = y, fade = a * ma })
|
|
if yellow > 0.001 and self.text_credit_msg_hl then
|
|
self.text_credit_msg_hl:draw({ x = x, y = y, fade = a * ma * yellow })
|
|
end
|
|
end
|
|
end
|
|
|
|
function Entry:draw_credit(a, sel, blink_f, flash_row, flash_a, loop_rows)
|
|
for row = 1, 2 do
|
|
local armed = (row == sel)
|
|
local ra = (sel == nil or sel == 0 or armed) and a or (a * DIM_UNSELECTED)
|
|
local rf = (armed or loop_rows) and blink_f or ROW_LOOP_F0
|
|
self:draw_credit_row(row, rf, ra)
|
|
end
|
|
local now = tex.get_current_ms()
|
|
if sel and sel > 0 then
|
|
local pulse = 0.08 + 0.10 * math.sin((now - self.cr_blink_t0) * 0.006)
|
|
tex.draw_texture(self.cr_flash, { index = sel - 1, fade = a * pulse })
|
|
end
|
|
|
|
|
|
if flash_row and flash_a and flash_a > 0.002 then
|
|
tex.draw_texture(self.cr_flash, { index = flash_row - 1, fade = a * flash_a })
|
|
end
|
|
end
|
|
|
|
function Entry:draw_side_select_buttons(side)
|
|
local now = tex.get_current_ms()
|
|
__hss_entry_guide = { ms = now, phase = "side" }
|
|
if side ~= self.cr_side then
|
|
self.cr_side = side
|
|
self.cr_blink_t0 = now -- a newly armed row restarts its attract cycle
|
|
end
|
|
self.cr_seen_frame = self.cr_frame
|
|
self.cr_decide_t0 = nil
|
|
|
|
local fi = math.min(15, 5 + (now - self.cr_t0) * 0.06)
|
|
local a = credit_fade:get("player1_text_instance", fi, "a") or 1.0
|
|
|
|
local sel = (not self.cr_arcade)
|
|
and ((side == 0 and 1) or (side == 2 and 2) or 0)
|
|
or nil
|
|
local blink_f = ROW_LOOP_F0 + ((now - self.cr_blink_t0) * 0.06) % ROW_LOOP_LEN
|
|
self:draw_credit(a, sel, blink_f, nil, nil, self.cr_arcade)
|
|
-- depth 28 > depth 23: the guide sits OVER the credit rows.
|
|
self:draw_control_guide()
|
|
YD_ENTRY_CREDIT_MS = now
|
|
end
|
|
|
|
function Entry:draw_footer(p1_joined, p2_joined)
|
|
YD_ENTRY_BOTH_JOINED = (p1_joined == true and p2_joined == true)
|
|
self.any_joined = (p1_joined == true or p2_joined == true)
|
|
end
|
|
|
|
function Entry:draw_player_entry()
|
|
self:draw_credit_decide()
|
|
end
|
|
|
|
function Entry:decide_side_select(side)
|
|
self.cr_pending_decide = (side == 2) and 2 or 1
|
|
end
|
|
|
|
function Entry:draw_credit_decide()
|
|
local now = tex.get_current_ms()
|
|
if self.cr_seen_frame ~= nil and self.cr_decide_t0 == nil then
|
|
if self.cr_frame > self.cr_seen_frame then
|
|
self.cr_seen_frame = nil
|
|
if self.cr_pending_decide then
|
|
-- arcade model: the engine told us which row entered
|
|
self.cr_decide_t0 = now
|
|
self.cr_decide_row = self.cr_pending_decide
|
|
self.cr_pending_decide = nil
|
|
elseif self.cr_side == 0 or self.cr_side == 2 then
|
|
-- cursor model: side 1 is 「つかわない」 -- cancelled, not decided.
|
|
self.cr_decide_t0 = now
|
|
self.cr_decide_row = (self.cr_side == 0) and 1 or 2
|
|
end
|
|
end
|
|
end
|
|
if self.cr_decide_t0 == nil then return end
|
|
|
|
local t = (now - self.cr_decide_t0) * 0.06 -- frames since decide
|
|
local flash_a = credit_row:get("#8@4", 125 + math.min(t, DECIDE_FLASH_F), "a") or 0
|
|
local fade_f = 16 + math.max(0, t - (DECIDE_FLASH_F + 1)) -- fade_out starts after
|
|
local a = credit_fade:get("player1_text_instance", math.min(fade_f, 35), "a") or 0
|
|
if a <= 0.002 then
|
|
self.cr_decide_t0 = nil
|
|
return
|
|
end
|
|
self:draw_credit(a, nil, ROW_LOOP_F0, self.cr_decide_row, flash_a)
|
|
YD_ENTRY_CREDIT_MS = now
|
|
end
|