mirror of
https://github.com/ninjamuffin99/Funkin.git
synced 2024-11-10 16:55:17 +00:00
541 lines
17 KiB
Haxe
541 lines
17 KiB
Haxe
package funkin.ui.debug.charting;
|
|
|
|
import haxe.ui.data.ArrayDataSource;
|
|
import funkin.play.character.BaseCharacter.CharacterType;
|
|
import funkin.play.event.SongEvent;
|
|
import funkin.play.event.SongEventData;
|
|
import funkin.play.song.SongData.SongTimeChange;
|
|
import funkin.play.song.SongSerializer;
|
|
import funkin.ui.haxeui.components.CharacterPlayer;
|
|
import haxe.ui.components.Button;
|
|
import haxe.ui.components.CheckBox;
|
|
import haxe.ui.components.DropDown;
|
|
import haxe.ui.components.Label;
|
|
import haxe.ui.components.NumberStepper;
|
|
import haxe.ui.components.NumberStepper;
|
|
import haxe.ui.components.Slider;
|
|
import haxe.ui.components.TextField;
|
|
import haxe.ui.containers.dialogs.Dialog;
|
|
import haxe.ui.containers.Box;
|
|
import haxe.ui.containers.Frame;
|
|
import haxe.ui.containers.Grid;
|
|
import haxe.ui.containers.Group;
|
|
import haxe.ui.core.Component;
|
|
import haxe.ui.events.UIEvent;
|
|
|
|
/**
|
|
* Available tools for the chart editor state.
|
|
*/
|
|
enum ChartEditorToolMode
|
|
{
|
|
Select;
|
|
Place;
|
|
}
|
|
|
|
class ChartEditorToolboxHandler
|
|
{
|
|
public static function setToolboxState(state:ChartEditorState, id:String, shown:Bool):Void
|
|
{
|
|
if (shown) showToolbox(state, id);
|
|
else
|
|
hideToolbox(state, id);
|
|
}
|
|
|
|
public static function showToolbox(state:ChartEditorState, id:String)
|
|
{
|
|
var toolbox:Dialog = state.activeToolboxes.get(id);
|
|
|
|
if (toolbox == null) toolbox = initToolbox(state, id);
|
|
|
|
if (toolbox != null)
|
|
{
|
|
toolbox.showDialog(false);
|
|
}
|
|
else
|
|
{
|
|
trace('ChartEditorToolboxHandler.showToolbox() - Could not retrieve toolbox: $id');
|
|
}
|
|
}
|
|
|
|
public static function hideToolbox(state:ChartEditorState, id:String):Void
|
|
{
|
|
var toolbox:Dialog = state.activeToolboxes.get(id);
|
|
|
|
if (toolbox == null) toolbox = initToolbox(state, id);
|
|
|
|
if (toolbox != null)
|
|
{
|
|
toolbox.hideDialog(DialogButton.CANCEL);
|
|
}
|
|
else
|
|
{
|
|
trace('ChartEditorToolboxHandler.hideToolbox() - Could not retrieve toolbox: $id');
|
|
}
|
|
}
|
|
|
|
public static function minimizeToolbox(state:ChartEditorState, id:String):Void {}
|
|
|
|
public static function maximizeToolbox(state:ChartEditorState, id:String):Void {}
|
|
|
|
public static function initToolbox(state:ChartEditorState, id:String):Dialog
|
|
{
|
|
var toolbox:Dialog = null;
|
|
switch (id)
|
|
{
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_TOOLS_LAYOUT:
|
|
toolbox = buildToolboxToolsLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_NOTEDATA_LAYOUT:
|
|
toolbox = buildToolboxNoteDataLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_EVENTDATA_LAYOUT:
|
|
toolbox = buildToolboxEventDataLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_DIFFICULTY_LAYOUT:
|
|
toolbox = buildToolboxDifficultyLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_METADATA_LAYOUT:
|
|
toolbox = buildToolboxMetadataLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_CHARACTERS_LAYOUT:
|
|
toolbox = buildToolboxCharactersLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_PLAYER_PREVIEW_LAYOUT:
|
|
toolbox = buildToolboxPlayerPreviewLayout(state);
|
|
case ChartEditorState.CHART_EDITOR_TOOLBOX_OPPONENT_PREVIEW_LAYOUT:
|
|
toolbox = buildToolboxOpponentPreviewLayout(state);
|
|
default:
|
|
// This happens if you try to load an unknown layout.
|
|
trace('ChartEditorToolboxHandler.initToolbox() - Unknown toolbox ID: $id');
|
|
toolbox = null;
|
|
}
|
|
|
|
// This happens if the layout you try to load has a syntax error.
|
|
if (toolbox == null) return null;
|
|
|
|
// Make sure we can reuse the toolbox later.
|
|
toolbox.destroyOnClose = false;
|
|
state.activeToolboxes.set(id, toolbox);
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
public static function getToolbox(state:ChartEditorState, id:String):Dialog
|
|
{
|
|
var toolbox:Dialog = state.activeToolboxes.get(id);
|
|
|
|
// Initialize the toolbox without showing it.
|
|
if (toolbox == null) toolbox = initToolbox(state, id);
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxToolsLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_TOOLS_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 50;
|
|
toolbox.y = 50;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxTools', false);
|
|
}
|
|
|
|
var toolsGroup:Group = toolbox.findComponent("toolboxToolsGroup", Group);
|
|
|
|
if (toolsGroup == null) return null;
|
|
|
|
toolsGroup.onChange = (event:UIEvent) -> {
|
|
switch (event.target.id)
|
|
{
|
|
case 'toolboxToolsGroupSelect':
|
|
state.currentToolMode = ChartEditorToolMode.Select;
|
|
case 'toolboxToolsGroupPlace':
|
|
state.currentToolMode = ChartEditorToolMode.Place;
|
|
default:
|
|
trace('ChartEditorToolboxHandler.buildToolboxToolsLayout() - Unknown toolbox tool selected: $event.target.id');
|
|
}
|
|
}
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxNoteDataLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_NOTEDATA_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 75;
|
|
toolbox.y = 100;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxNotes', false);
|
|
}
|
|
|
|
var toolboxNotesNoteKind:DropDown = toolbox.findComponent("toolboxNotesNoteKind", DropDown);
|
|
var toolboxNotesCustomKindLabel:Label = toolbox.findComponent("toolboxNotesCustomKindLabel", Label);
|
|
var toolboxNotesCustomKind:TextField = toolbox.findComponent("toolboxNotesCustomKind", TextField);
|
|
|
|
toolboxNotesNoteKind.onChange = (event:UIEvent) -> {
|
|
var isCustom = (event.data.id == '~CUSTOM~');
|
|
|
|
if (isCustom)
|
|
{
|
|
toolboxNotesCustomKindLabel.hidden = false;
|
|
toolboxNotesCustomKind.hidden = false;
|
|
|
|
state.selectedNoteKind = toolboxNotesCustomKind.text;
|
|
}
|
|
else
|
|
{
|
|
toolboxNotesCustomKindLabel.hidden = true;
|
|
toolboxNotesCustomKind.hidden = true;
|
|
|
|
state.selectedNoteKind = event.data.id;
|
|
}
|
|
}
|
|
|
|
toolboxNotesCustomKind.onChange = (event:UIEvent) -> {
|
|
state.selectedNoteKind = toolboxNotesCustomKind.text;
|
|
}
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxEventDataLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_EVENTDATA_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 100;
|
|
toolbox.y = 150;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxEvents', false);
|
|
}
|
|
|
|
var toolboxEventsEventKind:DropDown = toolbox.findComponent("toolboxEventsEventKind", DropDown);
|
|
var toolboxEventsDataGrid:Grid = toolbox.findComponent("toolboxEventsDataGrid", Grid);
|
|
|
|
toolboxEventsEventKind.dataSource = new ArrayDataSource();
|
|
|
|
var songEvents:Array<SongEvent> = SongEventParser.listEvents();
|
|
|
|
for (event in songEvents)
|
|
{
|
|
toolboxEventsEventKind.dataSource.add({text: event.getTitle(), value: event.id});
|
|
}
|
|
|
|
toolboxEventsEventKind.onChange = (event:UIEvent) -> {
|
|
var eventType:String = event.data.value;
|
|
|
|
trace('ChartEditorToolboxHandler.buildToolboxEventDataLayout() - Event type changed: $eventType');
|
|
|
|
var schema:SongEventSchema = SongEventParser.getEventSchema(eventType);
|
|
|
|
if (schema == null)
|
|
{
|
|
trace('ChartEditorToolboxHandler.buildToolboxEventDataLayout() - Unknown event kind: $eventType');
|
|
return;
|
|
}
|
|
|
|
buildEventDataFormFromSchema(state, toolboxEventsDataGrid, schema);
|
|
}
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildEventDataFormFromSchema(state:ChartEditorState, target:Box, schema:SongEventSchema):Void
|
|
{
|
|
trace(schema);
|
|
// Clear the frame.
|
|
target.removeAllComponents();
|
|
|
|
state.selectedEventData = {};
|
|
|
|
for (field in schema)
|
|
{
|
|
// Add a label.
|
|
var label:Label = new Label();
|
|
label.text = field.title;
|
|
target.addComponent(label);
|
|
|
|
var input:Component;
|
|
switch (field.type)
|
|
{
|
|
case INTEGER:
|
|
var numberStepper:NumberStepper = new NumberStepper();
|
|
numberStepper.id = field.name;
|
|
numberStepper.step = field.step == null ? 1.0 : field.step;
|
|
numberStepper.min = field.min;
|
|
numberStepper.max = field.max;
|
|
numberStepper.value = field.defaultValue;
|
|
input = numberStepper;
|
|
case FLOAT:
|
|
var numberStepper:NumberStepper = new NumberStepper();
|
|
numberStepper.id = field.name;
|
|
numberStepper.step = field.step == null ? 0.1 : field.step;
|
|
numberStepper.min = field.min;
|
|
numberStepper.max = field.max;
|
|
numberStepper.value = field.defaultValue;
|
|
input = numberStepper;
|
|
case BOOL:
|
|
var checkBox = new CheckBox();
|
|
checkBox.id = field.name;
|
|
checkBox.selected = field.defaultValue == true;
|
|
input = checkBox;
|
|
case ENUM:
|
|
var dropDown:DropDown = new DropDown();
|
|
dropDown.id = field.name;
|
|
dropDown.dataSource = new ArrayDataSource();
|
|
|
|
// Add entries to the dropdown.
|
|
for (optionName in field.keys.keys())
|
|
{
|
|
var optionValue = field.keys.get(optionName);
|
|
trace('$optionName : $optionValue');
|
|
dropDown.dataSource.add({value: optionValue, text: optionName});
|
|
}
|
|
|
|
dropDown.value = field.defaultValue;
|
|
|
|
input = dropDown;
|
|
case STRING:
|
|
input = new TextField();
|
|
input.id = field.name;
|
|
input.text = field.defaultValue;
|
|
default:
|
|
// Unknown type. Display a label so we know what it is.
|
|
input = new Label();
|
|
input.id = field.name;
|
|
input.text = field.type;
|
|
}
|
|
|
|
target.addComponent(input);
|
|
|
|
input.onChange = (event:UIEvent) -> {
|
|
trace('ChartEditorToolboxHandler.buildEventDataFormFromSchema() - ${event.target.id} = ${event.target.value}');
|
|
|
|
if (event.target.value == null) state.selectedEventData.remove(event.target.id);
|
|
else
|
|
state.selectedEventData.set(event.target.id, event.target.value);
|
|
}
|
|
}
|
|
}
|
|
|
|
static function buildToolboxDifficultyLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_DIFFICULTY_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 125;
|
|
toolbox.y = 200;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxDifficulty', false);
|
|
}
|
|
|
|
var difficultyToolboxSaveMetadata:Button = toolbox.findComponent("difficultyToolboxSaveMetadata", Button);
|
|
var difficultyToolboxSaveChart:Button = toolbox.findComponent("difficultyToolboxSaveChart", Button);
|
|
var difficultyToolboxSaveAll:Button = toolbox.findComponent("difficultyToolboxSaveAll", Button);
|
|
var difficultyToolboxLoadMetadata:Button = toolbox.findComponent("difficultyToolboxLoadMetadata", Button);
|
|
var difficultyToolboxLoadChart:Button = toolbox.findComponent("difficultyToolboxLoadChart", Button);
|
|
|
|
difficultyToolboxSaveMetadata.onClick = (event:UIEvent) -> {
|
|
SongSerializer.exportSongMetadata(state.currentSongMetadata);
|
|
};
|
|
|
|
difficultyToolboxSaveChart.onClick = (event:UIEvent) -> {
|
|
SongSerializer.exportSongChartData(state.currentSongChartData);
|
|
};
|
|
|
|
difficultyToolboxSaveAll.onClick = (event:UIEvent) -> {
|
|
state.exportAllSongData();
|
|
};
|
|
|
|
difficultyToolboxLoadMetadata.onClick = (event:UIEvent) -> {
|
|
// Replace metadata for current variation.
|
|
SongSerializer.importSongMetadataAsync(function(songMetadata) {
|
|
state.currentSongMetadata = songMetadata;
|
|
});
|
|
};
|
|
|
|
difficultyToolboxLoadChart.onClick = (event:UIEvent) -> {
|
|
// Replace chart data for current variation.
|
|
SongSerializer.importSongChartDataAsync(function(songChartData) {
|
|
state.currentSongChartData = songChartData;
|
|
state.noteDisplayDirty = true;
|
|
});
|
|
};
|
|
|
|
state.difficultySelectDirty = true;
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxMetadataLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_METADATA_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 150;
|
|
toolbox.y = 250;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxMetadata', false);
|
|
}
|
|
|
|
var inputSongName:TextField = toolbox.findComponent('inputSongName', TextField);
|
|
inputSongName.onChange = (event:UIEvent) -> {
|
|
var valid = event.target.text != null && event.target.text != "";
|
|
|
|
if (valid)
|
|
{
|
|
inputSongName.removeClass('invalid-value');
|
|
state.currentSongMetadata.songName = event.target.text;
|
|
}
|
|
else
|
|
{
|
|
state.currentSongMetadata.songName = null;
|
|
}
|
|
};
|
|
|
|
var inputSongArtist:TextField = toolbox.findComponent('inputSongArtist', TextField);
|
|
inputSongArtist.onChange = (event:UIEvent) -> {
|
|
var valid = event.target.text != null && event.target.text != "";
|
|
|
|
if (valid)
|
|
{
|
|
inputSongArtist.removeClass('invalid-value');
|
|
state.currentSongMetadata.artist = event.target.text;
|
|
}
|
|
else
|
|
{
|
|
state.currentSongMetadata.artist = null;
|
|
}
|
|
};
|
|
|
|
var inputStage:DropDown = toolbox.findComponent('inputStage', DropDown);
|
|
inputStage.onChange = (event:UIEvent) -> {
|
|
var valid = event.data != null && event.data.id != null;
|
|
|
|
if (valid)
|
|
{
|
|
state.currentSongMetadata.playData.stage = event.data.id;
|
|
}
|
|
};
|
|
|
|
var inputNoteSkin:DropDown = toolbox.findComponent('inputNoteSkin', DropDown);
|
|
inputNoteSkin.onChange = (event:UIEvent) -> {
|
|
if (event.data.id == null) return;
|
|
state.currentSongMetadata.playData.noteSkin = event.data.id;
|
|
};
|
|
|
|
var inputBPM:NumberStepper = toolbox.findComponent('inputBPM', NumberStepper);
|
|
inputBPM.onChange = (event:UIEvent) -> {
|
|
if (event.value == null || event.value <= 0) return;
|
|
|
|
var timeChanges = state.currentSongMetadata.timeChanges;
|
|
if (timeChanges == null || timeChanges.length == 0)
|
|
{
|
|
timeChanges = [new SongTimeChange(-1, 0, event.value, 4, 4, [4, 4, 4, 4])];
|
|
}
|
|
else
|
|
{
|
|
timeChanges[0].bpm = event.value;
|
|
}
|
|
|
|
Conductor.forceBPM(event.value);
|
|
|
|
state.currentSongMetadata.timeChanges = timeChanges;
|
|
};
|
|
|
|
var inputScrollSpeed:Slider = toolbox.findComponent('inputScrollSpeed', Slider);
|
|
inputScrollSpeed.onChange = (event:UIEvent) -> {
|
|
var valid = event.target.value != null && event.target.value > 0;
|
|
|
|
if (valid)
|
|
{
|
|
inputScrollSpeed.removeClass('invalid-value');
|
|
state.currentSongChartData.scrollSpeed = event.target.value;
|
|
}
|
|
else
|
|
{
|
|
state.currentSongChartData.scrollSpeed = null;
|
|
}
|
|
};
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxCharactersLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_CHARACTERS_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 175;
|
|
toolbox.y = 300;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxCharacters', false);
|
|
}
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxPlayerPreviewLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_PLAYER_PREVIEW_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 200;
|
|
toolbox.y = 350;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxPlayerPreview', false);
|
|
}
|
|
|
|
var charPlayer:CharacterPlayer = toolbox.findComponent('charPlayer');
|
|
// TODO: We need to implement character swapping in ChartEditorState.
|
|
charPlayer.loadCharacter('bf');
|
|
// charPlayer.setScale(0.5);
|
|
charPlayer.setCharacterType(CharacterType.BF);
|
|
charPlayer.flip = true;
|
|
|
|
return toolbox;
|
|
}
|
|
|
|
static function buildToolboxOpponentPreviewLayout(state:ChartEditorState):Dialog
|
|
{
|
|
var toolbox:Dialog = cast state.buildComponent(ChartEditorState.CHART_EDITOR_TOOLBOX_OPPONENT_PREVIEW_LAYOUT);
|
|
|
|
if (toolbox == null) return null;
|
|
|
|
// Starting position.
|
|
toolbox.x = 200;
|
|
toolbox.y = 350;
|
|
|
|
toolbox.onDialogClosed = (event:DialogEvent) -> {
|
|
state.setUICheckboxSelected('menubarItemToggleToolboxOpponentPreview', false);
|
|
}
|
|
|
|
var charPlayer:CharacterPlayer = toolbox.findComponent('charPlayer');
|
|
// TODO: We need to implement character swapping in ChartEditorState.
|
|
charPlayer.loadCharacter('dad');
|
|
// charPlayer.setScale(0.5);
|
|
charPlayer.setCharacterType(CharacterType.DAD);
|
|
charPlayer.flip = false;
|
|
|
|
return toolbox;
|
|
}
|
|
}
|