mirror of
https://github.com/ninjamuffin99/Funkin.git
synced 2024-12-01 11:13:06 +00:00
1569 lines
40 KiB
Haxe
1569 lines
40 KiB
Haxe
package funkin.charting;
|
|
|
|
import funkin.Conductor.BPMChangeEvent;
|
|
import funkin.Note.NoteData;
|
|
import funkin.Section.SwagSection;
|
|
import funkin.SongLoad.SwagSong;
|
|
import funkin.audiovis.ABotVis;
|
|
import funkin.audiovis.PolygonSpectogram;
|
|
import funkin.audiovis.SpectogramSprite;
|
|
import flixel.FlxSprite;
|
|
import flixel.addons.display.FlxGridOverlay;
|
|
import flixel.addons.transition.FlxTransitionableState;
|
|
import flixel.addons.ui.FlxInputText;
|
|
import flixel.addons.ui.FlxUI;
|
|
import flixel.addons.ui.FlxUICheckBox;
|
|
import flixel.addons.ui.FlxUIDropDownMenu;
|
|
import flixel.addons.ui.FlxUIInputText;
|
|
import flixel.addons.ui.FlxUINumericStepper;
|
|
import flixel.addons.ui.FlxUITabMenu;
|
|
import flixel.group.FlxGroup;
|
|
import flixel.math.FlxMath;
|
|
import flixel.system.FlxSound;
|
|
import flixel.text.FlxText;
|
|
import flixel.ui.FlxButton;
|
|
import flixel.util.FlxColor;
|
|
import haxe.Json;
|
|
import lime.media.AudioBuffer;
|
|
import lime.utils.Assets;
|
|
import openfl.events.Event;
|
|
import openfl.events.IOErrorEvent;
|
|
import openfl.net.FileReference;
|
|
import funkin.rendering.MeshRender;
|
|
import funkin.play.PlayState;
|
|
|
|
using Lambda;
|
|
using StringTools;
|
|
using flixel.util.FlxSpriteUtil; // add in "compiler save" that saves the JSON directly to the debug json using File.write() stuff on windows / sys
|
|
|
|
class ChartingState extends MusicBeatState
|
|
{
|
|
var _file:FileReference;
|
|
|
|
var UI_box:FlxUITabMenu;
|
|
var sidePreview:FlxSprite;
|
|
|
|
/**
|
|
* Array of notes showing when each section STARTS in STEPS
|
|
* Usually rounded up??
|
|
*/
|
|
var curSection:Int = 0;
|
|
|
|
public static var lastSection:Int = 0;
|
|
|
|
var bpmTxt:FlxText;
|
|
|
|
var strumLine:FlxSprite;
|
|
var curSong:String = 'Dadbattle';
|
|
var amountSteps:Int = 0;
|
|
var bullshitUI:FlxGroup;
|
|
|
|
var highlight:FlxSprite;
|
|
|
|
var GRID_SIZE:Int = 40;
|
|
|
|
var dummyArrow:FlxSprite;
|
|
|
|
var curRenderedNotes:FlxTypedGroup<Note>;
|
|
var curRenderedSustains:FlxTypedGroup<FlxSprite>;
|
|
|
|
var gridBG:FlxSprite;
|
|
|
|
var _song:SwagSong;
|
|
|
|
var typingShit:FlxInputText;
|
|
/*
|
|
* WILL BE THE CURRENT / LAST PLACED NOTE
|
|
**/
|
|
var curSelectedNote:NoteData;
|
|
|
|
var tempBpm:Float = 0;
|
|
|
|
var vocals:VoicesGroup;
|
|
|
|
var leftIcon:HealthIcon;
|
|
var rightIcon:HealthIcon;
|
|
|
|
var audioBuf:AudioBuffer = new AudioBuffer();
|
|
|
|
var playheadTest:FlxSprite;
|
|
|
|
var staticSpecGrp:FlxTypedGroup<SpectogramSprite>;
|
|
|
|
override function create()
|
|
{
|
|
curSection = lastSection;
|
|
|
|
// sys.io.File.saveContent('./bitShit.txt', "swag");
|
|
|
|
// trace(audioBuf.sampleRate);
|
|
|
|
gridBG = FlxGridOverlay.create(GRID_SIZE, GRID_SIZE, GRID_SIZE * 8, GRID_SIZE * 16);
|
|
trace("GRD BG: " + gridBG.height);
|
|
add(gridBG);
|
|
|
|
leftIcon = new HealthIcon('bf');
|
|
rightIcon = new HealthIcon('dad');
|
|
leftIcon.scrollFactor.set(1, 1);
|
|
rightIcon.scrollFactor.set(1, 1);
|
|
|
|
leftIcon.setGraphicSize(0, 45);
|
|
rightIcon.setGraphicSize(0, 45);
|
|
|
|
add(leftIcon);
|
|
add(rightIcon);
|
|
|
|
leftIcon.setPosition(0, -100);
|
|
rightIcon.setPosition(gridBG.width / 2, -100);
|
|
|
|
var gridBlackLine:FlxSprite = new FlxSprite(gridBG.x + gridBG.width / 2).makeGraphic(2, Std.int(gridBG.height), FlxColor.BLACK);
|
|
add(gridBlackLine);
|
|
|
|
curRenderedNotes = new FlxTypedGroup<Note>();
|
|
curRenderedSustains = new FlxTypedGroup<FlxSprite>();
|
|
|
|
if (PlayState.SONG != null)
|
|
{
|
|
_song = SongLoad.songData = PlayState.SONG;
|
|
trace("LOADED A PLAYSTATE SONGFILE");
|
|
}
|
|
else
|
|
{
|
|
_song = SongLoad.songData = SongLoad.getDefaultSwagSong();
|
|
}
|
|
|
|
FlxG.mouse.visible = true;
|
|
FlxG.save.bind('funkin', 'ninjamuffin99');
|
|
|
|
tempBpm = _song.bpm;
|
|
|
|
addSection();
|
|
|
|
// sections = SongLoad.getSong();
|
|
|
|
updateGrid();
|
|
|
|
loadSong(_song.song);
|
|
Conductor.changeBPM(_song.bpm);
|
|
Conductor.mapBPMChanges(_song);
|
|
|
|
bpmTxt = new FlxText(1000, 50, 0, "", 16);
|
|
bpmTxt.scrollFactor.set();
|
|
add(bpmTxt);
|
|
|
|
strumLine = new FlxSprite(0, 50).makeGraphic(Std.int(GRID_SIZE * 8), 4);
|
|
add(strumLine);
|
|
|
|
dummyArrow = new FlxSprite().makeGraphic(GRID_SIZE, GRID_SIZE, 0xFFCC2288);
|
|
dummyArrow.alpha = 0.3;
|
|
add(dummyArrow);
|
|
|
|
var tabs = [
|
|
{name: "Song", label: 'Song'},
|
|
{name: "Section", label: 'Section'},
|
|
{name: "Note", label: 'Note'}
|
|
];
|
|
|
|
UI_box = new FlxUITabMenu(null, tabs, true);
|
|
|
|
UI_box.resize(300, 400);
|
|
UI_box.x = (FlxG.width / 4) * 3;
|
|
UI_box.y = 120;
|
|
add(UI_box);
|
|
|
|
addSongUI();
|
|
addSectionUI();
|
|
addNoteUI();
|
|
|
|
add(curRenderedNotes);
|
|
add(curRenderedSustains);
|
|
|
|
changeSection();
|
|
super.create();
|
|
}
|
|
|
|
function addSongUI():Void
|
|
{
|
|
var UI_songTitle = new FlxUIInputText(10, 10, 70, _song.song, 8);
|
|
typingShit = UI_songTitle;
|
|
|
|
var check_voices = new FlxUICheckBox(10, 25, null, null, "Has voice track", 100);
|
|
check_voices.checked = _song.needsVoices;
|
|
// _song.needsVoices = check_voices.checked;
|
|
check_voices.callback = function()
|
|
{
|
|
_song.needsVoices = check_voices.checked;
|
|
trace('CHECKED!');
|
|
};
|
|
|
|
var check_mute_inst = new FlxUICheckBox(10, 200, null, null, "Mute Instrumental (in editor)", 100);
|
|
check_mute_inst.checked = false;
|
|
check_mute_inst.callback = function()
|
|
{
|
|
var vol:Float = 1;
|
|
|
|
if (check_mute_inst.checked)
|
|
vol = 0;
|
|
|
|
FlxG.sound.music.volume = vol;
|
|
};
|
|
|
|
var saveButton:FlxButton = new FlxButton(110, 8, "Save", function()
|
|
{
|
|
saveLevel();
|
|
});
|
|
|
|
var saveCompiler:FlxButton = new FlxButton(110, 30, "Save compile", function()
|
|
{
|
|
saveLevel(true);
|
|
});
|
|
|
|
var reloadSong:FlxButton = new FlxButton(saveButton.x + saveButton.width + 10, saveButton.y, "Reload Audio", function()
|
|
{
|
|
loadSong(_song.song);
|
|
});
|
|
|
|
var reloadSongJson:FlxButton = new FlxButton(reloadSong.x, saveButton.y + 30, "Reload JSON", function()
|
|
{
|
|
FlxTransitionableState.skipNextTransIn = true;
|
|
FlxTransitionableState.skipNextTransOut = true;
|
|
loadJson(_song.song.toLowerCase());
|
|
});
|
|
|
|
var loadAutosaveBtn:FlxButton = new FlxButton(reloadSongJson.x, reloadSongJson.y + 30, 'load autosave', loadAutosave);
|
|
|
|
var stepperSpeed:FlxUINumericStepper = new FlxUINumericStepper(10, 80, 0.1, 1, 0.1, 10, 2);
|
|
stepperSpeed.value = SongLoad.getSpeed();
|
|
// stepperSpeed.value = _song.speed[SongLoad.curDiff];
|
|
stepperSpeed.name = 'song_speed';
|
|
|
|
var stepperBPM:FlxUINumericStepper = new FlxUINumericStepper(10, 65, 1, 100, 1, 999, 3);
|
|
stepperBPM.value = Conductor.bpm;
|
|
stepperBPM.name = 'song_bpm';
|
|
|
|
var characters:Array<String> = CoolUtil.coolTextFile(Paths.txt('characterList'));
|
|
|
|
var player1DropDown = new FlxUIDropDownMenu(10, 100, FlxUIDropDownMenu.makeStrIdLabelArray(characters, true), function(character:String)
|
|
{
|
|
_song.player1 = characters[Std.parseInt(character)];
|
|
updateHeads();
|
|
});
|
|
player1DropDown.selectedLabel = _song.player1;
|
|
|
|
var player2DropDown = new FlxUIDropDownMenu(140, 100, FlxUIDropDownMenu.makeStrIdLabelArray(characters, true), function(character:String)
|
|
{
|
|
_song.player2 = characters[Std.parseInt(character)];
|
|
updateHeads();
|
|
});
|
|
player2DropDown.selectedLabel = _song.player2;
|
|
|
|
var difficultyDropDown = new FlxUIDropDownMenu(10, 230, FlxUIDropDownMenu.makeStrIdLabelArray(_song.difficulties, true), function(diff:String)
|
|
{
|
|
SongLoad.curDiff = _song.difficulties[Std.parseInt(diff)];
|
|
SongLoad.checkAndCreateNotemap(SongLoad.curDiff);
|
|
|
|
while (SongLoad.getSong()[curSection] == null)
|
|
addSection();
|
|
|
|
updateGrid();
|
|
});
|
|
difficultyDropDown.selectedLabel = SongLoad.curDiff;
|
|
|
|
var difficultyAdder = new FlxUIInputText(130, 230, 100, "", 12);
|
|
|
|
var addDiff:FlxButton = new FlxButton(130, 250, "Add Difficulty", function()
|
|
{
|
|
difficultyAdder.text = "";
|
|
// something to regenerate difficulties
|
|
});
|
|
|
|
var tab_group_song = new FlxUI(null, UI_box);
|
|
tab_group_song.name = "Song";
|
|
tab_group_song.add(UI_songTitle);
|
|
|
|
tab_group_song.add(check_voices);
|
|
tab_group_song.add(check_mute_inst);
|
|
tab_group_song.add(saveButton);
|
|
tab_group_song.add(saveCompiler);
|
|
tab_group_song.add(reloadSong);
|
|
tab_group_song.add(reloadSongJson);
|
|
tab_group_song.add(loadAutosaveBtn);
|
|
tab_group_song.add(stepperBPM);
|
|
tab_group_song.add(stepperSpeed);
|
|
tab_group_song.add(player1DropDown);
|
|
tab_group_song.add(player2DropDown);
|
|
tab_group_song.add(difficultyDropDown);
|
|
tab_group_song.add(difficultyAdder);
|
|
tab_group_song.add(addDiff);
|
|
|
|
UI_box.addGroup(tab_group_song);
|
|
UI_box.scrollFactor.set();
|
|
|
|
FlxG.camera.focusOn(gridBG.getGraphicMidpoint());
|
|
}
|
|
|
|
var stepperLength:FlxUINumericStepper;
|
|
var check_mustHitSection:FlxUICheckBox;
|
|
var check_changeBPM:FlxUICheckBox;
|
|
var stepperSectionBPM:FlxUINumericStepper;
|
|
var check_altAnim:FlxUICheckBox;
|
|
|
|
function addSectionUI():Void
|
|
{
|
|
var tab_group_section = new FlxUI(null, UI_box);
|
|
tab_group_section.name = 'Section';
|
|
|
|
stepperLength = new FlxUINumericStepper(10, 10, 4, 0, 0, 999, 0);
|
|
stepperLength.value = SongLoad.getSong()[curSection].lengthInSteps;
|
|
stepperLength.name = "section_length";
|
|
|
|
stepperSectionBPM = new FlxUINumericStepper(10, 80, 1, Conductor.bpm, 1, 999, 3);
|
|
stepperSectionBPM.value = Conductor.bpm;
|
|
stepperSectionBPM.name = 'section_bpm';
|
|
|
|
var stepperCopy:FlxUINumericStepper = new FlxUINumericStepper(110, 130, 1, 1, -999, 999, 0);
|
|
|
|
var copyButton:FlxButton = new FlxButton(10, 130, "Copy last section", function()
|
|
{
|
|
copySection(Std.int(stepperCopy.value));
|
|
});
|
|
|
|
var clearSectionButton:FlxButton = new FlxButton(10, 150, "Clear", clearSection);
|
|
|
|
var swapSection:FlxButton = new FlxButton(10, 170, "Swap section", function()
|
|
{
|
|
for (i in 0...SongLoad.getSong()[curSection].sectionNotes.length)
|
|
{
|
|
var note:Note = new Note(0, 0);
|
|
note.data = SongLoad.getSong()[curSection].sectionNotes[i];
|
|
note.data.noteData = (note.data.noteData + 4) % 8;
|
|
SongLoad.getSong()[curSection].sectionNotes[i] = note.data;
|
|
updateGrid();
|
|
}
|
|
});
|
|
|
|
check_mustHitSection = new FlxUICheckBox(10, 30, null, null, "Must hit section", 100);
|
|
check_mustHitSection.name = 'check_mustHit';
|
|
check_mustHitSection.checked = true;
|
|
// _song.needsVoices = check_mustHit.checked;
|
|
|
|
check_altAnim = new FlxUICheckBox(10, 400, null, null, "Alt Animation", 100);
|
|
check_altAnim.name = 'check_altAnim';
|
|
|
|
check_changeBPM = new FlxUICheckBox(10, 60, null, null, 'Change BPM', 100);
|
|
check_changeBPM.name = 'check_changeBPM';
|
|
|
|
tab_group_section.add(stepperLength);
|
|
tab_group_section.add(stepperSectionBPM);
|
|
tab_group_section.add(stepperCopy);
|
|
tab_group_section.add(check_mustHitSection);
|
|
tab_group_section.add(check_altAnim);
|
|
tab_group_section.add(check_changeBPM);
|
|
tab_group_section.add(copyButton);
|
|
tab_group_section.add(clearSectionButton);
|
|
tab_group_section.add(swapSection);
|
|
|
|
UI_box.addGroup(tab_group_section);
|
|
}
|
|
|
|
var stepperSusLength:FlxUINumericStepper;
|
|
var stepperPerNoteSpeed:FlxUINumericStepper;
|
|
|
|
function addNoteUI():Void
|
|
{
|
|
var tab_group_note = new FlxUI(null, UI_box);
|
|
tab_group_note.name = 'Note';
|
|
|
|
stepperSusLength = new FlxUINumericStepper(10, 10, Conductor.stepCrochet / 2, 0, 0, Conductor.stepCrochet * 16);
|
|
stepperSusLength.value = 0;
|
|
stepperSusLength.name = 'note_susLength';
|
|
|
|
stepperPerNoteSpeed = new FlxUINumericStepper(10, 40, 0.1, 1, 0.01, 100, 2);
|
|
stepperPerNoteSpeed.value = 1;
|
|
stepperPerNoteSpeed.name = "note_PerNoteSpeed";
|
|
|
|
var noteSpeedName:FlxText = new FlxText(40, stepperPerNoteSpeed.y, 0, "Note Speed Multiplier");
|
|
|
|
var applyLength:FlxButton = new FlxButton(100, 10, 'Apply');
|
|
|
|
tab_group_note.add(stepperSusLength);
|
|
tab_group_note.add(stepperPerNoteSpeed);
|
|
tab_group_note.add(noteSpeedName);
|
|
tab_group_note.add(applyLength);
|
|
|
|
UI_box.addGroup(tab_group_note);
|
|
}
|
|
|
|
// var spec:SpectogramSprite;
|
|
|
|
function loadSong(daSong:String):Void
|
|
{
|
|
if (FlxG.sound.music != null)
|
|
{
|
|
FlxG.sound.music.stop();
|
|
// vocals.stop();
|
|
}
|
|
|
|
var pathShit = Paths.inst(daSong);
|
|
|
|
if (!openfl.utils.Assets.cache.hasSound(pathShit))
|
|
{
|
|
var library = Assets.getLibrary("songs");
|
|
var symbolPath = pathShit.split(":").pop();
|
|
// @:privateAccess
|
|
// library.types.set(symbolPath, SOUND);
|
|
// @:privateAccess
|
|
// library.pathGroups.set(symbolPath, [library.__cacheBreak(symbolPath)]);
|
|
// var callback = callbacks.add("song:" + pathShit);
|
|
openfl.utils.Assets.loadSound(pathShit).onComplete(function(_)
|
|
{
|
|
// callback();
|
|
});
|
|
}
|
|
|
|
FlxG.sound.playMusic(Paths.inst(daSong), 0.6);
|
|
|
|
var musSpec:PolygonSpectogram = new PolygonSpectogram(FlxG.sound.music, FlxColor.RED, FlxG.height / 2, Math.floor(FlxG.height / 2));
|
|
musSpec.x += 170;
|
|
musSpec.scrollFactor.set();
|
|
musSpec.waveAmplitude = 50;
|
|
// musSpec.visType = FREQUENCIES;
|
|
add(musSpec);
|
|
|
|
sidePreview = new FlxSprite(0, 0).makeGraphic(40, FlxG.height, FlxColor.GRAY);
|
|
sidePreview.scrollFactor.set();
|
|
add(sidePreview);
|
|
|
|
// trace(audioBuf.data.length);
|
|
playheadTest = new FlxSprite(0, 0).makeGraphic(30, 2, FlxColor.RED);
|
|
playheadTest.scrollFactor.set();
|
|
playheadTest.alpha = 0.5;
|
|
add(playheadTest);
|
|
|
|
// WONT WORK FOR TUTORIAL OR TEST SONG!!! REDO LATER
|
|
vocals = new VoicesGroup(daSong, _song.voiceList);
|
|
// vocals = new FlxSound().loadEmbedded(Paths.voices(daSong));
|
|
// FlxG.sound.list.add(vocals);
|
|
|
|
staticSpecGrp = new FlxTypedGroup<SpectogramSprite>();
|
|
add(staticSpecGrp);
|
|
|
|
var aBoy:ABotVis = new ABotVis(FlxG.sound.music);
|
|
// add(aBoy);
|
|
|
|
for (index => voc in vocals.members)
|
|
{
|
|
var vocalSpec:SpectogramSprite = new SpectogramSprite(voc, FlxG.random.color(0xFFAAAAAA, FlxColor.WHITE, 100), musSpec.daHeight,
|
|
Math.floor(FlxG.height / 2));
|
|
vocalSpec.x = 70 - (50 * index);
|
|
// vocalSpec.visType = FREQUENCIES;
|
|
vocalSpec.daHeight = musSpec.daHeight;
|
|
vocalSpec.y = vocalSpec.daHeight;
|
|
vocalSpec.scrollFactor.set();
|
|
add(vocalSpec);
|
|
|
|
var staticVocal:SpectogramSprite = new SpectogramSprite(voc, FlxG.random.color(0xFFAAAAAA, FlxColor.WHITE, 100), GRID_SIZE * 16, GRID_SIZE * 8);
|
|
if (index == 0)
|
|
staticVocal.x -= 150;
|
|
|
|
if (index == 1)
|
|
staticVocal.x = gridBG.width;
|
|
|
|
staticVocal.visType = STATIC;
|
|
staticSpecGrp.add(staticVocal);
|
|
}
|
|
|
|
FlxG.sound.music.pause();
|
|
|
|
vocals.pause();
|
|
|
|
FlxG.sound.music.onComplete = function()
|
|
{
|
|
vocals.pause();
|
|
vocals.time = 0;
|
|
FlxG.sound.music.pause();
|
|
FlxG.sound.music.time = 0;
|
|
changeSection();
|
|
};
|
|
}
|
|
|
|
function generateUI():Void
|
|
{
|
|
while (bullshitUI.members.length > 0)
|
|
{
|
|
bullshitUI.remove(bullshitUI.members[0], true);
|
|
}
|
|
|
|
// general shit
|
|
var title:FlxText = new FlxText(UI_box.x + 20, UI_box.y + 20, 0);
|
|
bullshitUI.add(title);
|
|
/*
|
|
var loopCheck = new FlxUICheckBox(UI_box.x + 10, UI_box.y + 50, null, null, "Loops", 100, ['loop check']);
|
|
loopCheck.checked = notes[0]elected.doesLoop;
|
|
tooltips.add(loopCheck, {title: 'Section looping', body: "Whether or not it's a simon says style section", style: tooltipType});
|
|
bullshitUI.add(loopCheck);
|
|
|
|
*/
|
|
}
|
|
|
|
override function getEvent(id:String, sender:Dynamic, data:Dynamic, ?params:Array<Dynamic>)
|
|
{
|
|
if (id == FlxUICheckBox.CLICK_EVENT)
|
|
{
|
|
var check:FlxUICheckBox = cast sender;
|
|
var label = check.getLabel().text;
|
|
switch (label)
|
|
{
|
|
case 'Must hit section':
|
|
SongLoad.getSong()[curSection].mustHitSection = check.checked;
|
|
|
|
updateHeads();
|
|
|
|
case 'Change BPM':
|
|
SongLoad.getSong()[curSection].changeBPM = check.checked;
|
|
FlxG.log.add('changed bpm shit');
|
|
case "Alt Animation":
|
|
SongLoad.getSong()[curSection].altAnim = check.checked;
|
|
}
|
|
}
|
|
else if (id == FlxUINumericStepper.CHANGE_EVENT && (sender is FlxUINumericStepper))
|
|
{
|
|
var nums:FlxUINumericStepper = cast sender;
|
|
var wname = nums.name;
|
|
FlxG.log.add(wname);
|
|
if (wname == 'section_length')
|
|
{
|
|
SongLoad.getSong()[curSection].lengthInSteps = Std.int(nums.value);
|
|
updateGrid();
|
|
}
|
|
else if (wname == 'song_speed')
|
|
{
|
|
// _song.speed[SongLoad.curDiff] = nums.value;
|
|
_song.speed.normal = nums.value;
|
|
}
|
|
else if (wname == 'song_bpm')
|
|
{
|
|
tempBpm = nums.value;
|
|
Conductor.mapBPMChanges(_song);
|
|
Conductor.changeBPM(nums.value);
|
|
}
|
|
else if (wname == 'note_susLength')
|
|
{
|
|
curSelectedNote.sustainLength = nums.value;
|
|
updateGrid();
|
|
}
|
|
else if (wname == 'section_bpm')
|
|
{
|
|
SongLoad.getSong()[curSection].bpm = nums.value;
|
|
updateGrid();
|
|
}
|
|
}
|
|
|
|
// FlxG.log.add(id + " WEED " + sender + " WEED " + data + " WEED " + params);
|
|
}
|
|
|
|
var updatedSection:Bool = false;
|
|
|
|
/* this function got owned LOL
|
|
function lengthBpmBullshit():Float
|
|
{
|
|
if (SongLoad.getSong()[curSection].changeBPM)
|
|
return SongLoad.getSong()[curSection].lengthInSteps * (SongLoad.getSong()[curSection].bpm / _song.bpm);
|
|
else
|
|
return SongLoad.getSong()[curSection].lengthInSteps;
|
|
}*/
|
|
/**
|
|
* Gets the start time of section, defaults to the curSection
|
|
* @param section
|
|
* @return position of the song in... either seconds or milliseconds.... woops
|
|
*/
|
|
function sectionStartTime(?funnySection:Int):Float
|
|
{
|
|
if (funnySection == null)
|
|
funnySection = curSection;
|
|
|
|
var daBPM:Float = _song.bpm;
|
|
var daPos:Float = 0;
|
|
for (i in 0...funnySection)
|
|
{
|
|
if (SongLoad.getSong()[i].changeBPM)
|
|
{
|
|
daBPM = SongLoad.getSong()[i].bpm;
|
|
}
|
|
daPos += 4 * sectionCalc(daBPM);
|
|
}
|
|
return daPos;
|
|
}
|
|
|
|
function measureStartTime():Float
|
|
{
|
|
var daBPM:Float = _song.bpm;
|
|
var daPos:Float = sectionStartTime();
|
|
|
|
daPos = Math.floor(FlxG.sound.music.time / sectionCalc(daBPM)) * sectionCalc(daBPM);
|
|
return daPos;
|
|
}
|
|
|
|
function sectionCalc(bpm:Float)
|
|
{
|
|
return (1000 * 60 / bpm);
|
|
}
|
|
|
|
var p1Muted:Bool = false;
|
|
var p2Muted:Bool = false;
|
|
|
|
override function update(elapsed:Float)
|
|
{
|
|
// FlxG.camera.followLerp = CoolUtil.camLerpShit(0.05);
|
|
|
|
FlxG.sound.music.pan = FlxMath.remapToRange(FlxG.mouse.screenX, 0, FlxG.width, -1, 1) * 10;
|
|
|
|
curStep = recalculateSteps();
|
|
|
|
Conductor.songPosition = FlxG.sound.music.time;
|
|
_song.song = typingShit.text;
|
|
|
|
playheadTest.y = CoolUtil.coolLerp(playheadTest.y, FlxMath.remapToRange(Conductor.songPosition, 0, FlxG.sound.music.length, 0, FlxG.height), 0.5);
|
|
|
|
var strumLinePos:Float = getYfromStrum((Conductor.songPosition - sectionStartTime()) % (Conductor.stepCrochet * SongLoad.getSong()[curSection].lengthInSteps));
|
|
|
|
if (FlxG.sound.music != null)
|
|
{
|
|
if (FlxG.sound.music.playing)
|
|
strumLine.y = strumLinePos;
|
|
else
|
|
strumLine.y = CoolUtil.coolLerp(strumLine.y, strumLinePos, 0.5);
|
|
}
|
|
|
|
/* if (FlxG.sound.music.playing)
|
|
{
|
|
var normalizedShitIDK:Int = Std.int(FlxMath.remapToRange(Conductor.songPosition, 0, FlxG.sound.music.length, 0, audioBuf.data.length));
|
|
FlxG.watch.addQuick('WEIRD AUDIO SHIT LOL', audioBuf.data[normalizedShitIDK]);
|
|
// leftIcon.scale.x = FlxMath.remapToRange(audioBuf.data[normalizedShitIDK], 0, 255, 1, 2);
|
|
}*/
|
|
|
|
if (FlxG.keys.justPressed.X)
|
|
toggleAltAnimNote();
|
|
|
|
if (curBeat % 4 == 0 && curStep >= 16 * (curSection + 1))
|
|
{
|
|
// trace(curStep);
|
|
// trace((SongLoad.getSong()[curSection].lengthInSteps) * (curSection + 1));
|
|
trace('DUMBSHIT');
|
|
|
|
if (SongLoad.getSong()[curSection + 1] == null)
|
|
{
|
|
addSection();
|
|
}
|
|
|
|
changeSection(curSection + 1, false);
|
|
}
|
|
|
|
FlxG.watch.addQuick('daBeat', curBeat);
|
|
FlxG.watch.addQuick('daStep', curStep);
|
|
|
|
if (FlxG.mouse.pressedMiddle && FlxG.mouse.overlaps(gridBG))
|
|
{
|
|
if (FlxG.sound.music.playing)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
}
|
|
|
|
FlxG.sound.music.time = CoolUtil.coolLerp(FlxG.sound.music.time, getStrumTime(FlxG.mouse.y) + sectionStartTime(), 0.5);
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
|
|
if (FlxG.mouse.pressed)
|
|
{
|
|
if (FlxG.keys.pressed.ALT && FlxG.mouse.overlaps(gridBG)) // same shit as middle click / hold on grid
|
|
{
|
|
if (FlxG.sound.music.playing)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
}
|
|
|
|
FlxG.sound.music.time = getStrumTime(FlxG.mouse.y) + sectionStartTime();
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
else
|
|
{
|
|
if (FlxG.mouse.screenX <= 30 && FlxMath.inBounds(FlxG.mouse.screenY, 0, FlxG.height))
|
|
{
|
|
if (FlxG.sound.music.playing)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
}
|
|
|
|
FlxG.sound.music.time = CoolUtil.coolLerp(FlxG.sound.music.time,
|
|
FlxMath.remapToRange(FlxG.mouse.screenY, 0, FlxG.height, 0, FlxG.sound.music.length), 0.5);
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
if (FlxG.mouse.justPressed)
|
|
{
|
|
if (FlxG.mouse.overlaps(leftIcon))
|
|
{
|
|
if (leftIcon.char == _song.player1)
|
|
{
|
|
p1Muted = !p1Muted;
|
|
leftIcon.animation.curAnim.curFrame = p1Muted ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
p2Muted = !p2Muted;
|
|
|
|
leftIcon.animation.curAnim.curFrame = p2Muted ? 1 : 0;
|
|
}
|
|
|
|
vocals.members[0].volume = p1Muted ? 0 : 1;
|
|
|
|
// null check jus in case using old shit?
|
|
if (vocals.members[1] != null)
|
|
vocals.members[1].volume = p2Muted ? 0 : 1;
|
|
}
|
|
|
|
// sloppy copypaste lol deal with it!
|
|
if (FlxG.mouse.overlaps(rightIcon))
|
|
{
|
|
if (rightIcon.char == _song.player1)
|
|
{
|
|
p1Muted = !p1Muted;
|
|
rightIcon.animation.curAnim.curFrame = p1Muted ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
rightIcon.animation.curAnim.curFrame = p2Muted ? 1 : 0;
|
|
p2Muted = !p2Muted;
|
|
}
|
|
|
|
vocals.members[0].volume = p1Muted ? 0 : 1;
|
|
|
|
// null check jus in case using old shit?
|
|
if (vocals.members[1] != null)
|
|
vocals.members[1].volume = p2Muted ? 0 : 1;
|
|
}
|
|
|
|
if (FlxG.mouse.overlaps(curRenderedNotes))
|
|
{
|
|
curRenderedNotes.forEach(function(note:Note)
|
|
{
|
|
if (FlxG.mouse.overlaps(note))
|
|
{
|
|
selectNote(note);
|
|
}
|
|
});
|
|
}
|
|
else
|
|
{
|
|
if (FlxG.mouse.overlaps(gridBG))
|
|
{
|
|
FlxG.log.add('added note');
|
|
addNote();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FlxG.mouse.pressedRight)
|
|
{
|
|
if (FlxG.mouse.overlaps(curRenderedNotes))
|
|
{
|
|
curRenderedNotes.forEach(function(note:Note)
|
|
{
|
|
if (FlxG.mouse.overlaps(note))
|
|
{
|
|
trace('tryin to delete note...');
|
|
deleteNote(note);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if (FlxG.mouse.justReleased)
|
|
justPlacedNote = false;
|
|
|
|
if (FlxG.mouse.overlaps(gridBG))
|
|
{
|
|
if (justPlacedNote && FlxG.mouse.pressed && FlxG.mouse.y > getYfromStrum(curSelectedNote.strumTime))
|
|
{
|
|
var minusStuff:Float = FlxG.mouse.y - getYfromStrum(curSelectedNote.strumTime);
|
|
minusStuff -= GRID_SIZE;
|
|
minusStuff += GRID_SIZE / 2;
|
|
minusStuff = Math.floor(minusStuff / GRID_SIZE) * GRID_SIZE;
|
|
minusStuff = FlxMath.remapToRange(minusStuff, 0, 40, 0, Conductor.stepCrochet);
|
|
|
|
curSelectedNote.sustainLength = minusStuff;
|
|
|
|
updateNoteUI();
|
|
updateGrid();
|
|
}
|
|
|
|
dummyArrow.x = Math.floor(FlxG.mouse.x / GRID_SIZE) * GRID_SIZE;
|
|
if (FlxG.keys.pressed.SHIFT)
|
|
dummyArrow.y = FlxG.mouse.y;
|
|
else
|
|
dummyArrow.y = Math.floor(FlxG.mouse.y / GRID_SIZE) * GRID_SIZE;
|
|
}
|
|
|
|
if (FlxG.keys.justPressed.ENTER)
|
|
{
|
|
autosaveSong();
|
|
|
|
lastSection = curSection;
|
|
|
|
PlayState.SONG = _song;
|
|
|
|
// JUST FOR DEBUG DARNELL STUFF, GENERALIZE THIS FOR BETTER LOADING ELSEWHERE TOO!
|
|
PlayState.storyWeek = 8;
|
|
|
|
FlxG.sound.music.stop();
|
|
vocals.stop();
|
|
LoadingState.loadAndSwitchState(new PlayState());
|
|
// FlxG.switchState(new PlayState());
|
|
}
|
|
|
|
if (FlxG.keys.justPressed.E)
|
|
{
|
|
changeNoteSustain(Conductor.stepCrochet);
|
|
}
|
|
if (FlxG.keys.justPressed.Q)
|
|
{
|
|
changeNoteSustain(-Conductor.stepCrochet);
|
|
}
|
|
|
|
if (FlxG.keys.justPressed.TAB)
|
|
{
|
|
if (FlxG.keys.pressed.SHIFT)
|
|
{
|
|
UI_box.selected_tab -= 1;
|
|
if (UI_box.selected_tab < 0)
|
|
UI_box.selected_tab = 2;
|
|
}
|
|
else
|
|
{
|
|
UI_box.selected_tab += 1;
|
|
if (UI_box.selected_tab >= 3)
|
|
UI_box.selected_tab = 0;
|
|
}
|
|
}
|
|
|
|
if (!typingShit.hasFocus)
|
|
{
|
|
if (FlxG.keys.justPressed.SPACE)
|
|
{
|
|
if (FlxG.sound.music.playing)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
}
|
|
else
|
|
{
|
|
vocals.play();
|
|
FlxG.sound.music.play();
|
|
}
|
|
}
|
|
|
|
if (FlxG.keys.justPressed.R)
|
|
{
|
|
if (FlxG.keys.pressed.CONTROL)
|
|
resetSection(BEGINNING);
|
|
else if (FlxG.keys.pressed.SHIFT)
|
|
resetSection(MEASURE);
|
|
else
|
|
resetSection(SECTION);
|
|
}
|
|
|
|
if (FlxG.mouse.wheel != 0)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
var ctrlMod:Float = FlxG.keys.pressed.CONTROL ? 0.1 : 1;
|
|
var shiftMod:Float = FlxG.keys.pressed.SHIFT ? 2 : 1;
|
|
|
|
FlxG.sound.music.time -= (FlxG.mouse.wheel * Conductor.stepCrochet * 0.4 * ctrlMod * shiftMod);
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
|
|
if (FlxG.keys.justReleased.S)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
#if HAS_PITCH
|
|
FlxG.sound.music.pitch = 1;
|
|
vocals.pitch = 1;
|
|
#end
|
|
}
|
|
|
|
if (!FlxG.keys.pressed.SHIFT)
|
|
{
|
|
if (FlxG.keys.pressed.W || FlxG.keys.pressed.S)
|
|
{
|
|
var daTime:Float = 700 * FlxG.elapsed;
|
|
|
|
if (FlxG.keys.pressed.CONTROL)
|
|
daTime *= 0.2;
|
|
|
|
if (FlxG.keys.pressed.W)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
FlxG.sound.music.time -= daTime;
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
else
|
|
{
|
|
if (FlxG.keys.justPressed.S)
|
|
{
|
|
FlxG.sound.music.play();
|
|
vocals.play();
|
|
|
|
#if HAS_PITCH
|
|
FlxG.sound.music.pitch = 0.5;
|
|
vocals.pitch = 0.5;
|
|
#end
|
|
}
|
|
}
|
|
// FlxG.sound.music.time += daTime;
|
|
|
|
// vocals.time = FlxG.sound.music.time;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (FlxG.keys.justPressed.W || FlxG.keys.justPressed.S)
|
|
{
|
|
var daTime:Float = Conductor.stepCrochet * 2;
|
|
|
|
if (FlxG.keys.justPressed.W)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
FlxG.sound.music.time -= daTime;
|
|
vocals.time = FlxG.sound.music.time;
|
|
}
|
|
else
|
|
{
|
|
if (FlxG.keys.justPressed.S)
|
|
{
|
|
// FlxG.sound.music.time += daTime;
|
|
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
FlxG.sound.music.time += daTime;
|
|
vocals.time = FlxG.sound.music.time;
|
|
|
|
// FlxG.sound.music.play();
|
|
// vocals.play();
|
|
|
|
#if HAS_PITCH
|
|
FlxG.sound.music.pitch = 0.2;
|
|
vocals.pitch = 0.2;
|
|
#end
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_song.bpm = tempBpm;
|
|
|
|
/* if (FlxG.keys.justPressed.UP)
|
|
Conductor.changeBPM(Conductor.bpm + 1);
|
|
if (FlxG.keys.justPressed.DOWN)
|
|
Conductor.changeBPM(Conductor.bpm - 1); */
|
|
|
|
var shiftThing:Int = 1;
|
|
if (FlxG.keys.pressed.SHIFT)
|
|
shiftThing = 4;
|
|
if (FlxG.keys.justPressed.RIGHT || FlxG.keys.justPressed.D)
|
|
changeSection(curSection + shiftThing);
|
|
if (FlxG.keys.justPressed.LEFT || FlxG.keys.justPressed.A)
|
|
changeSection(curSection - shiftThing);
|
|
|
|
bpmTxt.text = bpmTxt.text = Std.string(FlxMath.roundDecimal(Conductor.songPosition / 1000, 3))
|
|
+ " / "
|
|
+ Std.string(FlxMath.roundDecimal(FlxG.sound.music.length / 1000, 3))
|
|
+ "\nSection: "
|
|
+ curSection;
|
|
super.update(elapsed);
|
|
}
|
|
|
|
function changeNoteSustain(value:Float):Void
|
|
{
|
|
if (curSelectedNote != null)
|
|
{
|
|
curSelectedNote.sustainLength += value;
|
|
curSelectedNote.sustainLength = Math.max(curSelectedNote.sustainLength, 0);
|
|
}
|
|
|
|
updateNoteUI();
|
|
updateGrid();
|
|
}
|
|
|
|
function toggleAltAnimNote():Void
|
|
{
|
|
if (curSelectedNote != null)
|
|
{
|
|
trace('ALT NOTE SHIT');
|
|
curSelectedNote.altNote = !curSelectedNote.altNote;
|
|
trace(curSelectedNote.altNote);
|
|
}
|
|
}
|
|
|
|
function recalculateSteps():Int
|
|
{
|
|
var lastChange:BPMChangeEvent = {
|
|
stepTime: 0,
|
|
songTime: 0,
|
|
bpm: 0
|
|
}
|
|
for (i in 0...Conductor.bpmChangeMap.length)
|
|
{
|
|
if (FlxG.sound.music.time > Conductor.bpmChangeMap[i].songTime)
|
|
lastChange = Conductor.bpmChangeMap[i];
|
|
}
|
|
|
|
curStep = lastChange.stepTime + Math.floor((FlxG.sound.music.time - lastChange.songTime) / Conductor.stepCrochet);
|
|
updateBeat();
|
|
|
|
return curStep;
|
|
}
|
|
|
|
function resetSection(songBeginning:SongResetType = SECTION):Void
|
|
{
|
|
updateGrid();
|
|
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
switch (songBeginning)
|
|
{
|
|
case SECTION:
|
|
// Basically old shit from changeSection???
|
|
FlxG.sound.music.time = sectionStartTime();
|
|
case BEGINNING:
|
|
FlxG.sound.music.time = 0;
|
|
curSection = 0;
|
|
case MEASURE:
|
|
FlxG.sound.music.time = measureStartTime(); // Math.floor(FlxG.mouse.y / GRID_SIZE) * GRID_SIZE
|
|
default:
|
|
}
|
|
|
|
vocals.time = FlxG.sound.music.time;
|
|
updateCurStep();
|
|
|
|
updateGrid();
|
|
updateSectionUI();
|
|
}
|
|
|
|
function changeSection(sec:Int = 0, ?updateMusic:Bool = true):Void
|
|
{
|
|
// trace('changing section' + sec);
|
|
|
|
if (SongLoad.getSong()[sec] != null)
|
|
{
|
|
curSection = sec;
|
|
|
|
updateGrid();
|
|
|
|
if (updateMusic)
|
|
{
|
|
FlxG.sound.music.pause();
|
|
vocals.pause();
|
|
|
|
/*var daNum:Int = 0;
|
|
var daLength:Float = 0;
|
|
while (daNum <= sec)
|
|
{
|
|
daLength += lengthBpmBullshit();
|
|
daNum++;
|
|
}*/
|
|
|
|
FlxG.sound.music.time = sectionStartTime();
|
|
vocals.time = FlxG.sound.music.time;
|
|
updateCurStep();
|
|
}
|
|
|
|
updateGrid();
|
|
updateSectionUI();
|
|
}
|
|
}
|
|
|
|
function copySection(?sectionNum:Int = 1)
|
|
{
|
|
var daSec = FlxMath.maxInt(curSection, sectionNum);
|
|
|
|
for (noteShit in SongLoad.getSong()[daSec - sectionNum].sectionNotes)
|
|
{
|
|
var strum = noteShit.strumTime + Conductor.stepCrochet * (SongLoad.getSong()[daSec].lengthInSteps * sectionNum);
|
|
|
|
var copiedNote:Note = new Note(strum, noteShit.noteData);
|
|
copiedNote.data.sustainLength = noteShit.sustainLength;
|
|
SongLoad.getSong()[daSec].sectionNotes.push(copiedNote.data);
|
|
}
|
|
|
|
updateGrid();
|
|
}
|
|
|
|
function updateSectionUI():Void
|
|
{
|
|
var sec = SongLoad.getSong()[curSection];
|
|
|
|
stepperLength.value = sec.lengthInSteps;
|
|
check_mustHitSection.checked = sec.mustHitSection;
|
|
check_altAnim.checked = sec.altAnim;
|
|
check_changeBPM.checked = sec.changeBPM;
|
|
stepperSectionBPM.value = sec.bpm;
|
|
|
|
updateHeads();
|
|
}
|
|
|
|
function updateHeads():Void
|
|
{
|
|
if (check_mustHitSection.checked)
|
|
{
|
|
leftIcon.changeIcon(_song.player1);
|
|
rightIcon.changeIcon(_song.player2);
|
|
|
|
leftIcon.animation.curAnim.curFrame = p1Muted ? 1 : 0;
|
|
rightIcon.animation.curAnim.curFrame = p2Muted ? 1 : 0;
|
|
}
|
|
else
|
|
{
|
|
leftIcon.changeIcon(_song.player2);
|
|
rightIcon.changeIcon(_song.player1);
|
|
|
|
leftIcon.animation.curAnim.curFrame = p2Muted ? 1 : 0;
|
|
rightIcon.animation.curAnim.curFrame = p1Muted ? 1 : 0;
|
|
}
|
|
leftIcon.setGraphicSize(0, 45);
|
|
rightIcon.setGraphicSize(0, 45);
|
|
|
|
leftIcon.height *= 0.6;
|
|
rightIcon.height *= 0.6;
|
|
}
|
|
|
|
function updateNoteUI():Void
|
|
{
|
|
if (curSelectedNote != null)
|
|
stepperSusLength.value = curSelectedNote.sustainLength;
|
|
}
|
|
|
|
function updateGrid():Void
|
|
{
|
|
// null if checks jus cuz i put updateGrid() in some weird places!
|
|
if (staticSpecGrp != null)
|
|
{
|
|
staticSpecGrp.forEach(function(spec)
|
|
{
|
|
if (spec != null)
|
|
spec.generateSection(sectionStartTime(), (Conductor.stepCrochet * 32) / 1000);
|
|
});
|
|
}
|
|
|
|
while (curRenderedNotes.members.length > 0)
|
|
{
|
|
curRenderedNotes.remove(curRenderedNotes.members[0], true);
|
|
}
|
|
|
|
while (curRenderedSustains.members.length > 0)
|
|
{
|
|
curRenderedSustains.remove(curRenderedSustains.members[0], true);
|
|
}
|
|
|
|
// generates the cool sidebar shit
|
|
if (sidePreview != null && sidePreview.active)
|
|
{
|
|
sidePreview.drawRect(0, 0, 40, FlxG.height, 0xFF444444);
|
|
|
|
/*
|
|
var sectionsNeeded:Int = Std.int(FlxG.sound.music.length / (sectionCalc(_song.bpm) * 4));
|
|
|
|
while (sectionsNeeded > 0)
|
|
{
|
|
sidePreview.drawRect(0, sectionsNeeded * (FlxG.height / sectionsNeeded), 40, FlxG.height / sectionsNeeded,
|
|
(sectionsNeeded % 2 == 0 ? 0xFF000000 : 0xFFFFFFFF));
|
|
|
|
sectionsNeeded--;
|
|
}
|
|
*/
|
|
|
|
for (secIndex => sideSection in SongLoad.getSong())
|
|
{
|
|
for (notes in sideSection.sectionNotes)
|
|
{
|
|
var col:Int = Note.codeColors[notes.noteData % 4];
|
|
|
|
var noteFlip:Int = (sideSection.mustHitSection ? 1 : -1);
|
|
var noteX:Float = 5 * (((notes.noteData - 4) * noteFlip) + 4);
|
|
|
|
sidePreview.drawRect(noteX, FlxMath.remapToRange(notes.strumTime, 0, FlxG.sound.music.length, 0, FlxG.height), 5, 1, col);
|
|
}
|
|
}
|
|
}
|
|
|
|
var sectionInfo:Array<NoteData> = SongLoad.getSong()[curSection].sectionNotes;
|
|
|
|
if (SongLoad.getSong()[curSection].changeBPM && SongLoad.getSong()[curSection].bpm > 0)
|
|
{
|
|
Conductor.changeBPM(SongLoad.getSong()[curSection].bpm);
|
|
FlxG.log.add('CHANGED BPM!');
|
|
}
|
|
else
|
|
{
|
|
// get last bpm
|
|
var daBPM:Float = _song.bpm;
|
|
for (i in 0...curSection)
|
|
if (SongLoad.getSong()[i].changeBPM)
|
|
daBPM = SongLoad.getSong()[i].bpm;
|
|
Conductor.changeBPM(daBPM);
|
|
}
|
|
|
|
/* // PORT BULLSHIT, INCASE THERE'S NO SUSTAIN DATA FOR A NOTE
|
|
for (sec in 0...SongLoad.getSong().length)
|
|
{
|
|
for (notesse in 0...SongLoad.getSong()[sec].sectionNotes.length)
|
|
{
|
|
if (SongLoad.getSong()[sec].sectionNotes[notesse][2] == null)
|
|
{
|
|
trace('SUS NULL');
|
|
SongLoad.getSong()[sec].sectionNotes[notesse][2] = 0;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
for (i in sectionInfo)
|
|
{
|
|
var daNoteInfo = i.noteData;
|
|
var daStrumTime = i.strumTime;
|
|
var daSus = i.sustainLength;
|
|
|
|
var note:Note = new Note(daStrumTime, daNoteInfo % 4);
|
|
note.data.sustainLength = daSus;
|
|
note.setGraphicSize(GRID_SIZE, GRID_SIZE);
|
|
note.updateHitbox();
|
|
note.x = Math.floor(daNoteInfo * GRID_SIZE);
|
|
note.y = Math.floor(getYfromStrum((daStrumTime - sectionStartTime()) % (Conductor.stepCrochet * SongLoad.getSong()[curSection].lengthInSteps)));
|
|
|
|
curRenderedNotes.add(note);
|
|
|
|
if (daSus > 0)
|
|
{
|
|
var sustainVis:FlxSprite = new FlxSprite(note.x + (GRID_SIZE / 2),
|
|
note.y + GRID_SIZE).makeGraphic(8, Math.floor(FlxMath.remapToRange(daSus, 0, Conductor.stepCrochet * 16, 0, gridBG.height)));
|
|
sustainVis.x -= sustainVis.width / 2;
|
|
sustainVis.color = Note.codeColors[note.data.noteData % 4];
|
|
curRenderedSustains.add(sustainVis);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function addSection(lengthInSteps:Int = 16):Void
|
|
{
|
|
var sec:SwagSection = {
|
|
lengthInSteps: lengthInSteps,
|
|
bpm: _song.bpm,
|
|
changeBPM: false,
|
|
mustHitSection: true,
|
|
sectionNotes: [],
|
|
typeOfSection: 0,
|
|
altAnim: false
|
|
};
|
|
|
|
SongLoad.getSong().push(sec);
|
|
}
|
|
|
|
function selectNote(note:Note):Void
|
|
{
|
|
var swagNum:Int = 0;
|
|
|
|
for (i in SongLoad.getSong()[curSection].sectionNotes)
|
|
{
|
|
if (i.strumTime == note.data.strumTime && i.noteData % 4 == note.data.noteData)
|
|
{
|
|
curSelectedNote = SongLoad.getSong()[curSection].sectionNotes[swagNum];
|
|
}
|
|
|
|
swagNum += 1;
|
|
}
|
|
|
|
updateGrid();
|
|
updateNoteUI();
|
|
}
|
|
|
|
function deleteNote(note:Note):Void
|
|
{
|
|
for (i in SongLoad.getSong()[curSection].sectionNotes)
|
|
{
|
|
if (i.strumTime == note.data.strumTime && i.noteData % 4 == note.data.noteData)
|
|
{
|
|
var placeIDK:Int = Std.int(((Math.floor(dummyArrow.y / GRID_SIZE) * GRID_SIZE)) / 40);
|
|
|
|
placeIDK = Std.int(Math.min(placeIDK, 15));
|
|
placeIDK = Std.int(Math.max(placeIDK, 1));
|
|
|
|
trace(placeIDK);
|
|
FlxG.sound.play(Paths.sound('funnyNoise/funnyNoise-0' + placeIDK));
|
|
|
|
FlxG.log.add('FOUND EVIL NUMBER');
|
|
SongLoad.getSong()[curSection].sectionNotes.remove(i);
|
|
}
|
|
}
|
|
|
|
updateGrid();
|
|
}
|
|
|
|
function clearSection():Void
|
|
{
|
|
SongLoad.getSong()[curSection].sectionNotes = [];
|
|
|
|
updateGrid();
|
|
}
|
|
|
|
function clearSong():Void
|
|
{
|
|
for (daSection in 0...SongLoad.getSong().length)
|
|
{
|
|
SongLoad.getSong()[daSection].sectionNotes = [];
|
|
}
|
|
|
|
updateGrid();
|
|
}
|
|
|
|
/**
|
|
* Is true if clicked and placed a note, set reset to false when releasing mouse button!
|
|
*/
|
|
var justPlacedNote:Bool = false;
|
|
|
|
private function addNote():Void
|
|
{
|
|
var noteStrum = getStrumTime(dummyArrow.y) + sectionStartTime();
|
|
var noteData = Math.floor(FlxG.mouse.x / GRID_SIZE);
|
|
var noteSus = 0;
|
|
var noteAlt = false;
|
|
|
|
justPlacedNote = true;
|
|
|
|
// FlxG.sound.play(Paths.sound('pianoStuff/piano-00' + FlxG.random.int(1, 9)), FlxG.random.float(0.01, 0.3));
|
|
|
|
function makeAndPlayChord(soundsToPlay:Array<String>)
|
|
{
|
|
var bullshit:Int = Std.int((Math.floor(dummyArrow.y / GRID_SIZE) * GRID_SIZE) / 40);
|
|
soundsToPlay.push('00' + Std.string((bullshit % 8) + 1));
|
|
|
|
for (key in soundsToPlay)
|
|
{
|
|
var snd:FlxSound = FlxG.sound.list.recycle(FlxSound).loadEmbedded(FlxG.sound.cache(Paths.sound("pianoStuff/piano-" + key)));
|
|
snd.autoDestroy = true;
|
|
FlxG.sound.list.add(snd);
|
|
snd.volume = FlxG.random.float(0.05, 0.7);
|
|
snd.pan = noteData - 2; // .... idk why tf panning doesnt work? (as of 2022/01/25) busted ass bullshit. I only went thru this fuss of creating FlxSound just for the panning!
|
|
|
|
// snd.proximity(FlxG.mouse.x, FlxG.mouse.y, gridBG, gridBG.width / 2);
|
|
|
|
snd.play();
|
|
}
|
|
}
|
|
|
|
switch (noteData)
|
|
{
|
|
case 0:
|
|
makeAndPlayChord(["015", "013", "009"]);
|
|
case 1:
|
|
makeAndPlayChord(["015", "012", "009"]);
|
|
case 2:
|
|
makeAndPlayChord(["015", "011", "009"]);
|
|
case 3:
|
|
makeAndPlayChord(["014", "011", "010"]);
|
|
}
|
|
|
|
// trace('bullshit $bullshit'); // trace(Math.floor(dummyArrow.y / GRID_SIZE) * GRID_SIZE);
|
|
|
|
var daNewNote:Note = new Note(noteStrum, noteData);
|
|
daNewNote.data.sustainLength = noteSus;
|
|
daNewNote.data.altNote = noteAlt;
|
|
SongLoad.getSong()[curSection].sectionNotes.push(daNewNote.data);
|
|
|
|
curSelectedNote = SongLoad.getSong()[curSection].sectionNotes[SongLoad.getSong()[curSection].sectionNotes.length - 1];
|
|
|
|
if (FlxG.keys.pressed.CONTROL)
|
|
{
|
|
// SongLoad.getSong()[curSection].sectionNotes.push([noteStrum, (noteData + 4) % 8, noteSus, noteAlt]);
|
|
}
|
|
|
|
trace(noteStrum);
|
|
trace(curSection);
|
|
|
|
updateGrid();
|
|
updateNoteUI();
|
|
|
|
autosaveSong();
|
|
}
|
|
|
|
function getStrumTime(yPos:Float):Float
|
|
{
|
|
return FlxMath.remapToRange(yPos, gridBG.y, gridBG.y + gridBG.height, 0, 16 * Conductor.stepCrochet);
|
|
}
|
|
|
|
function getYfromStrum(strumTime:Float):Float
|
|
{
|
|
return FlxMath.remapToRange(strumTime, 0, 16 * Conductor.stepCrochet, gridBG.y, gridBG.y + gridBG.height);
|
|
}
|
|
|
|
/*
|
|
function calculateSectionLengths(?sec:SwagSection):Int
|
|
{
|
|
var daLength:Int = 0;
|
|
|
|
for (i in SongLoad.getSong())
|
|
{
|
|
var swagLength = i.lengthInSteps;
|
|
|
|
if (i.typeOfSection == Section.COPYCAT)
|
|
swagLength * 2;
|
|
|
|
daLength += swagLength;
|
|
|
|
if (sec != null && sec == i)
|
|
{
|
|
trace('swag loop??');
|
|
break;
|
|
}
|
|
}
|
|
|
|
return daLength;
|
|
}*/
|
|
private var daSpacing:Float = 0.3;
|
|
|
|
function loadLevel():Void
|
|
{
|
|
trace(SongLoad.getSong());
|
|
}
|
|
|
|
function getNotes():Array<Dynamic>
|
|
{
|
|
var noteData:Array<Dynamic> = [];
|
|
|
|
for (i in SongLoad.getSong())
|
|
{
|
|
noteData.push(i.sectionNotes);
|
|
}
|
|
|
|
return noteData;
|
|
}
|
|
|
|
function loadJson(song:String):Void
|
|
{
|
|
PlayState.SONG = SongLoad.loadFromJson(song.toLowerCase(), song.toLowerCase());
|
|
LoadingState.loadAndSwitchState(new ChartingState());
|
|
}
|
|
|
|
function loadAutosave():Void
|
|
{
|
|
PlayState.SONG = FlxG.save.data.autosave;
|
|
FlxG.resetState();
|
|
}
|
|
|
|
function autosaveSong():Void
|
|
{
|
|
FlxG.save.data.autosave = _song;
|
|
// trace(FlxG.save.data.autosave);
|
|
FlxG.save.flush();
|
|
}
|
|
|
|
private function saveLevel(?debugSavepath:Bool = false)
|
|
{
|
|
// Right now the note data is saved as a Note.NoteData typedef / object or whatev
|
|
// we want to format it to an ARRAY. We turn it back into the typedef / object at the end of this function hehe
|
|
|
|
for (key in _song.noteMap.keys())
|
|
SongLoad.castNoteDataToArray(_song.noteMap[key]);
|
|
|
|
// SongLoad.castNoteDataToArray(_song.notes.easy);
|
|
// SongLoad.castNoteDataToArray(_song.notes.normal);
|
|
// SongLoad.castNoteDataToArray(_song.notes.hard);
|
|
|
|
var json = {"song": _song};
|
|
var data:String = Json.stringify(json, null, "\t");
|
|
|
|
#if sys
|
|
// quick workaround, since it easier to load into hashlink, thus quicker/nicer to test?
|
|
// should get this auto-saved into a file or somethin
|
|
var filename = _song.song.toLowerCase();
|
|
|
|
if (debugSavepath)
|
|
{
|
|
// file path to assumingly your assets folder in your SOURCE CODE assets folder!!!
|
|
// update this later so the save button ONLY appears when you compile in debug mode!
|
|
sys.io.File.saveContent('../../../../assets/preload/data/$filename/$filename.json', data);
|
|
}
|
|
else
|
|
sys.io.File.saveContent('./$filename.json', data);
|
|
#else
|
|
if ((data != null) && (data.length > 0))
|
|
{
|
|
_file = new FileReference();
|
|
_file.addEventListener(Event.COMPLETE, onSaveComplete);
|
|
_file.addEventListener(Event.CANCEL, onSaveCancel);
|
|
_file.addEventListener(IOErrorEvent.IO_ERROR, onSaveError);
|
|
_file.save(data.trim(), _song.song.toLowerCase() + ".json");
|
|
}
|
|
#end
|
|
|
|
for (key in _song.noteMap.keys())
|
|
SongLoad.castArrayToNoteData(_song.noteMap[key]);
|
|
|
|
// turn the array data back to Note.NoteData typedef
|
|
// SongLoad.castArrayToNoteData(_song.notes.easy);
|
|
// SongLoad.castArrayToNoteData(_song.notes.normal);
|
|
// SongLoad.castArrayToNoteData(_song.notes.hard);
|
|
}
|
|
|
|
function onSaveComplete(_):Void
|
|
{
|
|
_file.removeEventListener(Event.COMPLETE, onSaveComplete);
|
|
_file.removeEventListener(Event.CANCEL, onSaveCancel);
|
|
_file.removeEventListener(IOErrorEvent.IO_ERROR, onSaveError);
|
|
_file = null;
|
|
FlxG.log.notice("Successfully saved LEVEL DATA.");
|
|
}
|
|
|
|
/**
|
|
* Called when the save file dialog is cancelled.
|
|
*/
|
|
function onSaveCancel(_):Void
|
|
{
|
|
_file.removeEventListener(Event.COMPLETE, onSaveComplete);
|
|
_file.removeEventListener(Event.CANCEL, onSaveCancel);
|
|
_file.removeEventListener(IOErrorEvent.IO_ERROR, onSaveError);
|
|
_file = null;
|
|
}
|
|
|
|
/**
|
|
* Called if there is an error while saving the gameplay recording.
|
|
*/
|
|
function onSaveError(_):Void
|
|
{
|
|
_file.removeEventListener(Event.COMPLETE, onSaveComplete);
|
|
_file.removeEventListener(Event.CANCEL, onSaveCancel);
|
|
_file.removeEventListener(IOErrorEvent.IO_ERROR, onSaveError);
|
|
_file = null;
|
|
FlxG.log.error("Problem saving Level data");
|
|
}
|
|
}
|
|
|
|
enum SongResetType
|
|
{
|
|
BEGINNING;
|
|
MEASURE; // not sure if measure is 1/4 of a "SECTION" which is definitely a... bar.. right? its nerd shit whatever
|
|
SECTION;
|
|
}
|