sonolus-next-rush-engine 2.13.0 → 2.13.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/holodori/analyze.d.ts +3 -0
- package/dist/holodori/analyze.js +3 -0
- package/dist/holodori/convert.d.ts +3 -0
- package/dist/holodori/convert.js +252 -0
- package/dist/index.d.ts +3 -2
- package/dist/index.js +10 -2
- package/package.json +1 -1
|
@@ -0,0 +1,3 @@
|
|
|
1
|
+
import { isLevelData } from '../LevelData/analyze.js';
|
|
2
|
+
/** Holodori LevelData contains measure lines, which Next Rush does not use. */
|
|
3
|
+
export const isHolodoriLevelData = (input) => isLevelData(input) && input.entities.some((entity) => entity?.archetype === 'MeasureLine');
|
|
@@ -0,0 +1,252 @@
|
|
|
1
|
+
const GUIDE_GHOST = 100;
|
|
2
|
+
const GUIDE_NEUTRAL = 101;
|
|
3
|
+
const GUIDE_BLACK = 108;
|
|
4
|
+
const GUIDE_LAYER = 1;
|
|
5
|
+
const RGB_FIELDS = new Set(['segmentRed', 'segmentGreen', 'segmentBlue']);
|
|
6
|
+
const noteArchetypes = new Set([
|
|
7
|
+
'DamageNote',
|
|
8
|
+
'AnchorNote',
|
|
9
|
+
'TransientHiddenTickNote',
|
|
10
|
+
'TransientHiddenDamageTickNote',
|
|
11
|
+
]);
|
|
12
|
+
for (const critical of ['Normal', 'Critical']) {
|
|
13
|
+
for (const position of ['', 'Head', 'Tail']) {
|
|
14
|
+
for (const kind of ['Tap', 'Flick', 'Trace', 'TraceFlick', 'Release']) {
|
|
15
|
+
noteArchetypes.add(`${critical}${position}${kind}Note`);
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
noteArchetypes.add(`${critical}TickNote`);
|
|
19
|
+
}
|
|
20
|
+
for (const archetype of [...noteArchetypes])
|
|
21
|
+
noteArchetypes.add(`Fake${archetype}`);
|
|
22
|
+
const supportedArchetypes = new Set([
|
|
23
|
+
...noteArchetypes,
|
|
24
|
+
'Initialization',
|
|
25
|
+
'#BPM_CHANGE',
|
|
26
|
+
'#TIMESCALE_GROUP',
|
|
27
|
+
'#TIMESCALE_CHANGE',
|
|
28
|
+
'Connector',
|
|
29
|
+
'SimLine',
|
|
30
|
+
'CameraChange',
|
|
31
|
+
'Stage',
|
|
32
|
+
'StageMaskChange',
|
|
33
|
+
'StagePivotChange',
|
|
34
|
+
'StageStyleChange',
|
|
35
|
+
'StageTransformChange',
|
|
36
|
+
'Skill',
|
|
37
|
+
'FeverChance',
|
|
38
|
+
'FeverStart',
|
|
39
|
+
]);
|
|
40
|
+
const getValue = (entity, name, fallback = 0) => {
|
|
41
|
+
const field = entity.data.find((field) => field.name === name);
|
|
42
|
+
return field && 'value' in field ? field.value : fallback;
|
|
43
|
+
};
|
|
44
|
+
const setValue = (entity, name, value) => {
|
|
45
|
+
entity.data = entity.data.filter((field) => field.name !== name);
|
|
46
|
+
entity.data.push({ name, value });
|
|
47
|
+
};
|
|
48
|
+
const clamp01 = (value) => Math.max(0, Math.min(1, value));
|
|
49
|
+
/** Alpha values in Next Rush's draw order: white, R, G, B, Y, M, C, black. */
|
|
50
|
+
const getGuideAlphas = (entity) => {
|
|
51
|
+
const channels = ['segmentRed', 'segmentGreen', 'segmentBlue']
|
|
52
|
+
.map((name, index) => ({ value: clamp01(getValue(entity, name, 1)), index }))
|
|
53
|
+
.sort((a, b) => a.value - b.value);
|
|
54
|
+
const [low, middle, high] = channels;
|
|
55
|
+
const weights = Array(8).fill(0);
|
|
56
|
+
// Express RGB as white + a secondary + a primary + black (weights sum to 1).
|
|
57
|
+
// Purple is treated as magenta. Secondary indices are C, M, Y respectively.
|
|
58
|
+
weights[0] = low.value;
|
|
59
|
+
weights[[6, 5, 4][low.index]] = middle.value - low.value;
|
|
60
|
+
weights[high.index + 1] = high.value - middle.value;
|
|
61
|
+
weights[7] = 1 - high.value;
|
|
62
|
+
const alpha = clamp01(getValue(entity, 'segmentAlpha', 1));
|
|
63
|
+
const alphas = Array(8).fill(0);
|
|
64
|
+
let above = 0;
|
|
65
|
+
for (let index = 7; index >= 0; index--) {
|
|
66
|
+
const contribution = alpha * weights[index];
|
|
67
|
+
const remaining = 1 - above;
|
|
68
|
+
alphas[index] = remaining > 0 ? clamp01(contribution / remaining) : 0;
|
|
69
|
+
above += contribution;
|
|
70
|
+
}
|
|
71
|
+
return alphas;
|
|
72
|
+
};
|
|
73
|
+
/** Convert Holodori LevelData to Next Rush LevelData without mutating the input. */
|
|
74
|
+
export const hldToLeveldata = (hld, offset = 0) => {
|
|
75
|
+
const byName = new Map();
|
|
76
|
+
for (const entity of hld.entities) {
|
|
77
|
+
if (entity.name !== undefined)
|
|
78
|
+
byName.set(entity.name, entity);
|
|
79
|
+
}
|
|
80
|
+
const resolve = (entity, name) => {
|
|
81
|
+
const field = entity.data.find((field) => field.name === name);
|
|
82
|
+
return field && 'ref' in field ? byName.get(field.ref) : undefined;
|
|
83
|
+
};
|
|
84
|
+
const usedNames = new Set(byName.keys());
|
|
85
|
+
let nextId = 0;
|
|
86
|
+
const newName = () => {
|
|
87
|
+
let name;
|
|
88
|
+
do
|
|
89
|
+
name = `hld-${nextId++}`;
|
|
90
|
+
while (usedNames.has(name));
|
|
91
|
+
usedNames.add(name);
|
|
92
|
+
return name;
|
|
93
|
+
};
|
|
94
|
+
const converted = new Map();
|
|
95
|
+
const guideConnectors = [];
|
|
96
|
+
const entities = [];
|
|
97
|
+
const initialization = hld.entities.find((entity) => entity.archetype === 'Initialization');
|
|
98
|
+
const copy = (source, archetype = source.archetype) => ({
|
|
99
|
+
archetype,
|
|
100
|
+
name: source.name ?? newName(),
|
|
101
|
+
data: source.data
|
|
102
|
+
.filter((field) => !RGB_FIELDS.has(field.name))
|
|
103
|
+
.map((field) => ({ ...field })),
|
|
104
|
+
});
|
|
105
|
+
const init = initialization ? copy(initialization) : { archetype: 'Initialization', data: [] };
|
|
106
|
+
entities.push(init);
|
|
107
|
+
if (initialization)
|
|
108
|
+
converted.set(initialization, init);
|
|
109
|
+
for (const source of hld.entities) {
|
|
110
|
+
if (source.archetype === 'Initialization')
|
|
111
|
+
continue;
|
|
112
|
+
const archetype = source.archetype === 'SkillActivationLine' ? 'Skill' : source.archetype;
|
|
113
|
+
if (!supportedArchetypes.has(archetype))
|
|
114
|
+
continue;
|
|
115
|
+
if (archetype === 'Connector') {
|
|
116
|
+
const points = ['head', 'tail', 'segmentHead', 'segmentTail'].map((name) => resolve(source, name));
|
|
117
|
+
if (points.some((point) => !point || !noteArchetypes.has(point.archetype)))
|
|
118
|
+
continue;
|
|
119
|
+
if (getValue(points[2], 'segmentKind') === GUIDE_GHOST) {
|
|
120
|
+
guideConnectors.push(source);
|
|
121
|
+
continue;
|
|
122
|
+
}
|
|
123
|
+
}
|
|
124
|
+
if (archetype === 'SimLine' &&
|
|
125
|
+
['left', 'right'].some((name) => {
|
|
126
|
+
const point = resolve(source, name);
|
|
127
|
+
return !point || !noteArchetypes.has(point.archetype);
|
|
128
|
+
})) {
|
|
129
|
+
continue;
|
|
130
|
+
}
|
|
131
|
+
const entity = copy(source, archetype);
|
|
132
|
+
if (archetype === 'Skill') {
|
|
133
|
+
// Match the SUS -> USC -> LevelData Skill settings (engine defaults).
|
|
134
|
+
entity.data = [{ name: '#BEAT', value: getValue(source, '#BEAT') }];
|
|
135
|
+
}
|
|
136
|
+
else if (noteArchetypes.has(archetype)) {
|
|
137
|
+
const kind = getValue(source, 'segmentKind');
|
|
138
|
+
if (kind === GUIDE_GHOST)
|
|
139
|
+
setValue(entity, 'segmentKind', 0);
|
|
140
|
+
if (kind >= GUIDE_NEUTRAL && kind <= GUIDE_BLACK) {
|
|
141
|
+
setValue(entity, 'segmentLayer', GUIDE_LAYER);
|
|
142
|
+
setValue(entity, 'segmentThroughJudgeLine', 1);
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
converted.set(source, entity);
|
|
146
|
+
entities.push(entity);
|
|
147
|
+
}
|
|
148
|
+
// Holodori allows overlapping slide heads to share one tap. Keep one tap/flick
|
|
149
|
+
// head per overlapping pair and let the others accept that touch as traces.
|
|
150
|
+
const seenHeads = new Set();
|
|
151
|
+
const retainedHeadsByBeat = new Map();
|
|
152
|
+
for (const [source] of converted) {
|
|
153
|
+
if (source.archetype !== 'Connector')
|
|
154
|
+
continue;
|
|
155
|
+
const segmentHead = resolve(source, 'segmentHead');
|
|
156
|
+
const kind = getValue(segmentHead, 'segmentKind');
|
|
157
|
+
if (kind >= GUIDE_GHOST && kind <= GUIDE_BLACK)
|
|
158
|
+
continue;
|
|
159
|
+
const head = converted.get(resolve(source, 'head'));
|
|
160
|
+
if (seenHeads.has(head))
|
|
161
|
+
continue;
|
|
162
|
+
seenHeads.add(head);
|
|
163
|
+
if (!/^(Normal|Critical)(Head|Tail)?(Tap|Flick)Note$/.test(head.archetype))
|
|
164
|
+
continue;
|
|
165
|
+
const beat = getValue(head, '#BEAT');
|
|
166
|
+
const lane = getValue(head, 'lane');
|
|
167
|
+
const size = getValue(head, 'size');
|
|
168
|
+
const retainedHeads = retainedHeadsByBeat.get(beat) ?? [];
|
|
169
|
+
const overlaps = retainedHeads.some((other) => Math.abs(lane - getValue(other, 'lane')) < size + getValue(other, 'size'));
|
|
170
|
+
if (overlaps) {
|
|
171
|
+
head.archetype = head.archetype.endsWith('TapNote')
|
|
172
|
+
? head.archetype.replace('TapNote', 'TraceNote')
|
|
173
|
+
: head.archetype.replace('FlickNote', 'TraceFlickNote');
|
|
174
|
+
}
|
|
175
|
+
else {
|
|
176
|
+
retainedHeads.push(head);
|
|
177
|
+
retainedHeadsByBeat.set(beat, retainedHeads);
|
|
178
|
+
}
|
|
179
|
+
}
|
|
180
|
+
// Drop references to skipped entities and update names assigned to unnamed entities.
|
|
181
|
+
for (const entity of entities) {
|
|
182
|
+
entity.data = entity.data.flatMap((field) => {
|
|
183
|
+
if (!('ref' in field))
|
|
184
|
+
return [field];
|
|
185
|
+
const original = byName.get(field.ref);
|
|
186
|
+
const target = original && converted.get(original);
|
|
187
|
+
return target?.name === undefined ? [] : [{ name: field.name, ref: target.name }];
|
|
188
|
+
});
|
|
189
|
+
}
|
|
190
|
+
const guideNotes = new Map();
|
|
191
|
+
const alphaCache = new Map();
|
|
192
|
+
const alphasFor = (source) => {
|
|
193
|
+
let alphas = alphaCache.get(source);
|
|
194
|
+
if (!alphas) {
|
|
195
|
+
alphas = getGuideAlphas(source);
|
|
196
|
+
alphaCache.set(source, alphas);
|
|
197
|
+
}
|
|
198
|
+
return alphas;
|
|
199
|
+
};
|
|
200
|
+
const guideNote = (source, index) => {
|
|
201
|
+
let layers = guideNotes.get(source);
|
|
202
|
+
if (!layers) {
|
|
203
|
+
layers = new Map();
|
|
204
|
+
guideNotes.set(source, layers);
|
|
205
|
+
}
|
|
206
|
+
const existing = layers.get(index);
|
|
207
|
+
if (existing)
|
|
208
|
+
return existing;
|
|
209
|
+
// Use unscored anchors so RGB overlays never duplicate scored notes or active slides.
|
|
210
|
+
const entity = copy(converted.get(source), 'AnchorNote');
|
|
211
|
+
entity.name = newName();
|
|
212
|
+
entity.data = entity.data.filter((field) => !['next', 'prev', 'activeHead'].includes(field.name));
|
|
213
|
+
setValue(entity, 'segmentKind', GUIDE_NEUTRAL + index);
|
|
214
|
+
setValue(entity, 'segmentAlpha', alphasFor(source)[index]);
|
|
215
|
+
setValue(entity, 'segmentLayer', GUIDE_LAYER);
|
|
216
|
+
setValue(entity, 'segmentThroughJudgeLine', 1);
|
|
217
|
+
layers.set(index, entity);
|
|
218
|
+
entities.push(entity);
|
|
219
|
+
return entity;
|
|
220
|
+
};
|
|
221
|
+
for (const source of guideConnectors) {
|
|
222
|
+
const head = resolve(source, 'head');
|
|
223
|
+
const tail = resolve(source, 'tail');
|
|
224
|
+
const segmentHead = resolve(source, 'segmentHead');
|
|
225
|
+
const segmentTail = resolve(source, 'segmentTail');
|
|
226
|
+
for (let index = 0; index < 8; index++) {
|
|
227
|
+
if (alphasFor(segmentHead)[index] === 0 && alphasFor(segmentTail)[index] === 0)
|
|
228
|
+
continue;
|
|
229
|
+
entities.push({
|
|
230
|
+
archetype: 'Connector',
|
|
231
|
+
name: newName(),
|
|
232
|
+
data: [
|
|
233
|
+
{ name: 'head', ref: guideNote(head, index).name },
|
|
234
|
+
{ name: 'tail', ref: guideNote(tail, index).name },
|
|
235
|
+
{ name: 'segmentHead', ref: guideNote(segmentHead, index).name },
|
|
236
|
+
{ name: 'segmentTail', ref: guideNote(segmentTail, index).name },
|
|
237
|
+
],
|
|
238
|
+
});
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
for (const [source, layers] of guideNotes) {
|
|
242
|
+
for (const [index, entity] of layers) {
|
|
243
|
+
for (const name of ['next', 'prev']) {
|
|
244
|
+
const original = resolve(source, name);
|
|
245
|
+
const target = original && guideNotes.get(original)?.get(index);
|
|
246
|
+
if (target?.name !== undefined)
|
|
247
|
+
entity.data.push({ name, ref: target.name });
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
return { ...hld, bgmOffset: hld.bgmOffset + offset, entities };
|
|
252
|
+
};
|
package/dist/index.d.ts
CHANGED
|
@@ -1,13 +1,14 @@
|
|
|
1
1
|
import { LevelData } from '@sonolus/core';
|
|
2
2
|
import { type ExtendedEntityData, type ExtendedEntityDataField, extendedToLevelData } from './extended/convert.js';
|
|
3
|
+
import { hldToLeveldata } from './holodori/convert.js';
|
|
3
4
|
import { mmwsToUSC, ucmmwsToLevelData } from './mmw/convert.js';
|
|
4
5
|
import { susToUSC } from './sus/convert.js';
|
|
5
6
|
import { uscToLevelData } from './usc/convert.js';
|
|
6
7
|
import { USC } from './usc/index.js';
|
|
7
8
|
export * from './usc/index.js';
|
|
8
|
-
export { type ExtendedEntityData, type ExtendedEntityDataField, extendedToLevelData, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
|
|
9
|
+
export { type ExtendedEntityData, type ExtendedEntityDataField, extendedToLevelData, hldToLeveldata, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
|
|
9
10
|
export declare const convertToLevelData: (input: string | Uint8Array | USC | LevelData, offset?: number) => LevelData;
|
|
10
|
-
export declare const version = "2.13.
|
|
11
|
+
export declare const version = "2.13.2";
|
|
11
12
|
export declare const engineFullName: {
|
|
12
13
|
readonly en: 'Next RUSH';
|
|
13
14
|
};
|
package/dist/index.js
CHANGED
|
@@ -1,6 +1,8 @@
|
|
|
1
1
|
import { TextFunction } from '@sonolus/core';
|
|
2
2
|
import { isExtendedLevelData } from './extended/analyze.js';
|
|
3
3
|
import { extendedToLevelData, } from './extended/convert.js';
|
|
4
|
+
import { isHolodoriLevelData } from './holodori/analyze.js';
|
|
5
|
+
import { hldToLeveldata } from './holodori/convert.js';
|
|
4
6
|
import { isLevelData } from './LevelData/analyze.js';
|
|
5
7
|
import { detectMMWSType } from './mmw/analyze.js';
|
|
6
8
|
import { mmwsToUSC, ucmmwsToLevelData } from './mmw/convert.js';
|
|
@@ -8,8 +10,11 @@ import { susToUSC } from './sus/convert.js';
|
|
|
8
10
|
import { isUSC } from './usc/analyze.js';
|
|
9
11
|
import { uscToLevelData } from './usc/convert.js';
|
|
10
12
|
export * from './usc/index.js';
|
|
11
|
-
export { extendedToLevelData, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
|
|
13
|
+
export { extendedToLevelData, hldToLeveldata, mmwsToUSC, susToUSC, ucmmwsToLevelData, uscToLevelData, };
|
|
12
14
|
export const convertToLevelData = (input, offset = 0) => {
|
|
15
|
+
if (isHolodoriLevelData(input)) {
|
|
16
|
+
return hldToLeveldata(input, offset);
|
|
17
|
+
}
|
|
13
18
|
if (isExtendedLevelData(input)) {
|
|
14
19
|
const converted = extendedToLevelData(input, offset);
|
|
15
20
|
if (converted)
|
|
@@ -41,6 +46,9 @@ export const convertToLevelData = (input, offset = 0) => {
|
|
|
41
46
|
else if (typeof input === 'string') {
|
|
42
47
|
try {
|
|
43
48
|
const parsed = JSON.parse(input);
|
|
49
|
+
if (isHolodoriLevelData(parsed)) {
|
|
50
|
+
return hldToLeveldata(parsed, offset);
|
|
51
|
+
}
|
|
44
52
|
if (isExtendedLevelData(parsed)) {
|
|
45
53
|
const converted = extendedToLevelData(parsed, offset);
|
|
46
54
|
if (converted)
|
|
@@ -66,7 +74,7 @@ export const convertToLevelData = (input, offset = 0) => {
|
|
|
66
74
|
}
|
|
67
75
|
return uscToLevelData(usc, offset, true, true);
|
|
68
76
|
};
|
|
69
|
-
export const version = '2.13.
|
|
77
|
+
export const version = '2.13.2';
|
|
70
78
|
export const engineFullName = {
|
|
71
79
|
en: 'Next RUSH',
|
|
72
80
|
};
|