240 lines
6.8 KiB
Haxe
240 lines
6.8 KiB
Haxe
package funkin.backend.chart;
|
|
|
|
import funkin.backend.chart.ChartData.ChartEvent;
|
|
import funkin.backend.system.Conductor;
|
|
|
|
class FNFLegacyParser {
|
|
public static function parse(data:Dynamic, result:ChartData) {
|
|
// base fnf chart parsing
|
|
var data:SwagSong = data;
|
|
if (Reflect.hasField(data, "song")) {
|
|
var field:Dynamic = Reflect.field(data, "song");
|
|
if (!(field is String))
|
|
data = field;
|
|
}
|
|
|
|
result.scrollSpeed = data.speed;
|
|
result.stage = data.stage;
|
|
|
|
var p2isGF:Bool = false;
|
|
result.strumLines.push({
|
|
characters: [data.player2],
|
|
type: 0,
|
|
position: (p2isGF = data.player2.startsWith("gf")) ? "girlfriend" : "dad",
|
|
notes: []
|
|
});
|
|
result.strumLines.push({
|
|
characters: [data.player1],
|
|
type: 1,
|
|
position: "boyfriend",
|
|
notes: []
|
|
});
|
|
var gfName = data.gf != null ? data.gf : (data.gfVersion != null ? data.gfVersion : "gf");
|
|
if (!p2isGF && gfName != "none") {
|
|
result.strumLines.push({
|
|
characters: [gfName],
|
|
type: 2,
|
|
position: "girlfriend",
|
|
notes: [],
|
|
visible: false,
|
|
});
|
|
}
|
|
|
|
result.meta.bpm = data.bpm;
|
|
result.meta.needsVoices = data.needsVoices.getDefault(true);
|
|
|
|
var camFocusedBF:Bool = false;
|
|
var altAnims:Bool = false;
|
|
var beatsPerMeasure:Float = data.beatsPerMeasure.getDefault(Constants.DEFAULT_BEATS_PER_MEASURE);
|
|
var curBPM:Float = data.bpm;
|
|
var curTime:Float = 0;
|
|
var curCrochet:Float = ((60 / curBPM) * 1000);
|
|
|
|
if (data.notes != null) for(section in data.notes) {
|
|
if (section == null) {
|
|
curTime += curCrochet * beatsPerMeasure;
|
|
continue; // Yoshi Engine charts crash fix
|
|
}
|
|
|
|
if (camFocusedBF != (camFocusedBF = section.mustHitSection)) {
|
|
result.events.push({
|
|
time: curTime,
|
|
name: "Camera Movement",
|
|
params: [camFocusedBF ? 1 : 0]
|
|
});
|
|
}
|
|
|
|
if (section.altAnim == null) section.altAnim = false;
|
|
if (altAnims != (altAnims = section.altAnim)) {
|
|
result.events.push({
|
|
time: curTime,
|
|
name: "Alt Animation Toggle",
|
|
params: [altAnims, false, 0]
|
|
});
|
|
}
|
|
|
|
if (section.sectionNotes != null) for(note in section.sectionNotes) {
|
|
if (note[1] < 0) continue;
|
|
|
|
var daStrumTime:Float = note[0];
|
|
var daNoteData:Int = Std.int(note[1] % 8);
|
|
var daNoteType:Int = Std.int(note[1] / 8);
|
|
var gottaHitNote:Bool = daNoteData >= 4 ? !section.mustHitSection : section.mustHitSection;
|
|
|
|
if (note.length > 2) {
|
|
if (note[3] is Int && data.noteTypes != null)
|
|
daNoteType = Chart.addNoteType(result, data.noteTypes[Std.int(note[3])-1]);
|
|
else if (note[3] is String)
|
|
daNoteType = Chart.addNoteType(result, note[3]);
|
|
} else {
|
|
if(data.noteTypes != null)
|
|
daNoteType = Chart.addNoteType(result, data.noteTypes[daNoteType-1]);
|
|
}
|
|
|
|
result.strumLines[gottaHitNote ? 1 : 0].notes.push({
|
|
time: daStrumTime,
|
|
id: daNoteData % 4,
|
|
type: daNoteType,
|
|
sLen: note[2]
|
|
});
|
|
}
|
|
|
|
if (section.changeBPM && section.bpm != curBPM) {
|
|
curCrochet = ((60 / (curBPM = section.bpm)) * 1000);
|
|
|
|
result.events.push({
|
|
time: curTime,
|
|
name: "BPM Change",
|
|
params: [section.bpm]
|
|
});
|
|
}
|
|
|
|
curTime += curCrochet * beatsPerMeasure;
|
|
}
|
|
}
|
|
|
|
// have conductor set up BEFORE you run this :D -lunar
|
|
public static function encode(chart:ChartData):Dynamic {
|
|
var base:SwagSong = __convertToSwagSong(chart);
|
|
base.notes = __convertToSwagSections(chart);
|
|
|
|
for (strumLine in chart.strumLines)
|
|
for (note in strumLine.notes) {
|
|
var section:Int = Math.floor(Conductor.getStepForTime(note.time) / Conductor.getMeasureLength());
|
|
var swagSection:SwagSection = base.notes[section];
|
|
if (section > 0 && section < base.notes.length) {
|
|
var sectionNote:Array<Dynamic> = [
|
|
note.time, // TIME
|
|
note.id, // DATA
|
|
note.sLen // SUSTAIN LENGTH
|
|
];
|
|
|
|
if ((swagSection.mustHitSection && strumLine.type == OPPONENT) ||
|
|
(!swagSection.mustHitSection && strumLine.type == PLAYER))
|
|
sectionNote[1] += 4;
|
|
swagSection.sectionNotes.push(sectionNote);
|
|
}
|
|
}
|
|
|
|
return {song: base};
|
|
}
|
|
|
|
// To make it easier to write the psych parser... -lunar
|
|
@:noCompletion public static function __convertToSwagSong(chart:ChartData):SwagSong {
|
|
var base:SwagSong = {
|
|
song: chart.meta.name,
|
|
notes: null,
|
|
bpm: chart.meta.bpm,
|
|
speed: chart.scrollSpeed,
|
|
needsVoices: chart.meta.needsVoices,
|
|
|
|
player1: null,
|
|
player2: null,
|
|
validScore: true
|
|
};
|
|
|
|
for (strumLine in chart.strumLines)
|
|
switch (strumLine.type) {
|
|
case OPPONENT:
|
|
if (base.player2 == null) base.player2 = strumLine.characters.getDefault([Constants.DEFAULT_OPPONENT])[0];
|
|
case PLAYER:
|
|
if (base.player1 == null) base.player1 = strumLine.characters.getDefault([Constants.DEFAULT_CHARACTER])[0];
|
|
case ADDITIONAL: // do nothing
|
|
}
|
|
|
|
return base;
|
|
}
|
|
|
|
@:noCompletion public static function __convertToSwagSections(chart:ChartData):Array<SwagSection> {
|
|
var events:Array<ChartEvent> = [for (event in chart.events) Reflect.copy(event)];
|
|
|
|
var measures:Float = Conductor.getMeasuresLength();
|
|
var sections:Int = Math.floor(measures) + (measures % 1 > 0 ? 1 : 0);
|
|
|
|
var notes:Array<SwagSection> = cast new haxe.ds.Vector<SwagSection>(sections);
|
|
for (section in 0...sections) {
|
|
var baseSection:SwagSection = {
|
|
sectionNotes: [],
|
|
lengthInSteps: Std.int(Conductor.getMeasureLength()),
|
|
mustHitSection: notes[section-1] != null ? notes[section-1].mustHitSection : false,
|
|
bpm: notes[section-1] != null ? notes[section-1].bpm : chart.meta.bpm,
|
|
changeBPM: false,
|
|
altAnim: notes[section-1] != null ? notes[section-1].altAnim : false
|
|
};
|
|
|
|
var sectionEndTime:Float = Conductor.getTimeForStep(Conductor.getMeasureLength() * (section+1));
|
|
while(events.length > 0 && events[0].time < sectionEndTime) {
|
|
var event:ChartEvent = events.shift();
|
|
switch (event.name) {
|
|
case "Camera Movement":
|
|
baseSection.mustHitSection = chart.strumLines[event.params[0]].type == PLAYER;
|
|
case "Alt Animation Toggle":
|
|
baseSection.altAnim = event.params[0] || event.params[1];
|
|
case "BPM Change":
|
|
baseSection.changeBPM = true;
|
|
baseSection.bpm = event.params[0];
|
|
}
|
|
}
|
|
notes[section] = baseSection;
|
|
}
|
|
return notes;
|
|
}
|
|
}
|
|
|
|
typedef SwagSong =
|
|
{
|
|
var song:String;
|
|
var notes:Array<SwagSection>;
|
|
var bpm:Float;
|
|
var speed:Float;
|
|
var ?stage:String;
|
|
var ?noteTypes:Array<String>;
|
|
var ?events:Array<Dynamic>;
|
|
var ?needsVoices:Bool;
|
|
|
|
var player1:String;
|
|
var player2:String;
|
|
var ?gf:String;
|
|
var ?gfVersion:String;
|
|
var validScore:Bool;
|
|
|
|
// ADDITIONAL STUFF THAT MAY NOT BE PRESENT IN CHART
|
|
var ?maxHealth:Float;
|
|
var ?beatsPerMeasure:Float;
|
|
var ?stepsPerBeat:Float;
|
|
}
|
|
|
|
typedef SwagSection =
|
|
{
|
|
var sectionNotes:Array<Array<Dynamic>>;
|
|
var lengthInSteps:Int;
|
|
var ?sectionBeats:Float;
|
|
var ?typeOfSection:Int;
|
|
var mustHitSection:Bool;
|
|
var ?gfSection:Bool;
|
|
var bpm:Float;
|
|
var changeBPM:Bool;
|
|
var altAnim:Null<Bool>;
|
|
var ?camTarget:Null<Float>;
|
|
}
|