Musicreater/msctPkgver/main.py

# -*- coding: utf-8 -*-


# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需使用或借鉴 请依照 Apache 2.0 许可证进行许可


"""
音·创 库版 (Musicreater Package Version)
是一款免费开源的针对《我的世界：基岩版》的midi音乐转换库
注意！除了此源文件以外，任何属于此仓库以及此项目的文件均依照Apache许可证进行许可
Musicreater pkgver (Package Version 音·创 库版)
A free open source library used for convert midi file into formats that is suitable for **Minecraft: Bedrock Edition**.
Note! Except for this source file, all the files in this repository and this project are licensed under Apache License 2.0

   Copyright 2022 all the developers of Musicreater

   Licensed under the Apache License, Version 2.0 (the 'License');
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an 'AS IS' BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
"""

import os
import mido
import brotli


def makeZip(sourceDir, outFilename, compression=8, exceptFile=None):
    """使用compression指定的算法打包目录为zip文件\n
    默认算法为DEFLATED(8),可用算法如下：\n
    STORED = 0\n
    DEFLATED = 8\n
    BZIP2 = 12\n
    LZMA = 14\n
    """
    import zipfile

    zipf = zipfile.ZipFile(outFilename, 'w', compression)
    pre_len = len(os.path.dirname(sourceDir))
    for parent, dirnames, filenames in os.walk(sourceDir):
        for filename in filenames:
            if filename == exceptFile:
                continue
            pathfile = os.path.join(parent, filename)
            arcname = pathfile[pre_len:].strip(os.path.sep)  # 相对路径
            zipf.write(pathfile, arcname)
    zipf.close()


