《Unityで作るリズムゲーム》學習筆記（六）：「BMS文件讀取與解析」

譜面（沒有拍子與速度變化）的讀取

• 譜面（沒有拍子與速度變化）的腳本讀取，主要步驟為兩大步：

  • 讀取文件頭數據（Header Data）

    • 建立文件頭的正則表達式

      • //Header數據格式的正則表達式
        static List<string> headerPattern = new List<string>
        {
            @"#(PLAYER) (.*)",
            @"#(GENRE) (.*)",
            @"#(TITLE) (.*)",
            @"#(ARTIST) (.*)",
            @"#(BPM) (.*)",
            @"#(BPM[0-9A-Z]{2}) (.*)",
            @"#(PLAYLEVEL) (.*)",
            @"#(RANK) (.*)"
        };

    • 建立Header數據映射

      • //Header數據的名字與數據映射
        public Dictionary<string, string> headerData = new Dictionary<string, string>();

    • 遍歷bms文件中的所有行和Header正則，把符合正則的數據放到數據映射字典中

      • ///
        /// 解析HEADER數據
        ///
        void LoadHeaderLine(string line)
        {
            foreach (string pattern in headerPattern)
            {
                Match match = Regex.Match(line, pattern);
                if(match.Success)
                {
                    //Groups[0].Value為整個表達式
                    //Groups[1].Value = Header名
                    string headerName = match.Groups[1].Value;
                    //Groups[2].Value = 數據
                    string data = match.Groups[2].Value;
                    headerData[headerName] = data;
                    return;
                }
            }
        }

  • 讀取文件主要數據（Main Data）

    • 建立讀取MainData數據的正則表達式

      • //MainData數據格式的正則表達式
        //小節編號 - 000~999
        //通道編號 - 00~ZZ
        //分隔符 - :
        //數據本體 - 長度為2的倍數的任意字符
        static string mainDataPattern = @"#([0-9]{3})([0-9A-Z]{2}):(.*)";

    • 建立通道編號個位數與實際軌道編號映射

      • //通道編號的個位數（軌道編號）與實際的軌道編號映射
        Dictionary<char, int> lanePairs = new Dictionary<char, int>
        {
            {'1', 0 },
            {'2', 1 },
            {'3', 2 },
            {'4', 3 },
            {'5', 4 },
        };

    • 建立保存譜面所有note信息和LongNote頭押拍子位置的緩存集合

      • //所有notes信息
        public List<NoteProperty> noteProperties = new List<NoteProperty>();
        //每個軌道打開（開始）Long Note的最後一個節拍（Long Note頭押的一拍）
        //關閉（結束）Long Note時將其重設為-1（Long Note尾押）
        //用於判斷該軌道是否開始了長押
        float[] longNoteBeginBuffers = new float[] { -1, -1, -1, -1, -1 };

    • 建立每小節長度（4拍）的小節數組，長度為可能小節編號000~999 = 1000

      • //每小節長度，每小節4拍
        //小節編號取值為000~999，共1000小節
        float[] measureLengths = Enumerable.Repeat(4f, 1000).ToArray();

    • 建立代表有甚麼Note類型的枚舉

      • //數據（Note）類型
        public enum DataType
        {
            Unsupported,
            SingleNote,
            LongNote
        }

    • 建立通過通道編號來得到Note類型的方法

      • //通過通道編號來得到數據類型
        //1: SingleNote ; 5: LongNote
        DataType GetDataType(string channel)
        {
            switch (channel[0])
            {
                case '1':
                    return DataType.SingleNote;                
                case '5':
                    return DataType.LongNote;                
                default:
                    throw new Exception($"Can't get note type which is not specified.");                
            }
        }

    • 遍歷文件每一行，並對符合主數據正則的數據進行解析和讀取

      • 如果讀取成功，先把無法識別的數據排除

        • ///
          /// 解析MAIN DATA數據
          ///
          void LoadMainDataLine(string line)
          {                
              Match match = Regex.Match(line, mainDataPattern);
              //數據格式
              //nnn: 小節編號 => match.Groups[1].Value
              //xx: 通道編號 => match.Groups[2].Value
              //match.Groups[3].Value => 數據本體
              if (match.Success)
              {
                  //小節編號
                  int measureNum = Convert.ToInt32(match.Groups[1].Value);
                  //通道編號
                  string channel = match.Groups[2].Value;
                  //Data本體
                  string body = match.Groups[3].Value;
          ​
                  //通過通道編號得到數據的類型（Single/Long/etc）
                  DataType dataType = GetDataType(channel);
                  if (dataType == DataType.Unsupported) { return; }
                  //...
              }
          }

      • 然後再從小節開始進行計算，如該note所在小節的開始拍子、該小節被分成多少等分，然後遍歷所有「物體」（2個字元 = 1個物體），計算這些物體自身的開始拍子（小節的開始拍子 + 自身在當前小節的位置 * （小節長度/物體數量））

        • void LoadMainDataLine(string line)
          {
              //...
              else if(dataType == DataType.SingleNote ||
                  dataType == DataType.LongNote)
              {
                  //該小節開始的拍子 = 小節編號 * 4
                  float measureStartBeat = measureLengths.Take(measureNum).Sum();
                  //該小節被分為多少等分（有多少個物體）
                  int objCount = body.Length / 2;
                  //遍歷所有物體
                  for (int i = 0; i < objCount; i++)
                  {
                      //每兩個數字為1個物體
                      //02, 02, 00, 02...
                      string objNum = body.Substring(i * 2, 2);
                      //00 => 休止符
                      if(objNum == "00") { continue; }
          ​
                      //該物體在整首曲子中的所在拍子 = 所在小節開始的拍子 + 
                      //（自身索引（i） * 當前小節長度（measureLengths[measureNum]） / 物體數量）
                      float beat = measureStartBeat +
                          (i * measureLengths[measureNum] / objCount);
                      //...
                  }
              }      
          }

      • 最後再分別對兩種類型的note進行初始化。Long Note的初始化稍微會比較特別，當其所屬軌道上的長押緩存為-1時，代表該物體是長押的開始，並把拍子加到緩存；當下一個該軌道上的物體出現時，這個物體就是長押的結束，到這裡才能確定長押的beatStart（之前緩存下來的拍子）和beatEnd（當前拍子），並將其實例化出來。

        • void LoadMainDataLine(string line)
          {
              //...
              if(dataType == DataType.SingleNote ||
                 dataType == DataType.LongNote)
              {
                  //通道編號的個位數 = 具體軌道
                  int lane = lanePairs[channel[1]];
                  switch (dataType)
                  {
                      case DataType.Unsupported:
                          break;
                      case DataType.SingleNote:
                          noteProperties.Add(new NoteProperty(beat, beat, lane, NoteType.Single));
                          break;                                
                      case DataType.LongNote:
                          //當前軌道上的長押緩存為OFF（沒有LongNote）
                          if(longNoteBeginBuffers[lane] < 0)
                          {
                              //代表當前長押beat為Long Note的開始，保存該beat到緩存中
                              longNoteBeginBuffers[lane] = beat;
                          }
                          //當前軌道上的長押緩存為ON（已有LongNote的起點加入）
                          else
                          {
                              //代表現在要加入的是Long Note的終點
                              //該軌道上的長押緩存beat作為起點，當前beat為終點
                              noteProperties.Add(new NoteProperty(
                                  longNoteBeginBuffers[lane], beat, lane, NoteType.Long
                              ));
                              //Long Note的長押結束，重置緩存值為OFF（-1）
                              longNoteBeginBuffers[lane] = -1;
                          }
                          break;
                      default:
                          break;
                  }
              }             
          }

  • BmsLoader總體代碼如下

    • using System.Text.RegularExpressions;
      using System.Collections;
      using System.Collections.Generic;
      using UnityEngine;
      using System.Linq;
      using System.IO;
      using System.Text;
      using System;
      ​
      //數據（Note）類型
      public enum DataType
      {
          Unsupported,
          SingleNote,
          LongNote
      }
      ​
      public class BmsLoader
      {
          //MainData數據格式的正則表達式
          //小節編號 - 000~999
          //通道編號 - 00~ZZ
          //分隔符 - :
          //數據本體 - 長度為2的倍數的任意字符
          static string mainDataPattern = @"#([0-9]{3})([0-9A-Z]{2}):(.*)";
      ​
          //Header數據格式的正則表達式
          static List<string> headerPattern = new List<string>
          {
              @"#(PLAYER) (.*)",
              @"#(GENRE) (.*)",
              @"#(TITLE) (.*)",
              @"#(ARTIST) (.*)",
              @"#(BPM) (.*)",
              @"#(BPM[0-9A-Z]{2}) (.*)",
              @"#(PLAYLEVEL) (.*)",
              @"#(RANK) (.*)"
          };
      ​
          //通道編號的個位數（軌道編號）與實際的軌道編號映射
          Dictionary<char, int> lanePairs = new Dictionary<char, int>
          {
              {'1', 0 },
              {'2', 1 },
              {'3', 2 },
              {'4', 3 },
              {'5', 4 },
          };
      ​
          //Header數據的名字與數據映射
          public Dictionary<string, string> headerData = new Dictionary<string, string>();
          //所有notes信息
          public List<NoteProperty> noteProperties = new List<NoteProperty>();
          //速度變化信息
          public List<TempoChange> tempoChanges = new List<TempoChange>();
      ​
          //每小節長度，每小節4拍
          //小節編號取值為000~999，共1000小節
          float[] measureLengths = Enumerable.Repeat(4f, 1000).ToArray();
      ​
          //每個軌道打開（開始）Long Note的最後一個節拍（Long Note頭押的一拍）
          //關閉（結束）Long Note時將其重設為-1（Long Note尾押）
          //用於判斷該軌道是否開始了長押
          float[] longNoteBeginBuffers = new float[] { -1, -1, -1, -1, -1 };
      ​
          ///
          /// 讀取Bms文件構造函數
          ///
          public BmsLoader(string filePath)
          {
              //讀取Bms文件，將每一行保存在一個數組中
              string[] lines = File.ReadAllLines(filePath, Encoding.UTF8);
      ​
              //讀取Header數據
              foreach (string line in lines) { LoadHeaderLine(line); }
      ​
              tempoChanges.Add(
                  //設置0拍開始的BPM
                  new TempoChange(0, Convert.ToSingle(headerData["BPM"])));
      ​
              //讀取Main Data數據
              foreach (string line in lines) { LoadMainDataLine(line); }
      ​
              //把不同的速度（BPM）段根據其所發生的具體節拍（beat）從小到大排序
              tempoChanges = tempoChanges.OrderBy(x => x.beat).ToList();
          }
      ​
          ///
          /// 解析HEADER數據
          ///
          void LoadHeaderLine(string line)
          {
              foreach (string pattern in headerPattern)
              {
                  Match match = Regex.Match(line, pattern);
                  if(match.Success)
                  {
                      //Groups[0].Value為整個表達式
                      //Groups[1].Value = Header名
                      string headerName = match.Groups[1].Value;
                      //Groups[2].Value = 數據
                      string data = match.Groups[2].Value;
                      headerData[headerName] = data;
                      return;
                  }
              }
          }
      ​
          ///
          /// 解析MAIN DATA數據
          ///
          void LoadMainDataLine(string line)
          {                
              Match match = Regex.Match(line, mainDataPattern);
              //數據格式
              //nnn: 小節編號 => match.Groups[1].Value
              //xx: 通道編號 => match.Groups[2].Value
              //match.Groups[3].Value => 數據本體
              if (match.Success)
              {
                  //小節編號
                  int measureNum = Convert.ToInt32(match.Groups[1].Value);
                  //通道編號
                  string channel = match.Groups[2].Value;
                  //Data本體
                  string body = match.Groups[3].Value;
      ​
                  //通過通道編號得到數據的類型（Single/Long/etc）
                  DataType dataType = GetDataType(channel);
                  if (dataType == DataType.Unsupported) { return; }
                  else if(dataType == DataType.SingleNote ||
                          dataType == DataType.LongNote)
                  {
                      //該小節開始的拍子 = 小節編號 * 4
                      float measureStartBeat = measureLengths.Take(measureNum).Sum();
                      //該小節被分為多少等分（有多少個物體）
                      int objCount = body.Length / 2;
                      //遍歷所有物體
                      for (int i = 0; i < objCount; i++)
                      {
                          //每兩個數字為1個物體
                          //02, 02, 00, 02...
                          string objNum = body.Substring(i * 2, 2);
                          //00 => 休止符
                          if(objNum == "00") { continue; }
      ​
                          //該物體在整首曲子中的所在拍子 = 所在小節開始的拍子 + 
                          //（自身索引（i） * 當前小節長度（measureLengths[measureNum]） / 物體數量）
                          float beat = measureStartBeat +
                              (i * measureLengths[measureNum] / objCount);
      ​
                          if(dataType == DataType.SingleNote ||
                             dataType == DataType.LongNote)
                          {
                              //通道編號的個位數 = 具體軌道
                              int lane = lanePairs[channel[1]];
                              switch (dataType)
                              {
                                  case DataType.Unsupported:
                                      break;
                                  case DataType.SingleNote:
                                      noteProperties.Add(new NoteProperty(beat, beat, lane, NoteType.Single));
                                      break;                                
                                  case DataType.LongNote:
                                      //當前軌道上的長押緩存為OFF（沒有LongNote）
                                      if(longNoteBeginBuffers[lane] < 0)
                                      {
                                          //代表當前長押beat為Long Note的開始，保存該beat到緩存中
                                          longNoteBeginBuffers[lane] = beat;
                                      }
                                      //當前軌道上的長押緩存為ON（已有LongNote的起點加入）
                                      else
                                      {
                                          //代表現在要加入的是Long Note的終點
                                          //該軌道上的長押緩存beat作為起點，當前beat為終點
                                          noteProperties.Add(new NoteProperty(
                                              longNoteBeginBuffers[lane], beat, lane, NoteType.Long
                                          ));
                                          //Long Note的長押結束，重置緩存值為OFF（-1）
                                          longNoteBeginBuffers[lane] = -1;
                                      }
                                      break;
                                  default:
                                      break;
                              }
                          }
                      }
                  }            
              }
          }
      ​
          //通過通道編號來得到數據類型
          //1: SingleNote ; 5: LongNote
          DataType GetDataType(string channel)
          {
              if (channel[0] == '1') { return DataType.SINGLE_NOTE; }
              else if (channel[0] == '5') { return DataType.LONG_NOTE; }
              else { throw new Exception($"DataType Not Found With Channel: {channel}"); }
          }
      }

