343 lines
17 KiB
JavaScript
343 lines
17 KiB
JavaScript
import JSZip from 'jszip';
|
||
import db from './sql.mjs';
|
||
import { MAX_NOTES, MAX_HOLD_MS, cleanNotes, cleanTitle, insertMap } from './square_clicker.mjs';
|
||
|
||
// Beatmap import for Square Clicker: .osz sets (zip: audio, background, one .osu text file per
|
||
// difficulty) and loose .osu files, converted to Square Clicker notes { t, x, y, d, p? }.
|
||
//
|
||
// Standard and catch: circle / fruit -> tap, slider / juice stream -> slider (curve sampled, repeats
|
||
// become a path that goes back and forth, duration from length, timing and slider velocity),
|
||
// spinner / banana shower -> hold in the middle.
|
||
// Taiko: every object sits in the middle of the playfield, so positions are generated: a path that
|
||
// flows over the screen (don turns gently, kat turns sharply, distance grows with the time gap).
|
||
// Drumroll and denden -> hold.
|
||
// Mania: columns become lanes side by side, long notes holds; chords collapse to one note (one cursor).
|
||
|
||
const PF_W = 512, PF_H = 384; // playfield in osu pixels
|
||
// playfield -> viewport fractions, leaving room for the top bar and the edges
|
||
const toX = (x) => Math.max(0.02, Math.min(0.98, 0.1 + (x / PF_W) * 0.8));
|
||
const toY = (y) => Math.max(0.02, Math.min(0.98, 0.14 + (y / PF_H) * 0.74));
|
||
const MAX_OSU_BYTES = 4 * 1024 * 1024; // one .osu file
|
||
const MAX_DIFFS = 40;
|
||
|
||
// ── .osu text -> sections ─────────────────────────────────────────────────────
|
||
export const parseOsu = (text) => {
|
||
const out = { General: {}, Metadata: {}, Difficulty: {}, Events: [], TimingPoints: [], HitObjects: [] };
|
||
let sec = null;
|
||
for (let line of String(text).replace(/^/, '').split(/\r?\n/)) {
|
||
line = line.trim();
|
||
if (!line || line.startsWith('//')) continue;
|
||
const m = /^\[(\w+)\]$/.exec(line);
|
||
if (m) { sec = m[1]; continue; }
|
||
if (!sec) continue;
|
||
if (sec === 'General' || sec === 'Metadata' || sec === 'Difficulty') {
|
||
const i = line.indexOf(':');
|
||
if (i > 0) out[sec][line.slice(0, i).trim()] = line.slice(i + 1).trim();
|
||
} else if (Array.isArray(out[sec])) {
|
||
out[sec].push(line);
|
||
}
|
||
}
|
||
return out;
|
||
};
|
||
|
||
// ── curves ────────────────────────────────────────────────────────────────────
|
||
const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
|
||
const lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
|
||
|
||
const bezier = (pts) => {
|
||
let len = 0;
|
||
for (let i = 1; i < pts.length; i++) len += dist(pts[i - 1], pts[i]);
|
||
const n = Math.max(2, Math.min(200, Math.ceil(len / 4)));
|
||
const out = [];
|
||
for (let s = 0; s <= n; s++) {
|
||
let q = pts.slice();
|
||
const t = s / n;
|
||
while (q.length > 1) q = q.slice(1).map((p, i) => lerp(q[i], p, t)); // de Casteljau
|
||
out.push(q[0]);
|
||
}
|
||
return out;
|
||
};
|
||
|
||
const catmull = (pts) => {
|
||
const out = [];
|
||
for (let i = 0; i < pts.length - 1; i++) {
|
||
const p0 = pts[i - 1] || pts[i], p1 = pts[i], p2 = pts[i + 1], p3 = pts[i + 2] || p2;
|
||
for (let s = 0; s < 16; s++) {
|
||
const t = s / 16, t2 = t * t, t3 = t2 * t;
|
||
out.push([0, 1].map(k => 0.5 * (2 * p1[k] + (-p0[k] + p2[k]) * t + (2 * p0[k] - 5 * p1[k] + 4 * p2[k] - p3[k]) * t2 + (-p0[k] + 3 * p1[k] - 3 * p2[k] + p3[k]) * t3)));
|
||
}
|
||
}
|
||
out.push(pts[pts.length - 1]);
|
||
return out;
|
||
};
|
||
|
||
// Perfect circle through three points; null when they are (nearly) on a line
|
||
const arc = (a, b, c) => {
|
||
const d = 2 * (a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1]));
|
||
if (Math.abs(d) < 1e-3) return null;
|
||
const sq = (p) => p[0] * p[0] + p[1] * p[1];
|
||
const cx = (sq(a) * (b[1] - c[1]) + sq(b) * (c[1] - a[1]) + sq(c) * (a[1] - b[1])) / d;
|
||
const cy = (sq(a) * (c[0] - b[0]) + sq(b) * (a[0] - c[0]) + sq(c) * (b[0] - a[0])) / d;
|
||
const r = Math.hypot(a[0] - cx, a[1] - cy);
|
||
const a0 = Math.atan2(a[1] - cy, a[0] - cx);
|
||
let a2 = Math.atan2(c[1] - cy, c[0] - cx);
|
||
// direction: the way that passes through b (sign of the turn a -> b -> c)
|
||
const ccw = ((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) > 0;
|
||
if (ccw) { while (a2 < a0) a2 += 2 * Math.PI; } else { while (a2 > a0) a2 -= 2 * Math.PI; }
|
||
// sample well past the end point: the slider length decides where it stops
|
||
const span = (a2 - a0) * 2;
|
||
const n = Math.max(8, Math.min(200, Math.ceil(Math.abs(span) * r / 4)));
|
||
const out = [];
|
||
for (let s = 0; s <= n; s++) { const t = a0 + span * s / n; out.push([cx + r * Math.cos(t), cy + r * Math.sin(t)]); }
|
||
return out;
|
||
};
|
||
|
||
// Slider curve as a polyline (osu pixels), before cutting to the slider length
|
||
const curve = (type, pts) => {
|
||
if (type === 'P' && pts.length === 3) {
|
||
const c = arc(pts[0], pts[1], pts[2]);
|
||
if (c) return c;
|
||
return pts;
|
||
}
|
||
if (type === 'L') return pts;
|
||
if (type === 'C') return catmull(pts);
|
||
// Bezier (also the fallback): a repeated point starts a new segment
|
||
const out = [];
|
||
let seg = [pts[0]];
|
||
for (let i = 1; i < pts.length; i++) {
|
||
if (pts[i][0] === pts[i - 1][0] && pts[i][1] === pts[i - 1][1]) { out.push(...bezier(seg)); seg = [pts[i]]; }
|
||
else seg.push(pts[i]);
|
||
}
|
||
out.push(...bezier(seg));
|
||
return out;
|
||
};
|
||
|
||
// Cut / extend a polyline to exactly `length`, then resample it to k points evenly along it
|
||
const fitLength = (poly, length, k) => {
|
||
const cum = [0];
|
||
for (let i = 1; i < poly.length; i++) cum.push(cum[i - 1] + dist(poly[i - 1], poly[i]));
|
||
const total = cum[cum.length - 1];
|
||
const at = (s) => {
|
||
if (poly.length < 2) return poly[0];
|
||
if (s >= total) { // past the end: go on along the last direction
|
||
const a = poly[poly.length - 2], b = poly[poly.length - 1], l = dist(a, b) || 1;
|
||
return [b[0] + (b[0] - a[0]) / l * (s - total), b[1] + (b[1] - a[1]) / l * (s - total)];
|
||
}
|
||
let i = 1;
|
||
while (i < cum.length - 1 && cum[i] < s) i++;
|
||
const seg = cum[i] - cum[i - 1] || 1;
|
||
return lerp(poly[i - 1], poly[i], (s - cum[i - 1]) / seg);
|
||
};
|
||
return Array.from({ length: k }, (_, i) => at(length * i / (k - 1)));
|
||
};
|
||
|
||
// ── timing ────────────────────────────────────────────────────────────────────
|
||
// -> sorted [{ time, beatLength, sv }]: the beat length and slider velocity in effect from `time` on
|
||
const timingOf = (lines) => {
|
||
const out = [];
|
||
let beat = 500, sv = 1;
|
||
const pts = lines.map(l => l.split(',')).filter(p => p.length >= 2)
|
||
.map(p => ({ time: +p[0], bl: +p[1], unin: p.length > 6 ? p[6] === '1' : +p[1] > 0 }))
|
||
.filter(p => isFinite(p.time) && isFinite(p.bl))
|
||
.sort((a, z) => a.time - z.time || (z.unin - a.unin)); // uninherited first at the same time
|
||
for (const p of pts) {
|
||
if (p.unin && p.bl > 0) { beat = p.bl; sv = 1; }
|
||
else if (!p.unin && p.bl < 0) sv = Math.max(0.1, Math.min(10, -100 / p.bl));
|
||
out.push({ time: p.time, beatLength: beat, sv });
|
||
}
|
||
if (!out.length) out.push({ time: 0, beatLength: 500, sv: 1 });
|
||
return out;
|
||
};
|
||
const timingAt = (tps, t) => {
|
||
let cur = tps[0];
|
||
for (const p of tps) { if (p.time <= t + 1) cur = p; else break; }
|
||
return cur;
|
||
};
|
||
|
||
// ── generated positions (taiko) ───────────────────────────────────────────────
|
||
// A path that wanders over the screen: every note turns it a little (don) or a lot (kat), notes further
|
||
// apart in time are further apart on screen, and a spot that would cover a note still on screen (or leave
|
||
// the play area) is avoided by turning further until the spot is free
|
||
const flowPlace = (list) => {
|
||
const ASPECT = 1.6; // x/y are fractions of a wide viewport: a y step this much larger is the same distance
|
||
const ON_SCREEN_MS = 1200; // notes this close in time are visible together
|
||
const FREE_X = 0.065, FREE_Y = 0.12; // about a note and a bit, as viewport fractions
|
||
const inside = (x, y) => x >= 0.15 && x <= 0.85 && y >= 0.2 && y <= 0.82;
|
||
const out = [];
|
||
let x = 0.5, y = 0.5, ang = -Math.PI / 2, prevEnd = null;
|
||
for (const n of list) {
|
||
if (prevEnd !== null) {
|
||
const want = ang + (n.kat ? 2.2 : 0.3);
|
||
const step = Math.max(0.11, Math.min(0.3, (n.t - prevEnd) / 1000 * 0.35));
|
||
const recent = out.filter(o => n.t - o.t < ON_SCREEN_MS);
|
||
const free = (px, py) => inside(px, py) && !recent.some(o => Math.abs(o.x - px) < FREE_X && Math.abs(o.y - py) < FREE_Y);
|
||
let best = null;
|
||
for (let k = 0; k < 24 && !best; k++) { // want, want+0.26, want-0.26, want+0.52, ...
|
||
const a = want + (k % 2 ? 1 : -1) * Math.ceil(k / 2) * 0.26;
|
||
const px = x + Math.cos(a) * step, py = y + Math.sin(a) * step * ASPECT;
|
||
if (free(px, py)) best = [a, px, py];
|
||
}
|
||
if (!best) { // boxed in: the farthest in-bounds spot from the recent notes
|
||
let far = -1;
|
||
for (let k = 0; k < 24; k++) {
|
||
const a = want + k * Math.PI / 12;
|
||
const px = Math.max(0.15, Math.min(0.85, x + Math.cos(a) * step)), py = Math.max(0.2, Math.min(0.82, y + Math.sin(a) * step * ASPECT));
|
||
const dmin = recent.reduce((m, o) => Math.min(m, Math.hypot(o.x - px, (o.y - py) / ASPECT)), Infinity);
|
||
if (dmin > far) { far = dmin; best = [a, px, py]; }
|
||
}
|
||
}
|
||
[ang, x, y] = best;
|
||
}
|
||
prevEnd = n.t + (n.d || 0); // after a hold the gap counts from its end
|
||
out.push({ t: n.t, x: +x.toFixed(4), y: +y.toFixed(4), d: n.d || 0 });
|
||
}
|
||
return out;
|
||
};
|
||
|
||
// ── one difficulty -> notes ───────────────────────────────────────────────────
|
||
const MODES = ['standard', 'taiko', 'catch', 'mania'];
|
||
// -> { version, creator, notes, mode, error? }
|
||
export const convertOsu = (text) => {
|
||
const o = parseOsu(text);
|
||
const mode = parseInt(o.General.Mode || '0', 10) || 0;
|
||
const version = o.Metadata.Version || 'Normal';
|
||
const res = { version, creator: o.Metadata.Creator || '', mode, meta: o.Metadata, audioFile: o.General.AudioFilename || '', notes: [] };
|
||
if (!MODES[mode]) { res.error = 'unknown game mode ' + mode; return res; }
|
||
const tps = timingOf(o.TimingPoints);
|
||
const mult = parseFloat(o.Difficulty.SliderMultiplier) || 1.4;
|
||
const keys = Math.max(1, Math.min(18, Math.round(parseFloat(o.Difficulty.CircleSize) || 4))); // mania columns
|
||
const holdUntil = (t, end) => Math.max(0, Math.min(MAX_HOLD_MS, Math.round(end) - t));
|
||
const sliderMs = (t, p) => {
|
||
const tp = timingAt(tps, t);
|
||
const slides = Math.max(1, Math.min(50, parseInt(p[6], 10) || 1));
|
||
return (Math.max(1, +p[7] || 0) / (mult * 100 * tp.sv) * tp.beatLength) * slides;
|
||
};
|
||
let notes = [];
|
||
const flow = []; // taiko: { t, d, kat } placed afterwards
|
||
for (const line of o.HitObjects) {
|
||
const p = line.split(',');
|
||
if (p.length < 4) continue;
|
||
const x = +p[0], y = +p[1], t = Math.round(+p[2]), type = +p[3];
|
||
if (!isFinite(x) || !isFinite(y) || !isFinite(t) || t < 0) continue;
|
||
if (mode === 1) { // taiko: hitSound whistle (2) or clap (8) = kat
|
||
if (type & 2) flow.push({ t, d: holdUntil(t, t + sliderMs(t, p)) }); // drumroll
|
||
else if (type & 8) flow.push({ t, d: holdUntil(t, +p[5] || t) }); // denden
|
||
else if (type & 1) flow.push({ t, d: 0, kat: !!((+p[4] || 0) & 10) });
|
||
continue;
|
||
}
|
||
if (mode === 3) { // mania: x picks the column; type 128 = long note, end time in the extras
|
||
const col = Math.max(0, Math.min(keys - 1, Math.floor(x * keys / PF_W)));
|
||
const d = type & 128 ? holdUntil(t, parseInt(String(p[5] || '').split(':')[0], 10) || t) : 0;
|
||
notes.push({ t, x: +(0.15 + (col + 0.5) / keys * 0.7).toFixed(4), y: 0.62, d });
|
||
continue;
|
||
}
|
||
if (type & 2) { // slider: x,y,time,type,hitSound,curve,slides,length,...
|
||
const [ctype, ...cps] = String(p[5] || '').split('|');
|
||
const ctrl = [[x, y], ...cps.map(s => s.split(':').map(Number)).filter(q => q.length === 2 && q.every(isFinite))];
|
||
const slides = Math.max(1, Math.min(50, parseInt(p[6], 10) || 1));
|
||
const length = Math.max(1, +p[7] || 0);
|
||
const tp = timingAt(tps, t);
|
||
const perSlide = length / (mult * 100 * tp.sv) * tp.beatLength;
|
||
const d = Math.round(perSlide * slides);
|
||
if (!isFinite(d) || d <= 0 || ctrl.length < 2) { notes.push({ t, x: toX(x), y: toY(y), d: 0 }); continue; }
|
||
const k = Math.max(2, Math.min(Math.ceil(length / 12) + 1, 40, Math.floor(900 / slides)));
|
||
const leg = fitLength(curve(ctype, ctrl), length, k);
|
||
const path = [];
|
||
for (let s = 0; s < slides; s++) {
|
||
const pts = s % 2 ? leg.slice().reverse() : leg;
|
||
pts.forEach((q, i) => {
|
||
if (s > 0 && i === 0) return; // the turn point is already there
|
||
path.push([Math.round(perSlide * (s + i / (k - 1))), +toX(q[0]).toFixed(4), +toY(q[1]).toFixed(4)]);
|
||
});
|
||
}
|
||
notes.push({ t, x: toX(x), y: toY(y), d: Math.min(MAX_HOLD_MS, d), p: path });
|
||
} else if (type & 8) { // spinner: x,y,time,type,hitSound,endTime -> hold in the middle
|
||
const end = Math.round(+p[5] || t);
|
||
notes.push({ t, x: 0.5, y: toY(PF_H / 2), d: Math.max(0, Math.min(MAX_HOLD_MS, end - t)) });
|
||
} else if (type & 1) {
|
||
notes.push({ t, x: toX(x), y: toY(y), d: 0 });
|
||
}
|
||
}
|
||
if (mode === 1) notes = flowPlace(flow.sort((a, z) => a.t - z.t));
|
||
notes.sort((a, z) => a.t - z.t);
|
||
// one cursor: notes at the same moment (mania chords) collapse to the first
|
||
notes = notes.filter((n, i) => i === 0 || n.t - notes[i - 1].t > 1);
|
||
if (!notes.length) res.error = 'no hit objects';
|
||
else if (notes.length > MAX_NOTES) res.error = 'too many notes (' + notes.length + ', max ' + MAX_NOTES + ')';
|
||
res.notes = notes;
|
||
return res;
|
||
};
|
||
|
||
// Title of an imported map: "Insane (mapper)", other modes marked: "ONI (mapper, taiko)"
|
||
export const importedTitle = (diff) => {
|
||
const extra = [diff.creator, diff.mode ? MODES[diff.mode] : ''].filter(Boolean).join(', ');
|
||
return diff.version + (extra ? ' (' + extra + ')' : '');
|
||
};
|
||
|
||
// ── .osz -> { meta, audio: { name, data }, background: { name, data } | null, diffs, skipped } ──
|
||
// null when the zip has no .osu files (then it is a normal archive)
|
||
export const readOsz = async (buffer) => {
|
||
let zip;
|
||
try { zip = await JSZip.loadAsync(buffer); } catch (_) { return null; }
|
||
const files = Object.values(zip.files).filter(f => !f.dir);
|
||
const osuFiles = files.filter(f => /\.osu$/i.test(f.name)).slice(0, MAX_DIFFS);
|
||
if (!osuFiles.length) return null;
|
||
const byName = (name) => {
|
||
if (!name) return null;
|
||
const want = name.replace(/\\/g, '/').toLowerCase();
|
||
return files.find(f => f.name.toLowerCase() === want) || files.find(f => f.name.toLowerCase().endsWith('/' + want)) || null;
|
||
};
|
||
const diffs = [], skipped = [];
|
||
let meta = null, audioName = null, bgName = null;
|
||
for (const f of osuFiles) {
|
||
const text = await f.async('string');
|
||
if (text.length > MAX_OSU_BYTES) { skipped.push({ version: f.name, reason: 'file too large' }); continue; }
|
||
const d = convertOsu(text);
|
||
if (d.error) { skipped.push({ version: d.version, reason: d.error }); continue; }
|
||
diffs.push(d);
|
||
if (!meta) meta = d.meta;
|
||
if (!audioName) audioName = d.audioFile;
|
||
if (!bgName) {
|
||
const ev = parseOsu(text).Events.find(l => /^0\s*,\s*0\s*,/.test(l));
|
||
const m = ev && /^0\s*,\s*0\s*,\s*"?([^",]+)"?/.exec(ev);
|
||
if (m) bgName = m[1].trim();
|
||
}
|
||
}
|
||
// audio: the file the difficulties name, or any audio file in the set
|
||
const audioFile = byName(audioName) || files.find(f => /\.(mp3|ogg|wav|flac|m4a)$/i.test(f.name));
|
||
const bgFile = byName(bgName) || files.find(f => /\.(jpe?g|png)$/i.test(f.name));
|
||
diffs.sort((a, z) => a.notes.length - z.notes.length); // easiest first
|
||
return {
|
||
meta: meta || {},
|
||
audio: audioFile ? { name: audioFile.name, data: await audioFile.async('nodebuffer') } : null,
|
||
background: bgFile ? { name: bgFile.name, data: await bgFile.async('nodebuffer') } : null,
|
||
diffs,
|
||
skipped,
|
||
};
|
||
};
|
||
|
||
// "Artist - Title" for the item title
|
||
export const setTitle = (meta) => [meta.Artist || meta.ArtistUnicode, meta.Title || meta.TitleUnicode].filter(Boolean).join(' - ');
|
||
|
||
// Store converted difficulties as maps of an item (or album entry). A difficulty that is already
|
||
// there (same title and note count) is skipped, so importing a set twice adds nothing.
|
||
// -> { ids, skipped: [{ version, reason }] }
|
||
export const saveDiffs = async ({ itemId, albumItemId = null, userId, diffs, durationMs = 0 }) => {
|
||
const ids = [], skipped = [];
|
||
for (const d of diffs) {
|
||
const v = cleanNotes(d.notes, 0);
|
||
if (v.error) { skipped.push({ version: d.version, reason: v.error }); continue; }
|
||
const title = cleanTitle(importedTitle(d));
|
||
const [dupe] = await db`
|
||
SELECT id FROM sqc_maps
|
||
WHERE item_id = ${itemId} AND album_item_id IS NOT DISTINCT FROM ${albumItemId}::int
|
||
AND title = ${title} AND note_count = ${v.notes.length}
|
||
LIMIT 1
|
||
`;
|
||
if (dupe) { skipped.push({ version: d.version, reason: 'already imported' }); continue; }
|
||
const last = v.notes[v.notes.length - 1];
|
||
ids.push(await insertMap({ itemId, albumItemId, userId, title, notes: v.notes, durationMs: durationMs || last.t + last.d + 2000 }));
|
||
}
|
||
return { ids, skipped };
|
||
};
|