class midiConvert:
    def __init__(self):
        '''简单的midi转换类，将midi文件转换为我的世界结构或者包'''
        pass

    def convert(self, midiFile: str, outputPath: str):
        '''转换前需要先运行此函数来获取基本信息'''

        self.midiFile = midiFile
        '''midi文件路径'''
        self.midi = mido.MidiFile(self.midiFile)
        '''MidiFile对象'''
        self.outputPath = outputPath
        '''输出路径'''
        # 将self.midiFile的文件名，不含路径且不含后缀存入self.midiFileName
        self.midFileName = os.path.splitext(os.path.basename(self.midiFile))[0]
        '''文件名，不含路径且不含后缀'''

    def __Inst2soundIDwithX(self, instrumentID):
        """返回midi的乐器ID对应的我的世界乐器名，对于音域转换算法，如下：
            2**( ( msg.note - 60 - X ) / 12 ) 即为MC的音高，其中
            X的取值随乐器不同而变化：
            竖琴harp、电钢琴pling、班卓琴banjo、方波bit、颤音琴iron_xylophone 的时候为6
            吉他的时候为7
            贝斯bass、迪吉里杜管didgeridoo的时候为8
            长笛flute、牛铃cou_bell的时候为5
            钟琴bell、管钟chime、木琴xylophone的时候为4
        :param instrumentID: midi的乐器ID
        :param default: 如果instrumentID不在范围内，返回的默认我的世界乐器名称
        :return: (str我的世界乐器名, int转换算法中的X)"""

        if instrumentID == 105:
            return 'note.banjo', 6
        if instrumentID in range(32, 40):
            return 'note.bass', 8
        if instrumentID in range(115, 119):
            return 'note.basedrum', 7 # 注意，这里是底鼓，打击乐器无音域
        if instrumentID == 9 or instrumentID == 14:
            return 'note.bell', 4
        if instrumentID == 80 or instrumentID == 81:
            return 'note.bit', 6
        if instrumentID == 112:
            return 'note.cow_bell', 5
        if instrumentID == -1:
            return 'note.didgeridoo', 8
        if instrumentID in range(72, 80):
            return 'note.flute', 5
        if instrumentID in range(24, 32):
            return 'note.guitar', 7
        if instrumentID == -2:
            return 'note.hat', 7 # 注意，这里是击鼓沿，打击乐器无音域
        if instrumentID == 14:
            return 'note.chime', 4
        if instrumentID == 8 or instrumentID == 11:
            return 'iron_xylophone', 6
        if instrumentID == 2:
            return 'note.pling', 6
        if instrumentID == 114:
            return 'note.snare', 7 # 注意，这里是小军鼓，打击乐器无音域
        if instrumentID == 13:
            return 'note.xylophone', 4
        return 'note.pling', 6

    def __score2time(self, score: int):
        return str(int(int(score / 20) / 60)) + ':' + str(int(int(score / 20) % 60))

    def __formProgressBar(
        self,
        maxscore: int,
        scoreboardname: str,
        progressbar: tuple = (
            r'▶ %%N [ %%s/%^s %%% __________ %%t|%^t ]',
            ('§e=§r', '§7=§r'),
        ),
    ) -> list:

        pgsstyle = progressbar[0]
        '''用于被替换的进度条原始样式'''

        '''
        | 标识符   | 指定的可变量     |
        |---------|----------------|
        | `%%N`   | 乐曲名(即传入的文件名)|
        | `%%s`   | 当前计分板值     |
        | `%^s`   | 计分板最大值     |
        | `%%t`   | 当前播放时间     |
        | `%^t`   | 曲目总时长       |
        | `%%%`   | 当前进度比率     |
        | `_`     | 用以表示进度条占位|
        '''

        def __replace(
            s: str, tobeReplaced: str, replaceWith: str, times: int, other: str
        ):
            if times == 0:
                return s.replace(tobeReplaced, other)
            if times == s.count(tobeReplaced):
                return s.replace(tobeReplaced, replaceWith)
            result = ''
            t = 0
            for i in s:
                if i == tobeReplaced:
                    if t < times:
                        result += replaceWith
                        t += 1
                    else:
                        result += other
                else:
                    result += i

            return result

        idlist = {
            r'%%N': self.midFileName,
            r'%%s': r'%%s',
            r'%^s': str(maxscore),
            r'%%t': r'%%t',
            r'%^t': self.__score2time(maxscore),
            r'%%%': r'%%%',
        }

        ids = {}

        for i, j in idlist.items():
            if i != j:
                if i in pgsstyle:
                    pgsstyle = pgsstyle.replace(i, j)
            else:
                if i in pgsstyle:
                    ids[i] = True
                else:
                    ids[i] = False

        del idlist

        pgblength = pgsstyle.count('_')
        '''进度条的“条”长度'''

        finalprgsbar = []

        for i in range(maxscore):
            nowstr = pgsstyle
            if ids[r'%%s'] == True:
                nowstr = nowstr.replace(r'%%s', str(i + 1))
            if ids[r'%%t'] == True:
                nowstr = nowstr.replace(r'%%t', self.__score2time(i + 1))
            if ids[r'%%%'] == True:
                nowstr = nowstr.replace(
                    r'%%%', str(int((i + 1) / maxscore * 10000) / 100) + '%'
                )

            countof_s = int((i + 1) / maxscore * pgblength)

            finalprgsbar.append(
                'title @a[scores={'
                + scoreboardname
                + '='
                + str(i + 1)
                + '}] actionbar '
                + __replace(
                    nowstr, '_', progressbar[1][0], countof_s, progressbar[1][1]
                )
            )

        return finalprgsbar

    def __formCMDblk(
        self,
        command: str,
        particularValue: int,
        impluse: int = 0,
        condition: bool = False,
        needRedstone: bool = True,
        tickDelay: int = 0,
        customName: str = '',
        executeOnFirstTick: bool = False,
        trackOutput: bool = True,
    ):
        """
        使用指定项目返回指定的指令方块放置指令项
        :param command: `str`
            指令
        :param particularValue:
            方块特殊值，即朝向
                :0	下	无条件
                :1	上	无条件
                :2	z轴负方向	无条件
                :3	z轴正方向	无条件
                :4	x轴负方向	无条件
                :5	x轴正方向	无条件
                :6	下	无条件
                :7	下	无条件

                :8	下	有条件
                :9	上	有条件
                :10	z轴负方向	有条件
                :11	z轴正方向	有条件
                :12	x轴负方向	有条件
                :13	x轴正方向	有条件
                :14	下	有条件
                :14	下	有条件
            注意！此处特殊值中的条件会被下面condition参数覆写
        :param impluse: `int 0|1|2`
            方块类型
                0脉冲 1循环 2连锁
        :param condition: `bool`
            是否有条件
        :param needRedstone: `bool`
            是否需要红石
        :param tickDelay: `int`
            执行延时
        :param customName: `str`
            悬浮字
        :param lastOutput: `str`
            上次输出字符串，注意此处需要留空
        :param executeOnFirstTick: `bool`
            执行第一个已选项(循环指令方块是否激活后立即执行，若为False，则从激活时起延迟后第一次执行)
        :param trackOutput: `bool`
            是否输出

        :return:str
        """
        block = b"\x24" + particularValue.to_bytes(2, byteorder="big", signed=False)

        for i in [
            impluse.to_bytes(4, byteorder="big", signed=False),
            bytes(command, encoding="utf-8") + b"\x00",
            bytes(customName, encoding="utf-8") + b"\x00",
            bytes('', encoding="utf-8") + b"\x00",
            tickDelay.to_bytes(4, byteorder="big", signed=True),
            executeOnFirstTick.to_bytes(1, byteorder="big"),
            trackOutput.to_bytes(1, byteorder="big"),
            condition.to_bytes(1, byteorder="big"),
            needRedstone.to_bytes(1, byteorder="big"),
        ]:
            block += i
        return block

    def _toCmdList_m1(
        self, scoreboardname: str = 'mscplay', volume: float = 1.0, speed: float = 1.0
    ) -> list:
        """
        使用Dislink Sforza的转换思路，将midi转换为我的世界命令列表
        :param scoreboardname: 我的世界的计分板名称
        :param volume: 音量，注意：这里的音量范围为(0,1]，如果超出将被处理为正确值，其原理为在距离玩家 (1 / volume -1) 的地方播放音频
        :param speed: 速度，注意：这里的速度指的是播放倍率，其原理为在播放音频的时候，每个音符的播放时间除以 speed
        :return: tuple(命令列表, 命令个数, 计分板最大值)
        """
        tracks = []
        if volume > 1:
            volume = 1
        if volume <= 0:
            volume = 0.001

        commands = 0
        maxscore = 0

        for i, track in enumerate(self.midi.tracks):

            ticks = 0
            instrumentID = 0
            singleTrack = []

            for msg in track:
                ticks += msg.time
                if msg.is_meta:
                    if msg.type == 'set_tempo':
                        tempo = msg.tempo
                    if msg.type == 'program_change':
                        instrumentID = msg.program
                else:
                    if msg.type == 'note_on' and msg.velocity != 0:
                        nowscore = round(
                            (ticks * tempo)
                            / ((self.midi.ticks_per_beat * float(speed)) * 50000)
                        )
                        maxscore = max(maxscore, nowscore)
                        soundID, _X = self.__Inst2soundIDwithX(instrumentID)
                        singleTrack.append(
                            'execute @a[scores={'
                            + str(scoreboardname)
                            + '='
                            + str(nowscore)
                            + '}'
                            + f'] ~ ~ ~ playsound {soundID} @s ~ ~{1/volume-1} ~ {msg.velocity*(0.7 if msg.channel == 0 else 0.9)} {2**((msg.note-60-_X)/12)}'
                        )
                        commands += 1
            if len(singleTrack) != 0:
                tracks.append(singleTrack)

        return tracks, commands, maxscore

    def _toCmdList_withDelay_m1(
        self,
        volume: float = 1.0,
        speed: float = 1.0,
        player: str = '@a',
        isMixedWithPrograssBar=False,
    ) -> list:
        """
        使用Dislink Sforza的转换思路，将midi转换为我的世界命令列表，并输出每个音符之后的延迟
        :param volume: 音量，注意：这里的音量范围为(0,1]，如果超出将被处理为正确值，其原理为在距离玩家 (1 / volume -1) 的地方播放音频
        :param speed: 速度，注意：这里的速度指的是播放倍率，其原理为在播放音频的时候，每个音符的播放时间除以 speed
        :param player: 玩家选择器，默认为`@a`
        :param isMixedWithPrograssBar: 进度条，（当此参数为True时使用默认进度条，当此参数为其他值为真的表达式时识别为进度条自定义参数，若为其他值为假的表达式则不生成进度条）
        :return: 全部指令列表[ ( str指令, int距离上一个指令的延迟 ),...]
        """
        tracks = {}

        if volume > 1:
            volume = 1
        if volume <= 0:
            volume = 0.001

        if isMixedWithPrograssBar == True:
            isMixedWithPrograssBar = (
                r'▶ %%N [ %%s/%^s %%% __________ %%t|%^t ]',
                ('§e=§r', '§7=§r'),
            )

        for i, track in enumerate(self.midi.tracks):

            instrumentID = 0
            ticks = 0

            for msg in track:
                ticks += msg.time
                if msg.is_meta:
                    if msg.type == 'set_tempo':
                        tempo = msg.tempo
                    if msg.type == 'program_change':
                        instrumentID = msg.program
                else:
                    if msg.type == 'note_on' and msg.velocity != 0:
                        nowtick = round(
                            (ticks * tempo)
                            / ((self.midi.ticks_per_beat * float(speed)) * 50000)
                        )
                        soundID, _X = self.__Inst2soundIDwithX(instrumentID)
                        try:
                            tracks[nowtick].append(
                                f'execute {player} ~ ~ ~ playsound {soundID} @s ~ ~{1/volume-1} ~ {msg.velocity*(0.7 if msg.channel == 0 else 0.9)} {2**((msg.note-60-_X)/12)}'
                            )
                        except:
                            tracks[nowtick] = [
                                f'execute {player} ~ ~ ~ playsound {soundID} @s ~ ~{1/volume-1} ~ {msg.velocity*(0.7 if msg.channel == 0 else 0.9)} {2**((msg.note-60-_X)/12)}',
                            ]

        allticks = list(tracks.keys())

        if isMixedWithPrograssBar:

            pgsstyle = isMixedWithPrograssBar[0]
            '''用于被替换的进度条原始样式'''

            '''
            | 标识符   | 指定的可变量     |
            |---------|----------------|
            | `%%N`   | 乐曲名(即传入的文件名)|
            | `%%s`   | 当前计分板值     |
            | `%^s`   | 计分板最大值     |
            | `%%t`   | 当前播放时间     |
            | `%^t`   | 曲目总时长       |
            | `%%%`   | 当前进度比率     |
            | `_`     | 用以表示进度条占位|
            '''

            def __replace(
                s: str, tobeReplaced: str, replaceWith: str, times: int, other: str
            ):
                if times == 0:
                    return s.replace(tobeReplaced, other)
                if times == s.count(tobeReplaced):
                    return s.replace(tobeReplaced, replaceWith)
                result = ''
                t = 0
                for i in s:
                    if i == tobeReplaced:
                        if t < times:
                            result += replaceWith
                            t += 1
                        else:
                            result += other
                    else:
                        result += i

                return result

            idlist = {
                r'%%N': self.midFileName,
                r'%%s': r'%%s',
                r'%^s': str(allticks[-1]),
                r'%%t': r'%%t',
                r'%^t': self.__score2time(allticks[-1]),
                r'%%%': r'%%%',
            }

            ids = {}

            for i, j in idlist.items():
                if i != j:
                    if i in pgsstyle:
                        pgsstyle = pgsstyle.replace(i, j)
                else:
                    if i in pgsstyle:
                        ids[i] = True
                    else:
                        ids[i] = False

            del idlist

            pgblength = pgsstyle.count('_')
            '''进度条的“条”长度'''

        results = []

        for i in range(len(allticks)):
            if i != 0:
                for j in range(len(tracks[allticks[i]])):
                    if j != 0:
                        results.append((tracks[allticks[i]][j], 0))
                    else:
                        results.append(
                            (tracks[allticks[i]][j], allticks[i] - allticks[i - 1])
                        )
            else:
                for j in range(len(tracks[allticks[i]])):
                    results.append((tracks[allticks[i]][j], allticks[i]))

            if isMixedWithPrograssBar:

                nowstr = pgsstyle
                if ids[r'%%s'] == True:
                    nowstr = nowstr.replace(r'%%s', str(allticks[i] + 1))
                if ids[r'%%t'] == True:
                    nowstr = nowstr.replace(r'%%t', self.__score2time(allticks[i] + 1))
                if ids[r'%%%'] == True:
                    nowstr = nowstr.replace(
                        r'%%%', str(int((allticks[i] + 1) / allticks[-1] * 10000) / 100) + '%'
                    )

                countof_s = int((allticks[i] + 1) / allticks[-1] * pgblength)

                titlenow = __replace(
                    nowstr,
                    '_',
                    isMixedWithPrograssBar[1][0],
                    countof_s,
                    isMixedWithPrograssBar[1][1],
                )

                results.append((f'title {player} actionbar {titlenow}', 0,))

        return results

    def __fillSquareSideLength(self, total: int, maxHeight: int):
        '''给定总方块数量和最大高度，返回所构成的图形外切正方形的边长
        :param total: 总方块数量
        :param maxHeight: 最大高度
        :return: 外切正方形的边长 int'''
        import math

        return math.ceil(math.sqrt(math.ceil(total / maxHeight)))

    def tomcpack(
        self,
        method: int = 1,
        isAutoReset: bool = False,
        progressbar=None,
        scoreboardname: str = 'mscplay',
        volume: float = 1.0,
        speed: float = 1.0,
    ) -> bool:
        """
        使用method指定的转换算法，将midi转换为我的世界mcpack格式的包
        :param method: 转换算法
        :param isAutoReset: 是否自动重置计分板
        :param progressbar: 进度条，（当此参数为True时使用默认进度条，为其他的值为真的参数时识别为进度条自定义参数，为其他值为假的时候不生成进度条）
        :param scoreboardname: 我的世界的计分板名称
        :param volume: 音量，注意：这里的音量范围为(0,1]，其原理为在距离玩家 (1 / volume -1) 的地方播放音频
        :param speed: 速度，注意：这里的速度指的是播放倍率，其原理为在播放音频的时候，每个音符的播放时间除以 speed
        :return 成功与否，成功返回(True,True)，失败返回(False,str失败原因)
        """
        if method == 1:
            cmdlist, _a, maxscore = self._toCmdList_m1(scoreboardname, volume, speed)
        else:
            return (False, f'无法找到算法ID{method}对应的转换算法')
        del _a

        import json
        import uuid
        import shutil

        # 当文件f夹{self.outputPath}/temp/functions存在时清空其下所有项目，若其不存在则创建
        if os.path.exists(f'{self.outputPath}/temp/functions/'):
            shutil.rmtree(f'{self.outputPath}/temp/functions/')
        os.makedirs(f'{self.outputPath}/temp/functions/mscplay')

        # 写入manifest.json
        if not os.path.exists(f'{self.outputPath}/temp/manifest.json'):
            with open(
                f"{self.outputPath}/temp/manifest.json", "w", encoding='utf-8'
            ) as f:
                f.write(
                    "{\n  \"format_version\": 1,\n  \"header\": {\n    \"description\": \""
                    + self.midFileName
                    + " Pack : behavior pack\",\n    \"version\": [ 0, 0, 1 ],\n    \"name\": \""
                    + self.midFileName
                    + "Pack\",\n    \"uuid\": \""
                    + str(uuid.uuid4())
                    + "\"\n  },\n  \"modules\": [\n    {\n      \"description\": \""
                    + f"the Player of the Music {self.midFileName}"
                    + "\",\n      \"type\": \"data\",\n      \"version\": [ 0, 0, 1 ],\n      \"uuid\": \""
                    + str(uuid.uuid4())
                    + "\"\n    }\n  ]\n}"
                )
        else:
            with open(
                f'{self.outputPath}/temp/manifest.json', 'r', encoding='utf-8'
            ) as manifest:
                data = json.loads(manifest.read())
                data['header'][
                    'description'
                ] = f"the Player of the Music {self.midFileName}"
                data['header']['name'] = self.midFileName
                data['header']['uuid'] = str(uuid.uuid4())
                data['modules'][0]['description'] = 'None'
                data['modules'][0]['uuid'] = str(uuid.uuid4())
                manifest.close()
            open(f'{self.outputPath}/temp/manifest.json', 'w', encoding='utf-8').write(
                json.dumps(data)
            )

        # 将命令列表写入文件
        indexfile = open(
            f'{self.outputPath}/temp/functions/index.mcfunction', 'w', encoding='utf-8'
        )
        for track in cmdlist:
            indexfile.write(
                'function mscplay/track' + str(cmdlist.index(track) + 1) + '\n'
            )
            with open(
                f'{self.outputPath}/temp/functions/mscplay/track{cmdlist.index(track)+1}.mcfunction',
                'w',
                encoding='utf-8',
            ) as f:
                f.write('\n'.join(track))
        indexfile.writelines(
            (
                'scoreboard players add @a[scores={'
                + scoreboardname
                + '=1..}] '
                + scoreboardname
                + ' 1\n',
                (
                    'scoreboard players reset @a[scores={'
                    + scoreboardname
                    + '='
                    + str(maxscore + 20)
                    + '..}]'
                    + f' {scoreboardname}\n'
                )
                if isAutoReset
                else '',
                f'function mscplay/progressShow\n' if progressbar else '',
            )
        )

        if progressbar:
            if progressbar == True:
                with open(
                    f'{self.outputPath}/temp/functions/mscplay/progressShow.mcfunction',
                    'w',
                    encoding='utf-8',
                ) as f:
                    f.writelines(
                        '\n'.join(self.__formProgressBar(maxscore, scoreboardname))
                    )
            else:
                with open(
                    f'{self.outputPath}/temp/functions/mscplay/progressShow.mcfunction',
                    'w',
                    encoding='utf-8',
                ) as f:
                    f.writelines(
                        '\n'.join(
                            self.__formProgressBar(
                                maxscore, scoreboardname, progressbar
                            )
                        )
                    )

        indexfile.close()

        makeZip(
            f'{self.outputPath}/temp/', self.outputPath + f'/{self.midFileName}.mcpack'
        )

        shutil.rmtree(f'{self.outputPath}/temp/')

    def toBDXfile(
        self,
        method: int = 1,
        author: str = 'Eilles',
        progressbar=False,
        maxheight: int = 64,
        scoreboardname: str = 'mscplay',
        volume: float = 1.0,
        speed: float = 1.0,
        isAutoReset: bool = False,
    ):
        """
        使用method指定的转换算法，将midi转换为BDX结构文件
        :param method: 转换算法
        :param author: 作者名称
        :param progressbar: 进度条，（当此参数为True时使用默认进度条，为其他的值为真的参数时识别为进度条自定义参数，为其他值为假的时候不生成进度条）
        :param maxheight: 生成结构最大高度
        :param scoreboardname: 我的世界的计分板名称
        :param volume: 音量，注意：这里的音量范围为(0,1]，如果超出将被处理为正确值，其原理为在距离玩家 (1 / volume -1) 的地方播放音频
        :param speed: 速度，注意：这里的速度指的是播放倍率，其原理为在播放音频的时候，每个音符的播放时间除以 speed
        :param isAutoReset: 是否自动重置计分板
        :return 成功与否，成功返回(True,未经过压缩的源,结构占用大小)，失败返回(False,str失败原因)
        """

        if method == 1:
            cmdlist, totalcount, maxScore = self._toCmdList_m1(
                scoreboardname, volume, speed
            )
        else:
            return (False, f'无法找到算法ID {method} 对应的转换算法')

        if not os.path.exists(self.outputPath):
            os.makedirs(self.outputPath)

        with open(f"{self.outputPath}/{self.midFileName}.bdx", "w+") as f:
            f.write("BD@")

        _bytes = (
            b"BDX\x00"
            + author.encode("utf-8")
            + b" & Musicreater\x00\x01command_block\x00"
        )

        key = {
            "x": (b"\x0f", b"\x0e"),
            "y": (b"\x11", b"\x10"),
            "z": (b"\x13", b"\x12"),
        }
        '''key存储了方块移动指令的数据，其中可以用key[x|y|z][0|1]来表示xyz的减或增'''
        x = 'x'
        y = 'y'
        z = 'z'

        _sideLength = self.__fillSquareSideLength(totalcount, maxheight)

        yforward = True
        zforward = True

        nowy = 0
        nowz = 0
        nowx = 0

        commands = []

        for track in cmdlist:
            commands += track

        if isAutoReset:
            commands += (
                'scoreboard players reset @a[scores={'
                + scoreboardname
                + '='
                + str(maxScore + 20)
                + '}] '
                + scoreboardname
            )

        if progressbar:
            if progressbar == True:
                commands += self.__formProgressBar(maxScore, scoreboardname)
            else:
                commands += self.__formProgressBar(
                    maxScore, scoreboardname, progressbar
                )

        for cmd in commands:
            _bytes += self.__formCMDblk(
                cmd,
                (1 if yforward else 0)
                if (
                    ((nowy != 0) and (not yforward))
                    or ((yforward) and (nowy != maxheight))
                )
                else (3 if zforward else 2)
                if (
                    ((nowz != 0) and (not zforward))
                    or ((zforward) and (nowz != _sideLength))
                )
                else 5,
                impluse=2,
                condition=False,
                needRedstone=False,
                tickDelay=0,
                customName='',
                executeOnFirstTick=False,
                trackOutput=True,
            )

            nowy += 1 if yforward else -1

            if ((nowy > maxheight) and (yforward)) or ((nowy < 0) and (not yforward)):
                nowy -= 1 if yforward else -1

                yforward = not yforward

                nowz += 1 if zforward else -1

                if ((nowz > _sideLength) and (zforward)) or (
                    (nowz < 0) and (not zforward)
                ):
                    nowz -= 1 if zforward else -1
                    zforward = not zforward
                    _bytes += key[x][1]
                    nowx += 1
                else:

                    _bytes += key[z][int(zforward)]

            else:

                _bytes += key[y][int(yforward)]

        with open(f"{self.outputPath}/{self.midFileName}.bdx", "ab+") as f:
            f.write(brotli.compress(_bytes + b'XE'))

        return (True, _bytes, (nowx, maxheight, _sideLength))

    def toBDXfile_withDelay(
        self,
        method: int = 1,
        author: str = 'Eilles',
        progressbar=False,
        maxheight: int = 64,
        volume: float = 1.0,
        speed: float = 1.0,
        player: str = '@a',
    ):
        """
        使用method指定的转换算法，将midi转换为BDX结构文件
        :param method: 转换算法
        :param author: 作者名称
        :param progressbar: 进度条，（当此参数为True时使用默认进度条，为其他的值为真的参数时识别为进度条自定义参数，为其他值为假的时候不生成进度条）
        :param maxheight: 生成结构最大高度
        :param volume: 音量，注意：这里的音量范围为(0,1]，如果超出将被处理为正确值，其原理为在距离玩家 (1 / volume -1) 的地方播放音频
        :param speed: 速度，注意：这里的速度指的是播放倍率，其原理为在播放音频的时候，每个音符的播放时间除以 speed
        :param player: 玩家选择器，默认为`@a`
        :return 成功与否，成功返回(True,未经过压缩的源,结构占用大小)，失败返回(False,str失败原因)
        """

        if method == 1:
            cmdlist = self._toCmdList_withDelay_m1(volume, speed, player, progressbar)
        else:
            return (False, f'无法找到算法ID {method} 对应的转换算法')

        if not os.path.exists(self.outputPath):
            os.makedirs(self.outputPath)

        with open(f"{self.outputPath}/{self.midFileName}.bdx", "w+") as f:
            f.write("BD@")

        _bytes = (
            b"BDX\x00"
            + author.encode("utf-8")
            + b" & Musicreater\x00\x01command_block\x00"
        )

        key = {
            "x": (b"\x0f", b"\x0e"),
            "y": (b"\x11", b"\x10"),
            "z": (b"\x13", b"\x12"),
        }
        '''key存储了方块移动指令的数据，其中可以用key[x|y|z][0|1]来表示xyz的减或增'''
        x = 'x'
        y = 'y'
        z = 'z'

        _sideLength = self.__fillSquareSideLength(len(cmdlist), maxheight)

        yforward = True
        zforward = True

        nowy = 0
        nowz = 0
        nowx = 0

        for cmd, delay in cmdlist:
            _bytes += self.__formCMDblk(
                cmd,
                (1 if yforward else 0)
                if (
                    ((nowy != 0) and (not yforward))
                    or ((yforward) and (nowy != maxheight))
                )
                else (3 if zforward else 2)
                if (
                    ((nowz != 0) and (not zforward))
                    or ((zforward) and (nowz != _sideLength))
                )
                else 5,
                impluse=2,
                condition=False,
                needRedstone=False,
                tickDelay=delay,
                customName='',
                executeOnFirstTick=False,
                trackOutput=True,
            )

            nowy += 1 if yforward else -1

            if ((nowy > maxheight) and (yforward)) or ((nowy < 0) and (not yforward)):
                nowy -= 1 if yforward else -1

                yforward = not yforward

                nowz += 1 if zforward else -1

                if ((nowz > _sideLength) and (zforward)) or (
                    (nowz < 0) and (not zforward)
                ):
                    nowz -= 1 if zforward else -1
                    zforward = not zforward
                    _bytes += key[x][1]
                    nowx += 1
                else:

                    _bytes += key[z][int(zforward)]

            else:

                _bytes += key[y][int(yforward)]

        with open(f"{self.outputPath}/{self.midFileName}.bdx", "ab+") as f:
            f.write(brotli.compress(_bytes + b'XE'))

        return (True, _bytes, (nowx, maxheight, _sideLength))