コード例 #1
0
        public void TransformToProjectedData()
        {
            if (string.IsNullOrWhiteSpace(JsonData))
            {
                throw new InvalidOperationException("JsonData must be set before transforming to ProjectedData.");
            }

            var saveData = BeatmapSaveData.DeserializeFromJSONString(JsonData);

            ProjectedData = saveData.SerializeToBinary();
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: sc2ad/SongConverterPlus
        static void SerializeWrite(string fs)
        {
            var bs = BeatmapSaveData.DeserializeFromJSONString(File.ReadAllText(Path.Combine(required[1].Value, fs)));

            byte[]       bts    = bs.SerializeToBinary();
            StreamWriter writer = new StreamWriter(Path.Combine(required[2].Value, fs));

            Console.WriteLine("Writing Binary Array to: " + fs);
            writer.WriteLine("\t\tArray: [");
            foreach (byte b in bts)
            {
                writer.WriteLine("\t\t\t" + b);
            }
            writer.WriteLine("\t\t]");
            writer.Flush();
            writer.Close();
        }
コード例 #3
0
        public static IEnumerator <BeatmapDetails> CreateBeatmapDetailsFromFilesCoroutine(CustomPreviewBeatmapLevel customLevel)
        {
            StandardLevelInfoSaveData infoData       = customLevel.standardLevelInfoSaveData;
            BeatmapDetails            beatmapDetails = new BeatmapDetails();

            beatmapDetails.LevelID        = BeatmapDetailsLoader.GetSimplifiedLevelID(customLevel);
            beatmapDetails.SongName       = customLevel.songName;
            beatmapDetails.BeatsPerMinute = infoData.beatsPerMinute;

            // load difficulties
            beatmapDetails.DifficultyBeatmapSets = new SimplifiedDifficultyBeatmapSet[infoData.difficultyBeatmapSets.Length];
            for (int i = 0; i < infoData.difficultyBeatmapSets.Length; ++i)
            {
                var currentSimplifiedSet = new SimplifiedDifficultyBeatmapSet();
                beatmapDetails.DifficultyBeatmapSets[i] = currentSimplifiedSet;
                var currentSet = infoData.difficultyBeatmapSets[i];

                currentSimplifiedSet.CharacteristicName = currentSet.beatmapCharacteristicName;
                currentSimplifiedSet.DifficultyBeatmaps = new SimplifiedDifficultyBeatmap[currentSet.difficultyBeatmaps.Length];

                for (int j = 0; j < currentSet.difficultyBeatmaps.Length; ++j)
                {
                    var currentSimplifiedDiff = new SimplifiedDifficultyBeatmap();
                    currentSimplifiedSet.DifficultyBeatmaps[j] = currentSimplifiedDiff;
                    var currentDiff = currentSet.difficultyBeatmaps[j];

                    currentDiff.difficulty.BeatmapDifficultyFromSerializedName(out currentSimplifiedDiff.Difficulty);
                    currentSimplifiedDiff.NoteJumpMovementSpeed = currentDiff.noteJumpMovementSpeed;

                    string diffFilePath             = Path.Combine(customLevel.customLevelPath, currentDiff.beatmapFilename);
                    string fileContents             = null;
                    IEnumerator <string> textLoader = UnityMediaLoader.LoadTextCoroutine(diffFilePath);
                    while (textLoader.MoveNext())
                    {
                        fileContents = textLoader.Current;

                        if (fileContents == null)
                        {
                            yield return(null);
                        }
                    }

                    if (string.IsNullOrEmpty(fileContents))
                    {
                        yield break;
                    }

                    BeatmapSaveData beatmapSaveData = null;
                    try
                    {
                        beatmapSaveData = BeatmapSaveData.DeserializeFromJSONString(fileContents);
                    }
                    catch (Exception e)
                    {
                        Logger.log.Warn($"Exception occurred while trying to deserialize difficulty beatmap to BeatmapSaveData for '{customLevel.songName}'");
                        Logger.log.Debug(e);

                        yield break;
                    }

                    // missing difficulty files
                    if (beatmapSaveData == null)
                    {
                        yield break;
                    }

                    // count notes and bombs
                    currentSimplifiedDiff.NotesCount = 0;
                    currentSimplifiedDiff.BombsCount = 0;
                    foreach (var note in beatmapSaveData.notes)
                    {
                        if (note.type.IsBasicNote())
                        {
                            ++currentSimplifiedDiff.NotesCount;
                        }
                        else if (note.type == NoteType.Bomb)
                        {
                            ++currentSimplifiedDiff.BombsCount;
                        }
                    }

                    // count rotation events
                    currentSimplifiedDiff.SpawnRotationEventsCount = 0;
                    foreach (var mapEvent in beatmapSaveData.events)
                    {
                        if (mapEvent.type.IsRotationEvent())
                        {
                            ++currentSimplifiedDiff.SpawnRotationEventsCount;
                        }
                    }

                    currentSimplifiedDiff.ObstaclesCount = beatmapSaveData.obstacles.Count;
                }
            }

            // load audio
            string    audioFilePath             = Path.Combine(customLevel.customLevelPath, infoData.songFilename);
            AudioClip audioClip                 = null;
            IEnumerator <AudioClip> audioLoader = UnityMediaLoader.LoadAudioClipCoroutine(audioFilePath);

            while (audioLoader.MoveNext())
            {
                audioClip = audioLoader.Current;

                if (audioClip == null)
                {
                    yield return(null);
                }
            }

            if (audioClip == null)
            {
                yield break;
            }

            beatmapDetails.SongDuration = audioClip.length;

            yield return(beatmapDetails);
        }
コード例 #4
0
        /// <summary>
        /// Loads files associated with a custom beatmap and creates a BeatmapDetails object with the information contained in the files.
        /// </summary>
        /// <param name="customLevel">A custom level to create the BeatmapDetails object for.</param>
        /// <returns>BeatmapDetails object on success, otherwise null.</returns>
        public static BeatmapDetails CreateBeatmapDetailsFromFiles(CustomPreviewBeatmapLevel customLevel)
        {
            StandardLevelInfoSaveData infoData       = customLevel.standardLevelInfoSaveData;
            BeatmapDetails            beatmapDetails = new BeatmapDetails();

            beatmapDetails.LevelID        = BeatmapDetailsLoader.GetSimplifiedLevelID(customLevel);
            beatmapDetails.SongName       = customLevel.songName;
            beatmapDetails.BeatsPerMinute = infoData.beatsPerMinute;

            // load difficulties for note info
            beatmapDetails.DifficultyBeatmapSets = new SimplifiedDifficultyBeatmapSet[infoData.difficultyBeatmapSets.Length];
            for (int i = 0; i < infoData.difficultyBeatmapSets.Length; ++i)
            {
                var currentSimplifiedSet = new SimplifiedDifficultyBeatmapSet();
                beatmapDetails.DifficultyBeatmapSets[i] = currentSimplifiedSet;
                var currentSet = infoData.difficultyBeatmapSets[i];

                currentSimplifiedSet.CharacteristicName = currentSet.beatmapCharacteristicName;
                currentSimplifiedSet.DifficultyBeatmaps = new SimplifiedDifficultyBeatmap[currentSet.difficultyBeatmaps.Length];

                for (int j = 0; j < currentSet.difficultyBeatmaps.Length; ++j)
                {
                    var currentSimplifiedDiff = new SimplifiedDifficultyBeatmap();
                    currentSimplifiedSet.DifficultyBeatmaps[j] = currentSimplifiedDiff;
                    var currentDiff = currentSet.difficultyBeatmaps[j];

                    currentDiff.difficulty.BeatmapDifficultyFromSerializedName(out currentSimplifiedDiff.Difficulty);
                    currentSimplifiedDiff.NoteJumpMovementSpeed = currentDiff.noteJumpMovementSpeed;

                    string diffFilePath = Path.Combine(customLevel.customLevelPath, currentDiff.beatmapFilename);
                    if (!File.Exists(diffFilePath))
                    {
                        return(null);
                    }

                    BeatmapSaveData beatmapSaveData = null;
                    try
                    {
                        beatmapSaveData = BeatmapSaveData.DeserializeFromJSONString(File.ReadAllText(diffFilePath));
                    }
                    catch (Exception e)
                    {
                        Logger.log.Debug("Unable to create BeatmapDetails object from files (unexpected exception occurred trying to load BeatmapSaveData from file)");
                        Logger.log.Debug(e);
                        return(null);
                    }

                    if (beatmapSaveData == null)
                    {
                        Logger.log.Debug("Unable to create BeatmapDetails object from files (could not load BeatmapSaveData from file)");
                        return(null);
                    }

                    // count notes and bombs
                    currentSimplifiedDiff.NotesCount = 0;
                    currentSimplifiedDiff.BombsCount = 0;
                    foreach (var note in beatmapSaveData.notes)
                    {
                        if (note.type.IsBasicNote())
                        {
                            ++currentSimplifiedDiff.NotesCount;
                        }
                        else if (note.type == NoteType.Bomb)
                        {
                            ++currentSimplifiedDiff.BombsCount;
                        }
                    }

                    // count rotation events
                    currentSimplifiedDiff.SpawnRotationEventsCount = 0;
                    foreach (var mapEvent in beatmapSaveData.events)
                    {
                        if (mapEvent.type.IsRotationEvent())
                        {
                            ++currentSimplifiedDiff.SpawnRotationEventsCount;
                        }
                    }

                    currentSimplifiedDiff.ObstaclesCount = beatmapSaveData.obstacles.Count;
                }
            }

            // load audio for map length
            string    audioFilePath = Path.Combine(customLevel.customLevelPath, infoData.songFilename);
            AudioClip audioClip     = UnityMediaLoader.LoadAudioClip(audioFilePath);

            if (audioClip == null)
            {
                return(null);
            }

            beatmapDetails.SongDuration = audioClip.length;

            return(beatmapDetails);
        }