498 lines
20 KiB
Lua
498 lines
20 KiB
Lua
local F, DX, DY = 0.75, -166.5, 61.75
|
|
local F1 = 0.87
|
|
local CFG = {
|
|
dan_exam_info = { x = 22 * F, y = 94 * F, width = 940 * F + 40 },
|
|
dan_result_song_name = { x = 1240 * F1 + -153.6, y = 90 * F1 + 49.36, width = 705 * F1,
|
|
font_size = math.floor(40 * F1 + 0.5) }, -- banner right edge (1280) - 40
|
|
score_info_counter_margin = { x = 24 * F },
|
|
p1_counter_margin = { x = 24 * F1 },
|
|
dan_result_info_height = { y = 191 * F1 },
|
|
dan_result_hori_name = { x = 146.0, y = 123.5, width = 275 * F }, -- centred on the dan emblem
|
|
dan_result_diff_num_margin = { x = 12 * F1 },
|
|
}
|
|
-- exam captions: where the value starts, right of the label (Green px from its x 1163)
|
|
local CAP_DX = { gauge = 6, hit = 33, combo = 22, score = 0, judgegood = 23, judgebad = 32, renda = 5, judgeperfect = 23 }
|
|
local CAP_RIGHT = 180
|
|
local LABEL_R = { gauge = 2, hit = 29, combo = 18, score = -31, judgegood = 19, judgebad = 28, renda = 1, judgeperfect = 19 } -- label ink right edge (Green px from x 1163)
|
|
local COL_LABEL_END, COL_NUM_END, COL_UNIT = 30, 127, 135
|
|
local TITLE_FONT = math.floor(40 * F + 0.5)
|
|
local function cfg(k) return CFG[k] end
|
|
|
|
local FRAME_MS = 1000.0 / 60.0
|
|
local DIGIT_ROLL_MS = 500.0
|
|
local GAUGE_UNIT_MS = 3 * (1000.0 / 120.0)
|
|
local GAUGE_NUMIN_MS = 10 * FRAME_MS + 500.0
|
|
|
|
local SLIDE_MS = 22 * FRAME_MS
|
|
local SLIDE_DIST = 1600.0 * F1
|
|
local SLIDE_BREAK_AT = 5.0 / 22.0
|
|
local SLIDE_BREAK_X = 35.0 * F1
|
|
|
|
local function slide_offset(t)
|
|
if t <= 0 then return SLIDE_DIST end
|
|
if t >= SLIDE_MS then return 0.0 end
|
|
local p = t / SLIDE_MS
|
|
if p <= SLIDE_BREAK_AT then
|
|
return SLIDE_DIST + (SLIDE_BREAK_X - SLIDE_DIST) * (p / SLIDE_BREAK_AT)
|
|
end
|
|
return SLIDE_BREAK_X * (1.0 - (p - SLIDE_BREAK_AT) / (1.0 - SLIDE_BREAK_AT))
|
|
end
|
|
|
|
local function pen_count(subset, name)
|
|
local info = tex.get_texture_info(subset, name)
|
|
return info and #info.x or 1
|
|
end
|
|
|
|
DanResultDraw = {}
|
|
DanResultDraw.__index = DanResultDraw
|
|
|
|
function DanResultDraw.new(rd, prev_arrival, prev_best_score, best_score_show,
|
|
gauge_exam, gauge_value, gauge_border)
|
|
local self = setmetatable({}, DanResultDraw)
|
|
self.rd = rd
|
|
self.prev_arrival = prev_arrival
|
|
self.gauge_exam = gauge_exam
|
|
self.gauge_value = gauge_value
|
|
self.gauge_border = gauge_border
|
|
|
|
local function T(path) return tex.get_texture("dan_result/" .. path) end
|
|
|
|
self.t_genre_banner = T("background/genre_banner")
|
|
self.t_result_2_bg = T("background/result_2_bg")
|
|
self.t_result_2_divider = T("background/result_2_divider")
|
|
self.t_result_2_pullout = T("background/result_2_pullout")
|
|
|
|
self.t_song_num = T("result_info/song_num")
|
|
self.t_difficulty = T("result_info/difficulty")
|
|
self.t_diff_star = T("result_info/diff_star")
|
|
self.t_diff_x = T("result_info/diff_x")
|
|
self.t_diff_num = T("result_info/diff_num")
|
|
for _, n in ipairs({"good", "ok", "bad", "drumroll", "counter"}) do
|
|
self["p1_" .. n] = T("result_info/p1_" .. n)
|
|
end
|
|
self.t_good = T("result_info/good")
|
|
self.t_ok = T("result_info/ok")
|
|
self.t_bad = T("result_info/bad")
|
|
self.t_drumroll = T("result_info/drumroll")
|
|
self.t_counter = T("result_info/counter")
|
|
self.t_max_combo = T("result_info/max_combo")
|
|
self.t_max_hits = T("result_info/max_hits")
|
|
self.t_score_box = T("result_info/score_box")
|
|
self.t_score_counter = T("result_info/score_counter")
|
|
self.t_exam_header = T("result_info/exam_header")
|
|
self.t_dan_emblem = T("result_info/dan_emblem")
|
|
|
|
self.t_exam_bg = T("exam_info/exam_bg")
|
|
self.t_exam_overlay_1 = T("exam_info/exam_overlay_1")
|
|
self.t_exam_overlay_2 = T("exam_info/exam_overlay_2")
|
|
self.t_exam_max = T("exam_info/exam_max")
|
|
self.t_exam_gold = T("exam_info/exam_gold")
|
|
self.t_exam_red = T("exam_info/exam_red")
|
|
self.t_value_counter = T("exam_info/value_counter")
|
|
self.t_exam_less = T("exam_info/exam_less")
|
|
self.t_exam_more = T("exam_info/exam_more")
|
|
self.t_exam_percent = T("exam_info/exam_percent")
|
|
self.t_exam_fail = T("exam_info/fail")
|
|
self.t_gold_clear = T("exam_info/gold_clear")
|
|
self.t_red_clear = T("exam_info/red_clear")
|
|
|
|
self.vpen = pen_count("exam_info", "value_counter") > 1 and 1 or 0
|
|
self.ppen = pen_count("exam_info", "exam_percent") > 1 and 1 or 0
|
|
|
|
self.exam_icons = {
|
|
gauge = T("exam_info/exam_gauge"), combo = T("exam_info/exam_combo"),
|
|
hit = T("exam_info/exam_hit"), judgebad = T("exam_info/exam_judgebad"),
|
|
judgegood = T("exam_info/exam_judgegood"), judgeperfect = T("exam_info/exam_judgeperfect"),
|
|
score = T("exam_info/exam_score"), renda = T("exam_info/exam_drumroll"),
|
|
}
|
|
|
|
self.g_unfilled = T("gauge/1p_unfilled")
|
|
self.g_bar = T("gauge/1p_bar")
|
|
self.g_overlay = T("gauge/overlay")
|
|
self.g_rainbow = T("gauge/rainbow")
|
|
self.g_footer = T("gauge/footer")
|
|
self.g_tamashii = T("gauge/tamashii")
|
|
self.g_tamashii_dark = T("gauge/tamashii_dark")
|
|
self.g_tamashii_overlay = T("gauge/tamashii_overlay")
|
|
self.g_fire = T("gauge/tamashii_fire")
|
|
self.gauge_bar_width = 712.0 * F
|
|
|
|
local r = rd.odai_result
|
|
if r > 0 then
|
|
self.t_clear_variant = (r >= 4) and self.t_gold_clear or self.t_red_clear
|
|
end
|
|
|
|
local dan_title_cfg = tex.get_skin_config("dan_select_title") or {}
|
|
local font_size = TITLE_FONT
|
|
self.hori_name = text.create_raw_text(rd.dan_title, font_size,
|
|
{255,255,255,255}, {0,0,0,255}, false,
|
|
(dan_title_cfg.outline or -1) >= 0 and dan_title_cfg.outline or 5.0)
|
|
|
|
local sn_cfg = cfg("dan_result_song_name")
|
|
local song_font_size = (sn_cfg.font_size and sn_cfg.font_size > 0) and sn_cfg.font_size or font_size
|
|
local song_outline = (sn_cfg.outline and sn_cfg.outline >= 0) and sn_cfg.outline or 5.0
|
|
self.song_names = {}
|
|
for i, song in ipairs(rd.songs) do
|
|
local title = song.song_title
|
|
if song.hidden and song.unreached and prev_arrival < i then
|
|
title = "？？？？？？"
|
|
end
|
|
self.song_names[i] = text.create_raw_text(title, song_font_size,
|
|
{255,255,255,255}, {0,0,0,255}, false, song_outline)
|
|
end
|
|
|
|
return self
|
|
end
|
|
|
|
function DanResultDraw:draw_digit_counter(digits, margin_x, id, index, y, fade, scale, x_off, roll_t)
|
|
x_off = x_off or 0.0
|
|
roll_t = roll_t or -1.0
|
|
local n = #digits
|
|
for j = 1, n do
|
|
local r = n - j
|
|
local frame = tonumber(digits:sub(j, j))
|
|
if roll_t >= 0.0 then
|
|
if roll_t < r * DIGIT_ROLL_MS then goto continue end
|
|
if roll_t < (r + 1) * DIGIT_ROLL_MS then
|
|
frame = math.floor(roll_t / 83.0 + r) % 10
|
|
end
|
|
end
|
|
local x = x_off - (n - j + 1) * margin_x
|
|
tex.draw_texture(id, {frame = frame, scale = scale, x = x, y = y, fade = fade, index = index})
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
function DanResultDraw:draw_page1(now, p1f)
|
|
local height = cfg("dan_result_info_height").y
|
|
local margin = cfg("p1_counter_margin").x
|
|
|
|
for i, song in ipairs(self.rd.songs) do
|
|
local y = (i - 1) * height
|
|
local land
|
|
if i <= 3 then
|
|
land = ({40, 65, 90})[i] * FRAME_MS
|
|
else
|
|
land = 90 * FRAME_MS + (i - 3) * 25 * FRAME_MS
|
|
end
|
|
if now < land then goto continue end
|
|
local sx = slide_offset(now - land)
|
|
|
|
local rf = (song.unreached and 0.45 or 1.0) * (p1f or 1.0)
|
|
|
|
tex.draw_texture(self.t_genre_banner, {frame = song.genre_index, x = sx, y = y, fade = rf})
|
|
|
|
local sn_name = self.song_names[i]
|
|
if sn_name then
|
|
local sn = cfg("dan_result_song_name")
|
|
local tw = sn_name.width
|
|
local draw_w = (sn.width and sn.width > 0) and math.min(tw, sn.width) or tw
|
|
-- right-aligned at sn.x inside the banner (Green: left-aligned at its x 1230)
|
|
sn_name:draw({x = sn.x - draw_w + sx, y = y + sn.y, x2 = draw_w - tw, fade = rf})
|
|
end
|
|
|
|
tex.draw_texture(self.t_song_num, {frame = i - 1, x = sx, y = y, fade = rf})
|
|
tex.draw_texture(self.t_difficulty, {frame = song.selected_difficulty, x = sx, y = y, fade = rf})
|
|
tex.draw_texture(self.t_diff_star, {x = sx, y = y, fade = rf})
|
|
tex.draw_texture(self.t_diff_x, {x = sx, y = y, fade = rf})
|
|
|
|
local lv = tostring(song.diff_level)
|
|
local dm = cfg("dan_result_diff_num_margin").x
|
|
for j = 1, #lv do
|
|
tex.draw_texture(self.t_diff_num, {frame = tonumber(lv:sub(j, j)),
|
|
x = sx + (j - #lv) * dm, y = y, fade = rf})
|
|
end
|
|
|
|
local function draw_stat(icon, val, idx)
|
|
tex.draw_texture(icon, {x = sx, y = y, fade = rf})
|
|
if song.unreached then return end
|
|
local sv = tostring(val)
|
|
local n = #sv
|
|
for k = 1, n do
|
|
local ch = sv:sub(n - k + 1, n - k + 1)
|
|
tex.draw_texture(self.p1_counter, {frame = tonumber(ch),
|
|
x = sx - (k - 1) * margin, y = y, index = idx})
|
|
end
|
|
end
|
|
draw_stat(self.p1_good, song.good, 0)
|
|
draw_stat(self.p1_ok, song.ok, 1)
|
|
draw_stat(self.p1_bad, song.bad, 2)
|
|
draw_stat(self.p1_drumroll, song.drumroll, 3)
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
function DanResultDraw:draw_gauge_row(y, fade, now)
|
|
local on_page = now - self.page_start_ms
|
|
local cur = self.gauge_value
|
|
local landed = true
|
|
if not self.page2_skipped and on_page < self.totals_start + self.gauge_value * GAUGE_UNIT_MS then
|
|
cur = math.max(0.0, (on_page - self.totals_start) / GAUGE_UNIT_MS)
|
|
if cur > self.gauge_value then cur = self.gauge_value end
|
|
landed = false
|
|
end
|
|
local clear = cur >= self.gauge_border and self.gauge_border > 0
|
|
local w = self.gauge_bar_width * (cur / 100.0)
|
|
|
|
tex.draw_texture(self.g_unfilled, {y = y, fade = fade})
|
|
if w > 0 then
|
|
tex.draw_texture(self.g_bar, {y = y, x2 = w, fade = fade})
|
|
if clear and self.g_rainbow then
|
|
local frame = math.floor(tex.get_current_ms() / 50.0) % 8
|
|
tex.draw_texture(self.g_rainbow, {frame = frame, y = y, x2 = w, fade = fade})
|
|
end
|
|
end
|
|
tex.draw_texture(self.g_overlay, {y = y, fade = fade})
|
|
if self.gauge_border > 0 then
|
|
tex.draw_texture(self.g_footer, {y = y, x = self:gauge_border_x(), fade = fade})
|
|
end
|
|
|
|
local fever = self.gauge_value >= 100 and landed
|
|
tex.draw_texture((clear and landed) and self.g_tamashii or self.g_tamashii_dark, {y = y, fade = fade})
|
|
if clear and landed then tex.draw_texture(self.g_tamashii_overlay, {y = y, fade = fade}) end
|
|
-- the fire is drawn by draw_gauge_fire, under the page-2 totals
|
|
end
|
|
|
|
function DanResultDraw:draw_gauge_fire(fade, now)
|
|
if not self.g_fire or self.gauge_value < 100 then return end
|
|
local on_page = now - self.page_start_ms
|
|
local gi = self.gauge_exam
|
|
if gi == nil or gi < 0 then return end
|
|
local row = self.rows[gi + 1]
|
|
if not row or on_page < row.land then return end
|
|
local landed = self.page2_skipped or on_page >= self.totals_start + self.gauge_value * GAUGE_UNIT_MS
|
|
if not landed then return end
|
|
local y = 0 -- the soul gauge is in the top block
|
|
local frame = math.floor(tex.get_current_ms() / 50.0) % 8
|
|
tex.draw_texture(self.g_fire, {frame = frame, y = y, fade = fade})
|
|
end
|
|
|
|
function DanResultDraw:gauge_border_x()
|
|
return self.gauge_bar_width * (self.gauge_border / 100.0)
|
|
end
|
|
|
|
-- No exam_rainbow/exam_down80 tiers in this skin: only up_50 / up_80 / max.
|
|
function DanResultDraw:draw_exam_fill(state, w, y, fade)
|
|
if w <= 0 or state == "empty" then return end
|
|
local id = self.t_exam_max
|
|
if state == "up_50" then id = self.t_exam_red
|
|
elseif state == "up_80" or state == "down_80" then id = self.t_exam_gold
|
|
end
|
|
tex.draw_texture(id, {x2 = w, y = y, fade = fade})
|
|
end
|
|
|
|
function DanResultDraw:draw_exam_info(fade, now)
|
|
local rd = self.rd
|
|
local on_page = now - self.page_start_ms
|
|
local dei = cfg("dan_select_exam_info")
|
|
local offset_y = dei.y
|
|
local margin = dei.x
|
|
local border_pitch = margin -- no exam_border_counter in this skin
|
|
|
|
local hide_gauge = #rd.exams >= 4
|
|
local slot = 0
|
|
for i, exam in ipairs(rd.exams) do
|
|
local ed = rd.exam_data[i]
|
|
if not ed then goto continue end
|
|
if hide_gauge and exam.type == "gauge" then goto continue end
|
|
local y = slot * offset_y
|
|
slot = slot + 1
|
|
|
|
local row = self.rows[i] or {land = 0, fill0 = 0, filld = 0, numin = 0}
|
|
if on_page < row.land then goto continue end
|
|
|
|
local frac = 1.0
|
|
if not self.page2_skipped and row.filld > 0 then
|
|
frac = math.max(0.0, math.min(1.0, (on_page - row.fill0) / row.filld))
|
|
end
|
|
local row_numin = self.page2_skipped or on_page >= row.numin
|
|
|
|
tex.draw_texture(self.t_exam_bg, {y = y, fade = fade})
|
|
|
|
local tamashii_row = false -- the soul gauge itself is drawn in the top block
|
|
if tamashii_row then
|
|
self:draw_gauge_row(y, fade, now)
|
|
else
|
|
tex.draw_texture(self.t_exam_overlay_1, {y = y, fade = fade})
|
|
|
|
local p = ed.progress
|
|
if exam.range == "less" then p = 1.0 - (1.0 - p) * frac else p = p * frac end
|
|
local bar_w = dei.width * p
|
|
local bs = ed.bar_state
|
|
if frac < 1.0 then
|
|
local g = math.floor(p * 100.0)
|
|
bs = g <= 0 and "empty" or g <= 49 and "up_50" or g <= 99 and "up_80" or "up_100"
|
|
end
|
|
self:draw_exam_fill(bs, bar_w, y, fade)
|
|
end
|
|
|
|
local icon = self.exam_icons[exam.type]
|
|
|
|
local red_str = tostring(exam.red)
|
|
local csc = tamashii_row and (25.0 / 36.0) or 1.0
|
|
local gap1, gap2 = 4.0 * F * csc, 10.0 * F * csc
|
|
local cap_w = #red_str * border_pitch * csc
|
|
if exam.type == "gauge" then cap_w = cap_w + gap1 + 31.0 * F * csc end
|
|
if exam.range == "less" or exam.range == "more" then cap_w = cap_w + gap2 + 70.0 * F * csc end
|
|
local num_w = #red_str * border_pitch * csc
|
|
if exam.type == "gauge" then num_w = num_w + gap1 + 29.0 * F * csc end -- the %'s ink ends at 29 of 32 px
|
|
local cap_dx, cap_dy = COL_NUM_END * F - num_w, 0.0
|
|
if icon then
|
|
tex.draw_texture(icon, {x = (COL_LABEL_END - (LABEL_R[exam.type] or 0)) * F, y = y, fade = fade})
|
|
end
|
|
if tamashii_row then
|
|
cap_dx = self:gauge_border_x() - cap_w * 0.5
|
|
cap_dy = 52.0 * F
|
|
end
|
|
|
|
for k = 1, #red_str do
|
|
tex.draw_texture(self.t_value_counter, {frame = tonumber(red_str:sub(k, k)),
|
|
x = cap_dx + (k - 1) * border_pitch * csc,
|
|
y = y + cap_dy, fade = fade, index = 0})
|
|
end
|
|
local after = cap_dx + #red_str * border_pitch * csc
|
|
if exam.type == "gauge" then
|
|
tex.draw_texture(self.t_exam_percent, {x = after + gap1 + 17.0 * F, y = y + cap_dy, fade = fade, index = 0})
|
|
after = after + gap1 + 31.0 * F * csc
|
|
end
|
|
after = (COL_UNIT - 5) * F -- the unit's anchor is 5 px right of the value's
|
|
if exam.range == "less" then
|
|
tex.draw_texture(self.t_exam_less, {x = after, y = y + cap_dy, fade = fade})
|
|
elseif exam.range == "more" then
|
|
tex.draw_texture(self.t_exam_more, {x = after, y = y + cap_dy, fade = fade})
|
|
end
|
|
|
|
if not tamashii_row then
|
|
tex.draw_texture(self.t_exam_overlay_2, {y = y, fade = fade})
|
|
if row_numin then
|
|
local cur_str = tostring(ed.counter_value)
|
|
for k = 1, #cur_str do
|
|
tex.draw_texture(self.t_value_counter, {frame = tonumber(cur_str:sub(k, k)),
|
|
x = (k - 1) * margin, y = y, fade = fade, index = self.vpen})
|
|
end
|
|
if exam.type == "gauge" then
|
|
tex.draw_texture(self.t_exam_percent, {x = #cur_str * margin - 2.0 * F, y = y, fade = fade, index = self.ppen})
|
|
end
|
|
end
|
|
end
|
|
::continue::
|
|
end
|
|
end
|
|
|
|
function DanResultDraw:draw_page2(fade, now)
|
|
local rd = self.rd
|
|
local on_page = now - self.page_start_ms
|
|
|
|
tex.draw_texture(self.t_result_2_bg, {fade = fade})
|
|
for i = 0, 4 do
|
|
tex.draw_texture(self.t_result_2_divider, {x = i * 240 * F, fade = fade})
|
|
end
|
|
tex.draw_texture(self.t_result_2_pullout, {fade = fade})
|
|
|
|
tex.draw_texture(self.t_dan_emblem, {frame = rd.dan_color, fade = fade})
|
|
if self.hori_name then
|
|
local hn = cfg("dan_result_hori_name")
|
|
self.hori_name:draw({
|
|
x = hn.x - self.hori_name.width / 2.0,
|
|
y = hn.y,
|
|
x2 = math.min(self.hori_name.width, hn.width) - self.hori_name.width,
|
|
fade = fade,
|
|
})
|
|
end
|
|
|
|
local margin = cfg("score_info_counter_margin").x
|
|
|
|
local total_good, total_ok, total_bad, total_dr = 0, 0, 0, 0
|
|
for _, s in ipairs(rd.songs) do
|
|
total_good = total_good + s.good; total_ok = total_ok + s.ok
|
|
total_bad = total_bad + s.bad; total_dr = total_dr + s.drumroll
|
|
end
|
|
|
|
self:draw_gauge_fire(fade, now)
|
|
|
|
local totals_landed = self.page2_skipped or on_page >= self.totals_end
|
|
local roll_t = totals_landed and -1.0 or (on_page - self.totals_start)
|
|
if totals_landed or on_page >= self.totals_start then
|
|
local function draw_total(icon, total, idx_counter)
|
|
tex.draw_texture(icon, {fade = fade, index = 1})
|
|
self:draw_digit_counter(tostring(total), margin, self.t_counter, idx_counter, 0.0, fade, 1.0, margin, roll_t)
|
|
end
|
|
draw_total(self.t_good, total_good, 4)
|
|
draw_total(self.t_ok, total_ok, 5)
|
|
draw_total(self.t_bad, total_bad, 6)
|
|
draw_total(self.t_drumroll, total_dr, 7)
|
|
|
|
tex.draw_texture(self.t_max_combo, {fade = fade})
|
|
self:draw_digit_counter(tostring(rd.max_combo), margin, self.t_counter, 8, 0.0, fade, 1.0, margin, roll_t)
|
|
|
|
local total_hits = total_good + total_ok + total_bad + total_dr
|
|
tex.draw_texture(self.t_max_hits, {fade = fade})
|
|
self:draw_digit_counter(tostring(total_hits), margin, self.t_counter, 9, 0.0, fade, 1.0, margin, roll_t)
|
|
else
|
|
tex.draw_texture(self.t_good, {fade = fade, index = 1})
|
|
tex.draw_texture(self.t_ok, {fade = fade, index = 1})
|
|
tex.draw_texture(self.t_bad, {fade = fade, index = 1})
|
|
tex.draw_texture(self.t_drumroll, {fade = fade, index = 1})
|
|
tex.draw_texture(self.t_max_combo, {fade = fade})
|
|
tex.draw_texture(self.t_max_hits, {fade = fade})
|
|
end
|
|
|
|
tex.draw_texture(self.t_exam_header, {fade = fade})
|
|
|
|
tex.draw_texture(self.t_score_box, {fade = fade})
|
|
if totals_landed or on_page >= self.totals_start then
|
|
self:draw_digit_counter(tostring(rd.score), margin * 0.94, self.t_score_counter, 0, 0.0, fade, 1.0, 12.0, roll_t)
|
|
end
|
|
|
|
local gi = self.gauge_exam
|
|
local grow = gi and gi >= 0 and self.rows[gi + 1]
|
|
if self.g_unfilled and grow and on_page >= grow.land then self:draw_gauge_row(0, fade, now) end
|
|
self:draw_exam_info(fade, now)
|
|
|
|
if on_page < self.stamp_at then return end
|
|
|
|
if rd.odai_result >= 0 then
|
|
local r = rd.odai_result
|
|
if r == 0 then
|
|
tex.draw_texture(self.t_exam_fail, {fade = fade})
|
|
else
|
|
tex.draw_texture(self.t_clear_variant, {fade = fade})
|
|
end
|
|
else
|
|
local any_failed = false
|
|
for _, ed in ipairs(rd.exam_data) do if ed.failed then any_failed = true break end end
|
|
if any_failed then
|
|
tex.draw_texture(self.t_exam_fail, {fade = fade})
|
|
else
|
|
tex.draw_texture(self.t_red_clear, {fade = fade})
|
|
end
|
|
end
|
|
end
|
|
|
|
function DanResultDraw:draw(s)
|
|
local now = s.now
|
|
self.page_start_ms = s.page_start_ms
|
|
self.page1_start_ms = s.page1_start_ms
|
|
self.page2_skipped = s.page2_skipped
|
|
self.totals_start = s.totals_start
|
|
self.totals_end = s.totals_end
|
|
self.rows = s.rows
|
|
self.stamp_at = s.stamp_at
|
|
self.voice_at = s.voice_at
|
|
|
|
local p2f = s.page2_fade or 0.0
|
|
if p2f < 1.0 then self:draw_page1(now - self.page1_start_ms, 1.0 - p2f) end
|
|
self:draw_page2(s.page2_fade, now)
|
|
|
|
tex.draw_rect(0, 0, tex.get_screen_width(), tex.get_screen_height(), 0, 0, 0, math.floor(s.fade_out * 255))
|
|
end
|
|
|
|
-- no character and no nameplate on this screen: both moved off screen
|
|
function DanResultDraw:chara_pos()
|
|
return { -4000, -4000, 1.0 }
|
|
end
|
|
|
|
function DanResultDraw:nameplate_pos()
|
|
return { -4000, -4000, 0.0 }
|
|
end
|