• 要具體使用上述腳本對bms格式文件進行讀取，還需要對Beatmap腳本以及PlayerController腳本進行修改。

  • Beatmap：添加一個接收文件路徑的構造方法，在Beatmap被實例化時，會同時實例化一個BmsLoader，並bms文件路徑傳過去讓BmsLoader完成note數據和速度段數據的讀取和初始化

    • ///
      /// 實例化BeatMap時讓BmsLoader讀取並解析bms文件
      ///
      public BeatMap(string filePath)
      {
          BmsLoader bmsLoader = new BmsLoader(filePath);
          noteDatas = bmsLoader.noteProperties;
          tempoChangeDatas = bmsLoader.tempoChanges;
      }

  • PlayerController：設置文件路徑，在Awake中實例化beatmap並把譜面路徑傳遞過去。在beatmap通過bmsLoader完成譜面的初始化後， PlayerController就可以再通過beatmap中的noteDatas得到完成數據初始化後的每個notes，再將他們依次實例化到遊戲場景中，譜面（沒有變速）的讀取和解析就完成了

    • string beatmapDirectory = Application.dataPath + "/../Beatmaps";
      beatMap = new BeatMap(beatmapDirectory + "/sample1.bms");
      ​
      ​
      //Spawning Notes
      foreach (NoteProperty noteProperty in beatMap.noteDatas)
      {
          Instantiate(noteProperty.noteType == NoteType.Single ?
                      singleNotePrefab : longNotePrefab)
              .GetComponent<NoteControllerBase>()
              .noteProperty = noteProperty;
      }

  • Bms文件中的譜面