public static AudicaFile LoadAudicaFile(string path)
{
AudicaFile audicaFile = new AudicaFile();
ZipFile audicaZip = ZipFile.Read(path);
string appPath = Application.dataPath;
bool easy = false, standard = false, advanced = false, expert = false;
HandleCache.CheckCacheFolderValid();
HandleCache.ClearCueCache();
//Figure out what files we need to extract by getting the song.desc.
foreach (ZipEntry entry in audicaZip.Entries)
{
if (entry.FileName == "song.desc")
{
MemoryStream ms = new MemoryStream();
entry.Extract(ms);
string tempDesc = Encoding.UTF8.GetString(ms.ToArray());
JsonUtility.FromJsonOverwrite(tempDesc, audicaFile.desc);
ms.Dispose();
continue;
}
//Extract the cues files.
else if (entry.FileName == "expert.cues")
{
entry.Extract($"{appPath}/.cache");
expert = true;
}
else if (entry.FileName == "advanced.cues")
{
entry.Extract($"{appPath}/.cache");
advanced = true;
}
else if (entry.FileName == "moderate.cues")
{
entry.Extract($"{appPath}/.cache");
standard = true;
}
else if (entry.FileName == "beginner.cues")
{
entry.Extract($"{appPath}/.cache");
easy = true;
}
}
//Now we fill the audicaFile var with all the things it needs.
//Remember, all props in audicaFile.desc refer to either moggsong or the name of the mogg.
//Real clips are stored in main audicaFile object.
//Load the cues files.
if (expert)
{
audicaFile.diffs.expert = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/expert.cues"));
}
if (advanced)
{
audicaFile.diffs.advanced = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/advanced.cues"));
}
if (standard)
{
audicaFile.diffs.moderate = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/moderate.cues"));
}
if (easy)
{
audicaFile.diffs.beginner = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/beginner.cues"));
}
MemoryStream temp = new MemoryStream();
//Load the names of the moggs
foreach (ZipEntry entry in audicaZip.Entries)
{
if (entry.FileName == audicaFile.desc.moggSong)
{
entry.Extract(temp);
audicaFile.desc.moggMainSong = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray())) [0];
}
else if (entry.FileName == audicaFile.desc.sustainSongLeft)
{
entry.Extract(temp);
audicaFile.desc.moggSustainSongLeft = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray())) [0];
}
else if (entry.FileName == audicaFile.desc.sustainSongRight)
{
entry.Extract(temp);
audicaFile.desc.moggSustainSongRight = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray())) [0];
}
else if (entry.FileName == "song.mid")
{
entry.Extract($"{appPath}/.cache", ExtractExistingFileAction.OverwriteSilently);
audicaFile.song_mid = MidiFile.Read($"{appPath}/.cache/song.mid");
}
temp.SetLength(0);
}
bool mainSongCached = false, sustainRightCached = false, sustainLeftCached = false;
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedMainSong}.ogg"))
{
mainSongCached = true;
}
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedSustainSongRight}.ogg"))
{
sustainRightCached = true;
}
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedSustainSongLeft}.ogg"))
{
sustainLeftCached = true;
}
//If all the songs were already cached, skip this and go to the finish.
if (mainSongCached && sustainRightCached && sustainLeftCached)
{
Debug.Log("Audio files were already cached and will be loaded.");
goto Finish;
}
Debug.Log("Files not cached... Loading...");
//If the files weren't cached, we now need to cache them manually then load them.
MemoryStream tempMogg = new MemoryStream();
foreach (ZipEntry entry in audicaZip.Entries)
{
if (!mainSongCached && entry.FileName == audicaFile.desc.moggMainSong)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedMainSong);
}
else if (!sustainRightCached && entry.FileName == audicaFile.desc.moggSustainSongRight)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedSustainSongRight);
}
else if (!sustainLeftCached && entry.FileName == audicaFile.desc.moggSustainSongLeft)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedSustainSongLeft);
}
tempMogg.SetLength(0);
}
Finish:
audicaFile.filepath = path;
audicaZip.Dispose();
return(audicaFile);
}
public static AudicaFile LoadAudicaFile(string path)
{
AudicaFile audicaFile = new AudicaFile();
ZipFile audicaZip = ZipFile.Read(path);
string appPath = Application.dataPath;
bool easy = false, standard = false, advanced = false, expert = false, modifiers = false;
HandleCache.CheckCacheFolderValid();
HandleCache.ClearCueCache();
//Figure out what files we need to extract by getting the song.desc.
foreach (ZipEntry entry in audicaZip.Entries)
{
if (entry.FileName == "song.desc")
{
MemoryStream ms = new MemoryStream();
entry.Extract(ms);
string tempDesc = Encoding.UTF8.GetString(ms.ToArray());
JsonUtility.FromJsonOverwrite(tempDesc, audicaFile.desc);
ms.Dispose();
continue;
}
//Extract the cues files.
else if (entry.FileName == "expert.cues")
{
entry.Extract($"{appPath}/.cache");
expert = true;
}
else if (entry.FileName == "advanced.cues")
{
entry.Extract($"{appPath}/.cache");
advanced = true;
}
else if (entry.FileName == "moderate.cues")
{
entry.Extract($"{appPath}/.cache");
standard = true;
}
else if (entry.FileName == "beginner.cues")
{
entry.Extract($"{appPath}/.cache");
easy = true;
}
else if (entry.FileName == "modifiers.json")
{
entry.Extract($"{appPath}/.cache");
modifiers = true;
}
}
//Load moggsongg, has to be done after desc is loaded
if (audicaZip.ContainsEntry(audicaFile.desc.moggSong))
{
MemoryStream ms = new MemoryStream();
audicaZip[audicaFile.desc.moggSong].Extract(ms);
audicaFile.mainMoggSong = new MoggSong(ms);
Debug.Log($"MoggSong volumes: L{audicaFile.mainMoggSong.volume.l}, R{audicaFile.mainMoggSong.volume.r} ");
audicaZip[audicaFile.desc.moggSong].Extract($"{appPath}/.cache");
}
else
{
Debug.Log("Moggsong not found");
}
//Now we fill the audicaFile var with all the things it needs.
//Remember, all props in audicaFile.desc refer to either moggsong or the name of the mogg.
//Real clips are stored in main audicaFile object.
//Load the cues files.
if (expert)
{
audicaFile.diffs.expert = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/expert.cues"));
}
if (advanced)
{
audicaFile.diffs.advanced = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/advanced.cues"));
}
if (standard)
{
audicaFile.diffs.moderate = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/moderate.cues"));
}
if (easy)
{
audicaFile.diffs.beginner = JsonUtility.FromJson <CueFile>(File.ReadAllText($"{appPath}/.cache/beginner.cues"));
}
if (modifiers)
{
audicaFile.modifiers = JsonUtility.FromJson <ModifierList>(File.ReadAllText($"{appPath}/.cache/modifiers.json"));
}
MemoryStream temp = new MemoryStream();
//Load the names of the moggs
foreach (ZipEntry entry in audicaZip.Entries)
{
if (entry.FileName == audicaFile.desc.moggSong)
{
entry.Extract(temp);
audicaFile.desc.moggMainSong = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray()))[0];
}
else if (entry.FileName == audicaFile.desc.sustainSongLeft)
{
entry.Extract(temp);
audicaFile.desc.moggSustainSongLeft = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray()))[0];
}
else if (entry.FileName == audicaFile.desc.sustainSongRight)
{
entry.Extract(temp);
audicaFile.desc.moggSustainSongRight = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray()))[0];
}
else if (entry.FileName == audicaFile.desc.fxSong)
{
entry.Extract(temp);
audicaFile.desc.moggFxSong = MoggSongParser.parse_metadata(Encoding.UTF8.GetString(temp.ToArray()))[0];
}
else if (entry.FileName == "song.mid" || entry.FileName == audicaFile.desc.midiFile)
{
string midiFiileName = $"{appPath}/.cache/song.mid";
entry.Extract($"{appPath}/.cache", ExtractExistingFileAction.OverwriteSilently);
if (entry.FileName != "song.mid")
{
File.Delete(midiFiileName);
File.Move($"{appPath}/.cache/" + audicaFile.desc.midiFile, midiFiileName);
//Sometimes these midi files get marked with strange attributes. Reset them to normal so we don't have problems deleting them
File.SetAttributes(midiFiileName, FileAttributes.Normal);
}
audicaFile.song_mid = new MidiFile(midiFiileName);
//Album art, just gonna shove it here
}
else if (entry.FileName == "song.png" || entry.FileName == audicaFile.desc.albumArt)
{
string albumArtName = $"{appPath}/.cache/song.png";
entry.Extract($"{appPath}/.cache", ExtractExistingFileAction.OverwriteSilently);
if (entry.FileName != "song.png")
{
File.Delete(albumArtName);
File.Move($"{appPath}/.cache/" + audicaFile.desc.albumArt, albumArtName);
}
//audicaFile.song_png = new ArtFile(artFileName);
}
temp.SetLength(0);
}
bool mainSongCached = false, sustainRightCached = false, sustainLeftCached = false, extraSongCached = false;
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedMainSong}.ogg"))
{
mainSongCached = true;
}
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedSustainSongRight}.ogg"))
{
sustainRightCached = true;
}
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedSustainSongLeft}.ogg"))
{
sustainLeftCached = true;
}
if (File.Exists($"{appPath}/.cache/{audicaFile.desc.cachedFxSong}.ogg"))
{
extraSongCached = true;
}
//If all the songs were already cached, skip this and go to the finish.
if (mainSongCached && sustainRightCached && sustainLeftCached)
{
Debug.Log("Audio files were already cached and will be loaded.");
goto Finish;
}
Debug.Log("Files not cached... Loading...");
//If the files weren't cached, we now need to cache them manually then load them.
MemoryStream tempMogg = new MemoryStream();
foreach (ZipEntry entry in audicaZip.Entries)
{
if (!mainSongCached && entry.FileName == audicaFile.desc.moggMainSong)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedMainSong);
}
else if (!sustainRightCached && entry.FileName == audicaFile.desc.moggSustainSongRight)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedSustainSongRight);
}
else if (!sustainLeftCached && entry.FileName == audicaFile.desc.moggSustainSongLeft)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedSustainSongLeft);
}
else if (!extraSongCached && entry.FileName == audicaFile.desc.moggFxSong)
{
entry.Extract(tempMogg);
MoggToOgg(tempMogg.ToArray(), audicaFile.desc.cachedFxSong);
}
tempMogg.SetLength(0);
}
Finish:
audicaFile.filepath = path;
audicaZip.Dispose();
return(audicaFile);
}
public bool LoadAudicaFile(bool loadRecent = false, string filePath = null)
{
inTimingMode = false;
SetOffset(0);
if (audicaLoaded)
{
Export();
}
if (loadRecent)
{
audicaFile = null;
DeleteAllTargets();
audicaFile = AudicaHandler.LoadAudicaFile(PlayerPrefs.GetString("recentFile", null));
if (audicaFile == null)
{
return(false);
}
}
else if (filePath != null)
{
audicaFile = null;
DeleteAllTargets();
audicaFile = AudicaHandler.LoadAudicaFile(filePath);
PlayerPrefs.SetString("recentFile", audicaFile.filepath);
}
else
{
string[] paths = StandaloneFileBrowser.OpenFilePanel("Audica File (Not OST)", Path.Combine(Application.persistentDataPath), "audica", false);
if (paths.Length == 0)
{
return(false);
}
audicaFile = null;
DeleteAllTargets();
audicaFile = AudicaHandler.LoadAudicaFile(paths[0]);
PlayerPrefs.SetString("recentFile", paths[0]);
}
desc = audicaFile.desc;
// Get song BPM
if (audicaFile.song_mid != null)
{
float oneMinuteInMicroseconds = 60000000f;
var midiBpm = -1;
foreach (var tempo in audicaFile.song_mid.GetTempoMap().Tempo)
{
// TODO: Multi-bpm support :(
// Debug.Log($"FOUND TEMPO EVENT: {tempo}, BPM: {tempo.Value.BeatsPerMinute}");
midiBpm = (int)Math.Round(oneMinuteInMicroseconds / tempo.Value.MicrosecondsPerQuarterNote);
}
if (midiBpm != desc.tempo && midiBpm != -1)
{
// TODO: in-scene dialog box :/
//if (EditorUtility.DisplayDialog("BPM mismatch",
//"Detected different BPM values in midi and song.desc. NotReaper does not currently support multi-bpm tracks.",
// $"Use midi ({midiBpm})", $"Use song.desc ({desc.tempo})")) {
desc.tempo = midiBpm;
//}
}
}
//Update our discord presence
nrDiscordPresence.UpdatePresenceSongName(desc.title);
//Loads all the sounds.
StartCoroutine(GetAudioClip($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedMainSong}.ogg"));
StartCoroutine(LoadLeftSustain($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedSustainSongLeft}.ogg"));
StartCoroutine(LoadRightSustain($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedSustainSongRight}.ogg"));
//foreach (Cue cue in audicaFile.diffs.expert.cues) {
//AddTarget(cue);
//}
//Difficulty manager loads stuff now
audicaLoaded = true;
difficultyManager.LoadHighestDifficulty();
//Disable timing window buttons so users don't mess stuff up.
applyButtonTiming.interactable = false;
generateAudicaButton.interactable = false;
loadAudioFileTiming.interactable = false;
//Loaded successfully
NotificationShower.AddNotifToQueue(new NRNotification("Map loaded successfully!"));
NotificationShower.AddNotifToQueue(new NRNotification("Hold F1 to view shortcuts"));
return(true);
}
public static void ExportToAudicaFile(AudicaFile audicaFile)
{
if (!File.Exists(audicaFile.filepath))
{
Debug.Log("Save file is gone... :(");
return;
}
Encoding encoding = Encoding.GetEncoding(437);
using (var archive = ZipArchive.Open(audicaFile.filepath)) {
HandleCache.CheckCacheFolderValid();
HandleCache.CheckSaveFolderValid();
bool expert = false, advanced = false, standard = false, easy = false;
//Write the cues files to disk so we can add them to the audica file.
if (audicaFile.diffs.expert.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/expert-new.cues", CuesToJson(audicaFile.diffs.expert));
expert = true;
}
if (audicaFile.diffs.advanced.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/advanced-new.cues", CuesToJson(audicaFile.diffs.advanced));
advanced = true;
}
if (audicaFile.diffs.moderate.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/moderate-new.cues", CuesToJson(audicaFile.diffs.moderate));
standard = true;
}
if (audicaFile.diffs.beginner.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/beginner-new.cues", CuesToJson(audicaFile.diffs.beginner));
easy = true;
}
File.WriteAllText($"{Application.dataPath}/.cache/song-new.desc", JsonUtility.ToJson(audicaFile.desc));
var workFolder = Path.Combine(Application.streamingAssetsPath, "Ogg2Audica");
MidiFile songMidi = new MidiFile(Path.Combine(workFolder, "songtemplate.mid"));
MidiEventCollection events = new MidiEventCollection(0, (int)Constants.PulsesPerQuarterNote);
foreach (var tempo in audicaFile.desc.tempoList)
{
events.AddEvent(new TempoEvent((int)tempo.microsecondsPerQuarterNote, (long)tempo.time.tick), 0);
events.AddEvent(new TimeSignatureEvent((long)tempo.time.tick, (int)tempo.timeSignature.Numerator, (int)TimeSignature.GetMIDIDenominator(tempo.timeSignature.Denominator), 0, 8), 0);
}
events.PrepareForExport();
MidiFile.Export(Path.Combine(workFolder, $"{Application.dataPath}/.cache/song.mid"), events);
//Remove any files we'll be replacing
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.ToString() == "expert.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.desc")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.mid")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "advanced.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "moderate.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "beginner.cues")
{
archive.RemoveEntry(entry);
}
}
if (expert)
{
archive.AddEntry("expert.cues", $"{Application.dataPath}/.cache/expert-new.cues");
}
if (advanced)
{
archive.AddEntry("advanced.cues", $"{Application.dataPath}/.cache/advanced-new.cues");
}
if (standard)
{
archive.AddEntry("moderate.cues", $"{Application.dataPath}/.cache/moderate-new.cues");
}
if (easy)
{
archive.AddEntry("beginner.cues", $"{Application.dataPath}/.cache/beginner-new.cues");
}
archive.AddEntry("song.desc", $"{Application.dataPath}/.cache/song-new.desc");
archive.AddEntry("song.mid", $"{Application.dataPath}/.cache/song.mid");
archive.SaveTo(audicaFile.filepath + ".temp", SharpCompress.Common.CompressionType.None);
archive.Dispose();
}
File.Delete(audicaFile.filepath);
File.Move(audicaFile.filepath + ".temp", audicaFile.filepath);
Debug.Log("Export finished.");
}
public static void ExportToAudicaFile(AudicaFile audicaFile)
{
if (!File.Exists(audicaFile.filepath))
{
Debug.Log("Save file is gone... :(");
return;
}
Encoding encoding = Encoding.GetEncoding(437);
using (var archive = ZipArchive.Open(audicaFile.filepath)) {
HandleCache.CheckCacheFolderValid();
HandleCache.CheckSaveFolderValid();
bool expert = false, advanced = false, standard = false, easy = false;
//Write the cues files to disk so we can add them to the audica file.
if (audicaFile.diffs.expert.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/expert-new.cues", CuesToJson(audicaFile.diffs.expert));
expert = true;
}
if (audicaFile.diffs.advanced.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/advanced-new.cues", CuesToJson(audicaFile.diffs.advanced));
advanced = true;
}
if (audicaFile.diffs.moderate.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/moderate-new.cues", CuesToJson(audicaFile.diffs.moderate));
standard = true;
}
if (audicaFile.diffs.beginner.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/beginner-new.cues", CuesToJson(audicaFile.diffs.beginner));
easy = true;
}
File.WriteAllText($"{Application.dataPath}/.cache/song-new.desc", JsonUtility.ToJson(audicaFile.desc));
var workFolder = Path.Combine(Application.streamingAssetsPath, "Ogg2Audica");
MidiFile songMidi = MidiFile.Read(Path.Combine(workFolder, "songtemplate.mid"));
using (var tempoMapManager = new TempoMapManager(new TicksPerQuarterNoteTimeDivision(480)))
{
float oneMinuteInMicroseconds = 60000000f;
TempoMap tempoMap = tempoMapManager.TempoMap;
foreach (var tempo in audicaFile.desc.tempoList)
{
tempoMapManager.SetTempo(new MetricTimeSpan((long)(tempo.time * 1000000)), new Tempo((long)(oneMinuteInMicroseconds / tempo.bpm)));
}
songMidi.ReplaceTempoMap(tempoMap);
}
songMidi.Write(Path.Combine(workFolder, $"{Application.dataPath}/.cache/song.mid"), true, MidiFileFormat.MultiTrack);
//Remove any files we'll be replacing
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.ToString() == "expert.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.desc")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.mid")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "advanced.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "moderate.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "beginner.cues")
{
archive.RemoveEntry(entry);
}
}
if (expert)
{
archive.AddEntry("expert.cues", $"{Application.dataPath}/.cache/expert-new.cues");
}
if (advanced)
{
archive.AddEntry("advanced.cues", $"{Application.dataPath}/.cache/advanced-new.cues");
}
if (standard)
{
archive.AddEntry("moderate.cues", $"{Application.dataPath}/.cache/moderate-new.cues");
}
if (easy)
{
archive.AddEntry("beginner.cues", $"{Application.dataPath}/.cache/beginner-new.cues");
}
archive.AddEntry("song.desc", $"{Application.dataPath}/.cache/song-new.desc");
archive.AddEntry("song.mid", $"{Application.dataPath}/.cache/song.mid");
archive.SaveTo(audicaFile.filepath + ".temp", SharpCompress.Common.CompressionType.None);
archive.Dispose();
}
File.Delete(audicaFile.filepath);
File.Move(audicaFile.filepath + ".temp", audicaFile.filepath);
Debug.Log("Export finished.");
}
public bool LoadAudicaFile(bool loadRecent = false, string filePath = null)
{
inTimingMode = false;
if (audicaLoaded)
{
Export();
}
DeleteAllTargets();
audicaFile = null;
if (loadRecent)
{
audicaFile = AudicaHandler.LoadAudicaFile(PlayerPrefs.GetString("recentFile", null));
if (audicaFile == null)
{
return(false);
}
}
else if (filePath != null)
{
audicaFile = AudicaHandler.LoadAudicaFile(filePath);
PlayerPrefs.SetString("recentFile", audicaFile.filepath);
}
else
{
string[] paths = StandaloneFileBrowser.OpenFilePanel("Audica File (Not OST)", Path.Combine(Application.persistentDataPath), "audica", false);
if (paths.Length == 0)
{
return(false);
}
audicaFile = AudicaHandler.LoadAudicaFile(paths[0]);
PlayerPrefs.SetString("recentFile", paths[0]);
}
//SetOffset(0);
desc = audicaFile.desc;
//Update our discord presence
nrDiscordPresence.UpdatePresenceSongName(desc.title);
//Loads all the sounds.
StartCoroutine(GetAudioClip($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedMainSong}.ogg"));
StartCoroutine(LoadLeftSustain($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedSustainSongLeft}.ogg"));
StartCoroutine(LoadRightSustain($"file://{Application.dataPath}/.cache/{audicaFile.desc.cachedSustainSongRight}.ogg"));
//foreach (Cue cue in audicaFile.diffs.expert.cues) {
//AddTarget(cue);
//}
//Difficulty manager loads stuff now
audicaLoaded = true;
difficultyManager.LoadHighestDifficulty();
//Disable timing window buttons so users don't mess stuff up.
applyButtonTiming.interactable = false;
generateAudicaButton.interactable = false;
loadAudioFileTiming.interactable = false;
//Loaded successfully
NotificationShower.AddNotifToQueue(new NRNotification("Map loaded successfully!"));
return(true);
}
public static void ExportToAudicaFile(AudicaFile audicaFile)
{
if (!File.Exists(audicaFile.filepath))
{
Debug.Log("Save file is gone... :(");
return;
}
Encoding encoding = Encoding.GetEncoding(437);
using (var archive = ZipArchive.Open(audicaFile.filepath)) {
HandleCache.CheckCacheFolderValid();
HandleCache.CheckSaveFolderValid();
bool expert = false, advanced = false, standard = false, easy = false;
//Write the cues files to disk so we can add them to the audica file.
if (audicaFile.diffs.expert.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/expert-new.cues", CuesToJson(audicaFile.diffs.expert));
expert = true;
}
if (audicaFile.diffs.advanced.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/advanced-new.cues", CuesToJson(audicaFile.diffs.advanced));
advanced = true;
}
if (audicaFile.diffs.moderate.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/moderate-new.cues", CuesToJson(audicaFile.diffs.moderate));
standard = true;
}
if (audicaFile.diffs.beginner.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/beginner-new.cues", CuesToJson(audicaFile.diffs.beginner));
easy = true;
}
File.WriteAllText($"{Application.dataPath}/.cache/song-new.desc", JsonUtility.ToJson(audicaFile.desc));
//Remove any files we'll be replacing
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.ToString() == "expert.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.desc")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "advanced.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "moderate.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "beginner.cues")
{
archive.RemoveEntry(entry);
}
}
if (expert)
{
archive.AddEntry("expert.cues", $"{Application.dataPath}/.cache/expert-new.cues");
}
if (advanced)
{
archive.AddEntry("advanced.cues", $"{Application.dataPath}/.cache/advanced-new.cues");
}
if (standard)
{
archive.AddEntry("moderate.cues", $"{Application.dataPath}/.cache/moderate-new.cues");
}
if (easy)
{
archive.AddEntry("beginner.cues", $"{Application.dataPath}/.cache/beginner-new.cues");
}
archive.AddEntry("song.desc", $"{Application.dataPath}/.cache/song-new.desc");
archive.SaveTo(audicaFile.filepath + ".temp", SharpCompress.Common.CompressionType.None);
archive.Dispose();
}
File.Delete(audicaFile.filepath);
File.Move(audicaFile.filepath + ".temp", audicaFile.filepath);
Debug.Log("Export finished.");
}
public static void ExportToAudicaFile(AudicaFile audicaFile, bool autoSave)
{
if (!File.Exists(audicaFile.filepath))
{
Debug.Log("Save file is gone... :(");
return;
}
Encoding encoding = Encoding.GetEncoding(437);
string targetPath = audicaFile.filepath;
string autoSavePath = "";
using (var archive = ZipArchive.Open(audicaFile.filepath)) {
HandleCache.CheckCacheFolderValid();
HandleCache.CheckSaveFolderValid();
bool expert = false, advanced = false, standard = false, easy = false, modifiers = false;
//Write the cues files to disk so we can add them to the audica file.
if (audicaFile.diffs.expert.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/expert-new.cues", CuesToJson(audicaFile.diffs.expert));
expert = true;
}
if (audicaFile.diffs.advanced.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/advanced-new.cues", CuesToJson(audicaFile.diffs.advanced));
advanced = true;
}
if (audicaFile.diffs.moderate.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/moderate-new.cues", CuesToJson(audicaFile.diffs.moderate));
standard = true;
}
if (audicaFile.diffs.beginner.cues != null)
{
File.WriteAllText($"{Application.dataPath}/.cache/beginner-new.cues", CuesToJson(audicaFile.diffs.beginner));
easy = true;
}
audicaFile.modifiers = new ModifierList();
audicaFile.modifiers.modifiers = ModifierHandler.Instance.MapToDTO();
if (audicaFile.modifiers.modifiers.Count > 0)
{
File.WriteAllText($"{Application.dataPath}/.cache/modifiers-new.json", ModifiersToJson2(audicaFile.modifiers));
modifiers = true;
}
File.WriteAllText($"{Application.dataPath}/.cache/{audicaFile.desc.moggSong}", audicaFile.mainMoggSong.ExportToText());
File.WriteAllText($"{Application.dataPath}/.cache/song-new.desc", Newtonsoft.Json.JsonConvert.SerializeObject(audicaFile.desc, Formatting.Indented));
var workFolder = Path.Combine(Application.streamingAssetsPath, "Ogg2Audica");
MidiFile songMidi = new MidiFile(Path.Combine(workFolder, "songtemplate.mid"));
MidiEventCollection events = new MidiEventCollection(0, (int)Constants.PulsesPerQuarterNote);
foreach (var tempo in audicaFile.desc.tempoList)
{
events.AddEvent(new TempoEvent((int)tempo.microsecondsPerQuarterNote, (long)tempo.time.tick), 0);
events.AddEvent(new TimeSignatureEvent((long)tempo.time.tick, (int)tempo.timeSignature.Numerator, (int)TimeSignature.GetMIDIDenominator(tempo.timeSignature.Denominator), 0, 8), 0);
}
events.PrepareForExport();
MidiFile.Export(Path.Combine(workFolder, $"{Application.dataPath}/.cache/song.mid"), events);
//Remove any files we'll be replacing
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.ToString() == "expert.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.desc")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == audicaFile.desc.moggSong)
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.mid")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "song.png")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "advanced.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "moderate.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "beginner.cues")
{
archive.RemoveEntry(entry);
}
else if (entry.ToString() == "modifiers.json")
{
archive.RemoveEntry(entry);
}
}
if (expert)
{
archive.AddEntry("expert.cues", $"{Application.dataPath}/.cache/expert-new.cues");
}
if (advanced)
{
archive.AddEntry("advanced.cues", $"{Application.dataPath}/.cache/advanced-new.cues");
}
if (standard)
{
archive.AddEntry("moderate.cues", $"{Application.dataPath}/.cache/moderate-new.cues");
}
if (easy)
{
archive.AddEntry("beginner.cues", $"{Application.dataPath}/.cache/beginner-new.cues");
}
if (modifiers)
{
archive.AddEntry("modifiers.json", $"{Application.dataPath}/.cache/modifiers-new.json");
}
if (autoSave)
{
int pos = audicaFile.filepath.LastIndexOf(@"\") + 1;
string fileName = audicaFile.filepath.Substring(pos, audicaFile.filepath.Length - pos);
string shortName = fileName.Substring(0, fileName.LastIndexOf(@"."));
shortName = shortName.Replace(" ", "");
targetPath = $"{Application.dataPath}/autosaves/{shortName}/";
autoSavePath = targetPath;
targetPath += DateTime.Now.ToString("MM-dd_h-mm-ss_");
targetPath += fileName;
if (!Directory.Exists($"{Application.dataPath}/autosaves/"))
{
Directory.CreateDirectory($"{Application.dataPath}/autosaves/");
}
if (!Directory.Exists($"{Application.dataPath}/autosaves/{shortName}/"))
{
Directory.CreateDirectory($"{Application.dataPath}/autosaves/{shortName}/");
}
}
archive.AddEntry($"{audicaFile.desc.moggSong}", $"{Application.dataPath}/.cache/{audicaFile.desc.moggSong}");
archive.AddEntry("song.desc", $"{Application.dataPath}/.cache/song-new.desc");
archive.AddEntry("song.mid", $"{Application.dataPath}/.cache/song.mid");
if (File.Exists($"{Application.dataPath}/.cache/song.png"))
{
archive.AddEntry("song.png", $"{Application.dataPath}/.cache/song.png");
}
archive.SaveTo(audicaFile.filepath + ".temp", SharpCompress.Common.CompressionType.None);
archive.Dispose();
}
File.Delete($"{Application.dataPath}/.cache/{audicaFile.desc.moggSong}");
if (!autoSave)
{
File.Delete(audicaFile.filepath);
}
File.Move(audicaFile.filepath + ".temp", targetPath);
if (autoSave)
{
NRSettings.autosavePath = autoSavePath;
}
Debug.Log("Export finished.");
}