Пример #1
0
        private void OnBPM(BMSChart data, string command, string value)
        {
            int index = 0;

            if (command != "BPM")
            {
                index = Utility.FromBase36(command.Substring(command.Length - 2));
            }

            double bpmValue = 0.0;

            if (!double.TryParse(value,
                                 NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out bpmValue))
            {
                value = value.Replace(",", ".");
                if (!double.TryParse(value,
                                     NumberStyles.Number | NumberStyles.AllowExponent, CultureInfo.InvariantCulture, out bpmValue))
                {
                    Log.Error("Unable to parse BPM value: " + value.ToString());
                    return;
                }
            }

            data.bpmObjects[index] = bpmValue;
        }
Пример #2
0
        private void OnBMP(BMSChart data, string command, string value)
        {
            if (headerOnly)
            {
                return;
            }

            string indexStr = command.Substring(3);
            int    index    = Utility.FromBase36(indexStr);

            data.bgaObjects[index] = new BGAObject(value, indexStr);
        }
Пример #3
0
        private void OnWAV(BMSChart data, string command, string value)
        {
            if (headerOnly)
            {
                return;
            }

            string indexStr = command.Substring(3);
            int    index    = Utility.FromBase36(indexStr);

            data.soundObjects[index] = new SoundObject(new SoundFile(value), 1, indexStr);
        }
Пример #4
0
        private void OnStop(BMSChart data, string command, string value)
        {
            if (headerOnly)
            {
                return;
            }

            string indexStr = command.Substring(4);
            int    index    = Utility.FromBase36(indexStr);

            double stopValue = double.Parse(value);

            data.stopObjects[index] = stopValue;
        }
Пример #5
0
        private void OnHeader(BMSChart data, string command, string value)
        {
            if (!data.HeaderDefined(command))
            {
                Log.Error("Unsupported header command: " + command);
            }

            int    valueInt    = 0;
            double valueDouble = 0.0;

            if (data.HasHeader(command))
            {
                if (data.HasHeader <bool>(command) && value == null)
                {
                    data.SetHeader <bool>(command, true);
                }
                else if (data.HasHeader <int>(command) && int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out valueInt))
                {
                    data.SetHeader <int>(command, valueInt);
                }
                else if (data.HasHeader <double>(command) && double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out valueDouble))
                {
                    data.SetHeader <double>(command, valueDouble);
                }
                else
                {
                    data.SetHeader <string>(command, value);
                }
            }
            else
            {
                if (value == null)
                {
                    data.SetHeader <bool>(command, true);
                }
                else if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out valueInt))
                {
                    data.SetHeader <int>(command, valueInt);
                }
                else if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out valueDouble))
                {
                    data.SetHeader <double>(command, valueDouble);
                }
                else
                {
                    data.SetHeader <string>(command, value);
                }
            }
        }
Пример #6
0
        private void OnLongNote(BMSChart data, string command, string value)
        {
            if (headerOnly)
            {
                return;
            }

            if (value == null)
            {
                value = command.Substring(5);
            }

            int index = Utility.FromBase36(value);

            data.lnObjects.Add(index);
        }
