Yonokid/PyTaikoGreen
2
1 Fork 2
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
abafda3fe5b22aecce782b77d44a3687795f7b4f
PyTaikoGreen/Scripts/background/bg_collabs/kobayashi.lua
T

634 lines
27 KiB
Lua
Raw Blame History

local DonBGBase = require("background/bg_objects/donbg/base")
local Fever = require("background/bg_objects/fever")
local Dancer = require("background/bg_objects/dancer")
local RendaController = require("background/bg_objects/renda")
local ChibiController = require("background/bg_objects/chibi")
local BaseChibi = require("background/bg_objects/chibi/base")
local Timing = require("background/bg_objects/timing")
local pose_at, steps, concat = Timing.pose_at, Timing.steps, Timing.concat
-- Sachiko Kobayashi: a concert stage. Sachiko rises out of the floor and the dons rise onto
-- their platforms as the gauge fills; on clear the hall sinks away and she flies off into the
-- night sky on a crane, dressed as the queen.
local COLLAB_PATH = "background/collab/kobayashi"
local MAX_DANCERS = 5
-- Beats since the background was made, re-anchored when the bpm changes so it doesn't jump
local function new_clock(bpm) return { beats = 0, ms = 0, beat = 60000 / bpm } end
local function clock_update(c, current_time_ms, bpm)
if c.last then c.beats = c.beats + (current_time_ms - c.last) / c.beat end
c.last, c.ms = current_time_ms, current_time_ms
if bpm then c.beat = 60000 / bpm end
end
-- Runs fn with every draw moved down dy px (the hall sinking on clear)
local function shifted(dy, fn)
if dy == 0 then return fn() end
local orig = tex.draw_texture
tex.draw_texture = function(id, p)
p = p or {}
p.y = (p.y or 0) + dy
return orig(id, p)
end
local ok, err = pcall(fn)
tex.draw_texture = orig
if not ok then error(err, 0) end
end
-- 0 -> 1 -> 0 over a loop of `ms`
local function triangle(now, ms)
local k = (now % ms) / ms
return 1 - math.abs(1 - 2 * k)
end
-- Don band: the red strip (gold when cleared) scrolls one tile left every 14.67 s, the waves
-- over it two tiles and the clouds and cranes three, so the layers slide past at different
-- speeds. Ambient, in ms.
local DONBG = {
layers = {
{ key = "background", ms = 14667 },
{ key = "waves", ms = 14667, dx = -672 },
{ key = "sky", ms = 14667, dx = -1008 },
},
}
-- Stage: the concert hall, its right half mirrored, with a column of lamps either side whose
-- two sets of bulbs take turns, each fading up and down over 750 ms. Ambient, in ms.
local LAMP_MS = 750
local BGNormal = {}
BGNormal.__index = BGNormal
function BGNormal.new(clock)
local self = setmetatable({}, BGNormal)
self.name = "bg_0"
self.clock = clock
tex.load_folder(COLLAB_PATH, "bg_normal/" .. self.name)
self._id_bg = tex.get_texture(COLLAB_PATH .. "/" .. self.name .. "/background") or 0
self._id_lamps = tex.get_texture(COLLAB_PATH .. "/" .. self.name .. "/lamps") or 0
return self
end
function BGNormal:draw()
tex.draw_texture(self._id_bg)
tex.draw_texture(self._id_bg, { index = 1, mirror = "horizontal" })
local a = triangle(self.clock.ms, LAMP_MS)
for i = 0, 1 do
local mirror = i == 1 and "horizontal" or nil
-- frames 0, 1: the two sets of bulbs; 2, 3: their glow
for frame = 0, 3 do
tex.draw_texture(self._id_lamps, { index = i, frame = frame, fade = frame % 2 == 0 and a or 1 - a,
mirror = mirror, blend = frame >= 2 and "additive" or nil })
end
end
end
function BGNormal:destroy() tex.unload_folder(COLLAB_PATH, "bg_normal/" .. self.name) end
-- Dancers: Sachiko in the middle and four dons, each on a slot of the stage. Texture.json
-- positions are relative to the slot's centre; a layer scales and squashes about its
-- `origin` (default the image's centre). Lumen lets the game ask for 1, 3 or 5 dancers only,
-- so the dons join and leave in pairs. Timed in beats; the dance routines count a beat per
-- Lumen label (22.5 frames).
local SLOTS = { 160, 360, 640, 920, 1120 }
local DRAW_ORDER = { 5, 1, 4, 2, 3 } -- slots back to front
local DANCERS = { 1, 3, 3, 5, 5 } -- dancers on stage for 0..4 milestones
local function layer(key, poses, opts)
poses.key = key
for k, v in pairs(opts or {}) do poses[k] = v end
return poses
end
local function still(key, frame, opts) return layer(key, { { 0, frame or 0, 0, 0 } }, opts) end
-- hidden until `at`, then fades in over `beats`
local function fade_in(key, at, beats, opts, frame)
frame = frame or 0
return layer(key, { { 0, frame, 0, 0, hide = true }, { at, frame, alpha = 0, to = { 0, 0, alpha = 1 } },
{ at + beats, frame } }, opts)
end
local ADD = { blend = "additive" }
-- A don rises from below the stage onto its platform as the light comes on, overshoots and
-- settles with a squash; it leaves with a hop and drops back down as the light goes out.
local DON_ORIGIN = { 100, 184 } -- squashes about its feet
local DON_ENTER = {
beats = 2,
fade_in("floor", 0, 0.175),
fade_in("beam", 0, 0.175, ADD),
layer("ring", {
{ 0, 0, 0, 0, scale = 0.1, alpha = 0, to = { 0, 0, "out", scale = 0.9, alpha = 0.5 } },
{ 0.55, 0, scale = 0.9, alpha = 0.5, to = { 0, 0, scale = 1, alpha = 1 } }, { 0.85, 0 },
}),
layer("start", {
{ 0, 0, 0, 220, to = { nil, -44, "out" } }, { 0.575, 0, to = { nil, 0, "in" } },
{ 0.825, 0, to = { nil, 0, "out", sy = 0.95 } }, { 1.075, 0, sy = 0.95, to = { nil, 0, "in", sy = 1 } },
{ 1.325, 0 },
}, { origin = DON_ORIGIN }),
}
local function fade_out(key, at, beats, opts)
return layer(key, { { 0, 0, 0, 0 }, { at, 0, to = { 0, 0, alpha = 0 } }, { at + beats, 0, hide = true } }, opts)
end
local DON_LEAVE = {
beats = 1.25,
fade_out("floor", 1.075, 0.175),
fade_out("beam", 1.075, 0.175, ADD),
layer("ring", {
{ 0, 0, 0, 0, to = { 0, 0, "out", scale = 0.8, alpha = 0.5 } },
{ 0.6, 0, scale = 0.8, alpha = 0.5, to = { 0, 0, "in", scale = 0.1, alpha = 0 } }, { 1.25, 0, hide = true },
}),
layer("start", { { 0, 1, 0, 0, to = { nil, -44, "out" } }, { 0.525, 1, to = { nil, 220, "in" } } },
{ origin = DON_ORIGIN }),
}
-- The dons dance two bars: every beat a pose held most of the beat and a quick accent, the
-- first bar facing one way and the second the other; the shadow under them follows the pose
local function bar(first)
return { { first, 0.625 }, { first + 1, 0.375 }, { first + 2, 0.625 }, { first + 3, 0.375 } }
end
local function don_routine()
local poses = steps(bar(0), bar(0), bar(4), bar(4))
poses[1][3], poses[1][4] = 0, 0
return poses
end
local function don_dance()
return { beats = 8, still("floor"), still("beam", 0, ADD), layer("shadow", don_routine()),
layer("loop", don_routine()) }
end
-- Sachiko rises steadily through a trapdoor on a lift over 2.6 beats with her silhouette over her,
-- overshoots, settles, and the lights come up (lit lift and lip, floor light, beam); then she
-- opens her eyes. She sings with her hands together for a bar and a half, then waves.
local function rise(frame, alpha)
return { { 0, frame, 0, 323, alpha = alpha, to = { nil, -6 } },
{ 2.6, frame, alpha = alpha, to = { nil, 0, "in" } }, { 2.725, frame, alpha = alpha } }
end
local SACHI = {
enter = {
beats = 4.5,
still("_strip"),
fade_in("_floor", 2.725, 0.2),
still("_hole"),
layer("_lift", rise(0)),
fade_in("_lift", 2.725, 0.2, nil, 1),
fade_in("_beam", 2.725, 0.2, ADD),
layer("start", concat(rise(0), { { 2.95, 1 } })),
layer("_silhouette", concat(rise(0, 0.6), { { 2.75, 0, alpha = 0.6, to = { nil, nil, alpha = 0 } },
{ 2.95, 0, hide = true } })),
still("_lip"),
fade_in("_lip", 2.725, 0.2, nil, 1),
layer("_feet", { { 0, 0, 0, 0, hide = true }, { 2.725, 0 } }),
},
dance = {
beats = 4,
still("_floor"), still("_hole"), still("_lift", 1), still("_beam", 0, ADD),
layer("loop", steps({ { 0, 1.5, x = 0, y = 0 }, { 1, 0.25 }, { 2, 0.25 }, { 3, 1.5 }, { 4, 0.25 }, { 5, 0.25 } })),
still("_lip", 1),
layer("_feet", steps({ { 1, 1.5, x = 0, y = 0 }, { 2, 0.25 }, { 3, 0.25 }, { 4, 1.5 }, { 5, 0.25 }, { 6, 0.25 } })),
},
}
local SPECS = { [0] = SACHI }
for i = 1, 4 do SPECS[i] = { enter = DON_ENTER, dance = don_dance(), leave = DON_LEAVE } end
-- draws the current part's layers with the slot's centre at x (only the keys in `only`, if
-- given); beams move `beam_dy` px further (they hang from the rig, which sinks faster)
local function kobayashi_draw(self, x, beam_dy, only)
if not self.state then return end
local t = self:part_time()
for _, l in ipairs(self.parts[self.state]) do
local pose = pose_at(l, t)
if pose and (not only or only[l.key]) then
local tx = self:texture(pose.key or l.key)
local info = tx.info
if info and info.width then
local w, h = info.width, info.height
local o = l.origin or { w / 2, h / 2 }
local sx, sy = pose.sx, pose.sy
tex.draw_texture(tx.id, {
frame = pose.frame,
x = x + (pose.x or 0) + o[1],
y = (pose.y or 0) + o[2] + (l.key:find("beam") and beam_dy or 0),
x2 = w * (sx - 1),
y2 = h * (sy - 1),
origin = { o[1] * sx, o[2] * sy },
fade = pose.alpha,
blend = (pose.blend == nil and l.blend or pose.blend) or nil,
})
end
end
end
end
-- Clear: Lumen's normal_fever / fever_normal. Timed in beats from gaining or losing clear.
-- In: the lift pops Sachiko up out of the floor by 0.75 beats (a don holds it up from below),
-- then the whole hall (stage, dancers and rig) sinks 832px over 2.2 beats while she stays
-- put and the stars and the Earth's rim rise behind it. Lanterns drop in from 2 beats and
-- rays fade in from 2.5. A crane flies up behind her at 1.8, a white flash at 2.7 hides her
-- turning into the queen, the crane spreads its wings, and from 3.25 the queen rides it,
-- bobbing over a 4-beat loop under twinkling stars.
-- Out: the crane flaps and flies off, the queen fades back into Sachiko on the lift, the hall
-- comes back up over 1.45 beats and the lanterns lift away.
-- Groups slide into place (progress 0 -> 1) `at` beats after the clear over `beats`, and
-- slide back out linearly over `back`, from wherever they are. `ease` is how strongly they
-- slow down (Lumen's ease-out strength: 1 is quadratic, 0 linear).
local GROUPS = {
stage = { at = 0.75, beats = 2.225, ease = 0.8, back = 1.45 },
stars = { at = 0.75, beats = 2.225, ease = 0.5, back = 1.45 },
earth = { at = 0.75, beats = 2.225, back = 1.45 },
lanterns = { at = 1.975, beats = 1, ease = 0.4, back = 0.475 },
rays = { at = 2.5, beats = 0.675, back = 0.3 },
}
local STAGE_DROP, STARS_RISE, EARTH_RISE, GLOW_DROP = 832, 120, 196, 100
-- the rig sinks faster than the stage (parallax): the sign and truss 877px, the lighting bar
-- and its beams 924px
local TRUSS_EXTRA, RIG_EXTRA = 45 / STAGE_DROP, 92 / STAGE_DROP
local LANTERN_DROP = { 380, 380, 394, 394 } -- by lanterns/glows index (back row lower)
local GLOW_MS = 1000 -- lantern glows dim to 30% and back; rays swap
local OUT_BEATS = 1.725
-- the lift (and Sachiko on it) pops up 71px and sinks back as the hall drops; the don under
-- it pushes up 31px and stays
local LIFT_IN = {
{ 0, 0, 0, 0, to = { nil, 4, "out" } }, { 0.1, 0, to = { nil, -71 } }, { 0.775, 0, to = { nil, 0, "in" } },
{ 2.9, 0 }, { 2.925, 0, hide = true },
}
local HELPER_IN = { { 0, 0, 0, 0, to = { nil, 4, "out" } }, { 0.1, 0, to = { nil, -31 } }, { 0.75, 0 } }
-- her shadow fades as she lifts off and goes down with the hall
local FEET_IN = {
{ 0, 0, 0, 0 }, { 0.225, 0, to = { 0, 0, alpha = 0.4 } }, { 0.75, 0, alpha = 0.4, to = { 0, 0, "out", alpha = 0 } },
{ 2.975, 0, hide = true },
}
-- the crane: rises 237px, then spreads its wings (body and wings share frames)
local CRANE_IN = {
{ 0, 0, 0, 0, hide = true }, { 1.825, 0, 0, 237, to = { 0, 0, "out" } }, { 2.4, 0 }, { 2.55, 1 }, { 2.7, 2 },
{ 2.825, 3 }, { 3.25, 0, hide = true },
}
local FLASH = {
{ 0, 0, 0, 0, hide = true }, { 2.675, 0, alpha = 0, to = { 0, 0, alpha = 1 } }, { 2.9, 0 },
{ 3.05, 0, to = { 0, 0, alpha = 0 } }, { 3.225, 0, hide = true },
}
local QUEEN_AT, RIDE_AT = 2.925, 3.25
-- riding: the queen's poses and the crane's flaps over 4 beats, all bobbing together
local QUEEN_DANCE = steps({ { 0, 1.4, x = 0, y = 0 }, { 1, 0.3 }, { 2, 0.3 }, { 3, 1.7 }, { 4, 0.3 } })
local FLAP = 3.5 / 6
local CRANE_DANCE = steps({ { 0, 0.5, x = 0, y = 0 }, { 1, FLAP }, { 2, FLAP }, { 3, FLAP }, { 4, FLAP }, { 5, FLAP },
{ 6, FLAP } })
local BOB = { { 0, 0, 0, 0, to = { 0, 4 } }, { 0.75, 0, to = { 0, -16 } }, { 2.75, 0, to = { 0, 0 } }, length = 4 }
-- twinkles round the queen in the same 4-beat loop (90 Lumen frames): { frame, x, y, size }
-- from her centre; a star grows from 11% to 70% over 14 frames, then flares to full size and
-- fades in 6
local SPARKLE_LOOP, SPARKLE_LIFE = 90, 20
local SPARKLES = {
{ 0, -291, -86, 0.6 }, { 0, 291, -86, 0.6 }, { 7, -318, 91, 0.6 }, { 7, 318, 91, 0.6 },
{ 16, -543, -51, 0.6 }, { 16, 446, -118, 0.6 }, { 23, -385, -26, 0.6 }, { 23, 385, -26, 0.6 },
{ 25, -543, 99, 0.6 }, { 25, 446, 152, 0.6 }, { 28, 0, -116, 1 }, { 40, -157, -16, 1 }, { 40, 180, -16, 1 },
{ 40, -385, -26, 0.6 }, { 40, 385, -26, 0.6 }, { 45, -200, 136, 0.6 }, { 45, 200, 136, 0.6 },
{ 47, -543, -51, 0.6 }, { 47, 446, -118, 0.6 }, { 48, -244, 45, 1 }, { 48, 244, 45, 1 },
{ 53, -318, 91, 0.6 }, { 53, 318, 91, 0.6 }, { 57, -460, 105, 1 }, { 57, 350, 38, 1 },
{ 61, -446, -118, 0.6 }, { 61, 543, -51, 0.6 }, { 66, -385, -105, 0.6 }, { 66, 385, -105, 0.6 },
{ 68, -446, 152, 0.6 }, { 68, 543, 99, 0.6 }, { 69, -350, 38, 1 }, { 69, 460, 105, 1 },
}
local SPARKLE_HALF = 32
-- Out, from losing clear: the queen holds, then fades; Sachiko is back from 0.55 and gives a
-- little bob as the lift settles
local QUEEN_OUT = { { 0, 0, 0, 0 }, { 0.575, 0, to = { 0, 0, alpha = 0 } }, { 0.7, 0, hide = true } }
local SACHI_OUT = {
{ 0, 1, 0, 0, hide = true }, { 0.55, 1 }, { 1.45, 1, to = { nil, 3 } }, { 1.6, 0, y = 4, to = { nil, 1 } },
{ 1.7, 1, y = 0 },
}
local LIFT_OUT = { { 0, 0, 0, 0 }, { 1.325, 0, to = { nil, 4 } }, { 1.6, 0, to = { nil, 0 } }, { 1.7, 0 } }
local HELPER_OUT = { { 0, 0, 0, -31 }, { 1.3, 0, y = 70, to = { nil, 3 } }, { 1.5, 0 } }
-- the crane flaps twice and flies off up the screen
local CRANE_OUT = {
{ 0, 0, 0, 14 }, { 0.125, 1 }, { 0.25, 2 }, { 0.375, 3 }, { 0.7, 2, 0, 0 }, { 0.825, 1, 0, -22 },
{ 0.95, 0, 0, -62, to = { 0, -435 } }, { 1.3, 0, hide = true },
}
local function tween_value(tw, t)
if not tw then return 0 end
local k = math.max(0, math.min(1, (t - tw.at) / tw.beats))
k = k + (tw.ease or 0) * k * (1 - k)
return tw.from + (tw.to - tw.from) * k
end
local BGFever = {}
BGFever.__index = BGFever
function BGFever.new(clock)
local self = setmetatable({}, BGFever)
self.name = "bg_fever_0"
self.clock = clock
tex.load_folder(COLLAB_PATH, "bg_fever/" .. self.name)
self.ids = {}
for _, key in ipairs({ "backlight", "truss", "sign", "rig", "stars", "ground", "rim", "earth_glow",
"lantern_glow", "lanterns", "glows", "rays", "shaft", "column", "helper", "crane", "crane_dance", "wing",
"queen", "flash", "sparkle" }) do
self.ids[key] = tex.get_texture(COLLAB_PATH .. "/" .. self.name .. "/" .. key) or 0
end
self.groups = {}
return self
end
-- Sachiko and her lift are the centre dancer's textures (dancer folder, loaded by the group)
function BGFever:dancer_textures()
if self.sachi then return self.sachi end
self.sachi = {}
for _, key in ipairs({ "0_start", "0_hole", "0_lift", "0_lip", "0_feet" }) do
self.sachi[key] = tex.get_texture(COLLAB_PATH .. "/dancer_0/" .. key) or 0
end
return self.sachi
end
function BGFever:progress(name) return tween_value(self.groups[name], self.clock.beats) end
function BGFever:start()
local now = self.clock.beats
for name, g in pairs(GROUPS) do
self.groups[name] = { from = self:progress(name), to = 1, at = now + g.at, beats = g.beats, ease = g.ease }
end
self.state, self.t0 = "in", now
end
function BGFever:stop()
if not self.state then return end
local now = self.clock.beats
for name, g in pairs(GROUPS) do
self.groups[name] = { from = self:progress(name), to = 0, at = now, beats = g.back }
end
self.state, self.t0 = "out", now
end
function BGFever:update()
if self.state == "out" and self.clock.beats - self.t0 >= OUT_BEATS then self.state = nil end
end
function BGFever:active() return self.state ~= nil end
-- how far the hall has sunk, px
function BGFever:camera()
return self.state and math.floor(STAGE_DROP * self:progress("stage")) or 0
end
-- behind the hall: the night sky, the Earth's rim, the lanterns and the rays
function BGFever:draw_back()
if not self.state then return end
local ids, now = self.ids, self.clock.ms
local stars, earth = self:progress("stars"), self:progress("earth")
local lanterns, rays = self:progress("lanterns"), self:progress("rays")
tex.draw_texture(ids.stars, { y = STARS_RISE * stars })
tex.draw_texture(ids.ground, { y = EARTH_RISE * earth })
tex.draw_texture(ids.rim, { y = EARTH_RISE * earth })
for i = 0, 1 do
tex.draw_texture(ids.earth_glow, { index = i, y = EARTH_RISE * earth, blend = "additive",
mirror = i == 1 and "horizontal" or nil })
end
if lanterns > 0 then
tex.draw_texture(ids.lantern_glow, { y = GLOW_DROP * lanterns, fade = lanterns, blend = "additive" })
end
if rays > 0 then
local a = triangle(now, GLOW_MS)
tex.draw_texture(ids.rays, { frame = 0, fade = rays * a, blend = "additive" })
tex.draw_texture(ids.rays, { frame = 1, fade = rays * (1 - a), blend = "additive" })
end
if lanterns <= 0 then return end
local glow = 0.3 + 0.7 * (1 - triangle(now, GLOW_MS))
for row = 0, 1 do
for side = 0, 1 do
local i = row * 2 + side
tex.draw_texture(ids.lanterns, { index = i, y = -LANTERN_DROP[i + 1] * (1 - lanterns),
mirror = side == 1 and "horizontal" or nil })
end
for side = 0, 1 do
local i = row * 2 + side
tex.draw_texture(ids.glows, { index = i, y = -LANTERN_DROP[i + 1] * (1 - lanterns), fade = glow,
blend = "additive", mirror = side == 1 and "horizontal" or nil })
end
end
end
-- the rig above the stage, normally hidden under the lane: the sign with its backlight and
-- the truss either side (under the dancers' beams), and the lighting bar (over them)
function BGFever:draw_stage(cam)
if not self.state then return end
local ids, y = self.ids, cam * TRUSS_EXTRA
tex.draw_texture(ids.backlight, { y = y })
for i = 0, 1 do
tex.draw_texture(ids.truss, { index = i, y = y, mirror = i == 1 and "horizontal" or nil })
tex.draw_texture(ids.sign, { index = i, y = y })
end
end
function BGFever:draw_rig(cam)
if not self.state then return end
for i = 0, 1 do
tex.draw_texture(self.ids.rig, { index = i, y = cam * RIG_EXTRA, mirror = i == 1 and "horizontal" or nil })
end
end
local function draw_crane(ids, pose, dy)
if not pose then return end
tex.draw_texture(ids.crane, { frame = pose.frame, y = pose.y + dy })
for i = 0, 1 do
tex.draw_texture(ids.wing, { index = i, frame = pose.frame, y = pose.y + dy,
mirror = i == 1 and "horizontal" or nil })
end
end
function BGFever:draw_sparkles(t)
local f = (t * 22.5) % SPARKLE_LOOP
for _, s in ipairs(SPARKLES) do
local u = (f - s[1]) % SPARKLE_LOOP
if u < SPARKLE_LIFE then
local size, alpha = 0.109 + 0.591 * u / 13, 1
if u >= 14 then
local k = (u - 14) / 5
size, alpha = 0.75 + 0.25 * k, 0.832 * (1 - k)
end
size = size * s[4]
local o = SPARKLE_HALF * size
tex.draw_texture(self.ids.sparkle, {
x = s[2] + SPARKLE_HALF, y = s[3] + SPARKLE_HALF, x2 = 2 * SPARKLE_HALF * (size - 1),
y2 = 2 * SPARKLE_HALF * (size - 1), origin = { o, o }, fade = alpha, blend = "additive",
})
end
end
end
-- in front of the hall: Sachiko on her lift, the queen, the crane, the flash and the twinkles.
-- The trapdoor, the light column and her shadow go down with the hall (cam); the lift, the
-- don holding it and Sachiko stay put.
function BGFever:draw_front(cam)
if not self.state then return end
local ids, sachi = self.ids, self:dancer_textures()
local t = self.clock.beats - self.t0
local out = self.state == "out"
local lift = pose_at(out and LIFT_OUT or LIFT_IN, t)
local helper = pose_at(out and HELPER_OUT or HELPER_IN, t)
local feet = out and { alpha = 1 - self:progress("stage") } or pose_at(FEET_IN, t)
tex.draw_texture(sachi["0_hole"], { x = 640, y = cam })
if lift then tex.draw_texture(ids.shaft, { y = lift.y }) end
tex.draw_texture(ids.helper, { y = helper.y })
tex.draw_texture(ids.column, { y = cam })
if lift then tex.draw_texture(sachi["0_lift"], { x = 640, frame = 1, y = lift.y }) end
tex.draw_texture(sachi["0_lip"], { x = 640, frame = 1, y = cam })
if feet then tex.draw_texture(sachi["0_feet"], { x = 640, y = cam, fade = feet.alpha }) end
if out then
local p = pose_at(SACHI_OUT, t)
if p then tex.draw_texture(sachi["0_start"], { x = 640, frame = p.frame, y = p.y }) end
p = pose_at(QUEEN_OUT, t)
if p then tex.draw_texture(ids.queen, { fade = p.alpha }) end
draw_crane(ids, pose_at(CRANE_OUT, t), 0)
return
end
if t < QUEEN_AT then
tex.draw_texture(sachi["0_start"], { x = 640, y = lift and lift.y or 0 })
elseif t < RIDE_AT then
tex.draw_texture(ids.queen)
end
local flash = pose_at(FLASH, t)
if flash then tex.draw_texture(ids.flash, { fade = flash.alpha }) end
draw_crane(ids, pose_at(CRANE_IN, t), 0)
if t < RIDE_AT then return end
local u = t - RIDE_AT
local bob = pose_at(BOB, u % BOB.length).y
tex.draw_texture(ids.queen, { frame = pose_at(QUEEN_DANCE, u % QUEEN_DANCE.length).frame, y = bob })
local flap = pose_at(CRANE_DANCE, u % CRANE_DANCE.length).frame
tex.draw_texture(ids.crane_dance, { frame = flap, y = bob })
for i = 0, 1 do
tex.draw_texture(ids.wing, { index = i, frame = flap + 4, y = bob, mirror = i == 1 and "horizontal" or nil })
end
self:draw_sparkles(u)
end
function BGFever:destroy() tex.unload_folder(COLLAB_PATH, "bg_fever/" .. self.name) end
-- Chibis for good hits: さ or あ hops in from behind the lane and runs across, jumping every
-- beat: it ducks back and squashes, then springs up 59px and drops back
local CHIBI_MOTION = {
key = "1",
hop = { from = { -418, 21 }, peak = { -350, -15 }, up = 0.225 },
run = { y = 38 },
period = 1,
poses = {
{ 0, 0, 0, 0, sy = { 1, 0.9 }, to = { -31, 4, "out" } },
{ 0.125, 0, -31, 4, sy = { 0.9, 1.1 }, to = { -56, -4, "in" } },
{ 0.225, 0, -56, -4, sy = { 1.1, 0.9 }, to = { -27, -59, "out" } },
{ 0.625, 0, -27, -59, sy = { 0.9, 1 }, to = { 0, 0, "in" } },
},
}
local CHIBIS = {
setmetatable({ first = 0 }, { __index = CHIBI_MOTION }),
setmetatable({ first = 1 }, { __index = CHIBI_MOTION }),
}
-- Drumroll: the default flight up-right, one flight time per fan
local RENDA = { kinds = { { 0, 1733 }, { 1, 2000 } } }
-- Background
local KobayashiBackground = {}
KobayashiBackground.__index = KobayashiBackground
function KobayashiBackground.new(player_num, bpm)
local self = setmetatable({}, KobayashiBackground)
self.clock = new_clock(bpm)
self.donbg = DonBGBase.new(1, player_num, COLLAB_PATH, DONBG)
self.bg_normal = BGNormal.new(self.clock)
self.bg_fever = BGFever.new(self.clock)
self.fever = Fever.new(bpm, COLLAB_PATH)
local dancer_class = Dancer.define(SPECS)
dancer_class.draw = kobayashi_draw
self.dancer = Dancer.BaseDancerGroup.new(0, bpm, MAX_DANCERS, COLLAB_PATH, dancer_class)
table.sort(self.dancer.dancers, function(a, b) return a.index < b.index end)
self.dancer.needs_initial_dancer = false
self.dancer:add_dancer() -- Sachiko is always on stage
self.renda = RendaController.new(COLLAB_PATH, 0, RENDA)
self.chibi = ChibiController.new(bpm, COLLAB_PATH, 1)
self.is_clear = false
self.is_rainbow = false
return self
end
function KobayashiBackground:update(current_ms, bpm)
clock_update(self.clock, current_ms, bpm)
self.donbg:update(current_ms, bpm)
self.bg_fever:update()
self.fever:update(current_ms, bpm)
self.dancer:update(current_ms, bpm)
self.renda:update(current_ms)
self.chibi:update(current_ms, bpm)
end
function KobayashiBackground:handle_good(player_num)
BaseChibi.add(self.chibi, CHIBIS[math.random(#CHIBIS)], COLLAB_PATH, player_num)
end
function KobayashiBackground:handle_ok(player_num) self:handle_good(player_num) end
function KobayashiBackground:handle_bad(player_num) self.chibi:add_chibi(player_num, true) end
function KobayashiBackground:handle_drumroll(player_num) self.renda:add_renda() end
function KobayashiBackground:handle_balloon(player_num) self.renda:add_renda() end
function KobayashiBackground:handle_gauge(player_num, progress, is_clear, is_rainbow)
self.donbg:set_clear(is_clear)
if is_clear and not self.is_clear then self.bg_fever:start() end
if not is_clear and self.is_clear then self.bg_fever:stop() end
if is_rainbow and not self.is_rainbow then self.fever:start() end
if not is_rainbow and self.is_rainbow then self.fever:stop() end
self.is_clear = is_clear
self.is_rainbow = is_rainbow
local group = self.dancer
local want = is_clear and MAX_DANCERS or DANCERS[math.min(MAX_DANCERS - 1, math.floor(progress * MAX_DANCERS)) + 1]
while group.active_count < want do group:add_dancer() end
while group.active_count > want do group:leave_dancer() end
end
-- while clearing, the clear draws Sachiko and her lift; her floor light and beam stay
local SACHI_STAGE = { _floor = true, _beam = true }
function KobayashiBackground:draw_dancers(cam)
local fever = self.bg_fever:active()
for _, slot in ipairs(DRAW_ORDER) do
local d = self.dancer.active_dancers[slot]
if d then d:draw(SLOTS[slot], cam * RIG_EXTRA, fever and d.index == 0 and SACHI_STAGE or nil) end
end
end
function KobayashiBackground:draw_back()
local bg_fever = self.bg_fever
bg_fever:draw_back()
local cam = bg_fever:camera()
if cam < STAGE_DROP then
shifted(cam, function()
self.bg_normal:draw()
bg_fever:draw_stage(cam)
self:draw_dancers(cam)
bg_fever:draw_rig(cam)
end)
end
bg_fever:draw_front(cam)
self.donbg:draw()
self.renda:draw()
self.fever:draw()
self.chibi:draw()
end
function KobayashiBackground:draw_fore() end
function KobayashiBackground:destroy()
self.donbg:destroy()
self.bg_normal:destroy()
self.bg_fever:destroy()
self.fever:destroy()
self.dancer:destroy()
self.renda:destroy()
self.chibi:destroy()
end
return KobayashiBackground
Reference in new issue View Git Blame Copy Permalink