public void SaveTrack(SyncTrack track)
{
var path = GetTrackPath(track.Name);
using (var stream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite))
using (var serializer = new CommandSerializer(stream))
{
serializer.SerializeTrackEntries(track.Entries);
}
}
public void TryFindAndSelectSongObjects(IList <SongObject> songObjects)
{
Song song = editor.currentSong;
Chart chart = editor.currentChart;
foundSongObjects.Clear();
foreach (SongObject so in songObjects)
{
ChartObject chartObject = so as ChartObject;
SyncTrack syncTrack = so as SyncTrack;
Event eventObject = so as Event;
if (chartObject != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(chartObject, chart.chartObjects);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
foundSongObjects.Add(chart.chartObjects[insertionIndex]);
}
else
{
Debug.LogWarning("Failed to find chart object to highlight");
}
}
else if (syncTrack != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(syncTrack, song.syncTrack);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
foundSongObjects.Add(song.syncTrack[insertionIndex]);
}
else
{
Debug.LogWarning("Failed to find synctrack to highlight");
}
}
else if (eventObject != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(eventObject, song.eventsAndSections);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
foundSongObjects.Add(song.eventsAndSections[insertionIndex]);
}
else
{
Debug.LogWarning("Failed to find event to highlight");
}
}
else
{
Debug.LogError("Unable to handle object " + so.ToString());
}
}
currentSelectedObjects = foundSongObjects;
foundSongObjects.Clear();
}
/// <summary>
/// Adds a synctrack object (bpm or time signature) into the song.
/// </summary>
/// <param name="syncTrackObject">Item to add.</param>
/// <param name="autoUpdate">Automatically update all read-only arrays?
/// If set to false, you must manually call the updateArrays() method, but is useful when adding multiple objects as it increases performance dramatically.</param>
public void Add(SyncTrack syncTrackObject, bool autoUpdate = true)
{
syncTrackObject.song = this;
SongObjectHelper.Insert(syncTrackObject, _syncTrack);
if (autoUpdate)
{
UpdateCache();
}
}
public SyncTrack LoadTrack(string trackName)
{
var path = GetTrackPath(trackName);
using (var stream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var serializer = new CommandSerializer(stream))
{
var entries = serializer.DeserializeTrackEntries();
var track = new SyncTrack(trackName, entries);
return track;
}
}
/// <summary>
/// Adds a synctrack object (bpm or time signature) into the song.
/// </summary>
/// <param name="syncTrackObject">Item to add.</param>
/// <param name="autoUpdate">Automatically update all read-only arrays?
/// If set to false, you must manually call the updateArrays() method, but is useful when adding multiple objects as it increases performance dramatically.</param>
public void Add(SyncTrack syncTrackObject, bool autoUpdate = true)
{
syncTrackObject.song = this;
SongObjectHelper.Insert(syncTrackObject, _syncTrack);
if (autoUpdate)
{
UpdateCache();
}
if (this == ChartEditor.Instance.currentSong)
{
ChartEditor.isDirty = true;
}
}
/// <summary>
/// Removes a synctrack object (bpm or time signature) from the song.
/// </summary>
/// <param name="autoUpdate">Automatically update all read-only arrays?
/// If set to false, you must manually call the updateArrays() method, but is useful when removing multiple objects as it increases performance dramatically.</param>
/// <returns>Returns whether the removal was successful or not (item may not have been found if false).</returns>
public bool Remove(SyncTrack syncTrackObject, bool autoUpdate = true)
{
bool success = false;
if (syncTrackObject.tick > 0)
{
success = SongObjectHelper.Remove(syncTrackObject, _syncTrack);
}
if (success)
{
syncTrackObject.song = null;
}
if (autoUpdate)
{
UpdateCache();
}
return(success);
}
static string CheckForErrorsMoonscraper(Song song, ValidationParameters validationParams, ref bool hasErrors)
{
bool hasErrorsLocal = false;
StringBuilder sb = new StringBuilder();
sb.AppendLine("Moonscraper validation report: ");
// Check if any objects have exceeded the max length
{
uint tick = song.TimeToTick(validationParams.songLength, song.resolution);
// Song objects
{
// Synctrack
{
int index, length;
SongObjectHelper.GetRange(song.syncTrack, tick, uint.MaxValue, out index, out length);
for (int i = index; i < length; ++i)
{
hasErrorsLocal |= true;
SyncTrack st = song.syncTrack[i];
sb.AppendFormat("\tFound synctrack object beyond the length of the song-\n");
sb.AppendFormat("\t\tType = {0}, position = {1}\n", st.GetType(), st.tick);
}
}
// Events
{
int index, length;
SongObjectHelper.GetRange(song.eventsAndSections, tick, uint.MaxValue, out index, out length);
for (int i = index; i < length; ++i)
{
hasErrorsLocal |= true;
MoonscraperChartEditor.Song.Event eventObject = song.eventsAndSections[i];
sb.AppendFormat("\tFound event object beyond the length of the song-\n");
sb.AppendFormat("\t\tType = {0}, position = {1}\n", eventObject.GetType(), eventObject.tick);
}
}
}
// Chart objects
foreach (Song.Instrument instrument in EnumX <Song.Instrument> .Values)
{
if (instrument == Song.Instrument.Unrecognised)
{
continue;
}
foreach (Song.Difficulty difficulty in EnumX <Song.Difficulty> .Values)
{
Chart chart = song.GetChart(instrument, difficulty);
int index, length;
SongObjectHelper.GetRange(chart.chartObjects, tick, uint.MaxValue, out index, out length);
for (int i = index; i < length; ++i)
{
hasErrorsLocal |= true;
ChartObject co = chart.chartObjects[i];
sb.AppendFormat("\tFound chart object beyond the length of the song-\n");
sb.AppendFormat("\t\tType = {0}, position = {1}\n", co.GetType(), co.tick);
}
}
}
}
if (!hasErrorsLocal)
{
sb.AppendLine("\tNo errors detected");
}
hasErrors |= hasErrorsLocal;
return(sb.ToString());
}
public void TryFindAndSelectSongObjects(IList <SongObject> songObjects)
{
Song song = editor.currentSong;
Chart chart = editor.currentChart;
foundSongObjects.Clear();
int warnChartObj = 0;
int warnSyncObj = 0;
int warnEventObj = 0;
foreach (SongObject so in songObjects)
{
ChartObject chartObject = so as ChartObject;
SyncTrack syncTrack = so as SyncTrack;
Event eventObject = so as Event;
if (chartObject != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(chartObject, chart.chartObjects);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
if (!foundSongObjects.Contains(chart.chartObjects[insertionIndex]))
{
foundSongObjects.Add(chart.chartObjects[insertionIndex]);
}
}
else
{
++warnChartObj;
}
}
else if (syncTrack != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(syncTrack, song.syncTrack);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
if (!foundSongObjects.Contains(song.syncTrack[insertionIndex]))
{
foundSongObjects.Add(song.syncTrack[insertionIndex]);
}
}
else
{
++warnSyncObj;
}
}
else if (eventObject != null)
{
int insertionIndex = SongObjectHelper.FindObjectPosition(eventObject, song.eventsAndSections);
if (insertionIndex != SongObjectHelper.NOTFOUND)
{
if (!foundSongObjects.Contains(song.eventsAndSections[insertionIndex]))
{
foundSongObjects.Add(song.eventsAndSections[insertionIndex]);
}
}
else
{
++warnEventObj;
}
}
else
{
UnityEngine.Debug.LogError("Unable to handle object " + so.ToString());
}
}
if (warnChartObj > 0)
{
UnityEngine.Debug.LogWarning(string.Format("Failed to find {0} chart object/s to highlight", warnChartObj));
}
if (warnSyncObj > 0)
{
UnityEngine.Debug.LogWarning(string.Format("Failed to find {0} synctrack/s to highlight", warnSyncObj));
}
if (warnEventObj > 0)
{
UnityEngine.Debug.LogWarning(string.Format("Failed to find {0} event/s to highlight", warnEventObj));
}
currentSelectedObjects = foundSongObjects;
foundSongObjects.Clear();
}
static void DeleteSongObject <T>(T foundSongObject) where T : SongObject
{
bool updateCache = false;
if (foundSongObject.controller)
{
foundSongObject.controller.gameObject.SetActive(false); // Forces the controller to release the note
}
// Update the surrounding objects based on changes made here
switch ((SongObject.ID)foundSongObject.classID)
{
case SongObject.ID.Starpower:
{
ChartEditor.Instance.songObjectPoolManager.SetAllPoolsDirty(); // Update notes in the range
break;
}
case SongObject.ID.BPM:
{
ChartEditor.Instance.songObjectPoolManager.SetAllPoolsDirty(); // Re position all objects
break;
}
case SongObject.ID.Note:
{
Note note = foundSongObject as Note;
// Update the previous note in the case of chords with 2 notes
if (note.previous != null && note.previous.controller)
{
note.previous.controller.SetDirty();
}
if (note.next != null && note.next.controller)
{
note.next.controller.SetDirty();
}
break;
}
}
{
ChartObject chartObj = foundSongObject as ChartObject;
if (chartObj != null)
{
Chart chart = chartObj.chart;
if (chart != null)
{
chart.Remove(chartObj, updateCache);
}
return;
}
}
{
SyncTrack syncObj = foundSongObject as SyncTrack;
if (syncObj != null)
{
if (syncObj.tick != 0)
{
Song song = foundSongObject.song;
if (song != null)
{
song.Remove(syncObj, updateCache);
}
}
return;
}
}
{
Event eventObj = foundSongObject as Event;
if (eventObj != null)
{
Song song = foundSongObject.song;
if (song != null)
{
song.Remove(eventObj, updateCache);
}
return;
}
}
UnityEngine.Debug.LogError("Unhandled songobject deletion case!");
}