Пример #7
0
        private void OnChannel(BMSChart data, string line, ref BMSMeasure lastMeasure)
        {
            // channel sentences
            // # <measure:3> <channel:2> : <object data>
            // for object data, 00 = musical rest

            if (headerOnly)
            {
                return;
            }

            int    measureIndex;
            int    channelIndex;
            string channelValue;

            if (!ParseChannelLine(line, out measureIndex, out channelIndex, out channelValue))
            {
                Log.Error("Invalid channel line");
                return;
            }

            if (channelRefs.ContainsKey(channelIndex))
            {
                channelRefs[channelIndex]++;
            }
            else
            {
                channelRefs.Add(channelIndex, 1);
            }

            if (!BMSChannel.IsSupported(channelIndex))
            {
                Log.Error("Unsupported channel type " + line.Substring(4, 2));
                return;
            }

            bool isSoundChannel  = BMSChannel.IsSound(channelIndex);
            bool isPlayerChannel = BMSChannel.IsPlayer(channelIndex);

            BMSMeasure measure = null;

            if (lastMeasure != null && lastMeasure.index == measureIndex)
            {
                measure = lastMeasure;
            }
            else
            {
                measure = data.GetMeasure(measureIndex);
                if (measure == null)
                {
                    measure = new BMSMeasure(measureIndex);
                    data.measureList.Add(measure);
                }
            }
            lastMeasure = measure;

            int channelLength = 1;

            if (channelIndex == (int)BMSChannel.Type.Meter)
            {
                double meter = 1.0;
                if (!double.TryParse(channelValue,
                                     NumberStyles.Float, CultureInfo.InvariantCulture, out meter))
                {
                    channelValue = channelValue.Replace(",", ".");
                    if (!double.TryParse(channelValue,
                                         NumberStyles.Float, CultureInfo.InvariantCulture, out meter))
                    {
                        Log.Error("Unable to parse meter value: " + channelValue.ToString());
                    }
                }
                measure.meter = meter;
            }
            else
            {
                channelLength = channelValue.Length / 2;
                if (channelValue.Length % 2 != 0)
                {
                    Log.Warning("Channel data length not divisible by 2");
                }

                List <int> objects = new List <int>(channelLength);
                for (int i = 0; i < channelValue.Length; i += 2)
                {
                    int value;
                    if (channelIndex == (int)BMSChannel.Type.BPM)
                    {
                        string bpmStr = channelValue.Substring(i, 2);
                        if (!int.TryParse(bpmStr, NumberStyles.HexNumber,
                                          CultureInfo.InvariantCulture, out value))
                        {
                            Log.Warning("Invalid BPM value in channel line: " + bpmStr);
                            channelLength = objects.Count;
                            break;
                        }
                    }
                    else
                    {
                        if (!Utility.TryFromBase36(channelValue[i], channelValue[i + 1], out value))
                        {
                            Log.Warning("Invalid value in channel line: " + channelValue.Substring(i, 2));
                            channelLength = objects.Count;
                            break;
                        }
                    }

                    objects.Add(value);

                    if (value != 0)
                    {
                        data.eventCount++;
                    }
                }

                // new channel data is applied to existing channel data (excluding BGM channel)
                if (channelIndex != (int)BMSChannel.Type.BGM && !BMSChannel.IsLong(channelIndex) &&
                    measure.HasChannel(channelIndex))
                {
                    int longNoteType = data.GetHeader <int>("LNTYPE");

                    foreach (BMSChannel channel in measure.channelList)
                    {
                        if (channel.index != channelIndex)
                        {
                            continue;
                        }

                        // when merging data with LNTYPE 2, section filler must not be
                        // filled with 0's in order to not close the long notes at wrong times.
                        bool lnWorkaround = longNoteType == 2 && BMSChannel.IsLong(channel.index);
                        BMSChannel.MergeChannels(channel, objects, lnWorkaround);

                        channelLength = channel.values.Count;
                        break;
                    }
                }
                else if (objects.Count > 0)
                {
                    measure.Add(channelIndex, objects);
                }
            }

            if (channelLength > measure.maxLength)
            {
                measure.maxLength = channelLength;
            }
        }
