public override void SortObjects()
{
LoadedContainers = new List <BeatmapObjectContainer>(
LoadedContainers.OrderBy(x => x.objectData._time) //0 -> end of map
.ThenBy(x => ((BeatmapNote)x.objectData)._lineIndex) //0 -> 3
.ThenBy(x => ((BeatmapNote)x.objectData)._lineLayer) //0 -> 2
.ThenBy(x => ((BeatmapNote)x.objectData)._type)); //Red -> Blue -> Bomb
uint id = 0;
foreach (var container in LoadedContainers)
{
if (container.objectData is BeatmapNote noteData)
{
noteData.id = id;
id++;
}
if (container.OutlineVisible && !SelectionController.IsObjectSelected(container))
{
container.OutlineVisible = false;
}
//Gain back some performance by stopping here if we already have the object's materials.
//Obviously on first load it's gonna suck ass however after that, we should be fine.
if (objectsWithNoteMaterials.Add(container))
{
foreach (Renderer renderer in container.GetComponentsInChildren <Renderer>())
{
foreach (Material mat in renderer.materials.Where(x => x?.HasProperty("_Editor_IsPlaying") ?? false))
{
allNoteRenderers.Add(mat);
}
}
}
}
UseChunkLoading = true;
}
public void InitiateChildrenManagers()
{
Forester = new Forester();
SelectionController = new SelectionController(); //jak tu coś urośnie to przerzucić do controls managera
ChildrenManagersInitiated = true;
}
// Motor motor;
// Selectable selectable;
// Use this for initialization
private void Start()
{
cam = Camera.main;
//motor = GetComponent<Motor>();
//selectable = GetComponent<Selectable>();
selectionController = GetComponent <SelectionController>();
}
public override BeatmapObjectContainer SpawnObject(BeatmapObject obj, out BeatmapObjectContainer conflicting, bool removeConflicting = true, bool refreshMap = true)
{
conflicting = null;
if (removeConflicting)
{
conflicting = LoadedContainers.FirstOrDefault(x => x.objectData._time == obj._time &&
((BeatmapNote)obj)._lineLayer == ((BeatmapNote)x.objectData)._lineLayer &&
((BeatmapNote)obj)._lineIndex == ((BeatmapNote)x.objectData)._lineIndex &&
((BeatmapNote)obj)._type == ((BeatmapNote)x.objectData)._type &&
ConflictingByTrackIDs(obj, x.objectData)
);
if (conflicting != null)
{
DeleteObject(conflicting, true, $"Conflicted with a newer object at time {obj._time}");
}
}
BeatmapNoteContainer beatmapNote = BeatmapNoteContainer.SpawnBeatmapNote(obj as BeatmapNote, ref notePrefab, ref bombPrefab, ref noteAppearanceSO);
beatmapNote.transform.SetParent(GridTransform);
beatmapNote.UpdateGridPosition();
LoadedContainers.Add(beatmapNote);
if (Settings.Instance.HighlightLastPlacedNotes)
{
beatmapNote.SetOutlineColor(Color.magenta);
}
if (refreshMap)
{
SelectionController.RefreshMap();
}
return(beatmapNote);
}
void Update()
{
if (PauseManager.IsPaused)
{
return;
}
ShiftHeld = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
AltHeld = Input.GetKey(KeyCode.LeftAlt) || Input.GetKey(KeyCode.RightAlt);
CtrlHeld = Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl) ||
Input.GetKey(KeyCode.LeftCommand) || Input.GetKey(KeyCode.RightCommand); //Can't forget our Apple friends.
GlobalKeybinds(); //These guys are here all day, all night
if (notePlacement.IsActive)
{
NotesKeybinds(); //Present when placing a note
}
if (bombPlacement.IsActive)
{
BombsKeybinds(); //Present when placing a bomb
}
if (obstaclePlacement.IsActive)
{
ObstacleKeybinds(); //Present when placing an obstacle
}
if (eventPlacement.IsActive)
{
EventsKeybinds(); //Present when placing an event.
}
if (SelectionController.HasSelectedObjects())
{
SelectionKeybinds(); //Present if objects are selected
}
}
private void UpdateRingPropagationMode()
{
foreach (BeatmapObjectContainer con in LoadedContainers)
{
if (ringPropagationEditing)
{
int pos = 0;
if (con.objectData._customData != null)
{
pos = (con.objectData?._customData["_propID"]?.AsInt ?? -1) + 1;
}
if ((con is BeatmapEventContainer e) && e.eventData._type != MapEvent.EVENT_TYPE_RING_LIGHTS)
{
e.UpdateAlpha(0);
pos = -1;
}
con.transform.localPosition = new Vector3(pos + 0.5f, 0.5f, con.transform.localPosition.z);
}
else
{
if (con is BeatmapEventContainer e)
{
e.UpdateAlpha(-1);
}
con.UpdateGridPosition();
}
}
SelectionController.RefreshMap();
}
public override BeatmapObjectContainer SpawnObject(BeatmapObject obj, out BeatmapObjectContainer conflicting, bool removeConflicting = true, bool refreshMap = true)
{
conflicting = null;
if (removeConflicting)
{
conflicting = LoadedContainers.FirstOrDefault(x => x.objectData._time == obj._time &&
((BeatmapObstacle)obj)._lineIndex == ((BeatmapObstacle)x.objectData)._lineIndex &&
((BeatmapObstacle)obj)._type == ((BeatmapObstacle)x.objectData)._type &&
ConflictingByTrackIDs(obj, x.objectData)
);
if (conflicting != null)
{
DeleteObject(conflicting, true, $"Conflicted with a newer object at time {obj._time}");
}
}
BeatmapObstacleContainer beatmapObstacle = BeatmapObstacleContainer.SpawnObstacle(obj as BeatmapObstacle, AudioTimeSyncController, ref obstaclePrefab, ref obstacleAppearanceSO);
beatmapObstacle.transform.SetParent(GridTransform);
beatmapObstacle.UpdateGridPosition();
LoadedContainers.Add(beatmapObstacle);
if (refreshMap)
{
SelectionController.RefreshMap();
}
return(beatmapObstacle);
}
internal override void ApplyToMap()
{
if (!IsSelecting)
{
IsSelecting = true;
originPos = instantiatedContainer.transform.localPosition;
alreadySelected = new HashSet <BeatmapObjectContainer>(SelectionController.SelectedObjects);
}
else
{
StartCoroutine(WaitABitFuckOffOtherPlacementControllers());
List <BeatmapObjectContainer> toSelect = new List <BeatmapObjectContainer>();
OverlapBox((containerBoye) =>
{
if (containerBoye != null && SelectedTypes.Contains(containerBoye.objectData.beatmapType))
{
toSelect.Add(containerBoye);
}
});
foreach (BeatmapObjectContainer obj in toSelect)
{
SelectionController.Select(obj, true, false);
}
SelectionController.RefreshSelectionMaterial(toSelect.Any());
IsSelecting = false;
OnPhysicsRaycast(previousHit, transformed);
}
}
private IEnumerator DelayedUpdate()
{
while (true)
{
yield return(new WaitForSeconds(1)); //I wouldn't want to update this every single frame.
List <BeatmapObjectContainer> sel = SelectionController.SelectedObjects.OrderBy(x => x.objectData._time).ToList();
int notesel = SelectionController.SelectedObjects.Where(x => x is BeatmapNoteContainer).Count(); // only active when notes are selected
if (SelectionController.HasSelectedObjects() && notesel > 0)
{
notesMesh.text = $"Selected Notes: {notesel}";
float beatTimeDiff = sel.Last().objectData._time - sel.First().objectData._time;
float secDiff = atsc.GetSecondsFromBeat(beatTimeDiff);
notesPSMesh.text = $"Selected NPS: {(notesel / secDiff).ToString("F2")}";
}
else
{
notesMesh.text = $"Notes: {notes.LoadedContainers.Count}";
notesPSMesh.text = $"Notes Per Second: {(notes.LoadedContainers.Count / cameraAudioSource.clip.length).ToString("F2")}";
}
obstaclesMesh.text = $"Obstacles: {obstacles.LoadedContainers.Count}";
eventsMesh.text = $"Events: {events.LoadedContainers.Count}";
bpmMesh.text = $"BPM Changes: {bpm.LoadedContainers.Count}";
float timeMapping = BeatSaberSongContainer.Instance.map._time;
int seconds = Mathf.Abs(Mathf.FloorToInt(timeMapping * 60 % 60));
int minutes = Mathf.FloorToInt(timeMapping % 60);
int hours = Mathf.FloorToInt(timeMapping / 60);
timeMappingMesh.text = string.Format("Time Mapping: {0:0}:{1:00}:{2:00}", hours, minutes, seconds);
}
}
public void DestroySelectedObject()
{
SelectionController sc = FindObjectOfType <SelectionController>();
Destroy(sc.GetSelectedObject);
sc.SetSelectedObject(null);
}
public void _on_Clickable_input_event(Godot.Object viewport, InputEvent @event, int shapeIdx)
{
if (Input.IsActionJustPressed("click"))
{
SelectionController.AddToSelectionQueue(parentNode);
}
}
public void SpawnNotes()
{
var noteA = new BeatmapNote
{
_time = 2,
_type = BeatmapNote.NOTE_TYPE_A,
_lineIndex = BeatmapNote.LINE_INDEX_FAR_LEFT,
_lineLayer = BeatmapNote.LINE_LAYER_BOTTOM,
_cutDirection = BeatmapNote.NOTE_CUT_DIRECTION_LEFT
};
var noteB = new BeatmapNote
{
_time = 3,
_type = BeatmapNote.NOTE_TYPE_B,
_lineIndex = BeatmapNote.LINE_INDEX_FAR_RIGHT,
_lineLayer = BeatmapNote.LINE_LAYER_TOP,
_cutDirection = BeatmapNote.NOTE_CUT_DIRECTION_UP_RIGHT
};
_notePlacement.queuedData = noteA;
_notePlacement.RoundedTime = _notePlacement.queuedData._time;
_notePlacement.ApplyToMap();
// Should conflict with existing note and delete it
_notePlacement.queuedData = noteB;
_notePlacement.RoundedTime = _notePlacement.queuedData._time;
_notePlacement.ApplyToMap();
SelectionController.Select(noteA);
SelectionController.Select(noteB, true);
}
/*****************************************************
* UPDATE THUMB/INDEX ROTATION
*
* INFO: Maintient à jour la rotation de l'objet 3D
* en fonction du pouce et de l'index de la main.
* Ajuste dynamiquement la vitesse de rotation
* selon la position du ou des doigts qui
* causent la rotation. C'est ici qu'on valide
* quels sont les doigts ouverts.
*
* *** TO OPTIMIZE ***
*
*****************************************************/
private void ThumbIndexRotation()
{
//Si la main qui permet d'effecuer la rotation est détectée.
//Si la manipulation contrôlé d'objet est activé.
if (DetectionController.GetInstance().IsHandDetected(ThumbOrIndexGesture.GetInstance().GetHand()) &&
PalmUIController.GetInstance().IsManipulationControlled())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToRotateList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToRotateList.Count > 0)
{
//Recupère le contrôleur de la la main
detectedHand = DetectionController.GetInstance().GetHand(ThumbOrIndexGesture.GetInstance().GetHand());
//Change l'etat des doigts si le pouce et/ou l'index est ouvert
if (detectedHand.GetFinger(FingersE.pouce).IsFingerOpen() || detectedHand.GetFinger(FingersE.index).IsFingerOpen())
{
isThumbOpen = detectedHand.GetFinger(FingersE.pouce).IsFingerOpen() ? true : false;
isIndexOpen = detectedHand.GetFinger(FingersE.index).IsFingerOpen() ? true : false;
}
foreach (SelectedObject objectToRotate in objectsToRotateList)
{
//Applique la rotation en fonction de la force
Vector3 rotationSpeed = stopPosition * amplifyFingerRotation;
Vector3 dynamicRotation = objectToRotate.TransformObject.worldToLocalMatrix * rotationSpeed;
objectToRotate.TransformObject.Rotate(dynamicRotation);
startPosition = Vector3.Lerp(stopPosition, Vector3.zero, Time.deltaTime);
}
}
}
}
internal override void ApplyToMap()
{
queuedData._time = (instantiatedContainer.transform.position.z / EditorScaleController.EditorScale)
+ atsc.CurrentBeat;
if ((KeybindsController.AltHeld || (Settings.Instance.PlaceOnlyChromaEvents && Settings.Instance.PlaceChromaEvents)) && !queuedData.IsUtilityEvent()) // no more laser speed events gone wack
{
MapEvent justChroma = BeatmapObject.GenerateCopy(queuedData);
justChroma._value = ColourManager.ColourToInt(colorPicker.CurrentColor);
BeatmapEventContainer container = objectContainerCollection.SpawnObject(justChroma) as BeatmapEventContainer;
BeatmapActionContainer.AddAction(new BeatmapEventPlacementAction(container, null));
SelectionController.RefreshMap();
queuedData = BeatmapObject.GenerateCopy(queuedData);
return;
}
BeatmapEventContainer spawned = objectContainerCollection.SpawnObject(BeatmapObject.GenerateCopy(queuedData)) as BeatmapEventContainer;
BeatmapEventContainer chroma = null;
if (Settings.Instance.PlaceChromaEvents && !queuedData.IsUtilityEvent() && (queuedValue != MapEvent.LIGHT_VALUE_OFF)) // off events arent affected by chroma blocks, no need to create extra ones
{
MapEvent chromaData = BeatmapObject.GenerateCopy(queuedData);
chromaData._time -= 1 / 64f;
chromaData._value = ColourManager.ColourToInt(colorPicker.CurrentColor);
chroma = objectContainerCollection.SpawnObject(chromaData) as BeatmapEventContainer;
}
BeatmapActionContainer.AddAction(new BeatmapEventPlacementAction(spawned, chroma));
SelectionController.RefreshMap();
queuedData = BeatmapObject.GenerateCopy(queuedData);
}
private void UpdateRingPropagationMode()
{
int nearestChunk = (int)Math.Round(AudioTimeSyncController.CurrentBeat / (double)ChunkSize, MidpointRounding.AwayFromZero);
foreach (BeatmapObjectContainer con in LoadedContainers)
{
if (ringPropagationEditing)
{
int pos = 0;
if (con.objectData._customData != null && con.objectData._customData["_propID"].IsNumber)
{
pos = (con.objectData?._customData["_propID"]?.AsInt ?? -1) + 1;
}
if ((con is BeatmapEventContainer e) && e.eventData._type != MapEvent.EVENT_TYPE_RING_LIGHTS)
{
con.SafeSetActive(false);
pos = -1;
}
con.transform.localPosition = new Vector3(pos + 0.5f, 0.5f, con.transform.localPosition.z);
}
else
{
con.UpdateGridPosition();
}
}
if (!ringPropagationEditing)
{
OnPlayToggle(AudioTimeSyncController.IsPlaying);
}
SelectionController.RefreshMap();
}
// Use this for initialization
void Start()
{
if (!m_selected) {
//GetClosestNodeInDirection ()
}
m_selection_controller = gameObject.GetComponent<SelectionController>();
}
private IEnumerator RefreshMap(bool notes, bool obstacles, bool events, bool others, bool full)
{
yield return(PersistentUI.Instance.FadeInLoadingScreen());
map = song.GetMapFromDifficultyBeatmap(diff);
loader.UpdateMapData(map);
float currentBeat = atsc.CurrentBeat;
atsc.MoveToTimeInBeats(0);
if (notes || full)
{
yield return(StartCoroutine(loader.LoadObjects(map._notes)));
}
if (obstacles || full)
{
yield return(StartCoroutine(loader.LoadObjects(map._obstacles)));
}
if (events || full)
{
yield return(StartCoroutine(loader.LoadObjects(map._events)));
}
if (others || full)
{
yield return(StartCoroutine(loader.LoadObjects(map._BPMChanges)));
}
if (others || full)
{
yield return(StartCoroutine(loader.LoadObjects(map._customEvents)));
}
tracksManager.RefreshTracks();
SelectionController.RefreshMap();
atsc.MoveToTimeInBeats(currentBeat);
yield return(PersistentUI.Instance.FadeOutLoadingScreen());
}
// Start is called before the first frame update
void Start()
{
myNavMeshAgent = GetComponent <NavMeshAgent>();
mySelectionController = FindObjectOfType <SelectionController>();
myRend = GetComponent <MeshRenderer>();
brake = GetComponent <BrakeController>();
}
internal override void ApplyToMap()
{
if (!IsSelecting)
{
IsSelecting = true;
startTime = RoundedTime;
}
else
{
StartCoroutine(WaitABitFuckOffOtherPlacementControllers());
List <BeatmapObjectContainer> toSelect = new List <BeatmapObjectContainer>();
//Big brain boye does big brain things with big brain box
BoxCollider boxyBoy = instantiatedContainer.GetComponent <BoxCollider>();
Collider[] boxyBoyHitsStuffTM = Physics.OverlapBox(boxyBoy.bounds.center, boxyBoy.bounds.extents, boxyBoy.transform.rotation, 1 << 9);
foreach (Collider collider in boxyBoyHitsStuffTM)
{
BeatmapObjectContainer containerBoye = collider.gameObject.GetComponent <BeatmapObjectContainer>();
if (containerBoye != null)
{
toSelect.Add(containerBoye);
}
}
if (!KeybindsController.ShiftHeld)
{
SelectionController.DeselectAll();
}
foreach (BeatmapObjectContainer obj in toSelect)
{
SelectionController.Select(obj, true, false);
}
SelectionController.RefreshSelectionMaterial(toSelect.Any());
}
}
public override BeatmapObjectContainer SpawnObject(BeatmapObject obj, out BeatmapObjectContainer conflicting, bool removeConflicting = true)
{
UseChunkLoading = false;
conflicting = LoadedContainers.FirstOrDefault(x => x.objectData._time == obj._time &&
(obj as MapEvent)._type == (x.objectData as MapEvent)._type &&
(obj as MapEvent)._customData == (x.objectData as MapEvent)._customData
);
if (conflicting != null && removeConflicting)
{
DeleteObject(conflicting);
}
BeatmapEventContainer beatmapEvent = BeatmapEventContainer.SpawnEvent(obj as MapEvent, ref eventPrefab, ref eventAppearanceSO);
beatmapEvent.transform.SetParent(GridTransform);
beatmapEvent.UpdateGridPosition();
if (RingPropagationEditing && (obj as MapEvent)._type == MapEvent.EVENT_TYPE_RING_LIGHTS)
{
int pos = 0;
if (!(obj._customData is null))
{
pos = obj._customData["_propID"].AsInt + 1;
}
Debug.Log(pos);
beatmapEvent.transform.localPosition = new Vector3(pos + 0.5f, 0.5f, beatmapEvent.transform.localPosition.z);
}
LoadedContainers.Add(beatmapEvent);
SelectionController.RefreshMap();
return(beatmapEvent);
}
/*****************************************************
* UPDATE
*
* INFO: Recupere la distance du scaling et met à jour
* l'objet à chaque frame. Un amplificateur de
* mouvement est utilisé pour faciliter le
* redimensionnement.
*
* Ex: Si l'amplificateur est de 2.0f et que les
* mains se déplacent de 1" vers l'extérieur,
* l'objet va grossir de 2" dans tous les sens.
*
*****************************************************/
void Update()
{
//Si la manipulation contrôlé d'objet est activé et que les deux mains sont détectés.
if (isScaling && DetectionController.GetInstance().IsBothHandsDetected() &&
PalmUIController.GetInstance().IsManipulationControlled())
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToScaleList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToScaleList.Count > 0)
{
float newDistance = GetDistance();
float distance = newDistance - lastDistance;
foreach (SelectedObject objectToScale in objectsToScaleList)
{
// Met à jour la dimension de l'objet (X,Y,Z) avec l'amplificateur pris en compte.
objectToScale.TransformObject.localScale += new Vector3(distance, distance, distance) * amplifyScale;
// Évite que le redimensionnement de l'objet soit trop petit ou trop grand
if (objectToScale.GetScale().x < minimumScale)
{
objectToScale.TransformObject.localScale = new Vector3(minimumScale, minimumScale, minimumScale);
}
if (objectToScale.GetScale().x > maximumScale)
{
objectToScale.TransformObject.localScale = new Vector3(maximumScale, maximumScale, maximumScale);
}
}
lastDistance = newDistance;
}
}
}
public void MirrorGradient()
{
var container = BeatmapObjectContainerCollection.GetCollectionForType(BeatmapObject.Type.EVENT);
if (container is EventsContainer eventsContainer)
{
var root = eventsContainer.transform.root;
var eventPlacement = root.GetComponentInChildren <EventPlacement>();
var eventA = new MapEvent(2, MapEvent.EVENT_TYPE_BACK_LASERS, MapEvent.LIGHT_VALUE_RED_FADE, JSON.Parse("{\"_lightGradient\": {\"_duration\": 1, \"_startColor\": [1, 0, 0, 1], \"_endColor\": [0, 1, 0, 1], \"_easing\": \"easeLinear\"}}"));
eventPlacement.queuedData = eventA;
eventPlacement.queuedValue = eventPlacement.queuedData._value;
eventPlacement.RoundedTime = eventPlacement.queuedData._time;
eventPlacement.ApplyToMap();
SelectionController.Select(eventA);
_mirror.Mirror();
EventTest.CheckEvent(eventsContainer, 0, 2, MapEvent.EVENT_TYPE_BACK_LASERS, MapEvent.LIGHT_VALUE_BLUE_FADE, JSON.Parse("{\"_lightGradient\": {\"_duration\": 1, \"_startColor\": [0, 1, 0, 1], \"_endColor\": [1, 0, 0, 1], \"_easing\": \"easeLinear\"}}"));
// Undo mirror
_actionContainer.Undo();
EventTest.CheckEvent(eventsContainer, 0, 2, MapEvent.EVENT_TYPE_BACK_LASERS, MapEvent.LIGHT_VALUE_RED_FADE, JSON.Parse("{\"_lightGradient\": {\"_duration\": 1, \"_startColor\": [1, 0, 0, 1], \"_endColor\": [0, 1, 0, 1], \"_easing\": \"easeLinear\"}}"));
}
}
/*****************************************************
* METHOD: UPDATE
*
* INFO: Recupere la distance de la translation et met
* à jour l'objet à chaque frame. Un amplificateur
* de mouvement est utilisé pour faciliter les
* déplacements.
*
* Ex: Si l'amplificateur est de 2.0f et que la
* main se déplace de 1" vers la gauche, l'objet
* va se déplacer de 2" vers la gauche.
*
*****************************************************/
void Update()
{
//Si la manipulation contrôlé d'objet est activé
if (PalmUIController.GetInstance().IsManipulationControlled())
{
// Si la main initialisé avec le geste Fist est détecté, on effectue une translation
if (isTranslating && DetectionController.GetInstance().IsHandDetected(hand))
{
//La liste des objets sélectionnés avec le raycast
List <SelectedObject> objectsToTranslateList = SelectionController.GetInstance().GetSelectedObjects();
if (objectsToTranslateList.Count > 0)
{
// Calcul la distance du déplacement
Vector3 newHandPosition = GetStartHandPosition();
Vector3 handDistance = newHandPosition - lastHandPosition;
foreach (SelectedObject objectToTranslate in objectsToTranslateList)
{
// Met à jour la position de l'objet (X,Y,Z) avec l'amplificateur pris en compte.
objectToTranslate.TransformObject.position += handDistance * amplifyMovement;
}
lastHandPosition = newHandPosition;
}
}
}
}
public void JsonApply()
{
var eventContainer = BeatmapObjectContainerCollection.GetCollectionForType(BeatmapObject.Type.EVENT);
var nodeEditor = Object.FindObjectOfType <NodeEditorController>();
var inputField = nodeEditor.GetComponentInChildren <TMP_InputField>();
var eventA = new MapEvent(2, MapEvent.EVENT_TYPE_BACK_LASERS, MapEvent.LIGHT_VALUE_OFF, JSON.Parse(@"{""matches"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""differs"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""typeDiffer"":{""i"":1,""s"":""s"",""o"":{},""a"":[1,2]},""lenDiffer"":[1],""updatedLenDiffer"":[1],""updated"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""updatedDiffer"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""updatedTypeDiffer"":{""i"":1,""s"":""s"",""o"":{},""a"":[1,2]}}"));
eventContainer.SpawnObject(eventA);
var eventB = new MapEvent(2, MapEvent.EVENT_TYPE_LEFT_LASERS, MapEvent.LIGHT_VALUE_OFF, JSON.Parse(@"{""matches"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""differs"":{""i"":2,""s"":""t"",""b"":false,""a"":[2,2]},""typeDiffer"":{""i"":{},""s"":[],""o"":true,""a"":1},""lenDiffer"":[1,2],""updatedLenDiffer"":[1,2],""updated"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""updatedDiffer"":{""i"":2,""s"":""t"",""b"":false,""a"":[2,2]},""updatedTypeDiffer"":{""i"":{},""s"":[],""o"":true,""a"":1}}"));
eventContainer.SpawnObject(eventB);
SelectionController.Select(eventA);
SelectionController.Select(eventB, true);
nodeEditor.NodeEditor_EndEdit(@"{""_time"": -, ""_type"": -, ""_value"": -, ""_customData"": {""matches"":{},""differs"":{},""typeDiffer"":{},""updatedLenDiffer"":[1],""updated"":{""i"":4,""s"":""q"",""b"":false,""a"":[3,2]},""updatedDiffer"":{""i"":4,""s"":""q"",""b"":false,""a"":[3,2]},""updatedTypeDiffer"":{""i"":1,""s"":""s"",""o"":{},""a"":[1,2]}}}");
Assert.AreEqual("{\n \"_time\" : 2,\n \"_type\" : -,\n \"_value\" : 0,\n \"_customData\" : {\n \"matches\" : {\n },\n \"differs\" : {\n },\n \"typeDiffer\" : {\n },\n \"updatedLenDiffer\" : [\n 1\n ],\n \"updated\" : {\n \"i\" : 4,\n \"s\" : \"q\",\n \"b\" : false,\n \"a\" : [\n 3,\n 2\n ]\n },\n \"updatedDiffer\" : {\n \"i\" : 4,\n \"s\" : \"q\",\n \"b\" : false,\n \"a\" : [\n 3,\n 2\n ]\n },\n \"updatedTypeDiffer\" : {\n \"i\" : 1,\n \"s\" : \"s\",\n \"o\" : {\n },\n \"a\" : [\n 1,\n 2\n ]\n }\n }\n}", inputField.text);
// Objects have been recreated, pick them up from the selection controller
var events = SelectionController.SelectedObjects.ToArray();
Assert.AreEqual("{\"_time\":2,\"_type\":0,\"_value\":0,\"_customData\":{\"matches\":{},\"differs\":{},\"typeDiffer\":{\"i\":1,\"s\":\"s\",\"o\":{},\"a\":[1,2]},\"lenDiffer\":[1],\"updatedLenDiffer\":[1],\"updated\":{\"i\":4,\"s\":\"q\",\"b\":false,\"a\":[3,2]},\"updatedDiffer\":{\"i\":4,\"s\":\"q\",\"b\":false,\"a\":[3,2]},\"updatedTypeDiffer\":{\"i\":1,\"s\":\"s\",\"o\":{},\"a\":[1,2]}}}", events[0].ConvertToJSON().ToString());
Assert.AreEqual("{\"_time\":2,\"_type\":2,\"_value\":0,\"_customData\":{\"matches\":{},\"differs\":{},\"typeDiffer\":{\"i\":{},\"s\":[],\"o\":true,\"a\":1},\"lenDiffer\":[1,2],\"updatedLenDiffer\":[1],\"updated\":{\"i\":4,\"s\":\"q\",\"b\":false,\"a\":[3,2]},\"updatedDiffer\":{\"i\":4,\"s\":\"q\",\"b\":false,\"a\":[3,2]},\"updatedTypeDiffer\":{\"i\":1,\"s\":\"s\",\"o\":{},\"a\":[1,2]}}}", events[1].ConvertToJSON().ToString());
}
private IEnumerator ConvertToLegacy()
{
List <BeatmapObject> ToSpawn = new List <BeatmapObject>();
List <BeatmapObjectContainer> ToDestroy = new List <BeatmapObjectContainer>();
yield return(PersistentUI.Instance.FadeInLoadingScreen());
if (BeatSaberSongContainer.Instance != null)
{
foreach (BeatmapObjectContainer container in notesContainer.LoadedContainers)
{
BeatmapNoteContainer note = container as BeatmapNoteContainer;
if (note.mapNoteData is BeatmapChromaNote)
{
ToSpawn.Add((note.mapNoteData as BeatmapChromaNote).ConvertToNote());
BeatmapNote bombData = new BeatmapNote((note.mapNoteData as BeatmapChromaNote).ConvertToNote().ConvertToJSON());
bombData._type = BeatmapNote.NOTE_TYPE_BOMB;
bombData._cutDirection = (note.mapNoteData as BeatmapChromaNote).BombRotation;
ToSpawn.Add(bombData);
ToDestroy.Add(note);
}
}
}
notesContainer.SortObjects();
foreach (BeatmapObjectContainer con in ToDestroy)
{
notesContainer.DeleteObject(con);
}
foreach (BeatmapObject data in ToSpawn)
{
notesContainer.SpawnObject(data, out _);
}
SelectionController.RefreshMap();
yield return(PersistentUI.Instance.FadeOutLoadingScreen());
}
public IEnumerator HardRefresh()
{
if (Settings.Instance.Load_Notes)
{
yield return(StartCoroutine(LoadObjects(map._notes)));
}
if (Settings.Instance.Load_Obstacles)
{
yield return(StartCoroutine(LoadObjects(map._obstacles)));
}
if (Settings.Instance.Load_Events)
{
yield return(StartCoroutine(LoadObjects(map._events)));
}
if (Settings.Instance.Load_Others)
{
yield return(StartCoroutine(LoadObjects(map._BPMChanges)));
yield return(StartCoroutine(LoadObjects(map._customEvents)));
}
PersistentUI.Instance.LevelLoadSliderLabel.text = "Finishing up...";
manager.RefreshTracks();
SelectionController.RefreshMap();
PersistentUI.Instance.LevelLoadSlider.gameObject.SetActive(false);
}
public void JsonMerge()
{
var eventContainer = BeatmapObjectContainerCollection.GetCollectionForType(BeatmapObject.Type.EVENT);
var nodeEditor = Object.FindObjectOfType <NodeEditorController>();
var inputField = nodeEditor.GetComponentInChildren <TMP_InputField>();
var eventA = new MapEvent(2, MapEvent.EVENT_TYPE_BACK_LASERS, MapEvent.LIGHT_VALUE_OFF, JSON.Parse(@"{""matches"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""differs"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""typeDiffer"":{""i"":1,""s"":""s"",""o"":{},""a"":[1,2]},""lenDiffer"":[1]}"));
eventContainer.SpawnObject(eventA);
var eventB = new MapEvent(2, MapEvent.EVENT_TYPE_LEFT_LASERS, MapEvent.LIGHT_VALUE_OFF, JSON.Parse(@"{""matches"":{""i"":1,""s"":""s"",""b"":true,""a"":[1,2]},""differs"":{""i"":2,""s"":""t"",""b"":false,""a"":[2,2]},""typeDiffer"":{""i"":{},""s"":[],""o"":true,""a"":1},""lenDiffer"":[1,2]}"));
eventContainer.SpawnObject(eventB);
var eventC = new MapEvent(2, MapEvent.EVENT_TYPE_RIGHT_LASERS, MapEvent.LIGHT_VALUE_OFF);
eventContainer.SpawnObject(eventC);
SelectionController.Select(eventC);
Assert.AreEqual("{\n \"_time\" : 2,\n \"_type\" : 3,\n \"_value\" : 0\n}", inputField.text);
SelectionController.Select(eventA);
Assert.AreEqual("{\n \"_time\" : 2,\n \"_type\" : 0,\n \"_value\" : 0,\n \"_customData\" : {\n \"matches\" : {\n \"i\" : 1,\n \"s\" : \"s\",\n \"b\" : true,\n \"a\" : [\n 1,\n 2\n ]\n },\n \"differs\" : {\n \"i\" : 1,\n \"s\" : \"s\",\n \"b\" : true,\n \"a\" : [\n 1,\n 2\n ]\n },\n \"typeDiffer\" : {\n \"i\" : 1,\n \"s\" : \"s\",\n \"o\" : {\n },\n \"a\" : [\n 1,\n 2\n ]\n },\n \"lenDiffer\" : [\n 1\n ]\n }\n}", inputField.text);
SelectionController.Select(eventB, true);
Assert.AreEqual("{\n \"_time\" : 2,\n \"_type\" : -,\n \"_value\" : 0,\n \"_customData\" : {\n \"matches\" : {\n \"i\" : 1,\n \"s\" : \"s\",\n \"b\" : true,\n \"a\" : [\n 1,\n 2\n ]\n },\n \"differs\" : {\n \"i\" : -,\n \"s\" : -,\n \"b\" : -,\n \"a\" : [\n -,\n 2\n ]\n },\n \"typeDiffer\" : {\n }\n }\n}", inputField.text);
}
public override void Redo(BeatmapActionContainer.BeatmapActionParams param)
{
oldSelected = new HashSet <BeatmapObjectContainer>(SelectionController.SelectedObjects);
SelectionController.DeselectAll();
SelectionController.SelectedObjects = new HashSet <BeatmapObjectContainer>(selected);
SelectionController.RefreshSelectionMaterial(false);
}
void Start()
{
Cursor.visible = false;
ui = GameObject.Find("NodeUIOverlay").GetComponent <UIController> ();
selection = GameObject.Find("SelectionCanvas").GetComponent <SelectionController> ();
look = GameObject.Find("EventSystem").GetComponent <LookInputModule> ();
legend = GameObject.Find("LegendCanvas");
mark = GameObject.Find("MarkCanvas");
mark_list = GameObject.Find("MarklistCanvas");
quit_dialog = GameObject.Find("QuitDialogCanvas");
//HideLegend ();
ui.Startup();
quit_dialog.SetActive(false);
ui.gameObject.SetActive(false);
selection.gameObject.SetActive(false);
mark.SetActive(false);
mark_list.SetActive(false);
nodes = new Hashtable();
links = new Hashtable();
statusText = GameObject.Find("StatusText").GetComponent <GUIText>();
statusText.text = "";
StartCoroutine(LoadLayout());
//GameObject.Find ("SelectionCanvas").SetActive (false);
}
void Start()
{
sc = FindObjectOfType <SelectionController>();
DirectoryInfo textureDir = new DirectoryInfo(Application.dataPath + "/Texture Files/");
fileCounter = CheckFolderSize(textureDir);
}
internal override void ApplyToMap()
{
if (isPlacing)
{
isPlacing = false;
queuedData._time = startTime;
queuedData._duration = instantiatedContainer.transform.localScale.z / EditorScaleController.EditorScale;
if (queuedData._duration == 0 && Settings.Instance.DontPlacePerfectZeroDurationWalls)
{
queuedData._duration = 0.01f;
}
BeatmapObstacleContainer spawned = objectContainerCollection.SpawnObject(queuedData, out BeatmapObjectContainer conflicting) as BeatmapObstacleContainer;
BeatmapActionContainer.AddAction(GenerateAction(spawned, conflicting));
SelectionController.RefreshMap();
queuedData = GenerateOriginalData();
instantiatedContainer.obstacleData = queuedData;
obstacleAppearanceSO.SetObstacleAppearance(instantiatedContainer);
instantiatedContainer.transform.localScale = new Vector3(
1, instantiatedContainer.transform.localPosition.y == 0 ? 3.5f : 2, 0);
Vector3 localRotation = spawned.transform.localEulerAngles;
Track track = tracksManager.CreateTrack(gridRotation.Rotation);
track.AttachContainer(spawned);
tracksManager?.RefreshTracks();
spawned.UpdateGridPosition();
spawned.transform.localEulerAngles = localRotation;
}
else
{
isPlacing = true;
originIndex = queuedData._lineIndex;
startTime = RoundedTime;
}
}
void Start()
{
Cursor.visible = false;
ui = GameObject.Find ("NodeUIOverlay").GetComponent<UIController> ();
selection = GameObject.Find ("SelectionCanvas").GetComponent<SelectionController> ();
look = GameObject.Find ("EventSystem").GetComponent<LookInputModule> ();
legend = GameObject.Find ("LegendCanvas");
mark = GameObject.Find ("MarkCanvas");
mark_list = GameObject.Find ("MarklistCanvas");
quit_dialog = GameObject.Find ("QuitDialogCanvas");
//HideLegend ();
ui.Startup ();
quit_dialog.SetActive (false);
ui.gameObject.SetActive (false);
selection.gameObject.SetActive (false);
mark.SetActive (false);
mark_list.SetActive (false);
nodes = new Hashtable();
links = new Hashtable();
statusText = GameObject.Find("StatusText").GetComponent<GUIText>();
statusText.text = "";
StartCoroutine( LoadLayout() );
//GameObject.Find ("SelectionCanvas").SetActive (false);
}
void Start()
{
m_selection_controller = gameObject.GetComponent<SelectionController>();
}
