626 lines
17 KiB
Lua
626 lines
17 KiB
Lua
local FRAME_MS = 1000 / 60
|
|
local INFO_MS = 10000
|
|
local INFO_FADE_MS = 20 * FRAME_MS
|
|
local GACHA_FRAMES = 835
|
|
|
|
local CUES = {
|
|
{ 11, "machine_down" }, { 60, "mdon_eye" }, { 93, "mdon_rotate" }, { 113, "capsule_down" }, { 117, "mdon_open" },
|
|
{ 168, "capsule_jump" }, { 189, "mdon_close" }, { 225, "machine_up" }, { 255, "capsule_fall" },
|
|
{ 297, "capsule_bowan" }, { 297, "capsule_light" }, { 297, "capsule_roll" }, { 297, "capsule_burst" },
|
|
{ 520, "capsule_flash" }, { 545, "get_jingle" }, { 598, "vo_get" },
|
|
}
|
|
|
|
local function play(name)
|
|
audio.play_sound("gacha_" .. name, "attract_mode")
|
|
end
|
|
|
|
local function ease_in(t)
|
|
return t * t
|
|
end
|
|
|
|
local function ease_out(t)
|
|
return 1 - (1 - t) * (1 - t)
|
|
end
|
|
|
|
local function linear(t)
|
|
return t
|
|
end
|
|
|
|
local function track(f, keys)
|
|
local v = nil
|
|
for _, k in ipairs(keys) do
|
|
if f < k[1] then
|
|
return v
|
|
end
|
|
if f <= k[2] then
|
|
local t = k[2] > k[1] and (f - k[1]) / (k[2] - k[1]) or 1
|
|
return k[3] + (k[4] - k[3]) * (k[5] or linear)(t)
|
|
end
|
|
v = k[4]
|
|
end
|
|
return v
|
|
end
|
|
|
|
local DON_FRAMES = {
|
|
{ 93, 1 }, { 96, 2 }, { 99, 3 }, { 102, 4 }, { 105, 5 }, { 108, 6 }, { 111, 0 }, { 117, 7 }, { 120, 8 },
|
|
{ 123, 9 }, { 126, 10 }, { 129, 11 }, { 132, 10 }, { 189, 9 }, { 192, 8 }, { 195, 7 }, { 198, 0 }, { 201, 7 },
|
|
{ 204, 0 },
|
|
}
|
|
local function don_frame(f)
|
|
local frame = 0
|
|
for _, e in ipairs(DON_FRAMES) do
|
|
if f < e[1] then
|
|
return frame
|
|
end
|
|
frame = e[2]
|
|
end
|
|
return frame
|
|
end
|
|
|
|
local function progress(f, f0, f1)
|
|
return math.max(0, math.min(1, (f - f0) / (f1 - f0)))
|
|
end
|
|
|
|
local function texture(name)
|
|
return tex.get_texture("title/gacha/" .. name)
|
|
end
|
|
|
|
local function size(name)
|
|
local info = tex.get_texture_info("gacha", name)
|
|
return info.x2[1], info.y2[1]
|
|
end
|
|
|
|
local function draw_centered(t, w, h, cx, cy, params)
|
|
local sx = params.scale or 1
|
|
local sy = sx * (params.squash or 1)
|
|
tex.draw_texture(t, {
|
|
x = cx,
|
|
y = cy,
|
|
x2 = w * (sx - 1),
|
|
y2 = h * (sy - 1),
|
|
origin = { w * sx / 2, h * sy / 2 },
|
|
rotation = params.rotation or 0,
|
|
fade = params.fade or 1,
|
|
})
|
|
end
|
|
|
|
local function spin_angle(f, f0, start)
|
|
return start - 9 * (f - f0)
|
|
end
|
|
|
|
local Capsule = {}
|
|
Capsule.__index = Capsule
|
|
|
|
function Capsule.new(small)
|
|
local self = setmetatable({}, Capsule)
|
|
local ball = small and "capsule_small" or "capsule"
|
|
local shine = small and "shine_small" or "shine"
|
|
self.t_ball = texture(ball)
|
|
self.t_shine = texture(shine)
|
|
self.ball_w, self.ball_h = size(ball)
|
|
self.shine_w, self.shine_h = size(shine)
|
|
self.visible = false
|
|
return self
|
|
end
|
|
|
|
function Capsule:set(cx, cy, scale, rotation, squash)
|
|
self.visible = true
|
|
self.cx = cx
|
|
self.cy = cy
|
|
self.scale = scale
|
|
self.rotation = rotation
|
|
self.squash = squash
|
|
end
|
|
|
|
function Capsule:draw()
|
|
if not self.visible then
|
|
return
|
|
end
|
|
draw_centered(self.t_ball, self.ball_w, self.ball_h, self.cx, self.cy, {
|
|
scale = self.scale,
|
|
rotation = self.rotation,
|
|
squash = self.squash,
|
|
})
|
|
draw_centered(self.t_shine, self.shine_w, self.shine_h, self.cx - 10 * self.scale, self.cy - 14 * self.scale, {
|
|
scale = self.scale,
|
|
fade = 0.602,
|
|
})
|
|
end
|
|
|
|
local GachaDon = {}
|
|
GachaDon.__index = GachaDon
|
|
|
|
function GachaDon.new()
|
|
local self = setmetatable({}, GachaDon)
|
|
self.t_stand = texture("stand")
|
|
self.t_don = texture("don")
|
|
self.t_don_face = texture("don_face")
|
|
self.t_don_lid = texture("don_lid")
|
|
self.visible = true
|
|
self.frame = 0
|
|
self.x = 0
|
|
self.drop = 0
|
|
self.face_visible = false
|
|
self.lid_visible = false
|
|
return self
|
|
end
|
|
|
|
function GachaDon:update(f)
|
|
self.visible = f < 255
|
|
self.frame = don_frame(f)
|
|
self.x = track(f, {
|
|
{ 57, 60, -0.75, -3 },
|
|
{ 61, 64, -2.25, 0 },
|
|
{ 210, 215, 0.65, 4 },
|
|
{ 216, 221, 3.15, -1 },
|
|
{ 222, 225, -1, -1 },
|
|
}) or 0
|
|
self.drop = track(f, { { 226, 254, 0, 440, ease_in } }) or 0
|
|
self.face_visible = f >= 96 and f < 99
|
|
self.lid_visible = f >= 132 and f < 176
|
|
end
|
|
|
|
function GachaDon:draw()
|
|
if not self.visible then
|
|
return
|
|
end
|
|
tex.draw_texture(self.t_stand, { y = self.drop })
|
|
tex.draw_texture(self.t_don, { frame = self.frame, x = self.x, y = self.drop })
|
|
end
|
|
|
|
function GachaDon:draw_face()
|
|
if self.face_visible then
|
|
tex.draw_texture(self.t_don_face)
|
|
end
|
|
end
|
|
|
|
function GachaDon:draw_lid()
|
|
if self.lid_visible then
|
|
tex.draw_texture(self.t_don_lid)
|
|
end
|
|
end
|
|
|
|
local GachaGlobe = {}
|
|
GachaGlobe.__index = GachaGlobe
|
|
|
|
function GachaGlobe.new()
|
|
local self = setmetatable({}, GachaGlobe)
|
|
self.t_globe = texture("globe")
|
|
self.t_hose_ring = texture("hose_ring")
|
|
self.back_visible = false
|
|
self.ring_visible = false
|
|
self.front_visible = false
|
|
return self
|
|
end
|
|
|
|
function GachaGlobe:update(f)
|
|
self.back_visible = f >= 10 and f < 105
|
|
if self.back_visible then
|
|
self.back_frame = f >= 100 and 1 or 0
|
|
self.back_x = track(f, { { 49, 53, 2, 10 }, { 54, 59, 6.95, 0, ease_out } }) or 0
|
|
self.back_y = track(f, { { 10, 48, -570, 4, ease_out }, { 49, 53, 3.2, 0 } })
|
|
end
|
|
|
|
local shake_x = track(f, { { 206, 212, 0, 10, ease_out }, { 213, 218, 9.85, 5, ease_in } })
|
|
local shake_y = track(f, { { 219, 225, 1.35, 5, ease_out }, { 226, 254, 4.3, -575, ease_in } }) or 0
|
|
self.ring_visible = f >= 105 and f < 254
|
|
self.ring_x = f < 206 and -2 or shake_x
|
|
self.ring_y = shake_y
|
|
|
|
self.front_visible = f >= 105 and f < 255
|
|
self.front_frame = f < 206 and 2 or 0
|
|
self.front_x = f < 206 and 0 or shake_x
|
|
self.front_y = f < 206 and 0 or shake_y
|
|
end
|
|
|
|
function GachaGlobe:draw_back()
|
|
if self.back_visible then
|
|
tex.draw_texture(self.t_globe, { frame = self.back_frame, x = self.back_x, y = self.back_y })
|
|
end
|
|
end
|
|
|
|
function GachaGlobe:draw_ring()
|
|
if self.ring_visible then
|
|
tex.draw_texture(self.t_hose_ring, { x = self.ring_x, y = self.ring_y })
|
|
end
|
|
end
|
|
|
|
function GachaGlobe:draw_front()
|
|
if self.front_visible then
|
|
tex.draw_texture(self.t_globe, { frame = self.front_frame, x = self.front_x, y = self.front_y })
|
|
end
|
|
end
|
|
|
|
local CapsuleRun = {}
|
|
CapsuleRun.__index = CapsuleRun
|
|
|
|
function CapsuleRun.new()
|
|
local self = setmetatable({}, CapsuleRun)
|
|
self.hose = Capsule.new(true)
|
|
self.out = Capsule.new(false)
|
|
self.fly = Capsule.new(false)
|
|
return self
|
|
end
|
|
|
|
function CapsuleRun:update(f)
|
|
self.hose.visible = false
|
|
self.out.visible = false
|
|
self.fly.visible = false
|
|
|
|
if f >= 113 and f < 120 then
|
|
local t = (f - 113) / 6
|
|
self.hose:set(847.7 + 2.9 * t, 357.05 + 43.85 * t, 1.5, spin_angle(f, 113, 0))
|
|
elseif f >= 120 and f < 140 then
|
|
local t = ease_in((f - 120) / 19)
|
|
self.hose:set(848.8 - 106.55 * t, 408.2 + 70.8 * t, 1.5, spin_angle(f, 113, 0))
|
|
end
|
|
|
|
if f >= 139 and f < 154 then
|
|
local t = (f - 139) / 14
|
|
self.out:set(690.5 - 102.15 * t, 489.5 + 47.2 * t, 1.4 + 0.093 * t, spin_angle(f, 139, 135))
|
|
elseif f >= 154 and f < 168 then
|
|
local y = track(f, { { 154, 164, 186.5, 190.5, ease_out }, { 165, 167, 190.2, 188 } })
|
|
local squash = track(f, { { 154, 164, 1, 0.9, ease_out }, { 165, 167, 0.911, 1 } })
|
|
self.out:set(583.5, 357 + y, 1.5, 0, squash)
|
|
end
|
|
|
|
if f >= 168 and f < 233 then
|
|
local t = ease_out(progress(f, 168, 228))
|
|
self.fly:set(583.4 - 147.6 * t, 544.95 - 633.4 * t, 1.5 + 0.5 * t, spin_angle(f, 168, 0))
|
|
end
|
|
end
|
|
|
|
local Sparkles = {}
|
|
Sparkles.__index = Sparkles
|
|
|
|
local SPARKLE_CENTERS = { { 518, 506 }, { 602, 507 } }
|
|
|
|
function Sparkles.new()
|
|
local self = setmetatable({}, Sparkles)
|
|
self.t_sparkle = texture("sparkle")
|
|
self.w, self.h = size("sparkle")
|
|
self.visible = false
|
|
return self
|
|
end
|
|
|
|
function Sparkles:update(f)
|
|
self.visible = f >= 60 and f < 100
|
|
local t = (f - 60) / 19
|
|
if t <= 1 then
|
|
self.scale = 0.1 + 0.9 * t
|
|
self.fade = t
|
|
else
|
|
self.scale = 1.025 + 0.475 * (t - 1)
|
|
self.fade = math.max(0, 0.949 * (2 - t))
|
|
end
|
|
end
|
|
|
|
function Sparkles:draw()
|
|
if not self.visible then
|
|
return
|
|
end
|
|
for _, center in ipairs(SPARKLE_CENTERS) do
|
|
draw_centered(self.t_sparkle, self.w, self.h, center[1], center[2], {
|
|
scale = self.scale,
|
|
fade = self.fade,
|
|
})
|
|
end
|
|
end
|
|
|
|
local BigCapsule = {}
|
|
BigCapsule.__index = BigCapsule
|
|
|
|
function BigCapsule.new()
|
|
local self = setmetatable({}, BigCapsule)
|
|
self.t_capsule = texture("big_capsule")
|
|
self.t_shine = texture("big_shine")
|
|
self.w, self.h = size("big_capsule")
|
|
self.visible = false
|
|
return self
|
|
end
|
|
|
|
function BigCapsule:update(f)
|
|
self.visible = f >= 255 and f < 297
|
|
self.y = track(f, {
|
|
{ 255, 284, -500, 0, ease_in },
|
|
{ 285, 290, 2.45, 8, ease_out },
|
|
{ 291, 295, 7.7, 0, ease_in },
|
|
}) or 0
|
|
self.squash = track(f, { { 285, 290, 0.969, 0.9, ease_out }, { 291, 295, 0.904, 1, ease_in } }) or 1
|
|
end
|
|
|
|
function BigCapsule:draw()
|
|
if not self.visible then
|
|
return
|
|
end
|
|
tex.draw_texture(self.t_capsule, {
|
|
y = self.y + self.h / 2 * (1 - self.squash),
|
|
y2 = self.h * (self.squash - 1),
|
|
})
|
|
tex.draw_texture(self.t_shine, { y = self.y })
|
|
end
|
|
|
|
local Cloud = {}
|
|
Cloud.__index = Cloud
|
|
|
|
function Cloud.new()
|
|
local self = setmetatable({}, Cloud)
|
|
self.t_cloud = texture("cloud")
|
|
self.visible = false
|
|
return self
|
|
end
|
|
|
|
function Cloud:update(f)
|
|
self.visible = f >= 296 and f < 320
|
|
if f < 303 then
|
|
self.frame = 0
|
|
elseif f < 308 then
|
|
self.frame = 1
|
|
elseif f < 314 then
|
|
self.frame = 2
|
|
else
|
|
self.frame = 3
|
|
end
|
|
self.scale = track(f, { { 296, 302, 0.1, 1.1 } })
|
|
self.y = track(f, { { 303, 307, 0, -10 }, { 308, 313, -10, -20 }, { 314, 319, -20, -30 } }) or 0
|
|
self.fade = track(f, { { 296, 302, 0, 1 }, { 314, 319, 1, 0 } })
|
|
end
|
|
|
|
function Cloud:draw()
|
|
if self.visible then
|
|
tex.draw_texture(self.t_cloud, {
|
|
frame = self.frame,
|
|
center = true,
|
|
scale = self.scale,
|
|
y = self.y,
|
|
fade = self.fade,
|
|
})
|
|
end
|
|
end
|
|
|
|
local Flash = {}
|
|
Flash.__index = Flash
|
|
|
|
function Flash.new()
|
|
local self = setmetatable({}, Flash)
|
|
self.t_rays = texture("rays")
|
|
self.w, self.h = size("rays")
|
|
self.visible = false
|
|
return self
|
|
end
|
|
|
|
function Flash:update(f)
|
|
self.visible = f >= 297 and f < 540
|
|
self.rotation = 0
|
|
self.fade = 1
|
|
if f < 303 then
|
|
self.scale = 0.335 + (f - 297) * 1.11
|
|
self.fade = (f - 297) / 6
|
|
elseif f <= 520 then
|
|
local t = (f - 303) / 217
|
|
self.scale = 7 - 6 * t
|
|
self.rotation = 360 * t
|
|
elseif f < 530 then
|
|
self.scale = 1 + (f - 520) * 0.6
|
|
else
|
|
self.scale = 7
|
|
self.fade = math.max(0, 1 - (f - 530) / 9)
|
|
end
|
|
end
|
|
|
|
function Flash:draw()
|
|
if self.visible then
|
|
draw_centered(self.t_rays, self.w, self.h, 638, 231, {
|
|
scale = self.scale,
|
|
rotation = self.rotation,
|
|
fade = self.fade,
|
|
})
|
|
end
|
|
end
|
|
|
|
local Prize = {}
|
|
Prize.__index = Prize
|
|
|
|
function Prize.new(frame)
|
|
local self = setmetatable({}, Prize)
|
|
self.frame = frame
|
|
self.t_rays = texture("rays")
|
|
self.rays_w, self.rays_h = size("rays")
|
|
self.t_prize = texture("prize")
|
|
self.t_frame = texture("frame")
|
|
self.t_prize_name = texture("prize_name")
|
|
self.t_label = texture("label")
|
|
self.t_get = texture("get")
|
|
self.t_message = texture("message")
|
|
return self
|
|
end
|
|
|
|
function Prize:update(f)
|
|
self.rays_visible = f >= 528
|
|
self.rays_rotation = 180 + 360 * ((f - 528) % 386) / 386
|
|
self.prize_visible = f >= 530
|
|
|
|
self.panel_visible = f >= 545
|
|
self.panel_y = track(f, { { 545, 552, 100, 0, ease_out } })
|
|
self.panel_fade = track(f, { { 545, 552, 0, 1, ease_out } })
|
|
|
|
self.get_visible = f >= 598
|
|
self.get_y = track(f, { { 598, 605, 55, -25, ease_out }, { 606, 610, -24, 0, ease_in } })
|
|
self.get_fade = track(f, { { 598, 605, 0, 1, ease_out } })
|
|
|
|
self.message_visible = f >= 760
|
|
end
|
|
|
|
function Prize:draw_message()
|
|
if self.message_visible then
|
|
tex.draw_texture(self.t_message)
|
|
end
|
|
end
|
|
|
|
function Prize:draw()
|
|
if self.rays_visible then
|
|
draw_centered(self.t_rays, self.rays_w, self.rays_h, 640, 219, { rotation = self.rays_rotation })
|
|
end
|
|
if self.prize_visible then
|
|
tex.draw_texture(self.t_prize, { frame = self.frame })
|
|
end
|
|
end
|
|
|
|
function Prize:draw_panel()
|
|
if not self.panel_visible then
|
|
return
|
|
end
|
|
tex.draw_texture(self.t_frame, { y = self.panel_y, fade = self.panel_fade })
|
|
tex.draw_texture(self.t_prize_name, { frame = self.frame, y = self.panel_y, fade = self.panel_fade })
|
|
tex.draw_texture(self.t_label, { y = self.panel_y, fade = self.panel_fade })
|
|
end
|
|
|
|
function Prize:draw_get()
|
|
if self.get_visible then
|
|
tex.draw_texture(self.t_get, { y = self.get_y, fade = self.get_fade })
|
|
end
|
|
end
|
|
|
|
local GachaScene = {}
|
|
GachaScene.__index = GachaScene
|
|
|
|
function GachaScene.new(prize_frame)
|
|
local self = setmetatable({}, GachaScene)
|
|
self.t_background = texture("background")
|
|
self.t_vignette = texture("vignette")
|
|
self.don = GachaDon.new()
|
|
self.globe = GachaGlobe.new()
|
|
self.capsules = CapsuleRun.new()
|
|
self.sparkles = Sparkles.new()
|
|
self.big_capsule = BigCapsule.new()
|
|
self.cloud = Cloud.new()
|
|
self.flash = Flash.new()
|
|
self.prize = Prize.new(prize_frame)
|
|
self.f = 0
|
|
return self
|
|
end
|
|
|
|
function GachaScene:update(f)
|
|
self.f = f
|
|
self.vignette_fade = track(f, { { 249, 255, 0, 1 } })
|
|
self.don:update(f)
|
|
self.globe:update(f)
|
|
self.capsules:update(f)
|
|
self.sparkles:update(f)
|
|
self.big_capsule:update(f)
|
|
self.cloud:update(f)
|
|
self.flash:update(f)
|
|
self.prize:update(f)
|
|
end
|
|
|
|
function GachaScene:draw()
|
|
tex.draw_texture(self.t_background)
|
|
if self.vignette_fade then
|
|
tex.draw_texture(self.t_vignette, { fade = self.vignette_fade })
|
|
end
|
|
self.big_capsule:draw()
|
|
self.prize:draw_message()
|
|
self.prize:draw()
|
|
self.flash:draw()
|
|
self.cloud:draw()
|
|
self.prize:draw_panel()
|
|
self.don:draw()
|
|
self.globe:draw_back()
|
|
self.capsules.out:draw()
|
|
self.don:draw_face()
|
|
self.sparkles:draw()
|
|
self.prize:draw_get()
|
|
self.don:draw_lid()
|
|
self.globe:draw_ring()
|
|
self.capsules.hose:draw()
|
|
self.globe:draw_front()
|
|
self.capsules.fly:draw()
|
|
|
|
if self.f >= 829 then
|
|
tex.draw_rect(0, 0, 1280, 720, 0, 0, 0, 255)
|
|
elseif self.f < 20 then
|
|
tex.draw_rect(0, 0, 1280, 720, 0, 0, 0, 255 * (1 - self.f / 19))
|
|
end
|
|
end
|
|
|
|
TournamentAttract = {}
|
|
TournamentAttract.__index = TournamentAttract
|
|
|
|
function TournamentAttract.new(current_ms)
|
|
local self = setmetatable({}, TournamentAttract)
|
|
self.now = current_ms
|
|
self.t_info = texture("info")
|
|
self.t_banner = texture("banner")
|
|
self.t_banner_glow = texture("banner_glow")
|
|
self:set_phase("title")
|
|
return self
|
|
end
|
|
|
|
function TournamentAttract:set_phase(phase)
|
|
self.phase = phase
|
|
self.phase_ms = self.now
|
|
self.cue = 1
|
|
if phase == "title" and not self.bgm_started then
|
|
|
|
self.bgm_started = true
|
|
play("bgm")
|
|
play("vo_start")
|
|
end
|
|
end
|
|
|
|
function TournamentAttract:close()
|
|
audio.stop_sound("gacha_bgm")
|
|
end
|
|
|
|
function TournamentAttract:update(current_ms)
|
|
self.now = current_ms
|
|
local elapsed = current_ms - self.phase_ms
|
|
if self.phase == "title" and elapsed >= 2 * INFO_MS then
|
|
self:set_phase("done")
|
|
elseif self.phase == "gacha" then
|
|
local f = elapsed / FRAME_MS
|
|
while CUES[self.cue] and CUES[self.cue][1] <= f do
|
|
play(CUES[self.cue][2])
|
|
self.cue = self.cue + 1
|
|
end
|
|
self.gacha:update(f)
|
|
if f >= GACHA_FRAMES then
|
|
self:set_phase("title")
|
|
end
|
|
end
|
|
end
|
|
|
|
function TournamentAttract:can_spin()
|
|
return self.phase == "title"
|
|
end
|
|
|
|
function TournamentAttract:spin(puchichara_id)
|
|
|
|
self.gacha = GachaScene.new(math.max(0, math.min(14, puchichara_id - 49)))
|
|
self:set_phase("gacha")
|
|
end
|
|
|
|
function TournamentAttract:is_finished()
|
|
return self.phase == "done"
|
|
end
|
|
|
|
function TournamentAttract:draw_title()
|
|
local elapsed = self.now - self.phase_ms
|
|
tex.draw_texture(self.t_info, { frame = 0 })
|
|
if elapsed >= INFO_MS then
|
|
tex.draw_texture(self.t_info, { frame = 1, fade = math.min(1, (elapsed - INFO_MS) / INFO_FADE_MS) })
|
|
end
|
|
tex.draw_texture(self.t_banner)
|
|
if math.floor(elapsed / FRAME_MS) % 20 < 9 then
|
|
tex.draw_texture(self.t_banner_glow)
|
|
end
|
|
end
|
|
|
|
function TournamentAttract:draw()
|
|
if self.phase == "title" then
|
|
self:draw_title()
|
|
elseif self.phase == "gacha" then
|
|
self.gacha:draw()
|
|
end
|
|
end
|