Пример #8
0
        public override Chart Load(string path)
        {
            BMSChart   data        = new BMSChart(Directory.GetParent(path).FullName);
            BMSMeasure lastMeasure = null;

            bool warnRandom = false;

            using (FileStream fileStream = new FileStream(path, FileMode.Open,
                                                          FileAccess.Read, FileShare.Read, 8192, FileOptions.SequentialScan))
            {
                using (StreamReader stream = new StreamReader(fileStream, System.Text.Encoding.GetEncoding("shift_jis"), true))
                {
                    string line;
                    int    lineNumber = -1;
                    while ((line = stream.ReadLine()) != null)
                    {
                        lineNumber++;

                        string command, value;
                        if (!ParseCommandLine(line, out command, out value))
                        {
                            continue;
                        }

                        if (command.StartsWithFast("WAV"))
                        {
                            OnWAV(data, command, value);
                        }
                        else if (command.StartsWithFast("BMP"))
                        {
                            OnBMP(data, command, value);
                        }
                        else if (command.StartsWithFast("BPM") || command.StartsWithFast("EXBPM"))
                        {
                            OnBPM(data, command, value);
                        }
                        else if (command.StartsWithFast("STOP"))
                        {
                            OnStop(data, command, value);
                        }
                        else if (command.StartsWithFast("LNOBJ"))
                        {
                            OnLongNote(data, command, value);
                        }
                        else if (command == "RANDOM")
                        {
                            warnRandom = true;
                        }
                        else if (command[0] >= '0' && command[0] <= '9')
                        {
                            OnChannel(data, line, ref lastMeasure);
                        }
                        else if (BMSChart.unsupportedObjects.Contains(command))
                        {
                            continue;                             // unsupported command, silently ignored
                        }
                        else
                        {
                            OnHeader(data, command, value);
                        }
                    }
                }
            }

            if (warnRandom)
            {
                Log.Warning("#RANDOM charts are not supported");
            }

            data.measureList.Sort(new Comparison <BMSMeasure>((m1, m2) =>
            {
                return(m1.index > m2.index ? 1 : (m1.index < m2.index ? -1 : 0));
            }));

            // insert empty measures at gaps
            for (int i = 0, skipped = 0; i < data.measureList.Count; i++)
            {
                if (data.measureList[i].index == i + skipped)
                {
                    continue;
                }

                if (skipToFirstMeasure && skipped == 0)
                {
                    skipped = data.measureList[i].index;
                    continue;
                }

                BMSMeasure measure = new BMSMeasure(i + skipped);
                BMSChannel channel = new BMSChannel(1);

                channel.values.Add(0);
                measure.channelList.Add(channel);
                measure.maxLength = 1;

                data.measureList.Insert(i, measure);
            }

            // check against overlapping long and regular notes
            int longNoteType = data.GetHeader <int>("LNTYPE");

            for (int i = 0; i < data.measureList.Count; i++)
            {
                for (int c = (int)BMSChannel.Type.P1KeyFirst; c < (int)BMSChannel.Type.P2KeyLast; ++c)
                {
                    BMSChannel keyChannel = data.measureList[i].GetChannel(c);
                    if (keyChannel == null)
                    {
                        continue;
                    }

                    for (int cl = 0; cl < data.measureList[i].channelList.Count; cl++)
                    {
                        if (data.measureList[i].channelList[cl].index != c + (BMSChannel.Type.P1LongFirst - BMSChannel.Type.P1KeyFirst))
                        {
                            continue;
                        }

                        BMSChannel lnChannel = data.measureList[i].channelList[cl];
                        if (keyChannel.values.Count != lnChannel.values.Count)
                        {
                            int  newLength    = Utility.lcm(keyChannel.values.Count, lnChannel.values.Count);
                            bool lnWorkaround = longNoteType == 2;
                            BMSChannel.NormalizeChannel(keyChannel, newLength, 0);
                            BMSChannel.NormalizeChannel(lnChannel, newLength, lnWorkaround ? -1 : 0);
                        }

                        int lnValue = -1;
                        for (int j = 0; j < keyChannel.values.Count; j++)
                        {
                            if (lnChannel.values[j] != -1)
                            {
                                lnValue = lnChannel.values[j];
                            }
                            else
                            {
                                lnChannel.values[j] = lnValue;
                            }

                            if (keyChannel.values[j] == 0 || lnValue == 0)
                            {
                                continue;
                            }
                            else if (lnValue != 0)
                            {
                                // Both channels have overlapping notes.
                                // Charter probably added both for compatibility reasons
                                // if the client doesn't support long notes.

                                keyChannel.values[j] = 0;
                            }
                        }
                    }
                }
            }

            if (longNoteType != 1)
            {
                Log.Warning("#LNTYPE " + longNoteType.ToString());
            }

            int p1KeyCount = 0;
            int p2KeyCount = 0;

            // merge long note references with regular keys
            List <int> channelKeys = channelRefs.Keys.ToList();

            foreach (int channelIndex in channelKeys)
            {
                if (BMSChannel.IsP1Long(channelIndex) || BMSChannel.IsP2Long(channelIndex))
                {
                    int offset     = BMSChannel.Type.P1LongFirst - BMSChannel.Type.P1KeyFirst;
                    int newChannel = channelIndex - offset;
                    int refs       = channelRefs[channelIndex];

                    if (channelRefs.ContainsKey(newChannel))
                    {
                        channelRefs[newChannel] += refs;
                    }
                    else
                    {
                        channelRefs.Add(newChannel, refs);
                    }
                }
            }

            foreach (var channel in channelRefs)
            {
                if (BMSChannel.IsP1Key(channel.Key))
                {
                    p1KeyCount++;
                }
                else if (BMSChannel.IsP2Key(channel.Key))
                {
                    p2KeyCount++;
                }
            }

            data.playerChannels = Math.Max(p1KeyCount, p2KeyCount);
            if (data.playerChannels != 6 && data.playerChannels != 8 && data.playerChannels != 9)
            {
                // non-standard format or some channels were left empty,
                // fallback to using specific key count based on the file extension.
                int    keyCount  = 0;
                string extension = Path.GetExtension(path).ToLowerInvariant();
                if (extension == ".bms")
                {
                    keyCount = 6;
                }
                else if (extension == ".bme" || extension == ".bml")
                {
                    keyCount = 8;
                }
                else if (extension == ".pms")
                {
                    keyCount = 9;

                    if (p1KeyCount <= 5 && p2KeyCount <= 4)
                    {
                        // actually one player chart
                        p2KeyCount = 0;
                    }
                }

                if (keyCount != 0)
                {
                    if (p1KeyCount > 0)
                    {
                        p1KeyCount = keyCount;
                    }
                    if (p2KeyCount > 0)
                    {
                        p2KeyCount = keyCount;
                    }
                }
            }

            data.playerChannels = Math.Max(p1KeyCount, p2KeyCount);
            data.hasTurntable   = data.playerChannels == 6 || data.playerChannels == 8;

            if (p2KeyCount > 0)
            {
                data.players = 2;
            }
            else if (p1KeyCount > 0)
            {
                data.players = 1;
            }

            // find the most optimal resolution for this chart
            long       resolution    = 1;
            const long maxResolution = long.MaxValue / (1000 * 4);

            try
            {
                foreach (BMSMeasure measure in data.measureList)
                {
                    foreach (BMSChannel channel in measure.channelList)
                    {
                        if (resolution % channel.values.Count != 0)
                        {
                            resolution = Utility.lcm(resolution, channel.values.Count);
                        }
                    }
                }
            }
            catch (ArithmeticException)
            {
                resolution = 0;
            }
            finally
            {
                if (resolution <= 0 || resolution > maxResolution)
                {
                    resolution = maxResolution;
                    Log.Warning("Required object resolution is too high for accurate playback");
                }
            }

            data.resolution_ = resolution;

            return(data);
        }