6 Commits

Author SHA1 Message Date
bgArray
ab3c55e7b7 2023/1/5 update-窗口5
这个链接-槽好抽象,明天再研究了
2023-01-05 23:02:15 +08:00
bgArray
082934d918 2023/1/4 update-窗口4
开始自己写喽
2023-01-04 22:44:00 +08:00
bgArray
28d59f8be9 2023/1/3 update-窗口3
还有很多要改的,得加油
2023-01-03 21:55:08 +08:00
bgArray
1103a06897 !2 同步-2023/1/2
Merge pull request !2 from bgArray/pkgver
2023-01-02 09:25:11 +00:00
bgArray
9734bf493a 窗口2 2022-12-30 17:06:34 +08:00
bgArray
dc1efc9e84 窗口1 2022-12-29 17:47:22 +08:00
116 changed files with 5449 additions and 17737 deletions

3
.gitattributes vendored
View File

@@ -1,3 +0,0 @@
*.yaml linguist-language=Python
*.xml linguist-language=Python
*.md linguist-language=Python

33
.gitignore vendored
View File

@@ -1,32 +1,12 @@
# sth. can't open
/msctPkgver/secrets/*.py
/msctPkgver/secrets/*.c
/fool/
# mystuff
/*.zip
/.vscode
/*.mid
/*.midi
/*.mcpack
/*.bdx
/*.msq
/*.fsq
/*.json
/*.mcstructure
.mscbackup
/logs
/languages
/llc_cli.py
/utils
test.py
RES.txt
/MSCT_Packer.py
/Packer/*.MPK
/Packer/checksum.txt
/bgArrayLib
/fcwslib
test_lyric-mido.py
*.mid
*.midi
# Byte-compiled / optimized
__pycache__/
@@ -52,7 +32,6 @@ share/python-wheels/
.installed.cfg
*.egg
MANIFEST
.pdm-build/
# PyInstaller
# Usually these files are written by a python script from a template
@@ -167,9 +146,3 @@ cython_debug/
# Pycharm
/.idea
# log
/.log
# package
.7z

View File

@@ -1 +0,0 @@
3.10

88
1.py Normal file
View File

@@ -0,0 +1,88 @@
# -*- coding: utf-8 -*-
################################################################################
## Form generated from reading UI file '1.ui'
##
## Created by: Qt User Interface Compiler version 6.4.1
##
## WARNING! All changes made in this file will be lost when recompiling UI file!
################################################################################
from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
QMetaObject, QObject, QPoint, QRect,
QSize, QTime, QUrl, Qt)
from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
QFont, QFontDatabase, QGradient, QIcon,
QImage, QKeySequence, QLinearGradient, QPainter,
QPalette, QPixmap, QRadialGradient, QTransform)
from PySide6.QtWidgets import (QApplication, QMainWindow, QMenuBar, QSizePolicy,
QStatusBar, QTabWidget, QToolButton, QVBoxLayout,
QWidget)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(800, 600)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.verticalLayoutWidget_2 = QWidget(self.centralwidget)
self.verticalLayoutWidget_2.setObjectName(u"verticalLayoutWidget_2")
self.verticalLayoutWidget_2.setGeometry(QRect(0, 0, 861, 681))
self.verticalLayout_2 = QVBoxLayout(self.verticalLayoutWidget_2)
self.verticalLayout_2.setObjectName(u"verticalLayout_2")
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.tabWidget = QTabWidget(self.verticalLayoutWidget_2)
self.tabWidget.setObjectName(u"tabWidget")
self.tab = QWidget()
self.tab.setObjectName(u"tab")
self.toolButton_2 = QToolButton(self.tab)
self.toolButton_2.setObjectName(u"toolButton_2")
self.toolButton_2.setGeometry(QRect(30, 10, 24, 22))
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QWidget()
self.tab_2.setObjectName(u"tab_2")
self.tabWidget.addTab(self.tab_2, "")
self.verticalLayout_2.addWidget(self.tabWidget)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setObjectName(u"menubar")
self.menubar.setGeometry(QRect(0, 0, 800, 26))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(u"statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
self.toolButton_2.clicked.connect(self.toolButton_2.click)
self.tabWidget.setCurrentIndex(0)
QMetaObject.connectSlotsByName(MainWindow)
# setupUi
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(QCoreApplication.translate("MainWindow", u"MainWindow", None))
self.toolButton_2.setText(QCoreApplication.translate("MainWindow", u"...", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab),
QCoreApplication.translate("MainWindow", u"Tab 1", None))
self.tabWidget.setTabText(self.tabWidget.indexOf(self.tab_2),
QCoreApplication.translate("MainWindow", u"Tab 2", None))
# retranslateUi
if __name__ == "__main__":
import sys
from PySide6 import QtWidgets
app = QtWidgets.QApplication(sys.argv) # 创建一个QApplication也就是你要开发的软件app
MainWindow = QtWidgets.QMainWindow() # 创建一个QMainWindow用来装载你需要的各种组件、控件
# MainWindow = QtWidgets.QWidget() # 创建一个QMainWindow用来装载你需要的各种组件、控件
ui = Ui_MainWindow() # ui是你创建的ui类的实例化对象
ui.setupUi(MainWindow) # 执行类中的setupUi方法方法的参数是第二步中创建的QMainWindow
MainWindow.show() # 执行QMainWindow的show()方法显示这个QMainWindow
sys.exit(app.exec_()) # 使用exit()或者点击关闭按钮退出QApplication

91
1.ui Normal file
View File

@@ -0,0 +1,91 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<widget class="QWidget" name="verticalLayoutWidget_2">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>861</width>
<height>681</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QTabWidget" name="tabWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Tab 1</string>
</attribute>
<widget class="QToolButton" name="toolButton_2">
<property name="geometry">
<rect>
<x>30</x>
<y>10</y>
<width>24</width>
<height>22</height>
</rect>
</property>
<property name="text">
<string>...</string>
</property>
</widget>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Tab 2</string>
</attribute>
</widget>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>26</height>
</rect>
</property>
</widget>
<widget class="QStatusBar" name="statusbar"/>
</widget>
<resources/>
<connections>
<connection>
<sender>toolButton_2</sender>
<signal>clicked()</signal>
<receiver>toolButton_2</receiver>
<slot>click()</slot>
<hints>
<hint type="sourcelabel">
<x>44</x>
<y>76</y>
</hint>
<hint type="destinationlabel">
<x>46</x>
<y>71</y>
</hint>
</hints>
</connection>
</connections>
</ui>

View File

@@ -1,123 +1,219 @@
# 汉钰律许可协议,第一版
**注意,以下条款或版权声明应当且必须是高于此项目中任何其他声明的**
**总第一版 第二次修订 · 二〇二四年七月七日编 二〇二五年四月二十六日修订**
1. 音·创的全部开发者享有其完整版权,其开发者可以在任一时刻终止以后音·创源代码开放,若经由其开发者授予特殊权利,则授权对象可以将源代码进行特定的被特殊授权的操作
2. 音·创或(及)其代码允许在 Apache2.0 协议的条款与说明下进行非商业使用
3. 除部分代码特殊声明外,音·创允许对其或(及)其代码进行商业化使用,但是需要经过音·创主要开发者(诸葛亮与八卦阵、金羿)的一致授权,同时,授权对象在商业化授权的使用过程中必须依照 Apache2.0 协议的条款与说明
4. 若存在对于音·创包含的部分代码的特殊开源声明,则此部分代码依照其特定的开源方式授权,但若此部分代码经由此部分代码的主要开发者一致特殊授权后商用,则授权对象在商用时依照此部分的开发者所准许的方式(或条款)进行商用,或默认依照 Apache2.0 协议进行商业化使用
5. Apache2.0 协议的英文原文副本可见下文
## 一、重要须知
> The English Translation of the TERMS AND CONDITIONS above is listed below
>
> This translated version is for reference only and has no legal effect.
>
> The version with legal effect is the Chinese version above.
1. 为保护采用本协议的作品在开源过程中,其著作权人所应有的权益,根据**中华人民共和国著作权法和相关法律法规**,制定本协议。
**Note, The TERMS AND CONDITIONS below should and must be above all others in this project**
2. 本协议履行过程中,请注意本协议中**免除或限制**民事主体**责任或权利**的条款、法律适用和争议解决条款(尤其是加有特殊标记的条款),这些条款应在中国法律所允许的范围内最大程度地适用。
1. *Musicreater* is fully copyrighted by all its developers, the developers have the right to make *Musicreater* close sourced at any time. Operations are permitted under specific terms instructed by its developer(s).
2. Non-commercial use of *Musicreater* and(or) its source code is permitted under Apache License 2.0.
3. Commercial use of *Musicreater* is permitted under Apache License 2.0 with the unanimous permission of the steering developers of *Musicreater* (*bgArray*诸葛亮与八卦阵 and *Eilles*金羿).
4. *Musicreater* is open sourced under priority given:
1. License granted by the core developer(s) of a section after negotiation.
2. Explicitly stated license.
3. Apache 2.0 License.
5. A copy of the original Apache Lisence 2.0 can be found below.
3. 若本协议所涉及的自然人**未满 18 周岁**,该自然人应在监护人的陪同下阅读本协议及有关本协议的条款内容,并在取得其监护人同意后开始或继续应用本协议所授权的行为。
4. 由于互联网服务、互联网内容的特殊性,若本协议以电子协议形式分发并签订,其依然有效。您一旦开始对本协议所授权之作品进行本协议所授权的行为,即视为您已经阅读、理解并同意并已经接受本协议的全部条款。
```text
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
5. 本协议的订立、履行、解释及争议的解决均**适用中华人民共和国法律并排除其他一切冲突法的适用**。_本协议订立于许可证最初的颁发者的地址。若颁发者为自然人则订立于该自然人户籍所在地若为法人或非法人组织则订立于其注册地_。本协议的订立各方应友好协商解决于协议所规定之行为的履行相关的争议如协商不成任何一方均可向合同签订地有管辖权的人民法院提起诉讼。
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6. 本协议的原本仅为现代汉语,书写于简体中文。若存在其他语言的翻译或其他同等语言但非简体中文文本的版本,应当无法律效力。
1. Definitions.
## 二、术语定义
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
1. “**许可证**”、“**协议**”(后文称“本协议”)是指根据本文档中所列举的全部术语、定义、条款、限制等文本,是本合同的简称称谓。本合同全称是 **“汉钰律许可协议,第一版”**。
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
2. “**协议颁发者**”(后文称“颁发者”)是将条款或协议应用于其拥有著作财产权的作品的民事主体,或由其指定从而拥有颁发者身份的民事主体。
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
3. “**源**”形式是指对包括但不限于 软件、硬件、文档、配置项 等种类的作品进行修改、编辑的首选形式;若不存在首选形式,则初次编辑该作品所需的形式即为源形式。
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
4. “**目标**”形式是指对源形式进行机械转换、翻译、打印、制造、加工等同类型活动后形成的结果形式,包括但不限于源代码编译后的目标软件、生成的文件、转换出的媒体、制造出的机械、打印出的实体文本、加工后的零件。
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
5. “**采用本协议的作品**”(后文称“此作品”)是指经颁发者授权而使用本协议进行授权的任何作品,该作品应在自然人可见处明确附加一个自然人可读的版权通知(可以参考文末附录中提供的示例);若在一个可分割的作品中,部分地采用本协议进行授权,则该部分应当视为一个独立的采用本协议的作品,该作品应当在自然人可见处明确附加一个自然人可读的范围限定和版权通知(同样可以参考文末附录中提供的示例)。
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
6. “**贡献**”是指对作品进行的,意在提交给此作品颁发者以让著作权人包含在其作品中的任何修订或补充,该修订或补充同样属于一种作品。依据此定义,**“提交”**一词表示经由此作品颁发者所指定的形式,将其所进行的修改发送给此作品颁发者。该形式应当包括在此作品颁发者指定的平台内发送易于编辑的修改信息、在此作品颁发者指定的电子邮箱中发送易于编辑的修改信息、在此作品颁发者指定的源码控制系统或发布跟踪系统上提交的易于编辑的修改信息,但由著作权人以明显标注或指定为“非贡献”的活动除外。颁发者自己对作品进行的修改同样视作对作品的贡献。
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
7. “**贡献者**”是指此作品颁发者接受的贡献的提交者,或包含在作品的贡献清单中的民事主体。贡献者在提交贡献并经此作品颁发者通过且该贡献已经被应用于此作品中后,该贡献者应当视为此作品的著作权人之一,但不应视为此作品非其贡献的部分的著作权人。一个作品的颁发者同样属于其贡献者。**请注意**,针对贡献者提交的贡献,该贡献者应被视为该贡献的协议颁发者,但不应视作本作品的颁发者。
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
8. “**用户**”、“**使用者**”是指行使本协议所授权之行为的民事主体。据此,贡献者亦属于用户。
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
9. “**商业性使用**”、“**商用**”是指任何以谋取利益为目的的使用,包括但不限于以贩卖、出租的形式对作品进行使用;但若将该获取利益之活动明确指示为“捐赠”,且在获利者在进行本协议所授权的活动时不以捐赠数额为标准而区别之,则此种的获取利益的“捐赠”行为不属于商业性使用。
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
## 三、权利授予
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
1. 任何由颁发者所进行的特殊声明、特别注意等此类内容,应当在法律效力上高于本协议的条款或声明;这些声明若与本协议冲突,本协议的该冲突部分无效;本协议与这些声明共同构成颁发者与用户之间的合同。
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
2. 此作品的贡献者享有其贡献的完整著作权。
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
3. 此作品的贡献者将自己的贡献的全部著作财产权,免费、公开、不可撤销、无限期、非专有地授予此作品的全部著作权人,并准许其在全世界范围内使用上述权利;若无明确的标识,贡献者允许此作品的颁发者对其贡献进行免费、公开、不可撤销、无限期、非专有、世界范围内的商业性使用。
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
4. 此作品的著作权人及贡献者授予用户**免费、公开、不可撤销、非专有、非商用**地以任意形式**复制、发行、展览、表演、放映、广播、信息网络传播、摄制、改编、翻译、汇编、二次授权**的权利,准许其在此作品颁发者所指定的区域与时间内行使上述权利;若此作品颁发者未特别指定的,则视作在全世界范围内无限期地授权;若此作品颁发者特别指定在特定情况下可以商用,则应当按照其所指定的条件进行商业性使用,商用的过程中,应当明确标识此作品的著作权人。
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
5. 一旦此作品有任意由非贡献形式而产生的更改,更改的部分将不视为此作品的一部分,除非该部分不可离开此作品单独存在;若该部分必须依赖此作品而不可与此作品分离从而单独存在,则更改后的作品不视作此作品,在这种情况下,除非此更改后的作品已获得此作品颁发者的特殊许可、或更改者即为此作品颁发者本人,否则对该作品进行的任何活动都应当遵守本协议。
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
6. 经贡献而产生的对此作品的更改,属于此作品的一部分;在此情况下,更改后的作品,依旧视作此作品。
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
7. 依据本款的第 4 条,若用户在本协议的授权下,将此作品授予他人进行任何形式的活动(即“二次授权”、“二次分发”),则应确保其使用的协议或授权内容,与本协议的条款不冲突;当存在与本协议条款的冲突时,则该冲突内容无效,被授权的第三方应依照本协议的条款进行活动;除非该用户获得了此作品颁发者的特殊许可、或该用户即为此作品颁发者本人。
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
8. 依据本款的第 5 条,若由非贡献形式而产生更改的部分是可分割而不需依赖此作品即可单独存在的,若该部分明确注明不使用本协议进行授权或明确声明了其他授权条款,则该部分不视作采用本协议;但未更改的部分仍应视作原此作品的一部分,需要采用本协议进行授权,除非此更改后的作品已获得此作品颁发者的特殊许可、或更改者即为此作品颁发者本人。
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
9. 若此作品或所提交的贡献包含其著作权人的专利,则该专利所有人即此作品的著作权人应准许此作品全体著作权人**免费、公开、不可撤销、非专有、无版权费的专利许可**,以便贡献者对作品进行本协议所授权进行的活动。
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
10. 上述专利许可的授予,仅适用于在所提交的贡献中,可由专利所有者授予的,且在对此作品进行本协议所授权的活动中,必须使用的专利。
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
11. 如果用户对任何民事主体,因其在进行本协议所授权进行的活动中侵犯该用户的专利而提起诉讼,那么根据本协议授予该用户的所有关于此作品的任何其他专利许可将在提起上述诉讼之日起终止。
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
12. 如果本作品作为用户的其他作品的不可分割的一部分进行任何民事活动,本协议依旧对本作品(即该用户的其他作品的一部分)生效;若本作品完全融入该用户的其他作品之中而不可独立存在,则该用户需要保证其作品存在与本协议冲突的条款;除非该作品已获得此作品颁发者的特殊许可、或该用户即为此作品颁发者本人。
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
## 四、使用条件
END OF TERMS AND CONDITIONS
在对此作品进行本协议所授权的民事活动中,应当同时满足以下条款:
1. 用户必须为此作品的任何其他接收者提供本协议的副本,在不得已无法提供副本的情况下,也应明确指示其他接收者可查阅本协议的位置。
Copyright 2022 Team-Ryoun 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray")
2. 用户必须在修改后的作品中附带明显的通知,声明用户已更改文件,并注明更改位置。
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
3. 若用户二次分发此作品,可以选择向此作品的接收者提供无偿或有偿的担保维修、支持服务或其他责任、义务。但是,该用户只可以其自己的名义提供上述内容,不得以任何其他贡献者的名义。且该用户必须明确表明任何此类责任或义务是由其个人独立提供,且其同意并应当承担赔偿此作品的全体贡献者因其个人承担上述责任义务而产生的任何赔偿责任。
http://www.apache.org/licenses/LICENSE-2.0
4. 用户不得删除或更改此作品中包含的任何许可声明(包括版权声明,专利声明,免责声明,或赔偿责任限制),除非该更改是对已知事实错误的修补、或其已获得此作品颁发者的特殊许可、或更改者即为此作品颁发者本人。
5. 若此作品将权益的声明通知作为一部分,那么由用户分发的任何版本的作品中须至少在下列三处之一包含该声明通知的自然人可读副本:
- 该作品的权益声明通知中
- 在源形式的文件中(当且仅当该作品开放源代码)
- 在惯例中作为第三方通知出现之处(当且仅当该作品会产生画面,且该画面可被自然人详细观察)
该通知的内容仅供信息提供,不应对许可证进行任何文字上的修改。用户可在其分发的作品中,在不构成修改本协议的前提下,在作品自身的声明通知或属性描述后或作为附录添加。
6. 依据本款第3条若用户二次分发此作品时选择向作品的接收者提供收费的担保服务则必须明确告知该接收者本协议全部内容与此作品原出处并确保其知悉上述内容但若用户在二次分发此作品时不选择提供任何服务则该用户不允许向作品的接收者收取任何费用除非该用户获得了此作品颁发者的特殊许可、或该用户即为此作品颁发者本人。
## 五、提交贡献
除非贡献者明确声明,在本作品中由该贡献者向颁发者的提供的提交,必须符合本协议的条款,并与本协议的条款不存在冲突;除非此贡献中与本协议冲突的附加条款已获得颁发者的特殊许可、或贡献者即为此作品颁发者本人。
## 六、商标相关
本协议并未授予用户,将颁发者的商标、专属标记或特定产品名称,用于合理的或惯例性的描述或此类声明之外其他任何位置的权利。
## 七、免责声明
1. 若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,**不予提供任何形式的担保、任何明示、任何暗示或类似承诺**,此类包括但不限于担保此作品毫无缺陷、担保此作品适于贩卖、担保此作品适于特定目的、担保使用此作品绝不侵权。用户将自行承担因此作品的质量或性能问题而产生的全部风险。若此作品在任何方面欠妥,将由用户(而非任何贡献者、而非任何颁发者)承担所有必要的服务、维修或除错的任何成本。本免责声明是本许可的重要组成部分。当且仅当遵守本免责声明时,本协议的其他条款中对本作品的使用授权方可生效。
2. 无论是因何种原因,如果不是在法律规定的特殊情况(如,确为贡献者的故意或重大过失)下或者经过了特殊准许,即使贡献者事先已知发生损害的可能,在使用本作品时,用户产生的任何直接、间接、特殊、偶然或必然造成的损失(包括但不限于商誉损失、工作延误、计算机系统故障等),**均不由任一贡献者承担**。
**以上是本许可协议的全部条款**
---
附录
**如何在自己的作品中应用 汉钰律许可协议**
若要在自己源形式的作品应用本协议,请在其中附加下面的通知模板,并将六角括号“〔〕”中的字段替换成自身的实际信息来替换(不包括括号本身)。这些文本必须以对应文件格式适当的注释句法包含在其中,可以是实体的纸质文档、也可以是网络公告或者计算机文件;或者脱离该源之外,另起一个新的文件,使之指向要应用本协议的那个作品。同时也建议将作品名或类别名以及目的说明之类的声明囊括在同一个可被打印的页面上作为版权通知的整体,这样更加容易的区分出第三方内容。
若需要在自己以目标形式存在的作品中应用本协议,同样需要附加下面的通知模板并更改六角括号中的字样。但是,这些文本可以是位于作品的标签上、位于作品的用户可见且能被自然人详细观察的画面之中、或者按照惯例中许可协议应该出现的位置;同时,这些文本的所处位置应当能够明确指示到本协议应用的那个作品。另外,建议将作品名或类别名以及目的说明之类的声明囊括在同一个可被打印的位置上作为版权通知的整体,这样更加容易的区分出第三方内容。
**通知模板**
```
版权所有 © 〔年份〕 〔著作权人〕
〔或者:版权所有 (C) 〔年份〕 〔著作权人〕〕
〔该作品〕根据 汉钰律许可协议,第一版(“本协议”)授权。
任何人皆可从以下地址获得本协议副本:〔本协议副本所在地址〕。
若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,不予提供任何形式的担保、任何明示、任何暗示或类似承诺。也就是说,用户将自行承担因此作品的质量或性能问题而产生的全部风险。
详细的准许和限制条款请见原协议文本。
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.
```

View File

@@ -1,71 +0,0 @@
# -*- coding: utf-8 -*-
"""
音·创
是一款免费开源的《我的世界》数字音频支持库。
Musicreater (音·创)
A free and open-source library for handling with **Minecraft** digital music.
版权所有 © 2026 睿乐组织
Copyright © 2026 TriM-Organization
音·创(“本项目”)的协议颁发者为 金羿、玉衡Alioth
The Licensor of Musicreater("this project") is Eilles, YuhengAlioth
本项目根据 第一版 汉钰律许可协议(“本协议”)授权。
任何人皆可从以下地址获得本协议副本:
https://gitee.com/TriM-Organization/Musicreater/blob/master/LICENSE.md。
若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,
不予提供任何形式的担保、任何明示、任何暗示或类似承诺。
也就是说,用户将自行承担因此作品的质量或性能问题而产生的全部风险。
详细的准许和限制条款请见原协议文本。
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__version__ = "3.0.0-alpha"
__author__ = (
("金羿", "Eilles"),
("玉衡Alioth", "YuhengAlioth"),
("鱼旧梦", "ElapsingDreams"),
("偷吃不是Touch", "Touch"),
)
from .paramcurve import ParamCurve, InterpolationMethod, BoundaryBehaviour
from .data import (
SingleMusic,
SingleTrack,
SingleNote,
SoundAtmos,
MineNote,
CurvableParam,
)
from .plugins import load_plugin_module
from .main import MusiCreater
__all__ = [
"__version__",
"__author__",
# 参数曲线相关
"ParamCurve",
"InterpolationMethod",
"BoundaryBehaviour",
# 音乐数据结构
"SingleMusic",
"SingleTrack",
"SingleNote",
"SoundAtmos",
"MineNote",
"CurvableParam",
# 工程项目相关
"load_plugin_module",
"MusiCreater",
]

View File

@@ -1,632 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 的插件基类,提供抽象接口以供实际插件使用
"""
"""
版权所有 © 2026 金羿
Copyright © 2026 Eilles
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# =====================
# NOTE: [WARNING]
# 这个文件是一坨屎山代码
# 请勿模仿,请多包容
# =====================
import sys
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import (
Dict,
Any,
Optional,
List,
Tuple,
Union,
Sequence,
BinaryIO,
Generator,
Iterator,
Set,
)
if sys.version_info >= (3, 11):
import tomllib
import tomli_w
else:
import tomli as tomllib # 第三方包
import tomli_w
from .exceptions import (
PluginConfigDumpError,
PluginConfigLoadError,
PluginMetainfoNotFoundError,
PluginMetainfoTypeError,
PluginMetainfoValueError,
PluginAttributeNotFoundError,
ParameterTypeError,
PluginInstanceNotFoundError,
)
from .data import SingleMusic, SingleTrack
# 已经全部由 plugins.py 提供接口
# 请用户从 plugins.py 导入
# 不要在这里导,会坏掉的
# __all__ = [
# # 枚举类
# "PluginType",
# # 抽象基类/数据类(插件参数定义)
# "PluginConfig",
# "PluginMetaInformation",
# # 抽象基类(插件定义)
# "MusicInputPlugin",
# "TrackInputPlugin",
# "MusicOperatePlugin",
# "TrackOperatePlugin",
# "MusicOutputPlugin",
# "TrackOutputPlugin",
# "ServicePlugin",
# "LibraryPlugin",
# # 插件注册用装饰函数
# "music_input_plugin",
# "track_input_plugin",
# "music_operate_plugin",
# "track_operate_plugin",
# "music_output_plugin",
# "track_output_plugin",
# "service_plugin",
# "library_plugin",
# ]
# ========================
# 枚举类
# ========================
class PluginTypes(str, Enum):
"""插件类型枚举"""
FUNCTION_MUSIC_IMPORT = "import_music_data"
FUNCTION_TRACK_IMPORT = "import_track_data"
FUNCTION_MUSIC_OPERATE = "music_data_operating"
FUNCTION_TRACK_OPERATE = "track_data_operating"
FUNCTION_MUSIC_EXPORT = "export_music_data"
FUNCTION_TRACK_EXPORT = "export_track_data"
SERVICE = "service"
LIBRARY = "library"
# ========================
# 数据类
# ========================
@dataclass
class PluginConfig(ABC):
"""插件配置基类"""
def to_dict(self) -> Dict[str, Any]:
"""将配置内容转换为字典
返回
====
Dict[str, Any]
配置项的字典表示,不包含以下划线开头的私有属性
"""
return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "PluginConfig":
"""从字典创建配置实例
参数
====
data: Dict[str, Any]
包含配置字段的字典
返回
====
PluginConfig
配置类的实例
"""
# 只保留类中定义的字段
field_names = {f.name for f in cls.__dataclass_fields__.values()}
filtered_data = {k: v for k, v in data.items() if k in field_names}
return cls(**filtered_data)
def save_to_file(self, file_path: Path) -> None:
"""保存配置到 TOML 文件
参数
====
file_path: Path
目标文件路径;必须以 .toml 为后缀
异常
====
PluginConfigDumpError
当文件后缀不是 .toml 或写入失败时抛出
"""
if file_path.suffix.upper() == ".TOML":
file_path.parent.mkdir(parents=True, exist_ok=True)
else:
raise PluginConfigDumpError(
"插件配置文件类型不应为`{}`,须为`TOML`格式。".format(file_path.suffix)
)
try:
with file_path.open("wb") as f:
tomli_w.dump(self.to_dict(), f, multiline_strings=False, indent=4)
except Exception as e:
raise PluginConfigDumpError(e)
@classmethod
def load_from_file(cls, file_path: Path) -> "PluginConfig":
"""从 TOML 文件加载配置
参数
====
file_path: Path
源文件路径
返回
====
PluginConfig
加载后的配置实例
异常
====
PluginConfigLoadError
当读取或解析失败时抛出
"""
try:
with file_path.open("rb") as f:
return cls.from_dict(tomllib.load(f))
except Exception as e:
raise PluginConfigLoadError(e)
@dataclass
class PluginMetaInformation(ABC):
"""插件元信息"""
name: str
"""插件名称,应为惟一之名"""
author: str
"""插件作者"""
description: str
"""插件简介"""
version: Tuple[int, ...]
"""插件版本号"""
type: PluginTypes
"""插件类型"""
license: str = "MIT License"
"""插件发布时采用的许可协议"""
dependencies: Sequence[str] = tuple()
"""插件是否对其他插件存在依赖"""
# ========================
# 抽象基类
# ========================
class TopPluginBase(ABC):
"""所有插件的抽象基类"""
metainfo: PluginMetaInformation
"""插件元信息"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if hasattr(cls, "metainfo"):
if not isinstance(cls.metainfo, PluginMetaInformation):
raise PluginMetainfoTypeError(
"类`{cls_name}`之属性`metainfo`的类型,必须为`PluginMetaInformation`".format(
cls_name=cls.__name__
)
)
else:
if not cls.__name__.endswith("PluginBase"):
raise PluginMetainfoNotFoundError(
"类`{cls_name}`必须定义一个`metainfo`属性。".format(
cls_name=cls.__name__
)
)
class TopInOutPluginBase(TopPluginBase, ABC):
"""导入导出用抽象基类"""
supported_formats: Tuple[str, ...] = tuple()
"""支持的格式(定义后会自动转大写)"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if hasattr(cls, "supported_formats"):
if cls.supported_formats:
# 强制转换为大写,并使用元组
cls.supported_formats = tuple(map(str.upper, cls.supported_formats))
else:
cls.supported_formats = tuple()
else:
raise PluginAttributeNotFoundError(
"用于导入导出数据的类`{cls_name}`必须定义一个`supported_formats`属性。".format(
cls_name=cls.__name__
)
)
def can_handle_file(self, file_path: Path) -> bool:
"""判断是否可处理某个文件
参数
====
file_path: Path
待检测的文件路径
返回
====
bool
若文件后缀已在本类中定义,则返回 True
"""
return file_path.suffix.upper().endswith(self.supported_formats)
def can_handle_format(self, format_name: str) -> bool:
"""判断是否可处理某个格式
参数
====
format_name: str
格式名称(如 'MIDI', 'WAV'
返回
====
bool
若格式名本类中已经定义,则返回 True
"""
return format_name.upper().endswith(self.supported_formats)
class MusicInputPluginBase(TopInOutPluginBase, ABC):
"""导入用插件抽象基类-完整曲目"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_MUSIC_IMPORT:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`MusicInputPlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_MUSIC_IMPORT`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def loadbytes(
self, bytes_buffer_in: BinaryIO, config: Optional[PluginConfig]
) -> "SingleMusic":
"""从字节流加载数据到完整曲目
参数
====
bytes_buffer_in: BinaryIO
输入的二进制字节流
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleMusic
解析得到的完整曲目对象
"""
pass
def load(self, file_path: Path, config: Optional[PluginConfig]) -> "SingleMusic":
"""从文件加载数据到完整曲目
参数
====
file_path: Path
输入文件路径
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleMusic
解析得到的完整曲目对象
"""
with file_path.open("rb") as f:
return self.loadbytes(f, config)
class TrackInputPluginBase(TopInOutPluginBase, ABC):
"""导入用插件抽象基类-单个音轨"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_TRACK_IMPORT:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`TrackInputPlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_TRACK_IMPORT`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def loadbytes(
self, bytes_buffer_in: BinaryIO, config: Optional[PluginConfig]
) -> "SingleTrack":
"""从字节流加载音符数据到单个音轨
参数
====
bytes_buffer_in: BinaryIO
输入的二进制字节流
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleTrack
解析得到的单个音轨对象
"""
pass
def load(self, file_path: Path, config: Optional[PluginConfig]) -> "SingleTrack":
"""从文件加载音符数据到单个音轨
参数
====
file_path: Path
输入文件路径
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleTrack
解析得到的单个音轨对象
"""
with file_path.open("rb") as f:
return self.loadbytes(f, config)
class MusicOperatePluginBase(TopPluginBase, ABC):
"""音乐处理用插件抽象基类-完整曲目"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_MUSIC_OPERATE:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`MusicOperatePlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_MUSIC_OPERATE`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def process(
self, data: "SingleMusic", config: Optional[PluginConfig]
) -> "SingleMusic":
"""处理完整曲目的数据
参数
====
data: SingleMusic
待处理的完整曲目
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleMusic
处理后的完整曲目
"""
pass
class TrackOperatePluginBase(TopPluginBase, ABC):
"""音乐处理用插件抽象基类-单个音轨"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_TRACK_OPERATE:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`TrackOperatePlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_TRACK_OPERATE`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def process(
self, data: "SingleTrack", config: Optional[PluginConfig]
) -> "SingleTrack":
"""处理单个音轨的音符数据
参数
====
data: SingleTrack
待处理的单个音轨
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
SingleTrack
处理后的单个音轨
"""
pass
class MusicOutputPluginBase(TopInOutPluginBase, ABC):
"""导出用插件的抽象基类-完整曲目"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_MUSIC_EXPORT:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`MusicOutputPlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_MUSIC_EXPORT`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def dumpbytes(
self, data: "SingleMusic", config: Optional[PluginConfig]
) -> BinaryIO:
"""将完整曲目导出为对应格式的字节流
参数
====
data: SingleMusic
待导出的完整曲目
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
BinaryIO
导出后的二进制字节流
"""
pass
@abstractmethod
def dump(
self, data: "SingleMusic", file_path: Path, config: Optional[PluginConfig]
):
"""将完整曲目导出为对应格式的文件
参数
====
data: SingleMusic
待导出的完整曲目
file_path: Path
输出文件路径
config: Optional[PluginConfig]
插件配置;**可选**
"""
pass
class TrackOutputPluginBase(TopInOutPluginBase, ABC):
"""导出用插件的抽象基类-单个音轨"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.FUNCTION_TRACK_EXPORT:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`TrackOutputPlugin`继承的,该类的子类应当为一个`PluginType.FUNCTION_TRACK_EXPORT`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def dumpbytes(
self, data: "SingleTrack", config: Optional[PluginConfig]
) -> BinaryIO:
"""将单个音轨导出为对应格式的字节流
参数
====
data: SingleTrack
待导出的单个音轨
config: Optional[PluginConfig]
插件配置;**可选**
返回
====
BinaryIO
导出后的二进制字节流
"""
pass
@abstractmethod
def dump(
self, data: "SingleTrack", file_path: Path, config: Optional[PluginConfig]
):
"""将单个音轨导出为对应格式的文件
参数
====
data: SingleTrack
待导出的单个音轨
file_path: Path
输出文件路径
config: Optional[PluginConfig]
插件配置;**可选**
"""
pass
class ServicePluginBase(TopPluginBase, ABC):
"""服务插件抽象基类"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.SERVICE:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`ServicePlugin`继承的,该类的子类应当为一个`PluginType.SERVICE`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
@abstractmethod
def serve(self, config: Optional[PluginConfig], *args) -> None:
"""服务插件的运行逻辑
参数
====
config: Optional[PluginConfig]
插件配置;**可选**
*args: Any
其他运行时参数
"""
pass
class LibraryPluginBase(TopPluginBase, ABC):
"""插件依赖库的抽象基类"""
def __init_subclass__(cls) -> None:
super().__init_subclass__()
if cls.metainfo.type != PluginTypes.LIBRARY:
raise PluginMetainfoValueError(
"插件类`{cls_name}`是从`LibraryPlugin`继承的,该类的子类应当为一个`PluginType.LIBRARY`类型的插件,而不是`PluginType.{cls_type}`".format(
cls_name=cls.__name__,
cls_type=cls.metainfo.type.name,
)
)
# 怎么?
# 插件的彼此依赖就不需要什么调用了吧

View File

@@ -1,59 +0,0 @@
# -*- coding: utf-8 -*-
"""
音·创 v3 内置的 Midi 读取插件
"""
"""
版权所有 © 2026 金羿、玉衡Alioth
Copyright © 2026 Eilles, YuhengAlioth
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import mido
from pathlib import Path
from typing import BinaryIO, Optional
from Musicreater import SingleMusic
from Musicreater.plugins import (
music_input_plugin,
PluginConfig,
PluginMetaInformation,
PluginTypes,
MusicInputPluginBase,
)
@music_input_plugin("midi_2_music_plugin")
class MidiImport2MusicPlugin(MusicInputPluginBase):
"""Midi 音乐数据导入插件"""
metainfo = PluginMetaInformation(
name="Midi 导入插件",
author="金羿、玉衡Alioth",
description="从 Midi 文件导入音乐数据",
version=(0, 0, 1),
type=PluginTypes.FUNCTION_MUSIC_IMPORT,
license="Same as Musicreater",
)
supported_formats = ("MID", "MIDI")
def loadbytes(
self, bytes_buffer_in: BinaryIO, config: PluginConfig | None
) -> SingleMusic:
midi_file = mido.MidiFile(file=bytes_buffer_in)
return SingleMusic() # =========================== TODO: 等待制作
def load(self, file_path: Path, config: Optional[PluginConfig]) -> "SingleMusic":
"""从 Midi 文件导入音乐数据"""
midi_file = mido.MidiFile(filename=file_path)
return SingleMusic() # =========================== TODO: 等待制作

File diff suppressed because it is too large Load Diff

View File

@@ -1,786 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 的内部数据类
"""
"""
版权所有 © 2026 金羿
Copyright © 2026 Eilles
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# “
# 把代码 洒落在这里
# 和音符 留下的沙砾
# 一点一点爬进你类定义的缝隙
# ” —— 乐曲访问 by resnah
import heapq
from math import sin, cos, asin, radians, degrees, sqrt, atan, inf, ceil
from dataclasses import dataclass
from typing import (
Optional,
Any,
List,
Tuple,
Union,
Dict,
Set,
Sequence,
Callable,
Generator,
Iterable,
Iterator,
Literal,
Hashable,
TypeVar,
)
from enum import Enum
from .exceptions import SingleNoteDecodeError, ParameterTypeError, ParameterValueError
from .paramcurve import ParamCurve
T = TypeVar("T")
class SoundAtmos:
"""声源方位类"""
sound_distance: float
"""声源距离 方块"""
sound_azimuth: Tuple[float, float]
"""声源方位 角度(rV左右 rH上下)"""
def __init__(
self,
distance: Optional[float] = None,
azimuth: Optional[Tuple[float, float]] = None,
) -> None:
"""
定义一个发声方位
Parameters
------------
distance: float
发声源距离玩家的距离(半径 `r`
注:距离越近,音量越高,默认为 0。此参数可以与音量成某种函数关系。
azimuth: tuple[float, float]
声源方位
此参数为tuple包含两个元素分别表示
`rV` 发声源在竖直(上下)轴上,从玩家视角正前方开始,向顺时针旋转的角度
`rH` 发声源在水平(左右)轴上,从玩家视角正前方开始,向上(到达玩家正上方顶点后变为向下,以此类推的旋转)旋转的角度
"""
self.sound_azimuth = (azimuth[0] % 360, azimuth[1] % 360) if azimuth else (0, 0)
"""声源方位"""
# 如果指定为零,那么为零,但如果不指定或者指定为负数,则为 0.01 的距离
self.sound_distance = (
(16 if distance > 16 else (distance if distance >= 0 else 0.01))
if distance is not None
else 0.01
)
"""声源距离"""
@classmethod
def from_displacement(
cls,
displacement: Optional[Tuple[float, float, float]] = None,
) -> "SoundAtmos":
if displacement is None:
# displacement = (0, 0, 0)
return cls()
else:
r = sqrt(displacement[0] ** 2 + displacement[1] ** 2 + displacement[2] ** 2)
if r == 0:
return cls(distance=0, azimuth=(0, 0))
else:
beta_h = round(degrees(asin(displacement[1] / r)), 8)
if displacement[2] == 0:
alpha_v = -90 if displacement[0] > 0 else 90
else:
alpha_v = round(
degrees(atan(-displacement[0] / displacement[2])), 8
)
return cls(distance=r, azimuth=(alpha_v, beta_h))
@property
def position_displacement(self) -> Tuple[float, float, float]:
"""声像位移,直接可应用于我的世界的相对视角的坐标参考系中(^x ^y ^z"""
dk1 = self.sound_distance * round(cos(radians(self.sound_azimuth[1])), 8)
return (
-dk1 * round(sin(radians(self.sound_azimuth[0])), 8),
self.sound_distance * round(sin(radians(self.sound_azimuth[1])), 8),
dk1 * round(cos(radians(self.sound_azimuth[0])), 8),
)
@dataclass(init=False)
class SingleNote:
"""存储单个音符的类"""
note_pitch: int
"""midi音高"""
velocity: int
"""力度"""
start_time: int
"""开始之时 命令刻"""
duration: int
"""音符持续时间 命令刻"""
high_precision_start_time: int
"""高精度开始时间偏量 1/1250 秒"""
extra_info: Dict[str, Any]
"""你觉得放什么好?"""
def __init__(
self,
midi_pitch: Optional[int],
midi_velocity: int,
start_time: int,
last_time: int,
mass_precision_time: int = 0,
extra_information: Dict[str, Any] = {},
):
"""
用于存储单个音符的类
Parameters
------------
midi_pitch: int
midi音高
midi_velocity: int
midi响度(力度)
start_time: int
开始之时(命令刻)
注:此处的时间是用从乐曲开始到当前的刻数
last_time: int
音符延续时间(命令刻)
mass_precision_time: int
高精度的开始时间偏移量(1/1250秒)
is_percussion: bool
是否作为打击乐器
extra_information: Dict[str, Any]
附加信息,尽量存储为字典
Returns
---------
MineNote 类
"""
self.note_pitch: int = 66 if midi_pitch is None else midi_pitch
"""midi音高"""
self.velocity: int = midi_velocity
"""响度(力度)"""
self.start_time: int = start_time
"""开始之时 命令刻"""
self.duration: int = last_time
"""音符持续时间 命令刻"""
self.high_precision_start_time: int = mass_precision_time
"""高精度开始时间偏量 0.4 毫秒"""
self.extra_info = extra_information if extra_information else {}
@classmethod
def decode(cls, code_buffer: bytes, is_high_time_precision: bool = True):
"""自字节码析出 SingleNote 类"""
duration_ = (
group_1 := int.from_bytes(code_buffer[:6], "big")
) & 0b11111111111111111
start_tick_ = (group_1 := group_1 >> 17) & 0b11111111111111111
note_velocity_ = (group_1 := group_1 >> 17) & 0b1111111
note_pitch_ = (group_1 := group_1 >> 7) & 0b1111111
try:
return cls(
midi_pitch=note_pitch_,
midi_velocity=note_velocity_,
start_time=start_tick_,
last_time=duration_,
mass_precision_time=code_buffer[6] if is_high_time_precision else 0,
)
except Exception as e:
# 我也不知道为什么这里要放一个异常处理
# 之前用到过吗?
# —— 2026.01.25 金羿
print(
"[Exception] 单音符解析错误,字节码`{}`{}启用高精度时间偏移\n".format(
code_buffer, "" if is_high_time_precision else ""
)
)
raise SingleNoteDecodeError(
e,
"技术信息:\nGROUP1\t`{}`\nCODE_BUFFER\t`{}`".format(
group_1, code_buffer
),
)
def encode(self, is_high_time_precision: bool = True) -> bytes:
"""
将数据打包为字节码
Parameters
------------
is_high_time_precision: bool
是否启用高精度,默认为**是**
Returns
---------
bytes
打包好的字节码
"""
# SingleNote 的字节码
# note_pitch 7 位 支持到 127
# velocity 长度 7 位 支持到 127
# start_tick 17 位 支持到 131071 即 109.22583 分钟 合 1.8204305 小时
# duration 17 位 支持到 131071 即 109.22583 分钟 合 1.8204305 小时
# 共 48 位 合 6 字节
# high_time_precision可选长度 8 位 支持到 255 合 1 字节 支持 1/1250 秒]
return (
(
(
((((self.note_pitch << 7) + self.velocity) << 17) + self.start_time)
<< 17
)
+ self.duration
).to_bytes(6, "big")
# + self.track_no.to_bytes(1, "big")
+ (
self.high_precision_start_time.to_bytes(1, "big")
if is_high_time_precision
else b""
)
)
def set_info(self, key: Union[str, Sequence[str]], value: Any):
"""设置附加信息"""
if isinstance(key, str):
self.extra_info[key] = value
elif (
isinstance(key, Sequence)
and isinstance(value, Sequence)
and (k := len(key)) == len(value)
):
for i in range(k):
self.extra_info[key[i]] = value[i]
else:
# 提供简单报错就行了,如果放一堆 if 语句,降低处理速度
raise ParameterTypeError(
"参数类型错误;键:`{}` 值:`{}`".format(key, value)
)
def get_info(self, key: str, default: Any = None) -> Any:
"""获取附加信息"""
return self.extra_info.get(key, default)
def stringize(self, include_extra_data: bool = False) -> str:
return "TrackedNote(Pitch = {}, Velocity = {}, StartTick = {}, Duration = {}, TimeOffset = {}".format(
self.note_pitch,
self.velocity,
self.start_time,
self.duration,
self.high_precision_start_time,
) + (
", ExtraData = {})".format(self.extra_info) if include_extra_data else ")"
)
# def __list__(self) -> List[int]:
# 我不认为这个类应当被作为列表使用
def __tuple__(
self,
) -> Tuple[int, int, int, int, int]:
return (
self.note_pitch,
self.velocity,
self.start_time,
self.duration,
self.high_precision_start_time,
)
def __dict__(self):
return {
"Pitch": self.note_pitch,
"Velocity": self.velocity,
"StartTick": self.start_time,
"Duration": self.duration,
"TimeOffset": self.high_precision_start_time,
"ExtraData": self.extra_info,
}
def __eq__(self, other) -> bool:
"""比较两个音符是否具有相同的属性,不计附加信息"""
if not isinstance(other, self.__class__):
return False
return self.__tuple__() == other.__tuple__()
def __lt__(self, other) -> bool:
"""比较自己是否在开始时间上早于另一个音符"""
if self.start_time == other.start_tick:
return self.high_precision_start_time < other.high_precision_time
else:
return self.start_time < other.start_tick
def __gt__(self, other) -> bool:
"""比较自己是否在开始时间上晚于另一个音符"""
if self.start_time == other.start_tick:
return self.high_precision_start_time > other.high_precision_time
else:
return self.start_time > other.start_tick
class CurvableParam(str, Enum):
"""可曲线化的参数枚举类"""
PITCH = "adjust_note_pitch"
VELOCITY = "adjust_note_velocity"
VOLUME = "adjust_note_volume"
DISTANCE = "adjust_note_sound_distance"
LR_PANNING = "adjust_note_leftright_panning_degree"
UD_PANNING = "adjust_note_updown_panning_degree"
@dataclass
class MineNote:
"""我的世界音符对象(仅提供我的世界相关接口)"""
pitch: float
"""midi音高"""
instrument: str
"""乐器ID"""
velocity: float
"""力度"""
volume: float
"""音量"""
start_tick: int
"""开始之时 命令刻"""
duration_tick: int
"""音符持续时间 命令刻"""
persiced_time: int
"""高精度开始时间偏量 1/1250 秒"""
percussive: bool
"""是否作为打击乐器启用"""
position: SoundAtmos
"""声像方位"""
@classmethod
def from_single_note(
cls,
note: SingleNote,
note_instrument: str,
sound_volume: float,
is_persiced_time: bool,
is_percussive_note: bool,
sound_position: SoundAtmos,
adjust_note_pitch: float = 0.0,
adjust_note_velocity: float = 0.0,
adjust_note_volume: float = 0.0,
adjust_note_sound_distance: float = 0.0,
adjust_note_leftright_panning_degree: float = 0.0,
adjust_note_updown_panning_degree: float = 0.0,
) -> "MineNote":
"""从SingleNote对象创建MineNote对象"""
sound_position.sound_distance += adjust_note_sound_distance
sound_position.sound_azimuth = (
sound_position.sound_azimuth[0] + adjust_note_leftright_panning_degree,
sound_position.sound_azimuth[1] + adjust_note_updown_panning_degree,
)
return cls(
pitch=note.note_pitch + adjust_note_pitch,
instrument=note_instrument,
velocity=note.velocity + adjust_note_velocity,
volume=sound_volume + adjust_note_volume,
start_tick=note.start_time,
duration_tick=note.duration,
persiced_time=note.high_precision_start_time if is_persiced_time else 0,
percussive=is_percussive_note,
position=sound_position,
)
class SingleTrack(List[SingleNote]):
"""存储单个轨道的类"""
track_name: str
"""轨道之名称"""
is_enabled: bool = True
"""该音轨是否启用"""
track_instrument: str
"""乐器ID"""
track_volume: float
"""该音轨的音量"""
is_high_time_precision: bool
"""该音轨是否使用高精度时间"""
is_percussive: bool
"""该音轨是否标记为打击乐器轨道"""
sound_position: SoundAtmos
"""声像方位"""
argument_curves: Dict[CurvableParam, Union[ParamCurve, Literal[None]]]
"""参数曲线"""
extra_info: Dict[str, Any]
"""你觉得放什么好?"""
def __init__(
self,
name: str = "未命名音轨",
instrument: str = "",
volume: float = 0,
precise_time: bool = True,
percussion: bool = False,
sound_direction: SoundAtmos = SoundAtmos(),
extra_information: Dict[str, Any] = {},
*args: SingleNote,
):
self.track_name = name
"""音轨名称"""
self.track_instrument = instrument
"""乐器ID"""
self.track_volume = volume
"""音量"""
self.is_high_time_precision = precise_time
"""是否使用高精度时间"""
self.is_percussive = percussion
"""是否为打击乐器"""
self.sound_position = sound_direction
"""声像方位"""
self.extra_info = extra_information if extra_information else {}
self.argument_curves = {item: None for item in CurvableParam}
super().__init__(*args)
super().sort()
def disable(self) -> None:
"""禁用音轨"""
self.is_enabled = False
def enable(self) -> None:
"""启用音轨"""
self.is_enabled = True
def toggle_able(self) -> None:
"""切换音轨的启用状态"""
self.is_enabled = not self.is_enabled
def append(self, object: SingleNote) -> None:
"""
添加一个音符,推荐使用 add 方法
"""
return self.add(object)
def add(self, item: SingleNote) -> None:
"""
在音轨里添加一个音符
"""
if not isinstance(item, SingleNote):
raise ParameterTypeError(
"单音轨类的元素类型须为单音符(`SingleNote`),不可为:`{}`".format(
type(item).__name__
)
)
super().append(item)
super().sort() # =========================== TODO 需要优化
def update(self, items: Iterable[SingleNote]):
"""
拼接两个音轨
"""
super().extend(items)
super().sort() # =========================== TODO 需要优化
def get(self, time: int) -> Generator[SingleNote, None, None]:
"""通过开始时间来获取音符"""
return (x for x in self if x.start_time == time)
def get_notes(
self, start_time: float, end_time: float = inf
) -> Generator[SingleNote, None, None]:
"""通过开始时间和结束时间来获取音符"""
if end_time < start_time:
raise ParameterValueError(
"获取音符的时间范围有误,终止时间`{}`早于起始时间`{}`".format(
end_time, start_time
)
)
elif start_time < 0 or end_time < 0:
raise ParameterValueError(
"获取音符的时间范围有误,终止时间`{}`和起始时间`{}`皆不可为负数".format(
end_time, start_time
)
)
return (
x
for x in self
if (x.start_time >= start_time) and (x.start_time <= end_time)
)
def get_minenotes(
self, range_start_time: float = 0, range_end_time: float = inf
) -> Generator[MineNote, Any, None]:
"""获取能够用以在我的世界播放的音符数据类"""
for _note in self.get_notes(range_start_time, range_end_time):
yield MineNote.from_single_note(
note=_note,
note_instrument=self.track_instrument,
sound_volume=self.track_volume,
is_persiced_time=self.is_high_time_precision,
is_percussive_note=self.is_percussive,
sound_position=self.sound_position,
**{
item.value: argcrv.value_at(_note.start_time)
for item in CurvableParam
if (argcrv := self.argument_curves[item])
},
)
@property
def note_amount(self) -> int:
"""音符数"""
return len(self)
@property
def track_notes(self) -> List[SingleNote]:
"""音符列表"""
return self
def set_info(self, key: Union[str, Sequence[str]], value: Any):
"""设置附加信息"""
if isinstance(key, str):
self.extra_info[key] = value
elif (
isinstance(key, Sequence)
and isinstance(value, Sequence)
and (k := len(key)) == len(value)
):
for i in range(k):
self.extra_info[key[i]] = value[i]
else:
# 提供简单报错就行了,如果放一堆 if 语句,降低处理速度
raise ParameterTypeError(
"参数类型错误;键:`{}` 值:`{}`".format(key, value)
)
def get_info(self, key: str, default: Any = None) -> Any:
"""获取附加信息"""
return self.extra_info.get(key, default)
class SingleMusic(List[SingleTrack]):
"""存储单个曲子的类"""
music_name: str
"""乐曲名称"""
music_creator: str
"""本我的世界曲目的制作者"""
music_original_author: str
"""曲目的原作者"""
music_description: str
"""当前曲目的简介"""
music_credits: str
"""曲目的版权信息"""
# 感叹一下什么交冗余设计啊!(叉腰)
extra_info: Dict[str, Any]
"""这还得放东西?"""
def __init__(
self,
name: str = "未命名乐曲",
creator: str = "未命名制作者",
original_author: str = "未命名原作者",
description: str = "未命名简介",
credits: str = "未命名版权信息",
*args: SingleTrack,
extra_information: Dict[str, Any] = {},
):
self.music_name = name
"""乐曲名称"""
self.music_creator = creator
"""曲目制作者"""
self.music_original_author = original_author
"""乐曲原作者"""
self.music_description = description
"""简介"""
self.music_credits = credits
"""版权信息"""
self.extra_info = extra_information if extra_information else {}
super().__init__(*args)
@property
def track_amount(self) -> int:
"""音轨数"""
return len(self)
@property
def music_tracks(self) -> Iterator[SingleTrack]:
"""音轨列表,不包含被禁用的音轨"""
return (track for track in self if track.is_enabled)
@staticmethod
def yield_from_tracks(
tracks: Sequence[Iterator[T]],
sort_key: Callable[[T], Any],
is_subseq_sorted: bool = True,
) -> Iterator[T]:
"""从任意迭代器列表迭代符合顺序的元素
(惰性多路归并多个迭代器,按 sort_key 排序)
参数
----
tracks: Sequence[Iterator[T]]
迭代器列表
sort_key: Callable[[T], Any]
接受 T 元素,返回可比较的键
is_subseq_sorted: bool = True
子序列是否已排序
迭代
----
归并后的每个元素,按 sort_key 升序
"""
if is_subseq_sorted:
return heapq.merge(*tracks, key=sort_key)
else:
# 初始化堆
heap_pool: List[Tuple[Any, int, T]] = []
for _index, _track in enumerate(tracks):
try:
item = next(_track)
heapq.heappush(heap_pool, (sort_key(item), _index, item))
except StopIteration:
continue
# 归并主循环
while heap_pool:
_key, _index, item = heapq.heappop(heap_pool)
yield item
try:
next_item = next(tracks[_index])
heapq.heappush(heap_pool, (sort_key(next_item), _index, next_item))
except StopIteration:
pass
# NEVER REACH:
# pool: List[Tuple[str, T]] = []
# remove_track: List[str] = []
# for _name, _track in tracks.items():
# try:
# pool.append((_name, next(_track)))
# except StopIteration:
# remove_track.append(_name)
# for _x in remove_track:
# tracks.pop(_x)
# del remove_track
# while tracks and pool:
# yield (_x := min(pool, key=sort_key))[1]
# try:
# pool.append((_x[0], next(tracks[_x[0]])))
# except StopIteration:
# tracks.pop(_x[0])
# pool.sort(key=sort_key)
# for _remain in pool:
# yield _remain[1]
def get_tracked_notes(
self, start_time: float, end_time: float = inf
) -> Generator[Iterator[SingleNote], Any, None]:
"""获取指定时间段的各个音轨的音符数据"""
return (track.get_notes(start_time, end_time) for track in self.music_tracks)
def get_tracked_minenotes(
self, start_time: float, end_time: float = inf
) -> Generator[Iterator[MineNote], Any, None]:
"""获取指定时间段的各个音轨的,供我的世界播放的音符数据类"""
return (
track.get_minenotes(start_time, end_time) for track in self.music_tracks
)
def get_notes(
self, start_time: float, end_time: float = inf
) -> Iterator[SingleNote]:
"""获取指定时间段的所有音符数据,按照时间顺序"""
if self.track_amount == 0:
return iter(())
return self.yield_from_tracks(
[track.get_notes(start_time, end_time) for track in self.music_tracks],
sort_key=lambda x: x.start_time,
)
def get_minenotes(
self, start_time: float, end_time: float = inf
) -> Generator[MineNote, Any, None]:
"""获取指定时间段所有的,供我的世界播放的音符数据类,按照时间顺序"""
if self.track_amount == 0:
return
yield from self.yield_from_tracks(
[track.get_minenotes(start_time, end_time) for track in self.music_tracks],
sort_key=lambda x: x.start_tick,
)
def set_info(self, key: Union[str, Sequence[str]], value: Any):
"""设置附加信息"""
if isinstance(key, str):
self.extra_info[key] = value
elif (
isinstance(key, Sequence)
and isinstance(value, Sequence)
and (k := len(key)) == len(value)
):
for i in range(k):
self.extra_info[key[i]] = value[i]
else:
# 提供简单报错就行了,如果放一堆 if 语句,降低处理速度
raise ParameterTypeError(
"参数类型错误;键:`{}` 值:`{}`".format(key, value)
)
def get_info(self, key: str, default: Any = None) -> Any:
"""获取附加信息"""
return self.extra_info.get(key, default)

View File

@@ -1,266 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 用到的一些报错类型
"""
"""
版权所有 © 2026 金羿 & 玉衡Alioth
Copyright © 2026 Eilles & YuhengAlioth
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# “
# There are planty of "exception"s in this library
# for I know I will always go with my heart.
# ” —— Cyberdevil by resnah
class MusicreaterBaseException(Exception):
"""音·创 v3 的所有错误均继承于此"""
def __init__(self, *args):
"""音·创 的所有错误均继承于此"""
super().__init__("[音·创] - ", *args)
def meow(self):
for i in self.args:
print(i + "喵~", end="")
def crash_it(self):
raise self
def __str__(self) -> str:
return "".join(self.args)
# =====================================
# NOTE
# 面对用户时候爆出去的我们认为这就是“外部错误”
# 如果是在程序内部数据传输等情况下出现的就是“内部错误”
# 例如,无法读取文件,这就是一个外部错误
# 某个参数的数据类型错误,这就是内部错误
# =====================================
class MusicreaterInnerlyError(MusicreaterBaseException):
"""内部错误"""
def __init__(self, *args):
"""内部错误(面向开发者的报错信息)"""
super().__init__("内部错误 - ", *args)
class MusicreaterOuterlyError(MusicreaterBaseException):
"""外部错误"""
def __init__(self, *args):
"""外部错误(面向用户的报错信息)"""
super().__init__("外部错误 - ", *args)
class InnerlyParameterError(MusicreaterInnerlyError):
"""内部传参错误"""
def __init__(self, *args):
"""参数错误"""
super().__init__("传参错误 - ", *args)
class ParameterTypeError(InnerlyParameterError, TypeError):
"""参数类型错误"""
def __init__(self, *args):
"""参数类型错误"""
super().__init__("参数类型错误:", *args)
class ParameterValueError(InnerlyParameterError, ValueError):
"""参数值存在错误"""
def __init__(self, *args):
"""参数其值存在错误"""
super().__init__("参数数值错误:", *args)
class PluginNotSpecifiedError(InnerlyParameterError, LookupError):
"""未指定插件"""
def __init__(self, *args):
"""未指定插件"""
super().__init__("未指定插件:", *args)
class OuterlyParameterError(MusicreaterOuterlyError):
"""外部参数错误"""
def __init__(self, *args):
"""参数错误"""
super().__init__("参数错误 - ", *args)
class ZeroSpeedError(OuterlyParameterError, ZeroDivisionError):
"""以0作为播放速度的错误"""
def __init__(self, *args):
"""以0作为播放速度的错误"""
super().__init__("播放速度为零:", *args)
class IllegalMinimumVolumeError(OuterlyParameterError, ValueError):
"""最小播放音量有误的错误"""
def __init__(self, *args):
"""最小播放音量错误"""
super().__init__("最小播放音量超出范围:", *args)
class FileFormatNotSupportedError(MusicreaterOuterlyError):
"""不支持的文件格式"""
def __init__(self, *args):
"""文件格式不受支持"""
super().__init__("不支持的文件格式:", *args)
class NoteBinaryDecodeError(MusicreaterOuterlyError):
"""音乐存储二进制数据解码错误"""
def __init__(self, *args):
"""音乐存储二进制数据无法正确解码"""
super().__init__("解码音乐存储二进制数据时出现问题 - ", *args)
class SingleNoteDecodeError(NoteBinaryDecodeError):
"""单个音符的二进制数据解码错误"""
def __init__(self, *args):
"""单个音符的二进制数据无法正确解码"""
super().__init__("音符解码出错:", *args)
class NoteBinaryFileTypeError(NoteBinaryDecodeError):
"""音乐存储二进制数据的文件类型错误"""
def __init__(self, *args):
"""无法识别音乐存储文件的类型"""
super().__init__("无法识别音乐存储文件对应的类型:", *args)
class NoteBinaryFileVerificationFailed(NoteBinaryDecodeError):
"""音乐存储二进制数据校验失败"""
def __init__(self, *args):
"""音乐存储文件与其校验值不一致"""
super().__init__("音乐存储文件校验失败:", *args)
class PluginDefineError(MusicreaterInnerlyError):
"""插件定义错误(内部相关)"""
def __init__(self, *args):
"""插件本身存在错误"""
super().__init__("插件内部错误 - ", *args)
class PluginInstanceNotFoundError(PluginDefineError, LookupError):
"""插件实例未找到"""
def __init__(self, *args):
"""插件实例未找到"""
super().__init__("插件实例未找到:", *args)
class PluginAttributeNotFoundError(PluginDefineError, AttributeError):
"""插件属性定义错误"""
def __init__(self, *args):
"""插件属性定义错误"""
super().__init__("插件类的必要属性不存在:", *args)
class PluginMetainfoError(PluginDefineError):
"""插件元信息定义错误"""
def __init__(self, *args):
"""插件元信息定义错误"""
super().__init__("插件元信息定义错误 - ", *args)
class PluginMetainfoTypeError(PluginMetainfoError, TypeError):
"""插件元信息定义类型错误"""
def __init__(self, *args):
"""插件元信息定义类型错误"""
super().__init__("插件元信息类型错误:", *args)
class PluginMetainfoValueError(PluginMetainfoError, ValueError):
"""插件元信息定义值错误"""
def __init__(self, *args):
"""插件元信息定义值错误"""
super().__init__("插件元信息数值错误:", *args)
class PluginMetainfoNotFoundError(PluginMetainfoError, PluginAttributeNotFoundError):
"""插件元信息定义缺少错误"""
def __init__(self, *args):
"""插件元信息定义缺少错误"""
super().__init__("插件元信息未定义:", *args)
class PluginLoadError(MusicreaterOuterlyError):
"""插件加载错误(外部相关)"""
def __init__(self, *args):
"""插件加载错误"""
super().__init__("插件加载错误 - ", *args)
class PluginNotFoundError(PluginLoadError):
"""插件未找到"""
def __init__(self, *args):
"""插件未找到"""
super().__init__("插件未找到:", *args)
class PluginRegisteredError(PluginLoadError):
"""插件重复注册"""
def __init__(self, *args):
"""插件已被注册注册"""
super().__init__("插件重复注册:", *args)
class PluginConfigRelatedError(MusicreaterOuterlyError):
"""插件配置相关错误"""
def __init__(self, *args):
"""插件配置相关错误"""
super().__init__("插件配置相关错误 - ", *args)
class PluginConfigLoadError(PluginLoadError, PluginConfigRelatedError):
"""插件配置加载错误"""
def __init__(self, *args):
"""配置文件无法加载"""
super().__init__("插件配置文件加载错误:", *args)
class PluginConfigDumpError(PluginConfigRelatedError):
"""插件配置保存错误"""
def __init__(self, *args):
"""配置文件无法保存"""
super().__init__("插件配置文件保存错误:", *args)

View File

@@ -1,285 +0,0 @@
# -*- coding: utf-8 -*-
"""
音·创
是一款免费开源的《我的世界》数字音频支持库。
Musicreater (音·创)
A free and open-source library for handling with **Minecraft** digital music.
版权所有 © 2026 睿乐组织
Copyright © 2026 TriM-Organization
音·创(“本项目”)的协议颁发者为 金羿、玉衡Alioth
The Licensor of Musicreater("this project") is Eilles, YuhengAlioth
本项目根据 第一版 汉钰律许可协议(“本协议”)授权。
任何人皆可从以下地址获得本协议副本:
https://gitee.com/TriM-Organization/Musicreater/blob/master/LICENSE.md。
若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,
不予提供任何形式的担保、任何明示、任何暗示或类似承诺。
也就是说,用户将自行承担因此作品的质量或性能问题而产生的全部风险。
详细的准许和限制条款请见原协议文本。
"""
# 音·创 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库根目录下的 License.md
# BUG退散BUG退散
# 异常与错误作乱之时
# 二六字组!万国码合!二六字组!万国码合!
# 赶快呼叫 程序员Let's Go
# BUG退散BUG退散
# 異常、誤りが、困った時は
# パラメータ メソッド!パラメータ メソッド!
# 助けてもらおう、開発者!レッツゴー!
# Bug retreat! Bug retreat!
# Exceptions and errors are causing chaos
# Words combine! Codes unite!
# Hurry to call the programmer! Let's Go!
import re
from difflib import get_close_matches
from typing import Dict, Generator, List, Optional, Tuple, Union, Mapping, Callable
from pathlib import Path
from .data import SingleMusic, SingleTrack
from .exceptions import (
FileFormatNotSupportedError,
PluginNotSpecifiedError,
PluginNotFoundError,
)
from ._plugin_abc import TopPluginBase
from .plugins import (
_global_plugin_registry,
PluginRegistry,
PluginConfig,
PluginTypes,
load_plugin_module,
T_IOPlugin,
T_Plugin,
)
class MusiCreater:
"""
音·创 v3 主要控制类
“创建者”一词的英文应该是“Creator”
"""
__plugin_registry: PluginRegistry
"""插件注册表实例"""
_plugin_cache: Dict[str, TopPluginBase]
"""插件缓存字典插件id为键、插件实例为值"""
music: SingleMusic
"""当前曲目实例"""
def __init__(self, whole_music: SingleMusic) -> None:
global _global_plugin_registry
self.__plugin_registry = _global_plugin_registry
self._plugin_cache = {}
self._cache_all_plugins()
self.music = whole_music
@staticmethod
def _get_plugin_within_iousage(
get_func: Callable[[Union[Path, str]], Generator[T_IOPlugin, None, None]],
fpath: Path,
plg_regdict: Dict[str, T_IOPlugin],
plg_id: Optional[str],
) -> T_IOPlugin:
__plugin: Optional[T_IOPlugin] = None
if plg_id:
__plugin = plg_regdict.get(plg_id)
else:
for __plg in get_func(fpath):
if __plugin:
raise PluginNotSpecifiedError(
"文件类型`{}`可被多个插件处理,请在调用函数的参数中指定插件名称".format(
fpath.suffix.upper()
)
)
__plugin = __plg
if __plugin:
return __plugin
else:
raise FileFormatNotSupportedError(
"无法找到处理`{}`类型文件的插件".format(fpath.suffix.upper())
)
@classmethod
def import_music(
cls,
file_path: Path,
plugin_id: Optional[str] = None,
plugin_config: Optional[PluginConfig] = None,
) -> "MusiCreater":
return cls(
whole_music=cls._get_plugin_within_iousage(
_global_plugin_registry.get_music_input_plugin_by_format,
file_path,
_global_plugin_registry._music_input_plugins,
plugin_id,
).load(file_path, plugin_config)
)
def import_track(
self,
file_path: Path,
plugin_id: Optional[str] = None,
plugin_config: Optional[PluginConfig] = None,
) -> SingleTrack:
self.music.append(
self._get_plugin_within_iousage(
self.__plugin_registry.get_track_input_plugin_by_format,
file_path,
self.__plugin_registry._track_input_plugins,
plugin_id,
).load(file_path, plugin_config)
)
return self.music[-1]
def export_music(
self,
file_path: Path,
plugin_id: Optional[str] = None,
plugin_config: Optional[PluginConfig] = None,
) -> None:
self._get_plugin_within_iousage(
self.__plugin_registry.get_music_output_plugin_by_format,
file_path,
self.__plugin_registry._music_output_plugins,
plugin_id,
).dump(self.music, file_path, plugin_config)
def export_track(
self,
track_index: int,
file_path: Path,
plugin_id: Optional[str] = None,
plugin_config: Optional[PluginConfig] = None,
) -> None:
self._get_plugin_within_iousage(
self.__plugin_registry.get_track_output_plugin_by_format,
file_path,
self.__plugin_registry._track_output_plugins,
plugin_id,
).dump(self.music[track_index], file_path, plugin_config)
def perform_operation_on_music(
self, plugin_id: str, plugin_config: Optional[PluginConfig] = None
):
if __plugin := self.__plugin_registry._music_operate_plugins.get(plugin_id):
# 这样做是为了兼容以后的*撤回/重做*功能
self.music = __plugin.process(self.music, plugin_config)
else:
raise PluginNotFoundError(
"无法找到惟一识别码为`{}`的插件".format(plugin_id)
)
def perform_operation_on_track(
self,
track_index: int,
plugin_id: str,
plugin_config: Optional[PluginConfig] = None,
):
if __plugin := self.__plugin_registry._track_operate_plugins.get(plugin_id):
# 这样做是为了兼容以后的*撤回/重做*功能
self.music[track_index] = __plugin.process(
self.music[track_index], plugin_config
)
else:
raise PluginNotFoundError(
"无法找到惟一识别码为`{}`的插件".format(plugin_id)
)
@staticmethod
def _camel_to_snake(name: str) -> str:
"""
将驼峰命名转换为蛇形命名
CyberAngel -> cyber_angel
"""
return re.sub(
"([a-z0-9])([A-Z])", r"\1_\2", re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
).lower()
def _parse_plugin_id(self, attr_name: str) -> Optional[str]:
"""解析属性名称为插件惟一识别码"""
# 尝试去除 _plugin 后缀
if attr_name.endswith("_plugin"):
candidate_name = attr_name[:-7] # 去除 "_plugin"
if candidate_name in self._plugin_cache:
return candidate_name
# 尝试转换为 snake_case如果插件名是驼峰式
snake_case_name = self._camel_to_snake(attr_name)
if snake_case_name != attr_name: # 避免重复转换
if snake_case_name in self._plugin_cache: # 尝试转换后的插件名
return snake_case_name
else:
return self._parse_plugin_id(snake_case_name)
return None
def _get_closest_plugin_id(self, requested_id: str) -> Optional[str]:
"""找到最接近的插件识别码(用于更好的错误提示)"""
matches = get_close_matches(
requested_id, self._plugin_cache.keys(), n=1, cutoff=0.6
)
return matches[0] if matches else None
def get_plugin_by_id(self, plg_id: str):
"""获取插件实例,并缓存起来,提高性能"""
if plg_id.startswith("_"):
raise AttributeError("属性`{}`不存在,不应访问类的私有属性".format(plg_id))
if plg_id in self._plugin_cache:
return self._plugin_cache[plg_id]
else:
plugin_name = self._parse_plugin_id(plg_id)
if plugin_name:
self._plugin_cache[plg_id] = self._plugin_cache[plugin_name]
return self._plugin_cache[plg_id]
closest = self._get_closest_plugin_id(plg_id)
raise AttributeError(
"插件`{}`不存在,请检查插件的惟一识别码是否正确".format(plg_id)
+ (
";或者阁下可能想要使用的是`{}`插件?".format(closest)
if closest
else ""
)
)
def __getattr__(self, plugin_id: str):
"""动态属性访问,允许直接 实例.插件名 来访问插件"""
return self.get_plugin_by_id(plugin_id)
def _cache_all_plugins(self):
"""获取所有已注册插件的名称"""
for __plugin_type, __plugins_map in self.__plugin_registry:
for __plugin_id, __plugin in __plugins_map.items():
if __plugin_id in self._plugin_cache: # 避免重复缓存
if (
__plugin.metainfo.version
<= self._plugin_cache[__plugin_id].metainfo.version
): # 优先使用版本号最大的插件
continue
self._plugin_cache[__plugin_id] = __plugin

View File

@@ -1,583 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 内部数据使用的参数曲线
"""
"""
版权所有 © 2026 金羿
Copyright © 2026 Eilles
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# WARNING 本文件所含之功能未经完整测试
# 鉴于白谭若佬给出的建议:本功能应是处于低优先级开发的
# 因此暂时用处不大,可以稍微放一会再进行开发
# 目前用人工智能生成了部分代码,只经过简单的测试
# 可以等伶伦工作站开发出来后再进行完整的测试
from math import ceil
from dataclasses import dataclass
from typing import Optional, Any, List, Tuple
from enum import Enum
import bisect
from .types import FittingFunctionType
def _evaluate_bezier_segment(
t0: float,
v0: float,
t1: float,
v1: float,
out_tangent: Optional[Tuple[float, float]],
in_tangent: Optional[Tuple[float, float]],
u: float,
) -> float:
"""
计算贝塞尔区间 [t0, t1] 在归一化参数 u ∈ [0,1] 处的 y 值。
控制点:
P0 = (t0, v0)
P1 = (t0 + out_dt, v0 + out_dv)
P2 = (t1 - in_dt, v1 - in_dv) ← 注意in_tangent 是相对于 t1 的偏移
P3 = (t1, v1)
"""
# 默认控制点:退化为线性
p0 = (t0, v0)
p3 = (t1, v1)
if out_tangent is not None:
p1 = (t0 + out_tangent[0], v0 + out_tangent[1])
else:
p1 = p0 # 无出手柄 → 与起点重合
if in_tangent is not None:
p2 = (t1 - in_tangent[0], v1 - in_tangent[1])
else:
p2 = p3 # 无入手柄 → 与终点重合
# 三次贝塞尔 y(t)
mt = 1.0 - u
return mt**3 * p0[1] + 3 * mt**2 * u * p1[1] + 3 * mt * u**2 * p2[1] + u**3 * p3[1]
class InterpolationMethod:
"""
预定义的标准化插值函数集合。所有函数接受归一化输入 u ∈ [0,1],返回 v ∈ [0,1]。
"""
@staticmethod
def linear(u: float) -> float:
"""
线性插值。
Parameters
----------
u : float
归一化时间,范围 [0, 1]。
Returns
-------
float
插值权重,范围 [0, 1]。
"""
return u
@staticmethod
def ease_in_quad(u: float) -> float:
"""
二次缓入(慢进快出)。
Parameters
----------
u : float
归一化时间,范围 [0, 1]。
Returns
-------
float
插值权重。
"""
return u * u
@staticmethod
def ease_out_quad(u: float) -> float:
"""
二次缓出(快进慢出)。
Parameters
----------
u : float
归一化时间,范围 [0, 1]。
Returns
-------
float
插值权重。
"""
return 1 - (1 - u) ** 2
@staticmethod
def ease_in_out_quad(u: float) -> float:
"""
二次缓入缓出。
Parameters
----------
u : float
归一化时间,范围 [0, 1]。
Returns
-------
float
插值权重。
"""
if u < 0.5:
return 2 * u * u
else:
return 1 - pow(-2 * u + 2, 2) / 2
@staticmethod
def hold(u: float) -> float:
"""
阶梯保持模式占位函数。实际插值逻辑在 ParamCurve.value_at 中特殊处理。
Parameters
----------
u : float
归一化时间(忽略)。
Returns
-------
float
无意义,仅作标识。
"""
return 0.0
@dataclass
class Keyframe:
"""
参数曲线上的一个关键帧,支持完整的入/出切线控制。
插值优先级:
1. 若 use_bezier=True → 使用贝塞尔模式(需 in_tangent / out_tangent
2. 否则 → 使用 out_interp 函数in_interp 被忽略)
"""
time: float
value: float
# 函数插值模式
out_interp: Optional[FittingFunctionType] = None
# 贝塞尔模式
in_tangent: Optional[Tuple[float, float]] = (
None # (dt, dv) ← 相对于自身(负 dt 表示左侧)
)
out_tangent: Optional[Tuple[float, float]] = (
None # (dt, dv) → 相对于自身(正 dt 表示右侧)
)
use_bezier: bool = False
class BoundaryBehaviour(str, Enum):
"""
边界行为枚举。
"""
CONSTANT = "constant"
"""返回默认基线值"""
HOLD = "hold"
"""保持首/尾关键帧的值"""
class ParamCurve:
"""
参数曲线类
"""
"""
支持动态节点编辑
用户通过添加/修改关键帧(时间-值对)来定义曲线,类自动在相邻关键帧之间生成插值段。
支持多种插值模式:线性('linear')、平滑缓动('smooth')、保持('hold')或自定义函数。
"""
base_line: float = 0.0
"""基线/默认值"""
base_interpolation_function: FittingFunctionType
"""默认(未指定区间时的)关键帧插值模式"""
boundary_behaviour: BoundaryBehaviour
"""边界行为,控制参数曲线在已定义的范围外的返回值"""
_keys: List[Keyframe]
"""关键帧列表"""
def __init__(
self,
base_value: float = 0.0,
default_interpolation_function: FittingFunctionType = InterpolationMethod.linear,
boundary_mode: BoundaryBehaviour = BoundaryBehaviour.CONSTANT,
):
"""
初始化参数曲线。
Parameters
----------
base_value : float
边界外默认值(当 boundary_mode 为 BoundaryBehaviour.CONSTANT 时使用)。
default_interpolation_function : FittingFunctionType
新关键帧的默认 out_interp。
boundary_mode : BoundaryBehaviour
范围外行为:
- BoundaryBehaviour.CONSTANT: 返回 base_value
- BoundaryBehaviour.HOLD: 保持首/尾关键帧值
"""
self.base_line = base_value
self.base_interpolation_function = default_interpolation_function
self.boundary_behaviour = boundary_mode
self._keys: List[Keyframe] = []
def __bool__(self) -> bool:
return bool(self._keys) or (self.base_line != 0)
def add_key(
self,
time: float,
value: float,
out_interp: Optional[FittingFunctionType] = None,
in_tangent: Optional[Tuple[float, float]] = None,
out_tangent: Optional[Tuple[float, float]] = None,
use_bezier: bool = False,
):
"""
添加或更新关键帧。
Parameters
----------
time : float
关键帧时间。
value : float
参数值。
out_interp : Optional[Callable]
出插值函数(若 use_bezier=False
in_tangent : Optional[Tuple[float, float]]
入切线偏移 (dt, dv)。dt 通常为负(表示左侧),但存储为绝对偏移。
out_tangent : Optional[Tuple[float, float]]
出切线偏移 (dt, dv)。dt 通常为正。
use_bezier : bool
是否使用贝塞尔插值。
Returns
-------
None
Notes
-----
若时间已存在,更新该关键帧的所有属性。
"""
interp = (
out_interp if out_interp is not None else self.base_interpolation_function
)
new_key = Keyframe(time, value, interp, in_tangent, out_tangent, use_bezier)
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
self._keys[idx] = new_key
else:
self._keys.insert(idx, new_key)
def remove_key(self, time: float):
"""
移除指定时间的关键帧。
Parameters
----------
time : float
要移除的关键帧时间。
Returns
-------
None
"""
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
del self._keys[idx]
def update_key_value(self, time: float, new_value: float):
"""更新关键帧值,保留其他属性。"""
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
k = self._keys[idx]
self._keys[idx] = Keyframe(
time, new_value, k.out_interp, k.in_tangent, k.out_tangent, k.use_bezier
)
def update_key_interp(
self,
time: float,
out_interp: Optional[FittingFunctionType] = None,
in_tangent: Optional[Tuple[float, float]] = None,
out_tangent: Optional[Tuple[float, float]] = None,
use_bezier: bool = False,
):
"""更新关键帧的插值属性。"""
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
k = self._keys[idx]
new_value = k.value
interp = out_interp if out_interp is not None else k.out_interp
self._keys[idx] = Keyframe(
time, new_value, interp, in_tangent, out_tangent, use_bezier
)
def set_key_tangents(
self,
time: float,
in_tangent: Optional[Tuple[float, float]] = None,
out_tangent: Optional[Tuple[float, float]] = None,
use_bezier: bool = True,
):
"""单独设置关键帧的切线,不改变值。"""
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
k = self._keys[idx]
self._keys[idx] = Keyframe(
time,
k.value,
out_interp=k.out_interp,
in_tangent=in_tangent,
out_tangent=out_tangent,
use_bezier=use_bezier,
)
def make_key_smooth(self, time: float):
"""
将关键帧设为“平滑”模式(自动对称切线,并设为贝塞尔模式)。
切线长度基于相邻关键帧的时间和值差。
"""
idx = bisect.bisect_left(self._keys, time, key=lambda k: k.time)
if idx < len(self._keys) and self._keys[idx].time == time:
k = self._keys[idx]
prev_k = self._keys[idx - 1] if idx > 0 else None
next_k = self._keys[idx + 1] if idx + 1 < len(self._keys) else None
# 默认切线长度:时间差的 1/3值差按比例
dt_in = dt_out = 0.1
dv_in = dv_out = 0.0
if prev_k and next_k:
dt_total = next_k.time - prev_k.time
dv_total = next_k.value - prev_k.value
dt_in = dt_out = dt_total / 3.0
dv_in = dv_out = dv_total / 3.0
elif prev_k:
dt_out = (k.time - prev_k.time) / 2.0
dv_out = (k.value - prev_k.value) / 2.0
dt_in = dt_out
dv_in = dv_out
elif next_k:
dt_in = (next_k.time - k.time) / 2.0
dv_in = (next_k.value - k.value) / 2.0
dt_out = dt_in
dv_out = dv_in
self.set_key_tangents(
time,
in_tangent=(-dt_in, -dv_in), # in_tangent 存储为偏移,使用时做减法
out_tangent=(dt_out, dv_out),
use_bezier=True,
)
def _get_boundary_value(self, t: float) -> float:
"""根据 boundary_mode 获取范围外的值。"""
if not self._keys:
return self.base_line
if self.boundary_behaviour == BoundaryBehaviour.CONSTANT:
return self.base_line
elif self.boundary_behaviour == BoundaryBehaviour.HOLD:
if t < self._keys[0].time:
return self._keys[0].value
else:
return self._keys[-1].value
else: # 可能会有别的模式吗?
return self.base_line
def value_at(self, t: float) -> float:
"""
计算时间 t 处的曲线值。
Parameters
----------
t : float
查询时间。
Returns
-------
float
插值结果。
"""
keys = self._keys
if not keys:
return self._get_boundary_value(t)
if t < keys[0].time or t > keys[-1].time:
return self._get_boundary_value(t)
times = [k.time for k in keys]
idx = bisect.bisect_right(times, t) - 1
if idx < 0:
return self._get_boundary_value(t)
if idx >= len(keys) - 1:
return keys[-1].value
k0 = keys[idx]
k1 = keys[idx + 1]
if k0.time == k1.time:
return k0.value
if k0.time == t:
return k0.value
if k1.time == t:
return k1.value
t0, v0 = k0.time, k0.value
t1, v1 = k1.time, k1.value
u = (t - t0) / (t1 - t0)
u = max(0.0, min(1.0, u))
# 贝塞尔模式(高优先级)
if k0.use_bezier or k1.use_bezier:
return _evaluate_bezier_segment(
t0,
v0,
t1,
v1,
out_tangent=k0.out_tangent,
in_tangent=k1.in_tangent, # ← 关键:使用下一帧的 in_tangent
u=u,
)
# 函数插值模式,优先处理阶梯保持模式
elif k0.out_interp is InterpolationMethod.hold:
return v0
interp_func = k0.out_interp or self.base_interpolation_function
v_norm = interp_func(u)
return v0 + v_norm * (v1 - v0)
def __call__(self, t: float) -> float:
return self.value_at(t)
def get_all_keys(self) -> List[Tuple[float, float]]:
"""返回 (time, value) 列表。"""
return [(k.time, k.value) for k in self._keys]
def set_default_interpolation_function(self, interp_func: FittingFunctionType):
"""设置默认插值函数。"""
self.base_interpolation_function = interp_func
def set_boundary_mode(
self, mode: BoundaryBehaviour, base_value: Optional[float] = None
):
"""
设置边界行为。
Parameters
----------
mode : BoundaryBehaviour
边界行为设定
base_value : Optional[float]
当 mode=BoundaryBehaviour.CONSTANT 时,指定新的默认值。
"""
self.boundary_behaviour = mode
if base_value is not None:
self.base_line = base_value
def bake(
self,
start: float,
end: float,
sample_rate: Optional[float] = None,
num_samples: Optional[int] = None,
dtype: Any = None,
) -> "np.ndarray": # type: ignore 这里这样用会报错吗?不知道,但是人工智能这样写了都,大抵是能用的吧
"""
将参数曲线在指定时间范围内烘焙为 NumPy 数组,用于高性能实时查询或音频渲染。
Parameters
----------
start : float
烘焙起始时间(包含)。
end : float
烘焙结束时间(不包含)。
sample_rate : Optional[float]
采样率(单位:样本/时间单位。例如若时间单位为秒sample_rate=48000 表示每秒 48k 样本。
必须与 `num_samples` 二选一提供。
num_samples : Optional[int]
输出数组的总样本数。若提供,则忽略 `sample_rate`。
dtype : Any, optional
输出数组的数据类型(如 np.float32。默认为 np.float64。
Returns
-------
np.ndarray
一维 NumPy 数组,长度为 `num_samples``arr[i] ≈ curve(start + i / sample_rate)`。
Exceptions
----------
ValueError
- 若 `start >= end`
- 若未提供 `sample_rate` 且未提供 `num_samples`
- 若 `num_samples <= 0`
Notes
-----
- 内部使用 `np.linspace` 生成时间轴,然后逐点调用 `self.value_at(t)`。
- 虽然目前是 Python 循环,但对于典型自动化曲线(<1000 关键帧NumPy 向量化优势主要体现在内存布局和后续处理。
- 如需极致性能(如 >1M 样本),可未来优化为 C++/Numba 加速,但当前已满足 DAW 自动化需求。
"""
if start >= end:
raise ValueError("起始值须小于结束值。")
if num_samples is not None:
if num_samples <= 0:
raise ValueError("烘焙的采样数须为非零自然数。")
n = num_samples
elif sample_rate is not None:
if sample_rate <= 0:
raise ValueError("烘焙的采样率须为正值。")
duration = end - start
n = int(ceil(duration * sample_rate))
# 别因为小数数值会产生的问题而越界了来着
if n == 0:
n = 1
else:
raise ValueError("烘焙参数时,须提供采样率或采样数。")
import numpy as np
# 生成对应时间的节点:[start, ..., end - dt]
times = np.linspace(start, end, n, endpoint=False)
# 计算每个时间节点上的参数值
# 我们认为在数字音频工作站的环境里,此值可能最多到 ~1e6 的样子,因此这样 for 一下应当可以接受
# WARNING: 人工智能是这样理解的,如果有问题的话后续可能需要更改
values = np.empty(n, dtype=dtype or np.float64)
for i in range(n):
values[i] = self.value_at(float(times[i]))
return values

View File

@@ -1,424 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 的插件接口与管理相关内容
"""
"""
版权所有 © 2026 金羿
Copyright © 2026 Eilles
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import importlib
from pathlib import Path
from typing import (
Dict,
Any,
Optional,
List,
Tuple,
Union,
Generator,
Set,
Iterable,
Iterator,
TypeVar,
Mapping,
Callable,
)
from itertools import chain
from ._plugin_abc import (
# 枚举类
PluginTypes,
# 抽象基类/数据类(插件参数定义)
PluginConfig,
PluginMetaInformation,
# 抽象基类(插件定义)
MusicInputPluginBase,
TrackInputPluginBase,
MusicOperatePluginBase,
TrackOperatePluginBase,
MusicOutputPluginBase,
TrackOutputPluginBase,
ServicePluginBase,
LibraryPluginBase,
# 顶层插件定义
TopPluginBase,
)
from .exceptions import (
PluginMetainfoNotFoundError,
ParameterTypeError,
PluginInstanceNotFoundError,
PluginRegisteredError,
)
__all__ = [
# 枚举类
"PluginTypes",
# 抽象基类/数据类(插件参数定义)
"PluginConfig",
"PluginMetaInformation",
# 抽象基类(插件定义)
"MusicInputPluginBase",
"TrackInputPluginBase",
"MusicOperatePluginBase",
"TrackOperatePluginBase",
"MusicOutputPluginBase",
"TrackOutputPluginBase",
"ServicePluginBase",
"LibraryPluginBase",
# 插件注册用装饰函数
"music_input_plugin",
"track_input_plugin",
"music_operate_plugin",
"track_operate_plugin",
"music_output_plugin",
"track_output_plugin",
"service_plugin",
"library_plugin",
]
T_IOPlugin = TypeVar(
"T_IOPlugin",
MusicInputPluginBase,
TrackInputPluginBase,
MusicOutputPluginBase,
TrackOutputPluginBase,
)
T_Plugin = TypeVar(
"T_Plugin",
MusicInputPluginBase,
TrackInputPluginBase,
MusicOperatePluginBase,
TrackOperatePluginBase,
MusicOutputPluginBase,
TrackOutputPluginBase,
ServicePluginBase,
LibraryPluginBase,
)
def load_plugin_module(package: Union[Path, str]):
"""自动发现并加载插件包中的插件
参数:
=====
package: Path | str, 可选
插件包路径或名称,当为 Path 类时为路径,为 str 时为包名,切勿混淆。
"""
if isinstance(package, Path):
relative_path = package.resolve().relative_to(Path.cwd().resolve())
if relative_path.stem == "__init__":
return importlib.import_module(".".join(relative_path.parts[:-1]))
else:
return importlib.import_module(
".".join(relative_path.parts[:-1] + (relative_path.stem,))
)
else:
return importlib.import_module(package)
class PluginRegistry:
"""插件注册管理器(注册表)"""
def __init__(self):
self._music_input_plugins: Dict[str, MusicInputPluginBase] = {}
self._track_input_plugins: Dict[str, TrackInputPluginBase] = {}
self._music_operate_plugins: Dict[str, MusicOperatePluginBase] = {}
self._track_operate_plugins: Dict[str, TrackOperatePluginBase] = {}
self._music_output_plugins: Dict[str, MusicOutputPluginBase] = {}
self._track_output_plugins: Dict[str, TrackOutputPluginBase] = {}
self._service_plugins: Dict[str, ServicePluginBase] = {}
self._library_plugins: Dict[str, LibraryPluginBase] = {}
def __iter__(self) -> Iterator[Tuple[PluginTypes, Mapping[str, TopPluginBase]]]:
"""迭代器,返回所有插件"""
return iter(
(
(PluginTypes.FUNCTION_MUSIC_IMPORT, self._music_input_plugins),
(PluginTypes.FUNCTION_TRACK_IMPORT, self._track_input_plugins),
(PluginTypes.FUNCTION_MUSIC_OPERATE, self._music_operate_plugins),
(PluginTypes.FUNCTION_TRACK_OPERATE, self._track_operate_plugins),
(PluginTypes.FUNCTION_MUSIC_EXPORT, self._music_output_plugins),
(PluginTypes.FUNCTION_TRACK_EXPORT, self._track_output_plugins),
(PluginTypes.SERVICE, self._service_plugins),
(PluginTypes.LIBRARY, self._library_plugins),
)
)
@staticmethod
def _register_plugin(cls_dict: dict, plg_class: type, plg_id: str) -> None:
"""注册插件"""
if plg_id in cls_dict:
if cls_dict[plg_id].metainfo.version >= plg_class.metainfo.version:
raise PluginRegisteredError(
"插件惟一识别码`{}`所对应的插件已存在更高版本`{}`,请勿重复注册同一插件!".format(
plg_id, plg_class.metainfo
)
)
cls_dict[plg_id] = plg_class()
def register_music_input_plugin(
self,
plugin_class: type,
plugin_id: str,
) -> None:
"""注册输入插件-整首曲目"""
self._register_plugin(self._music_input_plugins, plugin_class, plugin_id)
def register_track_input_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册输入插件-单个音轨"""
self._register_plugin(self._track_input_plugins, plugin_class, plugin_id)
def register_music_operate_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册曲目处理插件"""
self._register_plugin(self._music_operate_plugins, plugin_class, plugin_id)
def register_track_operate_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册音轨处理插件"""
self._register_plugin(self._track_operate_plugins, plugin_class, plugin_id)
def register_music_output_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册输出插件-整首曲目"""
self._register_plugin(self._music_output_plugins, plugin_class, plugin_id)
def register_track_output_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册输出插件-单个音轨"""
self._register_plugin(self._track_output_plugins, plugin_class, plugin_id)
def register_service_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册服务插件"""
self._register_plugin(self._service_plugins, plugin_class, plugin_id)
def register_library_plugin(self, plugin_class: type, plugin_id: str) -> None:
"""注册支持库插件"""
self._register_plugin(self._library_plugins, plugin_class, plugin_id)
@staticmethod
def _get_io_plugin_by_format(
plugin_regdict: Dict[str, T_IOPlugin], fpath_or_format: Union[Path, str]
) -> Generator[T_IOPlugin, None, None]:
if isinstance(fpath_or_format, str):
return (
plugin
for plugin in plugin_regdict.values()
if plugin.can_handle_format(fpath_or_format)
)
elif isinstance(fpath_or_format, Path):
return (
plugin
for plugin in plugin_regdict.values()
if plugin.can_handle_file(fpath_or_format)
)
else:
raise ParameterTypeError(
"用于指定“导入全曲的数据之类型”的参数,其类型须为`Path`路径或字符串,而非`{}`类型的`{}`值".format(
type(fpath_or_format), fpath_or_format
)
)
def get_music_input_plugin_by_format(
self, filepath_or_format: Union[Path, str]
) -> Generator[MusicInputPluginBase, None, None]:
"""通过指定输入的文件或格式,以获取对应的全曲导入用插件"""
return self._get_io_plugin_by_format(
self._music_input_plugins, filepath_or_format
)
def get_track_input_plugin_by_format(
self, filepath_or_format: Union[Path, str]
) -> Generator[TrackInputPluginBase, None, None]:
"""通过指定输入的文件或格式,以获取对应的单音轨导入用插件"""
return self._get_io_plugin_by_format(
self._track_input_plugins, filepath_or_format
)
def get_music_output_plugin_by_format(
self, filepath_or_format: Union[Path, str]
) -> Generator[MusicOutputPluginBase, None, None]:
"""通过指定输出的文件或格式,以获取对应的导出全曲用插件"""
return self._get_io_plugin_by_format(
self._music_output_plugins, filepath_or_format
)
def get_track_output_plugin_by_format(
self, filepath_or_format: Union[Path, str]
) -> Generator[TrackOutputPluginBase, None, None]:
"""通过指定输出的文件或格式,以获取对应的导出单个音轨用插件"""
return self._get_io_plugin_by_format(
self._track_output_plugins, filepath_or_format
)
def _get_plugin_by_name(
self,
plugin_regdict: Mapping[str, T_Plugin],
plugin_name: str,
plugin_usage: str = "",
) -> T_Plugin:
"""通过指定名称,以获取对应的插件,当名称重叠时,取版本号最大的"""
try:
return max(
[
plugin
for plugin in plugin_regdict.values()
if plugin.metainfo.name == plugin_name
],
key=lambda plugin: plugin.metainfo.version,
)
except ValueError:
raise PluginInstanceNotFoundError(
"未找到“用于{}、名为`{}`”的插件".format(plugin_usage, plugin_name)
)
def get_music_input_plugin(self, plugin_name: str) -> MusicInputPluginBase:
"""获取指定名称的全曲导入用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._music_input_plugins, plugin_name, "导入全曲"
)
def get_track_input_plugin(self, plugin_name: str) -> TrackInputPluginBase:
"""获取指定名称的单音轨导入用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._track_input_plugins, plugin_name, "导入单轨"
)
def get_music_operate_plugin(self, plugin_name: str) -> MusicOperatePluginBase:
"""获取指定名称的全曲处理用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._music_operate_plugins, plugin_name, "处理整个曲目"
)
def get_track_operate_plugin(self, plugin_name: str) -> TrackOperatePluginBase:
"""获取指定名称的单音轨处理用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._track_operate_plugins, plugin_name, "处理单个音轨"
)
def get_music_output_plugin(self, plugin_name: str) -> MusicOutputPluginBase:
"""获取指定名称的导出全曲用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._music_output_plugins, plugin_name, "导出完整曲目"
)
def get_track_output_plugin(self, plugin_name: str) -> TrackOutputPluginBase:
"""获取指定名称的导出单音轨用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(
self._track_output_plugins, plugin_name, "导出单个音轨"
)
def get_service_plugin(self, plugin_name: str) -> ServicePluginBase:
"""获取服务用插件,当名称重叠时,取版本号最大的"""
return self._get_plugin_by_name(self._service_plugins, plugin_name, "提供服务")
def get_library_plugin(self, plugin_name: str) -> LibraryPluginBase:
"""获取依赖库类插件,当名称重叠时,取版本号最高的"""
return self._get_plugin_by_name(
self._library_plugins, plugin_name, "作为依赖库"
)
def supported_input_formats(self) -> Set[str]:
"""所有支持的导入格式"""
return set(
chain.from_iterable(
plugin.supported_formats
for plugin in chain(
self._music_input_plugins.values(),
self._track_input_plugins.values(),
)
)
)
def supported_output_formats(self) -> Set[str]:
"""所有支持的导出格式"""
return set(
chain.from_iterable(
plugin.supported_formats
for plugin in chain(
self._music_output_plugins.values(),
self._track_output_plugins.values(),
)
)
)
_global_plugin_registry = PluginRegistry()
"""全局插件注册表实例"""
def __plugin_regist_decorator(plg_id: str, rgst_func: Callable[[type, str], None]):
def decorator(cls):
global _global_plugin_registry
cls.id = plg_id
rgst_func(cls, plg_id)
return cls
return decorator
def music_input_plugin(plugin_id: str):
"""全曲输入用插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_music_input_plugin
)
def track_input_plugin(plugin_id: str):
"""单轨输入用插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_track_input_plugin
)
def music_operate_plugin(plugin_id: str):
"""全曲处理用插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_music_operate_plugin
)
def track_operate_plugin(plugin_id: str):
"""音轨处理插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_track_operate_plugin
)
def music_output_plugin(plugin_id: str):
"""乐曲输出用插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_music_output_plugin
)
def track_output_plugin(plugin_id: str):
"""音轨输出用插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_track_output_plugin
)
def service_plugin(plugin_id: str):
"""服务插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_service_plugin
)
def library_plugin(plugin_id: str):
"""支持库插件装饰器"""
return __plugin_regist_decorator(
plugin_id, _global_plugin_registry.register_library_plugin
)

View File

@@ -1,25 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储 音·创 v3 定义的一些数据类型,可以用于类型检查器
"""
"""
版权所有 © 2026 金羿 & 玉衡Alioth
Copyright © 2026 Eilles & YuhengAlioth
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from typing import Callable, Dict, List, Literal, Mapping, Tuple, Union
FittingFunctionType = Callable[[float], float]
"""
拟合函数类型
"""

532
PySide6-Pkg.ui Normal file
View File

@@ -0,0 +1,532 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<widget class="QWidget" name="verticalLayoutWidget">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>951</width>
<height>611</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTabWidget" name="tabO">
<property name="currentIndex">
<number>1</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Tab 1</string>
</attribute>
<widget class="QWidget" name="verticalLayoutWidget_2">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>881</width>
<height>591</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QTableWidget" name="tableWidget"/>
</item>
</layout>
</widget>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Tab 2</string>
</attribute>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>10</x>
<y>10</y>
<width>71</width>
<height>16</height>
</rect>
</property>
<property name="text">
<string>TextLabel</string>
</property>
</widget>
<widget class="QWidget" name="widget" native="true">
<property name="geometry">
<rect>
<x>0</x>
<y>30</y>
<width>281</width>
<height>131</height>
</rect>
</property>
<widget class="QWidget" name="verticalLayoutWidget_3">
<property name="geometry">
<rect>
<x>10</x>
<y>0</y>
<width>271</width>
<height>131</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_7">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_6">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QWidget" name="widget_2" native="true">
<property name="geometry">
<rect>
<x>280</x>
<y>30</y>
<width>281</width>
<height>131</height>
</rect>
</property>
<widget class="QWidget" name="verticalLayoutWidget_4">
<property name="geometry">
<rect>
<x>10</x>
<y>0</y>
<width>271</width>
<height>131</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QLabel" name="label_9">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_8">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_10">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_12">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_13">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_11">
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QWidget" name="widget_3" native="true">
<property name="geometry">
<rect>
<x>10</x>
<y>160</y>
<width>781</width>
<height>191</height>
</rect>
</property>
<widget class="QWidget" name="verticalLayoutWidget_5">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>781</width>
<height>191</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label_14">
<property name="text">
<string>默认保存路径:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBox"/>
</item>
<item>
<widget class="QToolButton" name="toolButton">
<property name="text">
<string>...</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QLabel" name="label_15">
<property name="text">
<string>速度倍率</string>
</property>
</widget>
</item>
<item>
<widget class="QSlider" name="horizontalSlider">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QLabel" name="label_17">
<property name="text">
<string>音量倍率</string>
</property>
</widget>
</item>
<item>
<widget class="QSlider" name="horizontalSlider_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_9">
<item>
<widget class="QLabel" name="label_21">
<property name="text">
<string>最大指令生成高度</string>
</property>
</widget>
</item>
<item>
<widget class="QSpinBox" name="spinBox"/>
</item>
</layout>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_16">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_13">
<item>
<widget class="QLabel" name="label_24">
<property name="text">
<string>选择器模式</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBox_3"/>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="label_18">
<property name="text">
<string>计分板名称</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="textEdit">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_8">
<item>
<widget class="QLabel" name="label_20">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
<property name="text">
<string>玩家选择器</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="textEdit_2">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<item>
<widget class="QLabel" name="label_19">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
<property name="text">
<string>bdx作者名称</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="textEdit">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_11">
<item>
<widget class="QCheckBox" name="checkBox_2">
<property name="text">
<string>是否启用进度条</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="checkBox">
<property name="text">
<string>是否自定义进度条</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_22">
<property name="text">
<string>自定义进度条内容:</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="textEdit_3">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>22</height>
</size>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_18"/>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_12">
<item>
<widget class="QLabel" name="label_23">
<property name="maximumSize">
<size>
<width>120</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>选择命令格式版本</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBox_2">
<property name="maximumSize">
<size>
<width>200</width>
<height>16777215</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_14">
<item>
<widget class="QLabel" name="label_25">
<property name="text">
<string>选择转换算法版本</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBox_4"/>
</item>
</layout>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_15">
<item>
<widget class="QLabel" name="label_26">
<property name="text">
<string>选择导出模式</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="comboBox_5"/>
</item>
</layout>
</item>
</layout>
</widget>
</widget>
</widget>
<widget class="QWidget" name="tab_3">
<attribute name="title">
<string>页</string>
</attribute>
</widget>
<widget class="QWidget" name="tab_4">
<attribute name="title">
<string>页</string>
</attribute>
</widget>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QMenuBar" name="menubar">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>26</height>
</rect>
</property>
<widget class="QMenu" name="menu">
<property name="title">
<string>文件</string>
</property>
<addaction name="action"/>
<addaction name="action_Input"/>
</widget>
<addaction name="menu"/>
</widget>
<widget class="QStatusBar" name="statusbar"/>
<action name="action">
<property name="icon">
<iconset theme="document-open">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>打开 Open</string>
</property>
</action>
<action name="action_Input">
<property name="text">
<string>导入 Input</string>
</property>
</action>
</widget>
<resources/>
<connections/>
</ui>

169
README.md
View File

@@ -1,136 +1,79 @@
[Bilibili: 金羿ELS]: https://img.shields.io/badge/Bilibili-%E9%87%91%E7%BE%BFELS-00A1E7?style=for-the-badge
[Bilibili: 玉衡Alioth]: https://img.shields.io/badge/Bilibili-%E7%8E%89%E8%A1%A1Alioth-00A1E7?style=for-the-badge
[CodeStyle: black]: https://img.shields.io/badge/code%20style-black-121110.svg?style=for-the-badge
[python]: https://img.shields.io/badge/python-3.8-AB70FF?style=for-the-badge
[release]: https://img.shields.io/github/v/release/EillesWan/Musicreater?style=for-the-badge
[license]: https://img.shields.io/badge/Licence-%E6%B1%89%E9%92%B0%E5%BE%8B%E8%AE%B8%E5%8F%AF%E5%8D%8F%E8%AE%AE-228B22?style=for-the-badge
<h1 align="center">音·创 Musicreater</h1>
<h1 align="center">音·创 Musicreater </h1>
<h2 align="center">库版 Package Version</h2>
<p align="center">
<img width="128" height="128" src="https://gitee.com/TriM-Organization/Musicreater/raw/master/resources/msctIcon.png">
</img>
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
<h3 align="center">一款免费开源的《我的世界》数字音频支持库。</h3>
<p align="center">
<img src="https://img.shields.io/badge/BUILD%20WITH%20LOVE-FF3432?style=for-the-badge">
<a href='https://gitee.com/TriM-Organization/Musicreater'>
<img align="right" src='https://gitee.com/TriM-Organization/Musicreater/widgets/widget_1.svg' alt='Fork me on Gitee'>
</img>
</a>
<img src="https://forthebadge.com/images/badges/built-with-love.svg">
<p>
[![][Bilibili: 金羿ELS]](https://space.bilibili.com/397369002/)
[![][Bilibili: 玉衡Alioth]](https://space.bilibili.com/604072474)
[![][Bilibili: 凌云金羿]](https://space.bilibili.com/397369002/)
[![][Bilibili: 诸葛亮与八卦阵]](https://space.bilibili.com/604072474)
[![CodeStyle: black]](https://github.com/psf/black)
[![][python]](https://www.python.org/)
[![][license]](LICENSE)
[![][release]](../../releases)
[![GiteeStar](https://gitee.com/TriM-Organization/Musicreater/badge/star.svg?theme=gray)](https://gitee.com/TriM-Organization/Musicreater/stargazers)
[![GiteeFork](https://gitee.com/TriM-Organization/Musicreater/badge/fork.svg?theme=gray)](https://gitee.com/TriM-Organization/Musicreater/members)
[![GitHub Repo stars](https://img.shields.io/github/stars/TriM-Organization/Musicreater?color=white&logo=GitHub&style=plastic)](https://github.com/TriM-Organization/Musicreater/stargazers)
[![GitHub Repo Forks](https://img.shields.io/github/forks/TriM-Organization/Musicreater?color=white&logo=GitHub&style=plastic)](https://github.com/TriM-Organization/Musicreater/forks)
简体中文🇨🇳 | [English🇬🇧](README_EN.md)
## 介绍 🚀
## **嘿伙计,你是不是来错地儿了,这里还在开发,注意选对版本!**
音·创 是一款免费开源的针对 **《我的世界》** 音乐的支持库
## 介绍🚀
音·创 Musicreater 是一款免费开源的 **《我的世界:基岩版》** 音乐制作软件
音·创 库版 (Musicreater Package Version) 是一款免费开源的针对 **《我的世界:基岩版》** 的midi音乐转换库
欢迎加群:[861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)
> **注意** 本仓库内的项目仅仅是支持库,其用户为基岩版音乐相关软件的开发者
**此分支为音·创的包版本即便于其他软件使用的可被import版本**
### **看这看这!看这看这!看这看这!教程:[教程链接](./docs/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)**
## 软件作者✒
金羿 Eilles我的世界基岩版指令师个人开发者B站不知名UP主江西在校高中生。
诸葛亮与八卦阵 bgArray我的世界基岩版玩家喜欢编程和音乐深圳初二学生。
## 致谢🙏
- 感谢 **昀梦**\<QQ1515399885\> 找出指令生成错误bug并指正
- 感谢由 **Charlie_Ping “查理平”** 带来的bdx文件转换参考
以及mid转我的世界乐器参考表格
- 感谢由 **CMA_2401PT** 为我们的软件开发进行指导
- 感谢由 **Dislink Sforza “断联·斯福尔扎”**\<QQ1600515314\>带来的midi音色解析以及转换指令的算法我们将其改编并应用同时感谢他的[网页版转换器](https://dislink.github.io/midi2bdx/)给我们的开发与更新带来巨大的压力和动力,让我们在原本一骑绝尘的摸鱼道路上转向开发
- 感谢 **Touch “偷吃”**\<QQ1793537164\>提供的测试支持,并对程序的改进提供了丰富的意见;同时也感谢他的不断尝试新的内容,使我们的排错更进一步
- 感谢 **Mono**\<QQ738893087\>反馈安装时的问题
- 感谢 **Ammelia** 敦促我们进行新的功能开发,并为新功能提出了非常优秀的大量建议
> 感谢广大群友为此程序提供的测试等支持
>
> 面向常规用户的 **基岩版音乐转换工具** 请参阅:[伶伦转换器](../../../Linglun-Converter)
>
> 我们也正在开发面向高级用户的 **基岩版音乐编辑工具**(数字音频工作站):[伶伦](../../../LinglunStudio)
> 若您对我们有所贡献但您的名字没有显示在此列表中,请联系我!
## 联系我们📞
### 作者\<*金羿*\>(Eilles)联系方式
1. QQ 2647547478
2. 电邮 EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
3. 微信 WYI_DoctorYI
4. Telegram [@EillesWan](https://t.me/EillesWan)
### 作者\<*诸葛亮与八卦阵*\>(bgArray)联系方式
1. QQ 4740437765
## 安装 🔳
- 使用 pypi
```bash
pip install --upgrade Musicreater
```
- 如果无法更新最新,可以尝试:
```bash
pip install --upgrade -i https://pypi.python.org/simple Musicreater
```
- 克隆仓库并安装(最新内容但**不推荐**
```bash
git clone https://gitee.com/TriM-Organization/Musicreater.git
cd Musicreater
python setup.py install
```
以上命令中 `python`、`pip` 请依照各个环境不同灵活更换,可能为`python3`或`pip3`之类。
## 文档 📄
[生成文件的使用](./docs/%E7%94%9F%E6%88%90%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)
[仓库 API 文档](./docs/%E5%BA%93%E7%9A%84%E7%94%9F%E6%88%90%E4%B8%8E%E5%8A%9F%E8%83%BD%E6%96%87%E6%A1%A3.md)
## 作者 ✒
**金羿 Eilles**我的世界基岩版指令作者个人开发者B 站不知名 UP 主。
**玉衡Alioth Alioth**:我的世界基岩版玩家,喜欢编程和音乐,学生。
**偷吃不是Touch Touch**:我的世界基岩版指令制作者,提供测试支持
## 致谢 🙏
本致谢列表排名无顺序。
- 感谢 **昀梦**\<QQ1515399885\> 找出指令生成错误 bug 并指正
- 感谢由 **Charlie_Ping “查理平”** 带来的 BDX 文件转换参考,以及 MIDI-我的世界对应乐器 参考表格
- 感谢由 **[CMA_2401PT](https://github.com/CMA2401PT)** 为我们的软件开发的一些方面进行指导,同时我们参考了他的 BDXworkshop 作为 BDX 结构编辑的参考
- 感谢由 **[Dislink Sforza](https://github.com/Dislink) “断联·斯福尔扎”**\<QQ1600515314\> 带来的 midi 音色解析以及转换指令的算法,我们将其改编并应用;同时,感谢他的[网页版转换器](https://dislink.github.io/midi2bdx/)给我们的开发与更新带来巨大的压力和动力,让我们在原本一骑绝尘的摸鱼道路上转向开发。
- 感谢 **Mono**\<QQ738893087\> 反馈安装时的问题,辅助我们找到了视窗操作系统下的兼容性问题;感谢其反馈延迟播放器出现的重大问题,让我们得以修改全部延迟播放错误;尤其感谢他对于我们的软件的大力宣传
- 感谢 **Ammelia “艾米利亚”**\<QQ2838334637\> 敦促我们进行新的功能开发,并为新功能提出了非常优秀的大量建议,以及提供的 BDX 导入测试支持,为我们的新结构生成算法提供了大量的实际理论支持
- 感谢 **[神羽 “SnowyKami”](https://www.sfkm.me/)** 对我们项目的支持与宣传,非常感谢他为我们提供的服务器!
- 感谢 **指令师\_苦力怕 playjuice123**\<QQ240667197\> 为我们的程序找出错误,并提醒我们修复一个一直存在的大 bug。
- 感谢 **雷霆**\<QQ3555268519\> 用他那令所有开发者都大为光火的操作方法为我们的程序找出错误,并提醒修复 bug。
- 感谢 **小埋**\<QQ2039310975\> 反馈附加包生成时缺少描述和标题的问题。
- <table><tr><td>感谢 **油炸**&lt;QQ2836146704&gt; 激励我们不断开发新的内容。</td><td><img height="50" src="https://foruda.gitee.com/images/1695478907647543027/08ea9909_9911226.jpeg"></td></tr></table>
- 感谢 **雨**\<QQ237667809\> 反馈在新版本的指令格式下,计分板播放器的附加包无法播放的问题。
- 感谢 **梦幻duang**\<QQ13753593\> 为我们提供 Java 1.12.2 版本命令格式参考。
- 感谢 [_Open Note Block Studio_](https://github.com/OpenNBS/NoteBlockStudio) 项目的开发为我们提供持续的追赶动力。
> 感谢广大群友为此库提供的测试和建议等
> 若您对我们有所贡献但您的名字没有出现在此列表中,请联系我们!
## 联系 📞
若遇到库中的问题,欢迎在[](https://gitee.com/TriM-Organization/Musicreater/issues/new)提出你的 issue。
如果需要与开发组进行交流,欢迎加入我们的[开发闲聊 Q 群](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)。
亦可以联系我们[睿乐组织官方邮箱](mailto:TriM-Organization@hotmail.com),取得进一步联系!
---
此项目并非一个官方 《我的世界》_Minecraft_项目
此项目不隶属或关联于 Mojang Studios 或 微软
此项目亦不隶属或关联于 网易
“Minecraft”是 Mojang Synergies AB 的商标此项目中所有对于“我的世界”、“Minecraft”等相关称呼均为必要的介绍性使用
- 上文提及的 网易 公司,指代的是在中国大陆运营《我的世界:中国版》的上海网之易璀璨网络科技有限公司
NOT AN OFFICIAL MINECRAFT PRODUCT.
NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT.
NOT APPROVED BY OR ASSOCIATED WITH NETEASE.
[Bilibili: 凌云金羿]: https://img.shields.io/badge/Bilibili-%E5%87%8C%E4%BA%91%E9%87%91%E7%BE%BF-00A1E7?style=for-the-badge
[Bilibili: 诸葛亮与八卦阵]: https://img.shields.io/badge/Bilibili-%E8%AF%B8%E8%91%9B%E4%BA%AE%E4%B8%8E%E5%85%AB%E5%8D%A6%E9%98%B5-00A1E7?style=for-the-badge
[CodeStyle: black]: https://img.shields.io/badge/code%20style-black-121110.svg?style=for-the-badge
[python]: https://img.shields.io/badge/python-3.6-AB70FF?style=for-the-badge
[release]: https://img.shields.io/github/v/release/EillesWan/Musicreater?style=for-the-badge
[license]: https://img.shields.io/badge/Licence-Apache-228B22?style=for-the-badge

View File

@@ -1,138 +1,74 @@
[Bilibili: Eilles]: https://img.shields.io/badge/Bilibili-%E9%87%91%E7%BE%BFEilles-00A1E7?style=for-the-badge
[Bilibili: Alioth]: https://img.shields.io/badge/Bilibili-%E7%8E%89%E8%A1%A1Alioth-00A1E7?style=for-the-badge
[CodeStyle: black]: https://img.shields.io/badge/code%20style-black-121110.svg?style=for-the-badge
[python]: https://img.shields.io/badge/python-3.8-AB70FF?style=for-the-badge
[release]: https://img.shields.io/github/v/release/EillesWan/Musicreater?style=for-the-badge
[license]: https://img.shields.io/badge/Licence-%E6%B1%89%E9%92%B0%E5%BE%8B%E8%AE%B8%E5%8F%AF%E5%8D%8F%E8%AE%AE-228B22?style=for-the-badge
<h1 align="center">
音·创 Musicreater
</h1>
<h1 align="center">音·创 Musicreater</h1>
<p align="center">
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</img>
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
<h3 align="center">A free and open-source library for handling with <i>Minecraft</i> digital music.</h3>
<p align="center">
<img src="https://img.shields.io/badge/BUILD%20WITH%20LOVE-FF3432?style=for-the-badge">
</img>
<img src="https://forthebadge.com/images/badges/built-with-love.svg">
<p>
[![][Bilibili: Eilles]](https://space.bilibili.com/397369002/)
[![][Bilibili: Alioth]](https://space.bilibili.com/604072474)
[![][Bilibili: bgArray]](https://space.bilibili.com/604072474)
[![CodeStyle: black]](https://github.com/psf/black)
[![][python]](https://www.python.org/)
![][python]
[![][license]](LICENSE)
[![][release]](../../releases)
[![GiteeStar](https://gitee.com/TriM-Organization/Musicreater/badge/star.svg?theme=gray)](https://gitee.com/TriM-Organization/Musicreater/stargazers)
[![GiteeFork](https://gitee.com/TriM-Organization/Musicreater/badge/fork.svg?theme=gray)](https://gitee.com/TriM-Organization/Musicreater/members)
[![GitHub Repo stars](https://img.shields.io/github/stars/TriM-Organization/Musicreater?color=white&logo=GitHub&style=plastic)](https://github.com/TriM-Organization/Musicreater/stargazers)
[![GitHub Repo Forks](https://img.shields.io/github/forks/TriM-Organization/Musicreater?color=white&logo=GitHub&style=plastic)](https://github.com/TriM-Organization/Musicreater/forks)
[简体中文🇨🇳](README.md) | English🇬🇧
[简体中文 🇨🇳](README.md) | English🇬🇧
**Notice that the localizations of documents may probably NOT be up-to-date. The original document is in Chinese.**
**Notice that the language support of *README* may be a little SLOW.**
## Introduction🚀
Musicreater is a free open-source library used for handling with digital musics that being able to be played in _Minecraft_.
Musicreater(音·创) is a free open source software which is used for making and also creating music in **Minecraft: Bedrock Edition**.
Musicreater pkgver(Package Version 音·创 库版) is a free open source library used for convert midi file into formats that is suitable for **Minecraft: Bedrock Edition**.
Welcome to join our QQ group: [861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)
> **NOTICE** The project inside this repository is only the support library, which is mainly for the developers of music related software for _Minecraft: Bedrock Edition_.
>
> The _Bedrock Edition music convertor_ which is for common users is in [Linglun Converter](../../../Linglun-Converter).
>
> We are also developing a _BE music editor_ (digital audio workstation): [Linglun](../../../LinglunStudio)
### **SEEEEEEEEE Tutorials [HERE](./docs/Use%20of%20Funtions.md)**
### Authors✒
Eilles (金羿)A high school student, individual developer, unfamous BilibiliUPer, which knows a little about commands in *Minecraft: Bedrock Edition*
bgArray "诸葛亮与八卦阵": Fix bugs, improve code aesthetics, add new functions, change data format, etc.
## Installation 🔳
## Thanks🙏
- Via pypi
- Thank *昀梦*\<QQ1515399885\> for finding and correcting the bugs in the commands that *Musicreater* Created.
- Thank *Charlie_Ping “查理平”* for bdx convert function, and
the data label that's used to convert the mid's instruments into minecraft's instruments.
- Thank *CMA_2401PT* for BDXWorkShop as the .bdx structure's operation guide.
- Thank *Dislink Sforza* \<QQ1600515314\> for the algorithm brought to us, his midi analysis algorithm became one of us's best ones
- Thank *Arthur Morgan*\<QQ312280061\> for his/her biggest support for the debugging of Musicreater
- Thank *Touch “偷吃”*\<QQ1793537164\> for support of debugging and testing program and algorithm, as well his/her suggestions to the improvement of our project
- Thank *Mono*\<QQ738893087\> for reporting problems while installing
- Thanks for a lot of groupmates who support me and help me to test the program.
- If you have give me some help but u haven't been in the list, please contact me.
```bash
pip install Musicreater --upgrade
```
## Contact Information📞
- If above command cannot fetch latest version, try:
### Author *Eilles*(金羿)
```bash
pip install -i https://pypi.python.org/simple Musicreater --upgrade
```
1. QQ 2647547478
2. E-mail EillesWan2006@163.com
W-YI_DoctorYI@outlook.com EillesWan@outlook.com
3. WeChat WYI_DoctorYI
4. Telegram [@EillesWan](https://t.me/EillesWan)
- Clone repo and Install (Latest but **NOT RECOMMANDED**):
```bash
git clone https://github.com/TriM-Organization/Musicreater.git
cd Musicreater
python setup.py install
```
### Author *bgArray*(诸葛亮与八卦阵)
Commands such as `python`、`pip` could be changed to some like `python3` or `pip3` according to the difference of platforms.
1. QQ 4740437765
## Documentation 📄
(Not in English yet)
[生成文件的使用](./docs/%E7%94%9F%E6%88%90%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)
[仓库 API 文档](./docs/%E5%BA%93%E7%9A%84%E7%94%9F%E6%88%90%E4%B8%8E%E5%8A%9F%E8%83%BD%E6%96%87%E6%A1%A3.md)
### Authors ✒
**Eilles (金羿)**A student, individual developer, unfamous Bilibili UPer, which knows a little about commands in _Minecraft: Bedrock Edition_
**Alioth (玉衡Alioth)**: A student, player of _Minecraft: Bedrock Edition_, which is a fan of music and programming.
**Touch (偷吃不是 Touch)**: A man who is good at using command(s) in _Minecraft: Bedrock Edition_, who supported us of debugging and testing program and algorithm
## Acknowledgements 🙏
This list is not in any order.
- Thank _昀梦_\<QQ1515399885\> for finding and correcting the bugs in the commands that _Musicreater_ generated.
- Thank _Charlie_Ping “查理平”_ for the bdx convert function for reference, and the reference chart that's used to convert the mid's instruments into Minecraft's instruments.
- Thank _[CMA_2401PT](https://github.com/CMA2401PT)_ for BDXWorkShop for reference of the .bdx structure's operation, and his guidance in some aspects of our development.
- Thank _[Dislink Sforza](https://github.com/Dislink) “断联·斯福尔扎”_ \<QQ1600515314\> for his midi analysis algorithm brought to us, we had adapted it and made it applied in one of our working method; Also, thank him for the [WebConvertor](https://dislink.github.io/midi2bdx/) which brought us so much pressure and power to develop as well as update our projects better, instead of loaf on our project.
- Thank _Mono_\<QQ738893087\> for reporting problems while installing
- Thank _Ammelia “艾米利亚”_\<QQ2838334637\> for urging us to develop new functions, and put forward a lot of excellent suggestions for new functions, as well as the BDX file's importing test support provided, which has given a lot of practical theoretical support for our new Structure Generating Algorithm
- Thank _[神羽](https://gitee.com/snowykami) “[SnowyKami](https://github.com/snowyfirefly)”_ for supporting and promoting our project, and also thanks him for his server which given us to use for free.
- Thank _指令师\_苦力怕 “playjuice123”_\<QQ240667197\> for finding bugs within our code, and noticed us to repair a big problem.
- Thank _雷霆_\<QQ3555268519\> for his annoying and provoking operations which may awake some problems within the program by chance and reminding us to repair.
- Thank _小埋_\<QQ2039310975\> for reporting the empty add-on packs title and description problem.
- <table><tr><td>Thank <i>油炸</i> &lt;QQ2836146704&gt; for inspiring us to constantly develop something new.</td><td><img width="260" src="https://foruda.gitee.com/images/1695478907647543027/08ea9909_9911226.jpeg" alt="The groupmate on the picture was saying that our convert-QQ-bot had once brought him great convinience but now it closed down by some reason so he was feeling regretful." title="&quot;It was once, a convert-QQ-bot is just in front my eyes&quot;&#10;&quot;Until lose, I finally know cannot chase back what I needs&quot;"></td><td><small>&quot;It was once, a convert-QQ-bot is just in front my eyes&quot;<br>&quot;Until lose, I finally know cannot chase back what I needs&quot;</small></td></tr></table>
- Thank _雨_\<QQ237667809\> for give us report that under the new `execute` command format that the scoreboard player's add-on packs cannot play correctly.
- Thank _梦幻duang_\<QQ13753593\> for providing us with his knowlodeg of the command format in Minecraft: Java Edition Version 1.12.2.
- Thank [_Open Note Block Studio_](https://github.com/OpenNBS/NoteBlockStudio)'s Project for giving us the power and energy of continual developing.
> Thanks for the support and help of a lot of groupmates
> If you have given contributions but have not been in the list, please contact us!
## Contact Us 📞
Meet problems? Welcome to give out your issue [here](../../issues/new)!
Want to get in contact of developers? Welcome to join our [Chat QQ group](https://jq.qq.com/?_wv=1027&k=hpeRxrYr).
Or contact us via [TriM-Org Official Email](mailto:TriM-Organization@hotmail.com)!
---
NOT AN OFFICIAL MINECRAFT PRODUCT.
NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT.
NOT APPROVED BY OR ASSOCIATED WITH NETEASE.
此项目并非一个官方 《我的世界》_Minecraft_项目
此项目不隶属或关联于 Mojang Studios 或 微软
此项目亦不隶属或关联于 网易 相关
“Minecraft”是 Mojang Synergies AB 的商标此项目中所有对于“我的世界”、“Minecraft”等相关称呼均为必要的介绍性使用
- 上文提及的 网易 公司,指代的是在中国大陆运营《我的世界:中国版》的上海网之易璀璨网络科技有限公司
[Bilibili: Eilles]: https://img.shields.io/badge/Bilibili-%E5%87%8C%E4%BA%91%E9%87%91%E7%BE%BF-00A1E7?style=for-the-badge
[Bilibili: bgArray]: https://img.shields.io/badge/Bilibili-%E8%AF%B8%E8%91%9B%E4%BA%AE%E4%B8%8E%E5%85%AB%E5%8D%A6%E9%98%B5-00A1E7?style=for-the-badge
[CodeStyle: black]: https://img.shields.io/badge/code%20style-black-121110.svg?style=for-the-badge
[python]: https://img.shields.io/badge/python-3.6-AB70FF?style=for-the-badge
[release]: https://img.shields.io/github/v/release/EillesWan/Musicreater?style=for-the-badge
[license]: https://img.shields.io/badge/Licence-Apache-228B22?style=for-the-badge

View File

@@ -1,48 +0,0 @@
# 任务清单
## 待办事项
- 乐曲文件格式设计
目前想到的是:
1. 使用 `.MCT` 作为项目文件的后缀,然后考虑一下格式是否和之前的 MusicSequence 兼容,如果兼容的话可以照旧用 `.MSQ`,如不的话,可以试试想一个新的后缀名作为数据文件后缀
2. 要求数据文件支持完全流式读入
- 音轨静音处理
当前没有处理
- 优化音轨的存储方式
当前是用列表且每一次变动元素都要重新排序这样消耗太大了需要优化改用最小堆形式heapq
- 移植 v2 功能到内置插件
目前 v2 的功能有很多,都要移植到 v3。
1. 导入 Midi 文件到全曲
2. 导入 Midi 文件到指定轨道
3. 导出到延迟播放器的结构文件MCSTRUCTURE、BDX
4. 导出到延迟播放器的附加包
5. 导出到积分板播放器的以上两种形式
6. 导出到中继器播放器的以上两种形式
7. 在 WebSocket 播放器中播放
8. 导出到支持神羽资源包的以上 7 种形式
9. 对于 Midi 歌词的实验性功能
10. 对于 Java 版本适配的实验性功能
11. 对于听感优化的实验性功能(插值、偏移)
- 测试参数曲线的功能
- 支持导出音符盒构成的音乐
- 支持导出成 schematic 结构
## 讨论
1. [x] 是否应该在插件注册表 PluginRegistry 中采用 `Dict[插件名, 插件对象]` 的形式存储插件?
当前不采用这种方式是认为可以兼容一些极端场景下用户将一堆同名插件放在一起的情况。但是就算是插件放在一起,我们也可以有选择地读入注册表,比如依照版本号只读取最高版本的插件,并不需要全部存储在插件注册表中。所以其实用字典来存储是有利的?吗?
**当前已解决**
引入了插件惟一识别码之后当然是采用 `Dict[插件唯一识别码, 插件对象]` 来存储插件了~之前插件名称的内容是我想得太浅了,我写完所有代码之后才想到插件名称是中文还带空格的任意字符串……
2. 服务插件到底该怎么写?总不能留着一个 PluginType.SERVICE 的插件一直空在那里吧……
3. 插件依赖性的优化。目前没有处理各个插件依赖关系的问题,如果插件之间彼此依赖要怎么做?
我的想法是,这个依赖的处理由调用端来完成。比如我们的 伶伦工作站 是以 音·创 为核心的一个可视化数字音频工作站。
那么应该由伶伦来处理依赖关系并加载之。

View File

@@ -1,22 +0,0 @@
import shutil
import os
from rich.console import Console
from rich.progress import track
console = Console()
def main():
with console.status("寻众迹于 .egg-info 内"):
egg_info: list = []
for file in os.listdir():
if file.endswith(".egg-info"):
egg_info.append(file)
console.print(file)
for file in track(["build", "dist", "logs", *egg_info], description="正删档"):
if os.path.isdir(file) and os.access(file, os.W_OK):
shutil.rmtree(file)
if __name__ == "__main__":
main()

151
demo_convert.py Normal file
View File

@@ -0,0 +1,151 @@
# -*- coding: utf-8 -*-
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 Lisence.md
"""
音·创 库版 MIDI转换展示程序
Musicreater Package Version : Demo for Midi Conversion
Copyright 2023 all the developers of Musicreater
开源相关声明请见 ./Lisence.md
Terms & Conditions: ./Lisence.md
"""
from msctPkgver.main import *
import os
convertion = midiConvert()
while True:
midipath = input('请输入midi文件路径')
if os.path.exists(midipath):
break
else:
print('文件不存在,请重新输入')
outpath = input('请输入输出路径:')
if not os.path.exists(outpath):
os.makedirs(outpath)
while True:
try:
outFormat = int(input('请输入输出格式(0:mcpack|1:BDX结构)'))
if outFormat == 0:
isAutoReset = input('是否自动重置计分板(1|0)')
if isAutoReset != '':
isAutoReset = bool(int(isAutoReset))
while True:
isProgress = input('*进度条[本Demo不支持自定义]')
if isProgress != '':
if isProgress in ('1', 'True'):
isProgress = True
elif isProgress in ('0', 'False'):
isProgress = False
else:
isProgress = isProgress
else:
continue
break
sbname = input('请输入计分板名称:')
volume = input('请输入音量0-1')
if volume != '':
volume = float(volume)
speed = input('请输入速度倍率:')
if speed != '':
speed = float(speed)
elif outFormat == 1:
author = input('请输入作者:')
while True:
isProgress = input('*进度条[本Demo不支持自定义]')
if isProgress != '':
if isProgress in ('1', 'True'):
isProgress = True
elif isProgress in ('0', 'False'):
isProgress = False
else:
isProgress = isProgress
else:
continue
break
maxHeight = input('请输入指令结构最大生成高度:')
if maxHeight != '':
maxHeight = int(maxHeight)
sbname = input('请输入计分板名称:')
volume = input('请输入音量0-1')
if volume != '':
volume = float(volume)
speed = input('请输入速度倍率:')
if speed != '':
speed = float(speed)
isAutoReset = input('是否自动重置计分板(1|0)')
if isAutoReset != '':
isAutoReset = bool(int(isAutoReset))
break
except BaseException:
print('输入错误,请重新输入')
m = 1
'''采用的算法编号'''
if os.path.isdir(midipath):
for i in os.listdir(midipath):
if i.lower().endswith('.mid'):
print(f'正在操作{i}')
convertion.convert(midipath + '/' + i, outpath + '/' + i[:-4])
if outFormat == 0:
print(convertion.tomcpack(
m,
isAutoReset
if isAutoReset != ''
else bool(int(input('是否自动重置计分板(1|0)'))),
isProgress,
sbname if sbname != '' else input('请输入计分板名称:'),
volume if volume != '' else float(input('请输入音量0-1')),
speed if speed != '' else float(input('请输入速度倍率:')),
))
elif outFormat == 1:
print(convertion.toBDXfile(
m,
author if author != '' else input('请输入作者:'),
isProgress,
maxHeight if maxHeight != '' else int(input('请输入指令结构最大生成高度:')),
sbname if sbname != '' else input('请输入计分板名称:'),
volume if volume != '' else float(input('请输入音量0-1')),
speed if speed != '' else float(input('请输入速度倍率:')),
isAutoReset
if isAutoReset != ''
else bool(int(input('是否自动重置计分板(1|0)'))),
))
else:
convertion.convert(midipath, outpath)
if outFormat == 0:
print(convertion.tomcpack(
m,
isAutoReset if isAutoReset != '' else bool(int(input('是否自动重置计分板(1|0)'))),
isProgress,
sbname if sbname != '' else input('请输入计分板名称:'),
volume if volume != '' else float(input('请输入音量0-1')),
speed if speed != '' else float(input('请输入速度倍率:')),
))
elif outFormat == 1:
print(convertion.toBDXfile(
m,
author if author != '' else input('请输入作者:'),
isProgress,
maxHeight if maxHeight != '' else int(input('请输入指令结构最大生成高度:')),
sbname if sbname != '' else input('请输入计分板名称:'),
volume if volume != '' else float(input('请输入音量0-1')),
speed if speed != '' else float(input('请输入速度倍率:')),
isAutoReset if isAutoReset != '' else bool(int(input('是否自动重置计分板(1|0)'))),
))

101
demo_convert_bdx_byDelay.py Normal file
View File

@@ -0,0 +1,101 @@
# -*- coding: utf-8 -*-
# THIS PROGRAM IS ONLY A TEST EXAMPLE
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 Lisence.md
"""
音·创 库版 MIDI转换展示程序
Musicreater Package Version : Demo for Midi Conversion
Copyright 2023 all the developers of Musicreater
开源相关声明请见 ./Lisence.md
Terms & Conditions: ./Lisence.md
"""
from msctPkgver.main import *
convertion = midiConvert()
while True:
midipath = input('请输入midi文件路径')
if os.path.exists(midipath):
break
else:
print('文件不存在,请重新输入')
outpath = input('请输入输出路径:')
if not os.path.exists(outpath):
os.makedirs(outpath)
while True:
try:
authorname = input('请输入作者:')
while True:
isProgress = input('*进度条[本Demo不支持自定义]')
if isProgress != '':
if isProgress in ('1', 'True'):
isProgress = True
elif isProgress in ('0', 'False'):
isProgress = False
else:
isProgress = isProgress
else:
continue
break
volume = input('请输入音量0-1')
if volume != '':
volume = float(volume)
speed = input('请输入速度倍率:')
if speed != '':
speed = float(speed)
player = input('请输入玩家选择器:')
heightmax = input('请输入指令结构最大生成高度:')
if heightmax != '':
heightmax = int(heightmax)
break
except BaseException:
print('输入错误,请重新输入')
def operation(
i,
):
print(f'正在操作{i}')
convertion.convert(midipath + '/' + i, outpath)
convertion.toBDXfile_withDelay(
1,
authorname if authorname != '' else input('请输入作者:'),
isProgress,
heightmax if heightmax != '' else int(input('请输入指令结构最大生成高度:')),
volume if volume != '' else float(input('请输入音量(0-1]')),
speed if speed != '' else float(input('请输入速度倍率:')),
player if player != '' else input('请输入玩家选择器:'),
)
if os.path.isdir(midipath):
import threading
for i in os.listdir(midipath):
if i.lower().endswith('.mid'):
threading.Thread(target=operation, args=(i,)).start()
else:
convertion.convert(midipath, outpath)
convertion.toBDXfile_withDelay(
1,
authorname if authorname != '' else input('请输入作者:'),
isProgress,
heightmax if heightmax != '' else int(input('请输入指令结构最大生成高度:')),
volume if volume != '' else float(input('请输入音量(0-1]')),
speed if speed != '' else float(input('请输入速度倍率:')),
player if player != '' else input('请输入玩家选择器:'),
)

View File

@@ -1,13 +0,0 @@
<h1 align="center">音·创 Musicreater</h1>
<p align="center">
<img width="128" height="128" src="https://gitee.com/TriM-Organization/Musicreater/raw/master/resources/msctIcon.png" >
</p>
**此为开发相关文档,内容包括:库的简单调用、所生成文件结构的详细说明、特殊参数的详细解释**
# [main.py](../Musicreater/main.py)
## [类] MidiConvert
### [类函数] from_midi_file

262
docs/Use of Funtions.md Normal file
View File

@@ -0,0 +1,262 @@
<h1 align="center">音·创 Musicreater</h1>
<p align="center">
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
# Instructions for Using Demo(s)
*This is a tutorial for using the demo(s) of this library, not the Development Guide. If you want to see so, please read Below*
## Under Windows
0. Install Python 3.6+
First of all, you need to install the runtime environment of this library, *Python*. And a Installation Pack maybe the best choice:
> [Downloading Python 64-bit](https://www.python.org/ftp/python/3.8.10/python-3.8.10-amd64.exe)
> [Downloading Python 32-bit](https://www.python.org/ftp/python/3.8.10/python-3.8.10.exe)
While installing, it's better to check `Add Python 3.X to PATH`(just as the screenshot showed below), otherwise it needs to be set manually which may cause some time wasting
<img src=https://foruda.gitee.com/images/1662736520757331846/e38efb81_9911226.png>
If you are new to Python or not very familiar to Computer Programming, and having the disk space in your PC's System Partition (usually C:) of 150 MB, you can directly choose *Install Now*.
However, if you want to do it like a pro, choosing *Customize Installation*, it's a necessary to be sure to check `pip` and `py launcher` will be installed on your computer(see screenshot below). The two options is required for the next step of installing the requirements.
<img src=https://foruda.gitee.com/images/1662736621235871190/2ac3d98f_9911226.png>
After the installation, you can enter in your terminal(CMD/PowerShell/Bash/etc): "python" to ensure whether the installation was successful. If it was, your terminal will show things like below:
<img src=https://foruda.gitee.com/images/1659972669907359295/cmd.png>
1. Installing Requirements
It's better to open your terminal(CMD/PowerShell/Bash/etc) under Administrator Mode.
For example, if you want to use CMD in Administrator Mode, you can search `cmd` in the *Start Menu*, right click it and *Run as Administrator*
<img src="https://foruda.gitee.com/images/1662736878650993886/62487dd8_9911226.png">
Okay, after that, please enter in your terminal:
`pip install mido`
`pip install brotli`
If successful you will see something like below:
<img src="https://foruda.gitee.com/images/1662737676719454287/f61a70f7_9911226.png">
2. Download This Package and Demo(s)
- If you using Git, you can use the following commands to clone this lib:
`git clone -b pkgver https://gitee.com/EillesWan/Musicreater.git`
- If Git is not installed, you can download the zip package from the code page(from [GitHub](https://github.com/EillesWan/Musicreater.git) or [Gitee](https://gitee.com/EillesWan/Musicreater.git)). Or you are a Chinese fan having a QQ account, you can [Join the QQ Group 861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr) and get it from our GroupFiles.
<img src=" https://foruda.gitee.com/images/1659972440341216712/下载.png" >
2. Start Using Demo(s)
Open your terminal in the directory of this, taking CMD, for example, just enter the directory and enter `cmd` in the path box:
<img src=https://foruda.gitee.com/images/1659974437388532868/输入.png>
<img src=https://foruda.gitee.com/images/1659974754378201859/输入c.png>
And enter one of the commands below by choosing what you need:
`python demo_convert.py`
`python demo_convert_bdx_byDelay.py`
### Addition for Error(s) Using or Installing
1. Environment Error of Microsoft Visual C++ Redistributable
If you meet this condition as the screenshot shows:
<img src=https://foruda.gitee.com/images/1659972789779764953/bug.jpeg>
Your MSVC Environment may be not installed, and you can download and install
> [Here of 64-Bit VCREDIST](https://aka.ms/vs/17/release/vc_redist.x64.exe)
> [Here of 32-Bit VCREDIST](https://aka.ms/vs/17/release/vc_redist.x86.exe)
Thank our groupmate *Mono* again for helping finding this problem.
## Under Linux OS
### Install Runtime Environment
0. Install and Verify Python Runtime
Common Linux Releases do include a Python Runtime Environment, what we should do only is to check it is a satisfied version to our program. If the version ≥Python3.6, theoretically our program can be run.
We can type:
```bash
python -V
```
To check the Python version, as the follows
<img src=https://foruda.gitee.com/images/1665120915821957090/429561fd_9911226.png>
- Not Necessary
If you want to change a Python version just as what I want to do, it is such a great fantastic action! Let do as the follows:
- pacman Package ManagerIn Arch Linux Mostly
Let's write python3 into the ingore list of updating. Via `vim` to edit `/etc/pacman.conf`, add `python3` after `IgnorePkg`.
```bash
sudo vim /etc/pacman.conf
```
<img src=https://foruda.gitee.com/images/1665124611490335193/5e99ca26_9911226.png>
Then we can search for python releases in [Arch Achieve](https://archive.archlinux.org/packages/).*HERE, under Arch, Python refers to Python3 defaultly, while some other Linux releases using Python2 as default. So dose Arch Achieve.*What I find here is [Python3.8.6](https://archive.archlinux.org/packages/p/python/python-3.8.6-1-x86_64.pkg.tar.zst), so let's download she via `pacman`:
```bash
sudo pacman -U https://archive.archlinux.org/packages/p/python/python-3.8.6-1-x86_64.pkg.tar.zst
```
<img src=https://foruda.gitee.com/images/1665126362769399903/ea4b9598_9911226.png>
Perfect!
1. Install and Verify pip Package Manager
Before installing, it is to be checked, wheather Python's pip is OK:
```bash
python -m pip # To check is pip installed
# If a long tip occured, it is OK
# If returned as this, then not.
/usr/bin/python: No module named pip
# We can install pip via:
sudo pacman -S python-pip
# Verfy, remember.
python -m pip
# If you did but failed, we should use other methods to install pip:
wget https://bootstrap.pypa.io/get-pip.py
sudo python get-pip.py
# Verfy, must.
python -m pip
```
Over after checking, lets install the dependences.
```bash
pip install mido -i https://mirrors.aliyun.com/pypi/simple/
pip install brotli -i https://mirrors.aliyun.com/pypi/simple/
```
See the tips below as successfully installed
<img src="https://foruda.gitee.com/images/1662737676719454287/f61a70f7_9911226.png">
### Download this sources pack and Using its demos.
1. 使用Git下载本库及其示例代码
```bash
git clone -b pkgver https://gitee.com/EillesWan/Musicreater.git MSCTpkgver
```
当上述命令执行成功,你会在执行此命令的所在位置发现一个名为 `MSCTpkgver` 的文件夹,其中包含的正是我们心心念念下载的本程序和示例代码。
而我们要运行的也正是示例代码,因此,赶快进入下载到的文件夹:
```bash
cd MSCTpkgver
```
1. 开始使用
在目录下打开终端,执行以下命令:(选择你需要的)
```bash
python demo_convert.py
python demo_convert_bdx_byDelay.py
```
2. More Info for Parameters of Our Demo Program(s)
<img src=https://foruda.gitee.com/images/1659974810147043475/运行.png>
|Input Prompt|English Translation|Description|
|----------------|----------------|-------|
|请输入MIDI文件路径|Midi File Path|Path of a .mid file or a directory. While directory entered, our demo will convert all midi(s) in the directory|
|请输入输出路径|Output Path|Where files converted in|
|是否重置计分板|Whether Reset Scoreboard Automatically|Can only be 1 or 0(Recommanded 1)|
|*进度条[注]|Progressbar|Whether to enable Progressbar and customize progressbar style. Type 0 or False to disable, 1 or True to use default style, or type using format taught in follow the Instructions below to customize one you like|
|请输入计分板名称|Scoreboard Name|*Only not byDelay* The name of scoreboard that player using|
|请输入音量|Volume|Only decimal in [0,1],(Recommanded 1)|
|请输入速度倍率|Speed Multiplying Factor|Maybe you want to play it faster(1) or slower(0 1)?|
|请输入玩家选择器|Player Selector|Full Selector including `@x`. E.g: Play for players tagged `Holo`, enter `@a[tag=Holo]` on this parameter|
# Instructions for **Customize Progress Bar**
We have supported the function of making progress bar in *Minecraft*'s music player. And also the method of customize them. So the following instructions are about the parameters of the Progress Bar Customizition.
A Progress Bar, of course, is composed of **changeless** parts and **changable** parts. And the changable parts include texts or *images*(these images are made up of texts, or we can say, character paintings 😁). That is, for *Minecraft*, a changable image in a progress bar is just the "bar" part(which is like a stripe).
We use a string to describe the style of progress bar you need, and it includes many **identifier**s to replace the changable parts.
There are the identifiers:
| Identifier | Changable Part |
|--------------|------------------------------------------------------|
| `%%N` | Music name(file name which is imported into program) |
| `%%s` | Value of scoreboard of now |
| `%^s` | Max value of scoreboard |
| `%%t` | Current playback time |
| `%^t` | Total music time |
| `%%%` | Current playback progress |
| `_` | To be replaced by the *Bar* part of the progress bar |
The `_` is a placeholder to identifying the *bar* part, yeah, just the changable image.
This is an example of **style description string**, and this is also the default style of *Musicreater*'s progress bar.
`▶ %%N [ %%s/%^s %%% __________ %%t|%^t]`
This is a progress bar with only one line, but it is possible if you want to give a multiline parameter into the style description string.
But the string above is only for style identification, but we also need to identifying the changable image's image(just what the bar's look).
A "bar", simply, included 2 parts: *Have Been Played* & *Not Been Played*. So we use a tuple to pass the parameter. It's under a simple format: `(str: played, str: not)`. For example, the default parameter is below:
`('§e=§r', '§7=§r')`
So it's time to combine what I said in one parameter now!
This is a default definder parameter:
`('▶ %%N [ %%s/%^s %%% __________ %%t|%^t]',('§e=§r', '§7=§r'))`
*Tip: To avoid errors, please not to use the identifiers as the other part of your style.*

View File

@@ -0,0 +1,167 @@
## 使用前的准备工作
### 安装终端工具
这里我们选用 **Termux** 作为我们的终端工具来安装这是一个强大的终端模拟器旨在安卓环境下模拟Linux的软件包环境。
1. 下载
下载可以通过 [GitHub源](https://github.com/termux/termux-app/releases) 或者 [F-Droid源](https://f-droid.org/en/packages/com.termux/) ,个人建议选择 F-Droid 源,因为在国内可以访问得到,而 GitHub 源就看运气。
2. 安装
下载*APK*包后直接安装,安装后打开可以看到一个类似这样的界面:
<img height="512" src="https://foruda.gitee.com/images/1665933025120627254/a0479618_9911226.jpeg">
3. 完成
恭喜你,你已经获得了一个极客般流畅地操作你手机的终端工具。
### 安装运行环境
1. 换源
接下来,我们就要来准备安装一下 **Python** 运行环境了,这是运行 **Python** 源代码必要的。
首先,我估计你等不了多久,急得要死,所以我们要让下载速度稍微快一点,先来换个源。在 **Termux** 中,输入以下指令:
```bash
echo "deb https://mirror.mwt.me/termux/main stable main" > /data/data/com.termux/files/usr/etc/apt/sources.list
```
*感谢 天如<QQ 3291691454>为我们带来的简单换源方法。*
- *非必要步骤*:手动编辑换源
如果你闲着没事,非要要手动编辑个文档来换源,那用啥?用普通的编辑器肯定可以,于是我们就让他更普通一点,用**nano**吧!
在 **Termux** 中,输入以下指令:
```bash
export EDITOR=nano
apt edit-sources
```
那么请把看到的如左下图的界面变为右下图吧:
<table><tr>
<td><img src="https://foruda.gitee.com/images/1665933104313107707/41108f03_9911226.jpeg"> </td>
<td><img src="https://foruda.gitee.com/images/1665933122534781330/3887a901_9911226.jpeg"></td>
</tr></table>
- 图片中的文件,最后应该加入的两行为:
```bash
deb https://mirrors.ustc.edu.cn/termux/apt/termux-main/ stable main
deb https://mirrors.tuna.tsinghua.edu.cn/termux/apt/termux-main/ stable main
```
然后键入 `Ctrl`+`S`,再键入 `Ctrl`+`X`,退出`nano`。
在换源之后,你可能会见到类似的提示:
```bash
Your '/data/data/com.termux/files/usr/etc/apt/sources.list' file changed. Please run 'apt-get update'.
```
那就遵循它的指引,输入:
```bash
apt-get update
```
Alright.
2. 安装 **Python**
```bash
apt-get install python3
```
如果遇到提示问是否继续,那就输入`Y`表示是,如左下图,安装成功后,图若右下。
<table><tr>
<td><img src="https://foruda.gitee.com/images/1665933181440420034/7f0fb5fd_9911226.jpeg"></td>
<td><img src="https://foruda.gitee.com/images/1665933238339972260/a9f06f4f_9911226.jpeg"></td>
</tr></table>
接下来,我们来试一试 **Python** 是不是安装成了吧,输入
```bash
python3 -V
```
如果输出了形如 `Python 3.X.X` 的提示,则完成。
3. 安装依赖库
```bash
# 首先换源
pip config set global.index-url http://mirrors.aliyun.com/pypi/simple/
# 然后安装
pip install mido
pip install brotli
```
- 如果出现以下情况,真是死了鬼的,我们要来再搞个设置:
<img height="512" src="https://foruda.gitee.com/images/1665933289612919459/b87b7804_9911226.jpeg">
我们来修改收信任的源设置:
```bash
pip config set global.trusted-host mirrors.aliyun.com/
```
之后再来安装即可
```bash
pip install mido
pip install brotli
```
安装成功后您可能会见到类似下图的提示:
<img src="https://foruda.gitee.com/images/1662737676719454287/f61a70f7_9911226.png">
### 安装下载工具
既然已经有了运行环境,那么我们就需要下载下我们的**音·创库版示例代码**工具,我非常推崇**Git**这种方便快捷好用还能下载仓库的代码管理器,这个世界上你也找不到第二个,所以我们来安装一下:
```bash
pkg install git
```
安装完成后记得测试一下:
<img height="512" src="https://foruda.gitee.com/images/1665933331269483373/9374c85d_9911226.jpeg">
## 本代码库的下载与演示程序的使用
1. 使用Git下载本库及其示例代码
```bash
git clone -b pkgver https://gitee.com/EillesWan/Musicreater.git MSCTpkgver
```
当上述命令执行成功,你会在执行此命令的所在位置发现一个名为 `MSCTpkgver` 的文件夹,其中包含的正是我们心心念念下载的本程序和示例代码。
而我们要运行的也正是示例代码,因此,赶快进入下载到的文件夹:
```bash
cd MSCTpkgver
```
1. 开始使用演示程序
依照你的需要,执行以下命令之一:
```bash
python demo_convert.py #计分板播放器支持mcpack与BDX
python demo_convert_bdx_byDelay.py #延迟播放器仅支持BDX
```
运行成功了,哦耶!
<img height="512" src="https://foruda.gitee.com/images/1665933366784631363/db9f80f6_9911226.jpeg">

View File

@@ -0,0 +1,104 @@
## 运行环境安装
### 检验Python运行环境
0. 一般的Linux发行版都有安装Python环境我们只需要保证其版本即可理论上 ≥Python3.6 都可以运行我们的库
我们可以使用
```bash
python -V
```
来查看 Python 版本,如下
<img src=https://foruda.gitee.com/images/1665120915821957090/429561fd_9911226.png>
1. *非必要环节*:回退版本
如果你跟作者一样,觉得 Python 3.10+ 太难用很烦人的话,那真是皆大欢喜,让我们一起来回退版本吧!
- pacman 包管理器多用于Arch Linux上
1. 让我们先来把 python3 加入忽略升级的列表中,使用`vim`修改`/etc/pacman.conf`,在`IgnorePkg`后加上`python3`
```bash
sudo vim /etc/pacman.conf
```
<img src=https://foruda.gitee.com/images/1665124611490335193/5e99ca26_9911226.png>
2. 然后我们开始从[Arch Achieve](https://archive.archlinux.org/packages/)上找Python的版本列表。*这里说明一下在Arch中Python默认指的是Python3而与其他某些Linux发行版中Python默认指代Python2不同所以在Arch Achieve中也是如此。*)我这里找到的是[Python3.8.6](https://archive.archlinux.org/packages/p/python/python-3.8.6-1-x86_64.pkg.tar.zst),于是我们用`pacman`把她下载下来并安装:
```bash
sudo pacman -U https://archive.archlinux.org/packages/p/python/python-3.8.6-1-x86_64.pkg.tar.zst
```
<img src=https://foruda.gitee.com/images/1665126362769399903/ea4b9598_9911226.png>
3. 完美!
- 其他包管理器
暂无
### 检查并安装pip包管理器依赖
1. 我们在安装依赖库之前应该确认一下Python自带的包管理器pip是否安装到位
```bash
python -m pip # 确认pip是否安装
# 当这个命令输入后有长段提示出现则为已经安装
# 如果返回如下那么则pip尚未安装
/usr/bin/python: No module named pip
# 可以使用如下命令来安装pip
sudo pacman -S python-pip
# 安装完成后记得验证
python -m pip
# 如果还是失败那么就需要用其他工具安装pip
wget https://bootstrap.pypa.io/get-pip.py
sudo python get-pip.py
# 安装完成后一定要验证!!!
python -m pip
```
2. 确认完成之后,我们来安装一下依赖库:
```bash
pip install mido -i https://mirrors.aliyun.com/pypi/simple/
pip install brotli -i https://mirrors.aliyun.com/pypi/simple/
```
3. 安装成功后可能会见到类似下图的提示:
<img src="https://foruda.gitee.com/images/1662737676719454287/f61a70f7_9911226.png">
## 本代码库的下载与使用
1. 使用Git下载本库及其示例代码
```bash
git clone -b pkgver https://gitee.com/EillesWan/Musicreater.git MSCTpkgver
```
当上述命令执行成功,你会在执行此命令的所在位置发现一个名为 `MSCTpkgver` 的文件夹,其中包含的正是我们心心念念下载的本程序和示例代码。
而我们要运行的也正是示例代码,因此,赶快进入下载到的文件夹:
```bash
cd MSCTpkgver
```
1. 开始使用
在目录下打开终端,执行以下命令:(选择你需要的)
```bash
python demo_convert.py #计分板播放器支持mcpack与BDX
python demo_convert_bdx_byDelay.py #延迟播放器仅支持BDX
```

View File

@@ -0,0 +1,89 @@
## 一、运行环境安装
### (一)安装 Python3.6+
1. 首先需要下载Python的安装包最好是 *Python3.8*,因为作者就用的是这个版本
> [下载64位Python安装包](https://www.python.org/ftp/python/3.8.10/python-3.8.10-amd64.exe)
> [下载32位Python安装包](https://www.python.org/ftp/python/3.8.10/python-3.8.10.exe)
2. 在安装时,最好需要勾选 `Add Python 3.X to PATH`,如下图所示,当然,如果您对自己非常自信,您也可以手动设置此项目:
<img src=https://foruda.gitee.com/images/1662736520757331846/e38efb81_9911226.png>
- 若您对Python一知半解或者不怎么了解、并对自己的系统盘通常是C盘有大约150*兆字节*(MB)的信心的话,您可以在安装时直接选择*快速安装*(Install Now)
3. 若您选择了*自定义安装*(Customize Installation),请务必勾选 `pip``py launcher` 便于后续安装依赖,如下图:
<img src=https://foruda.gitee.com/images/1662736621235871190/2ac3d98f_9911226.png>
4. 安装结束之后可以在*终端*(命令行/PowerShell/Bash/etc)中输入python 试试是否安装成功成功安装之后在终端中输入python会显示诸如如下图片的提示
<img src=https://foruda.gitee.com/images/1659972669907359295/cmd.png>
### (二)安装依赖
1. 请以管理员模式打开您的*终端*(命令行/PowerShell/Bash/etc)
例如,命令行,可以如此打开:在*视窗开始菜单*(Windows开始)中搜索 `cmd`, 并以管理员身份运行
<img src="https://foruda.gitee.com/images/1662736878650993886/62487dd8_9911226.png">
2. 打开了终端之后,请在终端中输入以下指令
```bash
pip install mido -i https://mirrors.aliyun.com/pypi/simple/
pip install brotli -i https://mirrors.aliyun.com/pypi/simple/
```
3. 安装成功后您可能会见到类似下图的提示:
<img src="https://foruda.gitee.com/images/1662737676719454287/f61a70f7_9911226.png">
## 二、本工具的下载与使用
0. 下载本代码库以及演示程序
- 若您使用git请直接克隆本仓库
```bash
git clone -b pkgver https://gitee.com/EillesWan/Musicreater.git
```
- 若您不使用git可以在[*码云*(Gitee)](https://gitee.com/EillesWan/Musicreater.git)或[*GitHub*](https://github.com/EillesWan/Musicreater.git)下载zip包或者[加入QQ群聊861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr),在群文件中获取。
<img src="https://foruda.gitee.com/images/1669540786443169766/fabf0acd_9911226.png" >
值得注意的是这张图上有1、2两个数字虽然是手写的但确实是数字表示着要进行的步骤。希望眼尖得能找出我的口头禅的你们能够发现这两个用鼠标手写的数字并在安装时认真地执行。我认为这并不算十分的难移动鼠标并单击大约消耗不了多少卡路里不过我没有进行精确的计算我也不是十分的清楚这个活动对于一个常人来讲有多难但我怀疑它不难。
1. 开始使用
在目录下打开终端。
例如:打开命令行:请进入到目录下,在文件资源管理器的地址框内输入`cmd`
<img src=https://foruda.gitee.com/images/1659974437388532868/输入.png>
<img src=https://foruda.gitee.com/images/1659974754378201859/输入c.png>
执行以下命令:(选择你需要的)
```bash
python demo_convert.py #计分板播放器支持mcpack与BDX
python demo_convert_bdx_byDelay.py #延迟播放器仅支持BDX
```
## 三、安装时错误的补充说明
1. Microsoft Visual C++ Redistributable 环境出错
如果你遇到了类似以下这种情况:
<img src=https://foruda.gitee.com/images/1659972789779764953/bug.jpeg>
请下载最新的VCREDIST安装包可以参照[这个网页](https://docs.microsoft.com/zh-CN/cpp/windows/latest-supported-vc-redist)的说明,也可以在这直接选择你需要的安装包下载:
> [下载64位VCREDIST安装包](https://aka.ms/vs/17/release/vc_redist.x64.exe)
> [下载32位VCREDIST安装包](https://aka.ms/vs/17/release/vc_redist.x86.exe)
感谢群友Mono帮我们发现这个问题。

105
docs/功能使用说明.md Normal file
View File

@@ -0,0 +1,105 @@
<h1 align="center">音·创 Musicreater</h1>
<h2 align="center">库版 Package Version</h2>
<p align="center">
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
# 演示程序使用教程
*由于先前的 **读我文件**(README.md) 过于冗杂,现另辟蹊径来给大家全方位的教程。*
*这是演示程序demo的使用教程将在这里提供演示程序的相应的使用教程*
## 下载与启动教程
### [视窗(Windows)操作系统](./download%26atart/Windows.md)
### [里纽克斯(Linux)操作系统](./download%26atart/Linux.md)
### [安卓(Android)与安卓衍生操作系统](./download%26atart/Android.md)
## 演示程序使用教程
1. 参数说明
<img src=https://foruda.gitee.com/images/1659974810147043475/运行.png>
- midi路径含有mid文件路径、文件名、后缀的完整文件路径或者一个目录demo可接受批量转换。可以使用相对或绝对路径皆可
- 输出路径:输出文件夹的路径,不需要指示文件名
- 是否重置计分板:`1``0`(歌曲放完是否重置,推荐`1`
- 进度条:是否启用进度条,以及自定义进度条样式。输入`0``False`表示不启用进度条,输入`1``True`表示使用默认进度条,其余的输入均表示使用输入的格式作为自定义的进度条样式
若不支持自定义,则仅能输入`0``1`表示“关闭”或“开启”
- 计分板名称:游戏内的计分板名称
- 音量0-1之间的小数含01正常来说推荐`1`
- 速度倍率小数数据其值不可为0一般写`1`
- 玩家选择器:包括 `@x` 在内的全部选择器,即若要选择全部标签为`Holo`的玩家,则需要如此输入:`@a[tag=Holo]`
- 没有报错且在输出路径下找到mcpack或bdx即为生成成功
<img src=https://foruda.gitee.com/images/1659973655881460036/输出.png>
# 其他说明
## 对于 延迟播放器 的说明
问1什么是延迟播放器
答1播放音乐不同的音符之间存在间隔可以用不同的方式实现音符间空白的时间。其一是计分板通过给计分板加分对应分数播放对应的音符就可以间隔到还有就是命令方块自带的延迟这样也可以实现音符间空白。延迟播放器即后者但是因为只能对命令方块写入这样的延迟数据所以仅可以使用包含NBT的结构导出或者直接输出至世界。
问2可不可以不要积分板
答2详见问1切换你所需要的播放器即可。
## 对于 进度条自定义 功能的说明
因为我们提供了可以自动转换进度条的功能,因此在这里给出进度条自定义参数的详细解释。
请注意,并非所有的演示样例程序都支持自定义进度条。
一个进度条,明显地,有**固定部分**和**可变部分**来构成。而可变部分又包括了文字和图形两种(当然,《我的世界》里头的进度条,可变的图形也就是那个“条”了)。这一点你需要了解,因为后文中包含了很多这方面的概念需要你了解。
进度条的自定义功能使用一个字符串来定义自己的样式,其中包含众多**标识符**来表示可变部分。
标识符如下(注意大小写):
| 标识符 | 指定的可变量 |
|---------|----------------|
| `%%N` | 乐曲名(即传入的文件名)|
| `%%s` | 当前计分板值 |
| `%^s` | 计分板最大值 |
| `%%t` | 当前播放时间 |
| `%^t` | 曲目总时长 |
| `%%%` | 当前进度比率 |
| `_` | 用以表示进度条占位|
表示进度条占位的 `_` 是用来标识你的进度条的。也就是可变部分的唯一的图形部分。
**样式定义字符串**的样例如下,这也是默认的进度条的样式:
`▶ %%N [ %%s/%^s %%% __________ %%t|%^t]`
这是单独一行的进度条,当然你也可以制作多行的,如果是一行的,输出时所使用的指令便是 `title`,而如果是多行的话,输出就会用 `titleraw` 作为进度条字幕。
哦对了,上面的只不过是样式定义,同时还需要定义的是可变图形的部分,也就是进度条上那个真正的“条”。
对于这个我们就采用了固定参数的方法,对于一个进度条,无非就是“已经播放过的”和“没播放过的”两种形态,所以,使用一个元组来传入这两个参数就是最简单的了。元组的格式也很简单:`(str: 播放过的部分长啥样, str: 没播放过的部分长啥样)` 。例如,我们默认的进度“条”的定义是这样的:
`('§e=§r', '§7=§r')`
综合起来,把这些参数传给函数需要一个参数整合,你猜用的啥?啊对对对,我用的还是元组!
我们的默认定义参数如下:
`(r'▶ %%N [ %%s/%^s %%% __________ %%t|%^t]',('§e=§r', '§7=§r'))`
*对了!为了避免生成错误,请尽量避免使用标识符作为定义样式字符串的其他部分*

View File

@@ -1,315 +0,0 @@
<h1 align="center">音·创 Musicreater</h1>
<p align="center">
<img width="128" height="128" src="https://gitee.com/TriM-Organization/Musicreater/raw/master/resources/msctIcon.png" >
</p>
**此为开发相关文档,内容包括:库的简单调用、所生成文件结构的详细说明、特殊参数的详细解释**
# 库的简单调用
参见[example.py的相关部分](../example.py)使用此库进行MIDI转换非常简单。
- 在导入转换库后,使用 MidiConvert 类建立转换对象读取Midi文件
音·创库支持新旧两种execute语法需要在对象实例化时指定
```python
# 导入音·创库
import Musicreater
# 指定是否使用旧的execute指令语法即1.18及以前的《我的世界:基岩版》语法)
old_execute_format = False
# 可以通过文件地址自动读取
cvt_mid = Musicreater.MidiConvert.from_midi_file(
"Midi文件地址",
old_exe_format=old_execute_format
)
# 也可以导入Mido对象
cvt_mid = Musicreater.MidiConvert(
mido.MidiFile("Midi文件地址"),
"音乐名称",
old_exe_format=old_execute_format
)
```
- 获取 Midi 音乐经转换后的播放指令
```python
# 通过函数 to_command_list_in_score, to_command_list_in_delay
# 分别可以得到
# 以计分板作为播放器的指令对象列表、以延迟作为播放器的指令对象列表
# 数据不仅存储在对象本身内,也会以返回值的形式返回,详见代码内文档
# 使用 to_command_list_in_score 函数进行转换之后,返回值有三个
# 值得注意的是第一个返回值返回的是依照midi频道存储的指令对象列表
# 也就是列表套列表
# 但是,在对象内部所存储的数据却不会如此嵌套
command_channel_list, command_count, max_score = cvt_mid.to_command_list_in_score(
"计分板名称",
1.0, # 音量比率
1.0, # 速度倍率
)
# 使用 to_command_list_in_delay 转换后的返回值只有两个
# 但是第一个返回值没有列表套列表
command_list, max_delay = cvt_mid.to_command_list_in_delay(
1.0, # 音量比率
1.0, # 速度倍率
"@a", # 玩家选择器
)
# 运行之后,指令和总延迟会存储至对象内
print(
"音乐长度:{}/游戏刻".format(
cvt_mid.music_tick_num
)
)
print(
"指令如下:\n{}".format(
cvt_mid.music_command_list
)
)
```
- 除了获取播放指令外,还可以获取进度条指令
```python
# 通过函数 form_progress_bar 可以获得
# 以计分板为载体所生成的进度条的指令对象列表
# 数据不仅存储在对象本身内,也会以返回值的形式返回,详见代码内文档
# 使用 form_progress_bar 函数进行转换之后,返回值有三个
# 值得注意的是第一个返回值返回的是依照midi频道存储的指令对象列表
# 也就是列表套列表
cvt_mid.form_progress_bar(
max_score, # 音乐时长游戏刻
scoreboard_name, # 进度条使用的计分板名称
progressbar_style, # 进度条样式组(详见下方)
)
# 同上面生成播放指令的理,进度条指令也会存储至对象内
print(
"进度条指令如下:\n{}".format(
cvt_mid.progress_bar_command
)
)
```
在上面的代码中,进度条样式是可以自定义的,详见[下方说明](%E5%BA%93%E7%9A%84%E7%94%9F%E6%88%90%E4%B8%8E%E5%8A%9F%E8%83%BD%E6%96%87%E6%A1%A3.md#进度条自定义)。
- 转换成指令是一个方面接下来是再转换为可以导入MC的格式。我们提供了 **音·创** 内置的附加组件,可以借助 `MidiConvert` 对象转换为相应格式。
```python
# 导入 Musicreater
import Musicreater
# 导入附加组件功能
import Musicreater.plugin
# 导入相应的文件格式转换功能
# 转换为函数附加包
import Musicreater.plugin.funpack
# 转换为 BDX 结构文件
import Musicreater.plugin.bdxfile
# 转换为 mcstructure 结构文件
import Musicreater.plugin.mcstructfile
# 转换为结构附加包
import Musicreater.plugin.mcstructpack
# 直接通过 websocket 功能播放(正在开发)
import Musicreater.plugin.websocket
# 定义转换参数
cvt_cfg = Musicreater.plugin.ConvertConfig(
output_path,
volumn, # 音量大小参数
speed, # 速度倍率
progressbar, # 进度条样式组(详见下方)
)
# 使用附加组件转换,其调用的函数应为:
# Musicreater.plugin.输出格式.播放器格式
# 值得注意的是,并非所有输出格式都支持所有播放器格式
# 调用的时候还请注意甄别
# 例如,以下函数是将 MidiConvert 对象 cvt_mid
# 以 cvt_cfg 指定的参数
# 以延迟播放器转换为 mcstructure 文件
Musicreater.plugin.mcstructfile.to_mcstructure_file_in_delay(
cvt_mid,
cvt_cfg,
)
```
# 生成文件结构
## 名词解释
|名词|解释|备注|
|--------|-----------|----------|
|指令区|一个用于放置指令系统的区域,通常是常加载区。|常见于服务器指令系统、好友联机房间中|
|指令链(链)|与链式指令方块不同,一个指令链通常指代的是一串由某种非链式指令方块作为开头,后面连着一串链式指令方块的结构。|通常的链都应用于需要“单次激活而多指令”的简单功能|
|起始块|链最初的那个非链式指令方块。|此方块为脉冲方块或重复方块皆可|
|指令系统(系统)|指令系统通常指的是,由一个或多个指令链以及相关红石机构相互配合、一同组成的,为达到某种特定的功能而构建的整体结构。|通常的系统都应用于需要“综合调配指令”的复杂功能。可由多个实现不同功能的模块构成,不同系统之间可以相互调用各自的模块。|
|游戏刻(刻)|游戏的一刻是指《我的世界》的游戏进程循环运行一次所占用的时间。([详见《我的世界》中文维基](https://minecraft.fandom.com/zh/wiki/%E5%88%BB#%E6%B8%B8%E6%88%8F%E5%88%BB))。指令方块的延迟功能(即指令方块的“延迟刻数”设置项,此项的名称被误译为“已选中项的延迟”)的单位即为`1`游戏刻。|正常情况下,游戏固定以每秒钟 $20$ 刻的速率运行。但是,由于游戏内的绝大多数操作都是基于游戏进程循环而非现实中的时间来计时并进行的,一次游戏循环内也许会发生大量的操作,更多情况下,一秒对应的游戏刻会更少。|
|红石刻|一个红石刻代表了两个游戏刻。([详见《我的世界》中文维基](https://minecraft.fandom.com/zh/wiki/%E5%88%BB#%E7%BA%A2%E7%9F%B3%E5%88%BB))。红石中继器会带来 $1$~$4$ 个红石刻的延迟,其默认的延迟时间为 $1$ 红石刻。|正常情况下,红石信号在一个红石电路中传输回存在 $\frac{1}{10}$ 秒左右的延迟。但是,同理于游戏刻,一秒对应的红石刻是不定的。|
## 播放器
**音·创**生成的文件可以采用多种方式播放,一类播放方式,我们称其为**播放器**,例如**延迟播放器**和**计分板播放器**等等,以后推出的新的播放器,届时也会在此处更新。
为什么要设计这么多播放器?是为了适应不同的播放环境需要。通常情况下,一个音乐中含有多个音符,音符与音符之间存在间隔,这里就产生了不一样的,实现音符间时间间隔的方式。而不同的应用环境下,又会产生不一样的要求。接下来将对不同的播放器进行详细介绍。
### 参数释义
|参数|说明|备注|
|--------|-----------|----------|
|`ScBd`|指定的计分板名称||
|`Tg`|播放对象|选择器或玩家名|
|`x`|音发出时对应的分数值||
|`InstID`|声音效果ID|不同的声音ID可以对应不同的乐器详见转换[乐器对照表](./%E8%BD%AC%E6%8D%A2%E4%B9%90%E5%99%A8%E5%AF%B9%E7%85%A7%E8%A1%A8.md)|
|`Ht`|播放点对玩家的距离|通过距离来表达声音的响度。以 $S$ 表示此参数`Ht`以Vol表示音量百分比则计算公式为 $S = \frac{1}{Vol}-1$ |
|`Vlct`|原生我的世界中规定的播放力度|这个参数是一个谜一样的存在似乎它的值毫不重要……因为无论这个值是多少我们听起来都差不多。当此音符所在MIDI通道为第一通道则这个值为 $0.7$ 倍MIDI指定力度其他则为 $0.9$ 倍。|
|`Ptc`|音符的音高|这是决定音调的参数。以 $P$ 表示此参数, $n$ 表示其在MIDI中的编号 $x$ 表示一定的音调偏移,则计算公式为: $P = 2^\frac{n-60-x}{12}$。之所以存在音调偏移是因为在《我的世界》中,不同的[乐器存在不同的音域](https://zh.minecraft.wiki/wiki/%E9%9F%B3%E7%AC%A6%E7%9B%92#%E4%B9%90%E5%99%A8),我们通过音调偏移来进行调整。|
### 播放器内容
1. 计分板播放器
计分板播放器是一种传统的《我的世界》音乐播放方式。通过对于计分板加分来实现播放不同的音符。一个很简单的原理,就是**用不同的计分板分值对应不同的音符**,再通过加分,来达到那个分值,即播放出来。
在**音·创**中,用来达到这种效果的指令是这样的:
```mcfunction
execute @a[scores={ScBd=x}] ~ ~ ~ playsound InstID @s ^ ^ ^Ht Vlct Ptc
```
后四个参数决定了这个音的性质,而前两个参数仅仅是为了决定音播放的时间。
2. 延迟播放器
延迟播放器是通过《我的世界》游戏中,指令方块的设置项“延迟刻数”来达到定位音符的效果。**将所有的音符依照其播放时距离乐曲开始时的时间(毫秒),放在一个序列内,再计算音符两两之间对应的时间差值,转换为《我的世界》内对应的游戏刻数之后填入指令方块的设置中。**
在**音·创**中,由于此方式播放的音乐不需要用计分板,所以播放指令是这样的:
```mcfunction
execute Tg ~ ~ ~ playsound InstID @s ^ ^ ^Ht Vlct Ptc
```
其中后四个参数决定了这个音的性质。
由于这样的延迟数据是依赖于指令方块的设置项所以使用这种播放器所转换出的结果仅可以存储在包含方块NBT信息及方块实体NBT信息的结构文件中或者直接输出至世界。
3. 中继器播放器
中继器播放器是一种传统的《我的世界》红石音乐播放方式,利用游戏内“红石组件”之“红石中继器”以达到定位音符之用。**但是中继器的延迟为1红石刻**
## 文件格式
1. 附加包格式(`.mcpack`
使用附加包格式导出音乐,若采用计分板 播放器,则音乐会以指令函数文件(`.mcfunction`)存储于附加包内。而若为延迟或中继器播放器,则音乐回以结构文件(`.mcstructure`)存储。在所生成的附加包中,函数文件的存储结构应为:
- `functions\`
- `index.mcfunction`
- `stop.mcfunction`
- `mscply\`
- `progressShow.mcfunction`
- `track1.mcfunction`
- `track2.mcfunction`
- ...
- `trackN.mcfunction`
- `structures\`
- `XXX_main.mcstructure`
- `XXX_start.mcstructure`
- `XXX_reset.mcstructure`
- `XXX_pgb.mcstructure`
如图,其中,`index.mcfunction`文件、`stop.mcfunction`文件和`mscply`文件夹存在于函数目录的根下;在`mscply`目录中,包含音乐导出的众多音轨播放文件(`trackX.mcfunction`)。同时,若使用计分板播放器生成此包时启用生成进度条,则会包含`progressShow.mcfunction`文件。若选择延迟或中继器播放器,则会生成`structures`目录以及相关`.mcstructure`文件,其中`mian`表示音乐播放用的主要结构;`start`是用于初始化播放的部分,仅包含一个指令方块即起始块;`reset``pgb`仅在启用生成进度条时出现,前者用于重置临时计分板,后者用于显示进度条。
`index.mcfunction`用于开始播放:
1. 若为计分板播放器,则其中包含打开各个音轨对应函数的指令,以及加分指令,这里的加分,是将**播放计分板的值大于等于 $1$ 的所有玩家**的播放计分板分数增加 $1$。同时,若生成此包时选择了自动重置计分板的选项,则会包含一条重置计分板的指令。
2. 若为延迟或中继器播放器,则其中的指令仅包含用以正确加载结构的`structure`指令。
`stop.mcfunction`用于终止播放:
1. 若为计分板播放器,则其中包含将**全体玩家的播放计分板**重置的指令。
2. 若为延迟或中继器播放器,则其中包含**停用命令方块**和**启用命令方块**的指令。~~然鹅实际上对于播放而言是一点用也没有~~
> 你知道吗?音·创的最早期版本“《我的世界》函数音乐生成器”正是用函数来播放,不过这个版本采取的读入数据的形式大有不同。
2. 生成结构的方式
无论是音·创生成的是何种结构,`MCSTRUCTURE`还是`BDX`,都会依照此处的格式来生成。此处我们想说明的结构的格式不是结构文件存储的格式,而是结构导出之后方块摆放的方式。结构文件存储的格式这一点,在各个《我的世界》开发的相关网站上都可能会有说明。
考虑到进行《我的世界》游戏开发时,为了节约常加载区域,很多游戏会将指令区设立为一种层叠式的结构。这种结构会限制每一层的指令系统的高度,但是虽然长宽也是有限的,却仍然比其纵轴延伸得更加自由。
所以,结构的生成形状依照给定的高度和内含指令的数量决定。其 $Z$ 轴延伸长度为指令方块数量对于给定高度之商的向下取整结果的平方根的向下取整。用数学公式的方式表达,则是:
$$ MaxZ = \left\lfloor\sqrt{\left\lfloor{\frac{NoC}{MaxH}}\right\rfloor}\right\rfloor $$
其中,$MaxZ$ 即生成结构的$Z$轴最大延伸长度,$NoC$ 表示链结构中所含指令方块的个数,$MaxH$ 表示给定的生成结构的最大高度。
我们的结构生成器在生成指令链时,将首先以相对坐标系 $(0, 0, 0)$ (即相对原点)开始,自下向上堆叠高度轴(即 $Y$ 轴)的长,当高度轴达到了限制的高度时,便将 $Z$ 轴向正方向堆叠 $1$ 个方块,并开始自上向下重新堆叠,直至高度轴坐标达到相对为 $0$。若当所生成结构的 $Z$ 轴长达到了其最大延伸长度,则此结构生成器将反转 $Z$ 轴的堆叠方向,直至 $Z$ 轴坐标相对为 $0$。如此往复,直至指令链堆叠完成。
# 进度条自定义
因为我们提供了可以自动转换进度条的功能,因此在这里给出进度条自定义参数的详细解释。
一个进度条,明显地,有**固定部分**和**可变部分**来构成。而可变部分又包括了文字和图形两种(当然,《我的世界》里头的进度条,可变的图形也就是那个“条”了)。这一点你需要了解,因为后文中包含了很多这方面的概念需要你了解。
进度条的自定义功能使用一个字符串来定义自己的样式,其中包含众多**标识符**来表示可变部分。
标识符如下(注意大小写):
| 标识符 | 指定的可变量 |
|---------|----------------|
| `%%N` | 乐曲名(即传入的文件名)|
| `%%s` | 当前计分板值 |
| `%^s` | 计分板最大值 |
| `%%t` | 当前播放时间 |
| `%^t` | 曲目总时长 |
| `%%%` | 当前进度比率 |
| `_` | 用以表示进度条占位|
表示进度条占位的 `_` 是用来标识你的进度条的。也就是可变部分的唯一的图形部分。
**样式定义字符串(基础样式)**的样例如下,这也是默认进度条的基础样式:
```▶ %%N [ %%s/%^s %%% __________ %%t|%^t]```
这是单独一行的进度条,当然你也可以制作多行的,如果是一行的,输出时所使用的指令便是 `title`,而如果是多行的话,输出就会用 `titleraw` 作为进度条字幕。
哦对了,上面的只不过是样式定义,同时还需要定义的是可变图形的部分,也就是进度条上那个真正的“条”。
对于这个我们就采用了固定参数的方法,对于一个进度条,无非就是“已经播放过的”和“没播放过的”两种形态,例如,我们默认的进度“条”(**可变样式**)的定义是这样的:
**可变样式甲(已播放样式)**`'§e=§r'`
**可变样式乙(未播放样式)**`'§7=§r'`
综合起来,把这些参数传给函数需要一个参数整合,使用位于 `Musicreater/subclass.py` 下的 `ProgressBarStyle` 类进行定义:
我们的默认定义参数如下:
```python
DEFAULT_PROGRESSBAR_STYLE = ProgressBarStyle(
r"▶ %%N [ %%s/%^s %%% __________ %%t|%^t ]",
r"§e=§r",
r"§7=§r",
)
```
*为了避免生成错误,请尽量避免使用标识符作为定义样式字符串的其他部分*

180
docs/新手答疑指南.md Normal file
View File

@@ -0,0 +1,180 @@
<h1 align="center">音·创 Musicreater</h1>
<h2 align="center">库版 Package Version</h2>
<p align="center">
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
# 新手答疑指南
**考虑到某些用户电脑技术不是特别先进,且对这个项目充满了好奇心,但是又了解的不是很充分,
为此,我特别在这里写一份文档,解答各位的好奇心。放心,本文件全程中文,英文版本随后更新!**
## 第一部分 关于音·创的作用
### 1.1 音·创简介
音·创 Musicreater 是一款免费开源的 **《我的世界:基岩版》** 音乐制作软件
音·创 库版 (Musicreater Package Version) 是一款免费开源的针对 **《我的世界:基岩版》** 的midi音乐转换库
音·创 采用的是**带有特殊条款的Apache2.0**开源协议,详情请见[这里](https://gitee.com/EillesWan/Musicreater/blob/master/LICENSE.md)。
音·创
目前已经具备较为完善的**教程**,如果你还不知道音·创有教程,请点击
[
这里](https://gitee.com/EillesWan/Musicreater/blob/pkgver/docs/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)。
### 1.2 音·创到底目前有什么功能?
* - [x] 支持导入.mid文件
* - [x] 支持写入.mcpack文件
* - [x] 支持写入.bdx文件
* 不支持导入.mp3 .mp4 .wav等音频流文件
## 第二部分 关于格式的问题
### 2.1 关于.mid格式
其实对于经常玩音乐电子制作的朋友们来说mid格式并不陌生这里我简单介绍一下。
> mid格式是由MIDI继承而来。MID文件并不是一段录制好的声音而是记录声音的信息然后再告诉声卡如何再现音乐的一组指令。
> 这样一个MIDI文件每存1分钟的音乐只用大约510KB。今天MID文件主要用于原始乐器作品、流行歌曲的业余表演、游戏音轨以及电子贺卡等。
>
> ——百度百科
>
> MIDI 音乐,保存在电脑上,就是 *.mid 类型的文件。和一般意义上的“音乐”不同mid 类型的音乐通常并不是可直接发行供大众欣赏的音乐,
> 它更像是一种音乐创作者使用的工程文件。它没有歌词,不含有人类语言。如果说五线谱是给人类阅读的乐谱,
> MIDI音乐文件便是给计算机或其他电子设备使用的乐谱。对于“音乐”这个世界来说它微不足道却又是现代数字音乐的基石。虽不为大众所知
> 但在 MIDI 音乐爱好者眼中,它却是非常有意思的东西。有了 MIDI 音乐技术和一台电脑,基本就等于拥有了一个乐队,加上相关的音乐知识,
> 就可以自己指挥这个“乐队”,创作音乐作品了!
> 同时MIDI 技术由于数据结构简单又与音乐有关也成为了部分技术极客的爱好。有人使用MIDI技术+Arduino开源硬件制作了架子鼓
> 有人通过分析大量MIDI乐曲结构设计了人工智能作曲软件还有更酷的人使用MIDI音乐制作了随节奏变幻的特斯拉线圈
> 在MIDI 音乐的世界里汇聚了一批喜欢音乐又热爱技术的人。我们有理由相信玩MIDI音乐的你定是多才多艺的。
>
> ——midishow.com
**所以mid文件的本质是电子乐谱而不是记录声音波形文件的.mp3/.wav/.m4a等等文件**
### 2.2 关于.mid格式的获取
通过刚刚的介绍,你可能已经发现,*.mid文件因为受众并不多而并没有被广泛熟知因而你之前可能完全没见过这个文件更何况要弄一首自己心仪的歌了。
这里介绍几个获取.mid格式的方法
1. 最简单的方法就是成为一个作编曲的人,当然,很多人做不到这一点,但是有必要提到这一点,当你在下面的渠道中都无法获得想要的文件时,
你应该考虑是不是需要自己创作内容,或者,请别人帮你创作内容。
2. 当你没有这样的文件时,问问别人或者从群里下在公告的免费的也是个思路,不过这个办法通常使用次数有限。
3. 自己找mid现在我将给你提供一个完整的找mid的方法请认真学习
**1.** 首先你需要在www.midishow.com中注册一个账号并不复杂你可能只需要一个QQ号。
**2.** 登录你的账号,主界面应该如下图所示:
<img src="https://foruda.gitee.com/images/1672644995747340749/36c9c143_10062986.png">
**3.** 在显眼的搜索框中,输入你想要的歌曲名称,接下来的教程,我以`夜空中最亮的星`这首歌及它的mid来演示下载流程。点击搜索框完成这一步。
<img src="https://foruda.gitee.com/images/1672645340943813483/44d0db69_10062986.png">
**4.** 接下来看到搜索结果如下,你可以点进去一个听听,决定你是否要下载;也有可能你什么都没搜到,那你就得换首歌或者换个途径了。
<img src="https://foruda.gitee.com/images/1672645574402099694/6b7e18e5_10062986.png">
**5.** 点击播放按钮试听,网站上的效果可能一般,但是会听音乐的人应该很快就能决定你是否需要下载这个音乐。如果需要下载,你可以进行到下一步,
如果不行,那你可以退回刚刚的页面换一个。
<img src="https://foruda.gitee.com/images/1672645752246438160/47cead78_10062986.png">
**6.** 翻到最下面,如图,你可以对这首歌进行打分,打分可以使积分+1建议打5分你可以对这首歌进行评论一次有意义的评论可以+3分。
下载一首歌需要-3积分如果你先完成了这两项操作再下载那你还会再赚1积分。所以推荐这样做
<img src="https://foruda.gitee.com/images/1672646433045265565/26ea29b2_10062986.png">
**完成后会像这样:**
<img src="https://foruda.gitee.com/images/1672646242419857480/5e8809b8_10062986.png">
**7.** 接下来下载,往上翻网页,找到这个标识,然后单击。
<img src="https://foruda.gitee.com/images/1672646275215822535/63b402db_10062986.png">
**8.** 确认完毕后点击下载。
<img src="https://foruda.gitee.com/images/1672646309787744490/f459adac_10062986.png">
**9.** 完成下载,如图:
<img src="https://foruda.gitee.com/images/1672646335942429563/2449ed0b_10062986.png">
4. 使用mp3转换为mid的工具不得不说科技的进步带来了许多便利让这样困难的事情也变得简单。如果上述方法仍然没有解决你的问题
那么你可以在下一章节中找到有关这个途径的说明。
### 2.3 .mp3格式转换为.mid格式
**注意,使用这个技术有一定难度,酌情使用!**
概述mp3转mid需要把**模拟的波形频谱信号转为数字乐谱信号**,这个过程**一定有损失**。
请各位以后不要在答疑群中问类似于我这个转换效果为什么不好这样的问题,谢谢。
如果直接用**widi**的话相当于对声音进行了**傅里叶变换**,你确实可以分离出其中的音高,但是效果在不同情况下差异较大,
尤其是有架子鼓啊啥的玩也的时候,比较**差**。
[widi工具链接](https://pan.baidu.com/s/1j_Jui0piQ6rMOXM0GJtqTg) 提取码b0lw
**如果只有钢琴的谱子需要分离,有一个完美的选择**[这里](https://zhuanlan.zhihu.com/p/270999354)
如果不然有其他的乐器也需要分离那么可能就有点困难像cakewalk就确实也可以吧音频变成mid但是可能要
**先把原MP3分离成人声音轨、贝斯音轨等再傅里叶变换。**
当然我也可能了解的不全,没准现在已经有传新的技术可以分离的更好了,那就太棒了!(〃'▽'〃)
另外我们开发者也象征性的找了一些mp3转mid的网站我们没使用过不担保效果。
[https://www.serocs.cn/transcription/](https://www.serocs.cn/transcription/)
同时midishow论坛里有一些大佬也提供了解决方案看看他们的发言也是一个不错的选择。
我就只给个论坛链接了,经常有人问这种问题,你可以去那里随便找到一篇帖子看看。
[论坛](https://www.midishow.com/question)
### 2.4 输出格式的问题
在前面说到,输出主要有`.mcpack``.bdx`文件的输出,接下来我会围绕这两个文件进行简单的说明。
#### 2.4.1 .mcpack是什么
输出.mcpack文件其实对于一个**资深基岩版我的世界玩家**应该并不陌生。
.mcpack文件其实就是我的世界基岩版的附加包里面一般分为行为包和材质包
我们生成的命令组属于**行为包** (下图就是一个例子)
<img src="https://foruda.gitee.com/images/1672647779755793187/884abaa9_10062986.png">
如果你是国际电脑版基岩玩家就像我一样,是可以直接打开这个文件,并将这个包导入我的世界的。
关于怎么使用,请看[**这里**](https://gitee.com/EillesWan/Musicreater/blob/pkgver/docs/%E7%94%9F%E6%88%90%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)。
#### 2.4.2 .bdx是什么
.bdx 文件其实是FastBuilder这款软件的结构文件可以导入到我的世界。
由于这不属于官方文件且我并不是很熟悉这个结构所以请对这个格式有问题的好兄弟加一下QQ群问问群里负责导入的大佬。
## 第三部分 关于其他问题
**由于开发者们都很忙,群友们的耐心也都有限,所以恳请大家提出有意义的问题。这里附一个关于提问方法的链接,大家可以看看。**
[提问的智慧](https://github.com/tvvocold/How-To-Ask-Questions-The-Smart-Way)
希望不要我把这个文件在聊天中甩给你,那说明我可能已经没有耐心了。
看完这份说明,如果你打算开始使用我们的工具的话,请移步至[这里](https://gitee.com/EillesWan/Musicreater/blob/pkgver/docs/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)。
## 结尾
### 作者\<*金羿*\>(Eilles)联系方式
1. QQ 2647547478
2. 电邮 EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
3. 微信 WYI_DoctorYI
4. Telegram [@EillesWan](https://t.me/EillesWan)
### 作者\<*诸葛亮与八卦阵*\>(bgArray)联系方式
1. QQ 4740437765
**欢迎加群:[861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)**
**欢迎加群:[861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)**
**欢迎加群:[861684859](https://jq.qq.com/?_wv=1027&k=hpeRxrYr)**
(重要的事情说三遍)
**(有能力的同志麻烦给仓库star一下)**
**(有能力的同志麻烦给仓库star一下)**
**(有能力的同志麻烦给仓库star一下)**

View File

@@ -1,56 +1,32 @@
<h1 align="center">音·创 Musicreater</h1>
<h2 align="center">库版 Package Version</h2>
<p align="center">
<img width="128" height="128" src="https://gitee.com/TriM-Organization/Musicreater/raw/master/resources/msctIcon.png" >
<img width="128" height="128" src="https://s1.ax1x.com/2022/05/06/Ouhghj.md.png" >
</p>
# 生成文件的使用
# 生成文件的使用说明
*这是本库所生成文件的使用声明,不是使用本库的教程,若要查看**本库的文档**,可点击[此处](./%E5%BA%93%E7%9A%84%E7%94%9F%E6%88%90%E4%B8%8E%E5%8A%9F%E8%83%BD%E6%96%87%E6%A1%A3.md);若要查看有关文件结构的内容,可以点击[此处](./%E7%94%9F%E6%88%90%E6%96%87%E4%BB%B6%E7%BB%93%E6%9E%84%E8%AF%B4%E6%98%8E.md)*
*由于先前的 **读我文件**(README.md) 过于冗杂,现另辟蹊径来给大家全方位的教程。*
## 附加包格式
*这是本库生成后文件的相关说明,不是使用本库的教程,若要查看**本库的演示程序**使用教程,可点击[此处](%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8%E8%AF%B4%E6%98%8E.md)*
支持的文件后缀:`.MCPACK`
## 文件格式
- 计分板播放器
1. 附加包格式(`.mcpack`
1. 导入附加包
2. 在一个循环方块中输入指令 `function index`
3. 将需要聆听音乐的实体的播放所用计分板设置为 `1`
4. 激活循环方块
5. 若想要暂停播放,可以停止循环指令方块的激活状态
6. 若想要重置某实体的播放,可以将其播放用的计分板重置
7. 若要终止全部玩家的播放,在聊天框输入指令 `function stop`
使用附加包格式导出音乐,则音乐会以指令函数文件(`.mcfunction`)存储于附加包内。在附加包中,函数文件的存储结构应为:
> 其中 步骤三 和 步骤四 的顺序可以调换。
- 延迟播放器
1. 导入附加包
2. 在聊天框输入指令 `function index`
3. 同时激活所生成的循环和脉冲指令方块
4. 若要终止播放,在聊天框输入指令 `function stop` 试试看,不确保有用
> 需要注意的是,循环指令方块需要一直激活直到音乐结束
## 结构格式
支持的文件后缀:`.MCSTRUCTURE``.BDX`
1. 将结构导入世界
- 延迟播放器
2. 将结构生成的第一个指令方块之模式更改为**脉冲**
3. 激活脉冲方块
4. 若欲重置播放,可以停止对此链的激活,例如停止区块加载
5. 此播放器不支持暂停
- 计分板播放器
2. 在所生成的第一个指令方块前,放置一个循环指令方块,其朝向应当对着所生成的第一个方块
3. 在循环指令方块中输入使播放对象的播放用计分板加分的指令,延迟为 `0`,每次循环增加 `1`
4. 激活循环方块
5. 若想要暂停播放,可以停止循环指令方块的激活状态
6. 若想要重置某实体的播放,可以将其播放用的计分板重置
- `functions\`
- `index.mcfunction`
- `mscply\`
- `progressShow.mcfunction`
- `track1.mcfunction`
- `track2.mcfunction`
- ...
- `trackN.mcfunction`
如图,其中,`index.mcfunction`文件和`mscply`文件夹存在于函数目录的根下;在`mscply`目录中,包含音乐导出的众多音轨播放文件(`trackX.mcfunction`),同时,若生成此包时选择了带有进度条的选项,则会包含`progressShow.mcfunction`文件。
`index.mcfunction`用于开始播放,其中包含打开各个音轨对应函数的指令,以及加分指令,这里的加分,是将**播放计分板的值大于等于`1`**的所有**玩家**的播放计分板分数增加`1`。同时,若生成此包时选择了自动重置计分板的选项,则会包含一条重置计分板的指令。

View File

@@ -1,222 +0,0 @@
<h1 align="center">音·创 Musicreater</h1>
<p align="center">
<img width="128" height="128" src="https://gitee.com/TriM-Organization/Musicreater/raw/master/resources/msctIcon.png" >
</p>
# 转换乐器对照表
**_注意本文档中的对照表版权归属于音·创作者并按照本仓库根目录下 LICENSE.md 中规定开源_**
原表格请见[constant.py](../Musicreater/constants.py#176)
**_使用时请遵循协议规定_**
- 版权所有 © 2025 金羿 & 诸葛亮与八卦阵
- Copyright © 2025 Eilles & bgArray
* 音·创(“本项目”)的协议颁发者为 金羿、诸葛亮与八卦阵
* The Licensor of Musicreater("this project") is Eilles, bgArray.
本项目根据 第一版 汉钰律许可协议(“本协议”)授权。
任何人皆可从以下地址获得本协议副本https://gitee.com/EillesWan/YulvLicenses。
若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,不予提供任何形式的担保、任何明示、任何暗示或类似承诺。也就是说,用户将自行承担因此作品的质量或性能问题而产生的全部风险。
详细的准许和限制条款请见原协议文本。
音·创 开发交流群 861684859\
Email TriM-Organization@hotmail.com\
若需转载或借鉴 许可声明请查看仓库根目录下的 License.md
### 名词解释
| 名词 | 说明 |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------- |
| 音符名称 | 我的世界游戏内用于播放音乐的 `playsound` 指令所规定的 `Sound ID` |
| 音调偏移参数 | 在《我的世界》中,不同乐器的音域不同,对应的 `pitch` 值也不尽相同,该参数的解释请参考[文档说明](库的生成与功能文档.md#参数释义) |
# 乐音乐器
对照表版本2023 0527
| Midi 乐器值 | 音符名称 | 音调偏移参数 |
| ----------- | ------------------- | ------------ |
| 0 | note.harp | 6 |
| 1 | note.harp | 6 |
| 2 | note.pling | 6 |
| 3 | note.harp | 6 |
| 4 | note.pling | 6 |
| 5 | note.pling | 6 |
| 6 | note.harp | 6 |
| 7 | note.harp | 6 |
| 8 | note.share | 7 |
| 9 | note.harp | 6 |
| 10 | note.didgeridoo | 8 |
| 11 | note.harp | 6 |
| 12 | note.xylophone | 4 |
| 13 | note.chime | 4 |
| 14 | note.harp | 6 |
| 15 | note.harp | 6 |
| 16 | note.bass | 8 |
| 17 | note.harp | 6 |
| 18 | note.harp | 6 |
| 19 | note.harp | 6 |
| 20 | note.harp | 6 |
| 21 | note.harp | 6 |
| 22 | note.harp | 6 |
| 23 | note.guitar | 7 |
| 24 | note.guitar | 7 |
| 25 | note.guitar | 7 |
| 26 | note.guitar | 7 |
| 27 | note.guitar | 7 |
| 28 | note.guitar | 7 |
| 29 | note.guitar | 7 |
| 30 | note.guitar | 7 |
| 31 | note.bass | 8 |
| 32 | note.bass | 8 |
| 33 | note.bass | 8 |
| 34 | note.bass | 8 |
| 35 | note.bass | 8 |
| 36 | note.bass | 8 |
| 37 | note.bass | 8 |
| 38 | note.bass | 8 |
| 39 | note.bass | 8 |
| 40 | note.harp | 6 |
| 41 | note.harp | 6 |
| 42 | note.harp | 6 |
| 43 | note.harp | 6 |
| 44 | note.iron_xylophone | 6 |
| 45 | note.guitar | 7 |
| 46 | note.harp | 6 |
| 47 | note.harp | 6 |
| 48 | note.guitar | 7 |
| 49 | note.guitar | 7 |
| 50 | note.bit | 6 |
| 51 | note.bit | 6 |
| 52 | note.harp | 6 |
| 53 | note.harp | 6 |
| 54 | note.bit | 6 |
| 55 | note.flute | 5 |
| 56 | note.flute | 5 |
| 57 | note.flute | 5 |
| 58 | note.flute | 5 |
| 59 | note.flute | 5 |
| 60 | note.flute | 5 |
| 61 | note.flute | 5 |
| 62 | note.flute | 5 |
| 63 | note.flute | 5 |
| 64 | note.bit | 6 |
| 65 | note.bit | 6 |
| 66 | note.bit | 6 |
| 67 | note.bit | 6 |
| 68 | note.flute | 5 |
| 69 | note.harp | 6 |
| 70 | note.harp | 6 |
| 71 | note.flute | 5 |
| 72 | note.flute | 5 |
| 73 | note.flute | 5 |
| 74 | note.harp | 6 |
| 75 | note.flute | 5 |
| 76 | note.harp | 6 |
| 77 | note.harp | 6 |
| 78 | note.harp | 6 |
| 79 | note.harp | 6 |
| 80 | note.bit | 6 |
| 81 | note.bit | 6 |
| 82 | note.bit | 6 |
| 83 | note.bit | 6 |
| 84 | note.bit | 6 |
| 85 | note.bit | 6 |
| 86 | note.bit | 6 |
| 87 | note.bit | 6 |
| 88 | note.bit | 6 |
| 89 | note.bit | 6 |
| 90 | note.bit | 6 |
| 91 | note.bit | 6 |
| 92 | note.bit | 6 |
| 93 | note.bit | 6 |
| 94 | note.bit | 6 |
| 95 | note.bit | 6 |
| 96 | note.bit | 6 |
| 97 | note.bit | 6 |
| 98 | note.bit | 6 |
| 99 | note.bit | 6 |
| 100 | note.bit | 6 |
| 101 | note.bit | 6 |
| 102 | note.bit | 6 |
| 103 | note.bit | 6 |
| 104 | note.harp | 6 |
| 105 | note.banjo | 6 |
| 106 | note.harp | 6 |
| 107 | note.harp | 6 |
| 108 | note.harp | 6 |
| 109 | note.harp | 6 |
| 110 | note.harp | 6 |
| 111 | note.guitar | 7 |
| 112 | note.harp | 6 |
| 113 | note.bell | 4 |
| 114 | note.harp | 6 |
| 115 | note.cow_bell | 5 |
| 116 | note.bd | 7 |
| 117 | note.bass | 8 |
| 118 | note.bit | 6 |
| 119 | note.bd | 7 |
| 120 | note.guitar | 7 |
| 121 | note.harp | 6 |
| 122 | note.harp | 6 |
| 123 | note.harp | 6 |
| 124 | note.harp | 6 |
| 125 | note.hat | 7 |
| 126 | note.bd | 7 |
| 127 | note.snare | 7 |
# 打击乐器
| Midi 打击乐器值 | 音符名称 | 音调偏移参数 |
| --------------- | ------------------- | ------------ |
| 34 | note.bd | 7 |
| 35 | note.bd | 7 |
| 36 | note.hat | 7 |
| 37 | note.snare | 7 |
| 38 | note.snare | 7 |
| 39 | note.snare | 7 |
| 40 | note.hat | 7 |
| 41 | note.snare | 7 |
| 42 | note.hat | 7 |
| 43 | note.snare | 7 |
| 44 | note.snare | 7 |
| 45 | note.bell | 4 |
| 46 | note.snare | 7 |
| 47 | note.snare | 7 |
| 48 | note.bell | 4 |
| 49 | note.hat | 7 |
| 50 | note.bell | 4 |
| 51 | note.bell | 4 |
| 52 | note.bell | 4 |
| 53 | note.bell | 4 |
| 54 | note.bell | 4 |
| 55 | note.bell | 4 |
| 56 | note.snare | 7 |
| 57 | note.hat | 7 |
| 58 | note.chime | 4 |
| 59 | note.iron_xylophone | 6 |
| 60 | note.bd | 7 |
| 61 | note.bd | 7 |
| 62 | note.xylophone | 4 |
| 63 | note.xylophone | 4 |
| 64 | note.xylophone | 4 |
| 65 | note.hat | 7 |
| 66 | note.bell | 4 |
| 67 | note.bell | 4 |
| 68 | note.hat | 7 |
| 69 | note.hat | 7 |
| 70 | note.flute | 5 |
| 71 | note.flute | 5 |
| 72 | note.hat | 7 |
| 73 | note.hat | 7 |
| 74 | note.xylophone | 4 |
| 75 | note.hat | 7 |
| 76 | note.hat | 7 |
| 77 | note.xylophone | 4 |
| 78 | note.xylophone | 4 |
| 79 | note.bell | 4 |
| 80 | note.bell | 4 |

View File

@@ -1,149 +0,0 @@
# 音乐序列文件格式
音·创 库的音符序列文件格式包含两种,一种是常规的音乐序列存储采用的 MSQ 格式,另一种是为了流式读取音符而采用的 FSQ 格式。
## MSQ 数据格式
MSQ 格式是 音·创 库存储音符序列的一种字节码格式,取自 **M**usic**S**e**Q**uence 类之名。
现在 音·创 库及其上游软件使用的是在 第二版 的基础上增设校验功能的 MSQ 第三版。
### MSQ 第三版
第三版 MSQ 格式的码头是 `MSQ!` ,这一版中,所有的**字符串**皆以 _**GB18030**_ 编码进行编解码,**数值**皆是以 _**大端字节序**_ 存储的无符号整数。
码头是字节码前四个字节的内容,这一部分内容是可读的 ASCII 字串。因此,第三版的字节码中前四个字节的内容必为 `MSQ!`
第二版 MSQ 取 `MSQ@` 作为码头是因为美式键盘上 @ 是 Shift+2 键 按下取得的,故代表 MSQ 第二版。
你猜为什么第三版是 `MSQ!`
#### 元信息
| 信息名称 | 西文代号 | 位长(多少个 0 或 1 | 支持说明 |
| ------------------------------ | -------------------------- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **码头** | __ | 32 位 | 值为 `MSQ!` |
| **音乐名称长度** | music_name_length | 6 位 | 支持数值 0~63 |
| **最小音量** | minimum_volume | 10 位 | 支持数值 0~1023注意这里每个 1 代表最小音量的 0.001 个单位,即取值是此处表示数字的千分倍 |
| **是否启用高精度音符时间控制** | enable_high_precision_time | 1 位 | 1 是启用,反之同理 |
| **总音调偏移** | music_deviation | 15 位 | 支持数值 -16383~16383这里也是表示三位小数的和最小音量一样。这里 15 位中的第一位(从左往右)是正负标记,若为 1 则为负数,反之为正数,后面的 14 位是数值 |
| **音乐名称** | music_name | 依据先前定义 | 最多可支持 31 个中文字符 或 63 个西文字符,其长度取决于先前获知的 “音乐名称长度” 的定义 |
在这一元信息中,**音乐名称长度**和**最小音量**合计共 2 字节;**高精度音符时间控制启用**和**总音调偏移**合计共 2 字节;因此,除**音乐名称**为任意长度,前四字节内容均为固定。
#### 音符序列
每个序列前 4 字节为一个用以表示当前通道中音符数量的值,也就是**通道音符数**notes_count。也即是说一个通道内的音符可以是 0~4294967295 个。
在这之后,就是这些数量的音符了,其中每个音符的信息存储方式如下
| 信息名称 | 西文代号 | 位长 | 支持说明 |
| ---------------------------- | ------------------------ | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **乐器名称长度** | name_length | 6 位 | 支持数值 0~63 |
| **Midi 音高** | note_pitch | 7 位 | 支持数值 0~127 |
| **开始时刻** | start_tick | 17 位 | 单位 二十分之一秒,即约为 1 命令刻;支持数值 0~131071 即 109.22583 分钟 合 1.8204305 小时 |
| **音符持续刻数** | duration | 17 位 | 同上 |
| **是否作为打击乐器** | percussive | 1 位 | 1 是启用,反之同理 |
| **响度(力度)** | velocity | 7 位 | 支持数值 0~127 |
| **是否启用声像位移** | is_displacement_included | 1 位 | 1 是启用,反之同理 |
| **时间精度提升值**(非必含) | high_time_precision | 8 位 | 支持数值 0~255若在 元信息 中启用**高精度音符时间控制**,则此值启用,代表音符时间控制精度偏移,此值每增加 1则音符开始时刻向后增加 1/1250 秒 |
| **乐器名称** | sound_name | 依据先前定义 | 最多可支持 31 个中文字符 或 63 个西文字符,其长度取决于先前获知的 “乐器名称长度” 的定义 |
| **声像位移**(非必含) | position_displacement | 共三个值,每个值 16 位 共 48 位 | 若前述**是否启用声像位移**已启用,则此值启用;三个值分别代表 x、y、z 轴上的偏移,每个值支持数值 0~65535注意这里每个 1 代表最小音量的 0.001 个单位,即取值是此处表示数字的千分倍 |
#### 序列校验
_第三版新增_
在每个音符序列结尾包含一个 128 位的校验值,用以标识该序列结束的同时,验证该序列的完整性。
在这 128 位里,前 64 位是该通道音符数的 XXHASH64 校验值,以 3 作为种子值。
后 64 位是整个通道全部字节串的 XXHASH64 校验值(包括通道开头的音符数),以 该通道音符数 作为种子值。
#### 总体校验
_第三版新增_
在所有有效数据之后,包含一个 128 位的校验值,用以标识整个字节串结束的同时,验证整个字节码数据的完整性。
该 128 位的校验值是 包括码头在内的元信息的 XXHASH64 校验值(种子值是全曲音符数) 对于前述所有校验值彼此异或的异或 所得值之 XXHASH128 校验值,以 全曲音符总数 作为种子值。
请注意,是前述每个 XXHASH64 校验值的异或(每次取 XXHASH64 都计一遍),也就并非是每个序列结尾,那个已经合并了的 128 位校验值再彼此异或。对于这个异或值,再取其种子是 全曲音符数 的 XXHASH128 校验字节码。
听起来很复杂?我来举个例子。以下是该算法的伪代码。我们设:
- `meta_info` : `bytes` 为 元信息字节串
- `note_seq_1` : `bytes` 为 第一个音符序列的编码字节串
- `note_seq_2` : `bytes` 为 第二个音符序列的编码字节串
- `XXH64(bytes, seed)` : `bytes` 为 XXHASH64 校验函数
- `XXH128(bytes, seed)` : `bytes` 为 XXHASH128 校验函数
- `XOR(bytesLike, bytesLike)` : `bytes` 为 异或 函数
- `note_count` : `int` 为 全曲音符数
- `seq_1_note_count` : `int` 为 第一个音符序列的音符数
- `seq_2_note_count` : `int` 为 第二个音符序列的音符数
为了简化,我们假设只有两个序列,实际上每个通道都是一个序列(最多 16 个序列)
那么,一个完整的 MSQ 文件应当如下排列其字节串:
```assembly
ADD meta_info
ADD note_seq_1
ADD XXH64(seq_1_note_count, 3)
ADD XXH64(note_seq_1, seq_1_note_count)
ADD note_seq_2
ADD XXH64(seq_2_note_count, 3)
ADD XXH64(note_seq_2, seq_2_note_count)
ADD XXH128(
XOR(
XOR(
XXH64(meta_info, note_count),
XOR(
XXH64(seq_1_note_count, 3),
XXH64(note_seq_1, seq_1_note_count)
),
),
XOR(
XXH64(seq_2_note_count, 3),
XXH64(note_seq_2, seq_2_note_count),
)
),
note_count
)
```
## FSQ 数据格式
FSQ 格式是 音·创 库存储音符序列的一种字节码格式,取自 **F**lowing Music **S**e**q**uence 之名。
现在 音·创 库及其上游软件使用的是在 MSQ 第三版 的基础上进行流式的兼容性变动。
### FSQ 第一版
第一版的码头是 `FSQ!` ,这一版中,所有的**字符串**皆以 _**GB18030**_ 编码进行编解码,**数值**皆是以 _**大端字节序**_ 存储的无符号整数。
码头是字节串前四个字节的内容,这一部分内容是可读的 ASCII 字串。因此,这一版的文件前四个字节的内容必为 `FSQ!`
因为这一版本是在 MSQ 第三版的基础上演变而来的,因此取自 MSQ 码头的 `MSQ!` 而改作 `FSQ!`
#### 元信息
FSQ 第一版的元信息是在 MSQ 第三版的元信息的基础上增加了一个占 5 字节的全曲音符总数。
也就是说,与 MSQ 第三版一致的,在这一组信息中,**音乐名称长度**和**最小音量**合计共 2 字节;**高精度音符时间控制启用**和**总音调偏移**合计共 2 字节;因此,除**音乐名称**为任意长度,前四字节内容均为固定。而最后增加 5 字节作为全曲音符总数。
#### 音符序列
FSQ 格式不包含音符的通道信息,在读取处理时默认将同一乐器的音符视为同一通道。也就是说,仅存在一个序列。其中每个音符的信息存储方式与 MSQ 第三版一致。
音符序列的存储顺序是按照音符的**开始时间**进行排序的。
但是注意!有可能一个较长的音符的开始到结束时间内还包含有音符,此时如有要适配的读取器,还请继续读取直到下一个音符的开始时间大于此较长音符的结束时间。
在每 100 个音符后,插入一段 32 位的 XXHASH32 校验码,其所校验的内容为这一百个音符中每个音符的第 6 个字节彼此异或之结果,种子值为这一百个音符中每个音符的第 2 个字节的彼此异或结果。
若最后不满足 100 个音符,则不插入上述校验码。
#### 总体校验
在所有有效数据之后,包含一个 128 位的校验值,用以标识整个字节串结束的同时,验证整个字节码数据的完整性。
该 128 位的校验值是 包括码头在内的元信息的 XXHASH64 校验值(种子值是全曲音符数) 对于前述所有 XXHASH32 校验值彼此异或的异或 所得值之 XXHASH128 校验值,以 全曲音符总数 作为种子值。

18
example_convert_bdx.py Normal file
View File

@@ -0,0 +1,18 @@
# THIS PROGRAM IS ONLY A TEST EXAMPLE
from msctPkgver.main import *
convertion = midiConvert()
convertion.convert(input('请输入midi文件路径'), input('请输入输出路径:'))
for i in convertion.toBDXfile(
1,
input('请输入作者:'),
bool(int(input('是否开启进度条(1|0)'))),
int(input('请输入指令结构最大生成高度:')),
input('请输入计分板名称:'),
float(input('请输入音量(0-1]')),
float(input('请输入速度倍率:')),
bool(int(input('是否自动重置计分板(1|0)'))),
):
print(i)

View File

@@ -0,0 +1,24 @@
# THIS PROGRAM IS ONLY A TEST EXAMPLE
from msctPkgver.main import *
convertion = midiConvert()
convertion.convert(input("请输入midi文件路径"), input("请输入输出路径:"))
print(
convertion.tomcpack(
3,
bool(int(input("是否自动重置计分板(1|0)"))),
bool(int(input("是否开启进度条(1|0)"))),
input("请输入计分板名称:"),
float(input("请输入音量0-1")),
float(input("请输入速度倍率:")),
)
)
# for the test
# if __name__ == '__main__':
# convertion = midiConvert()
# convertion.convert(r"C:\Users\lc\Documents\MuseScore3\乐谱\乐谱\victory.mid", ".")
# convertion.tomcpack(
# 1, True, True, "scb", 1, 1)

22
example_convert_mcpack.py Normal file
View File

@@ -0,0 +1,22 @@
# THIS PROGRAM IS ONLY A TEST EXAMPLE
from msctPkgver.main import *
convertion = midiConvert()
convertion.convert(input('请输入midi文件路径'), input('请输入输出路径:'))
convertion.tomcpack(
1,
bool(int(input('是否自动重置计分板(1|0)'))),
bool(int(input('是否开启进度条(1|0)'))),
input('请输入计分板名称:'),
float(input('请输入音量0-1')),
float(input('请输入速度倍率:')),
)
# for the test
# if __name__ == '__main__':
# convertion = midiConvert()
# convertion.convert(r"C:\Users\lc\Documents\MuseScore3\乐谱\乐谱\victory.mid", ".")
# convertion.tomcpack(
# 1, True, True, "scb", 1, 1)

Binary file not shown.

After

Width:  |  Height:  |  Size: 16 KiB

343
magicDemo.py Normal file
View File

@@ -0,0 +1,343 @@
# -*- coding: utf-8 -*-
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 Lisence.md
"""
音·创 库版 MIDI转换示例程序
Musicreater Package Version : Demo for Midi Conversion
Copyright 2023 all the developers of Musicreater
开源相关声明请见 ./Lisence.md
Terms & Conditions: ./Lisence.md
"""
languages = {
"ZH_CN": {
"MSCT": "音·创",
"ChooseLang": "选择语言",
"LangChd": "当前语言已经切换为",
"ZH_CN": "简体中文",
"ZH_TW": "繁体中文(台湾)",
"EN_GB": "英语(英国)",
"EN_US": "英语(美国)",
":": "",
",": "",
".": "",
"ChooseFileFormat": "请输入输出格式[BDX(1)或MCPACK(0)]",
"ChoosePlayer": "请选择播放方式[计分板(1) 或 延迟(0)]",
"ChoosePath": "请输入MIDI路径或所在文件夹",
"WhetherArgEntering": "是否为文件夹内文件的转换统一参数[是(1) 或 否(0)]",
"EnterArgs": "请输入转换参数",
"noteofArgs": "文件夹内的全部midi将统一以此参数转换",
"ChooseSbReset": "是否自动重置计分板[是(1) 或 否(0)]",
"WhetherCstmProgressBar": "是否自定义进度条[是(1) 或 否(0)]",
"EnterProgressBarStyle": "请输入进度条样式",
"EnterSbName": "请输入计分板名称",
"EnterVolume": "请输入音量大小(0~1)",
"EnterSpeed": "请输入速度倍率",
"EnterAuthor": "请输入作者",
"EnterMaxHeight": "请输入指令结构最大生成高度",
"ErrEnter": "输入错误",
"Re-Enter": "请重新输入",
"Dealing": "正在处理",
"FileNotFound": "文件(夹)不存在",
"ChooseOutPath": "请输入结果输出路径",
"EnterSelecter": "请输入播放者选择器",
"Saying": "言·论",
}
}
import sys
if sys.argv.__len__() > 0:
currentLang = sys.argv[0]
if not currentLang in languages.keys():
currentLang = "ZH_CN"
else:
currentLang = "ZH_CN"
def _(__):
'''
`languages`
'''
return languages[currentLang][__]
import os
import random
import datetime
from msctPkgver.main import *
try:
from rich.console import Console
except ModuleNotFoundError as E:
if input("您需要安装 Rich 模块才能使用这个样例\n请问是否安装?(y/n)").lower() in ('y', '1'):
os.system("pip install Rich -i https://mirrors.aliyun.com/pypi/")
from rich.console import Console
else:
raise E
try:
import zhdate
except ModuleNotFoundError as E:
if input("您需要安装 zhdate 模块才能使用这个样例\n请问是否安装?(y/n)").lower() in ('y', '1'):
os.system("pip install zhdate -i https://mirrors.aliyun.com/pypi/")
import zhdate
else:
raise E
try:
import requests
except ModuleNotFoundError as E:
if input("您需要安装 requests 模块才能使用这个样例\n请问是否安装?(y/n)").lower() in ('y', '1'):
os.system("pip install requests -i https://mirrors.aliyun.com/pypi/")
import requests
else:
raise E
MainConsole = Console()
MainConsole.print(
"[#121110 on #F0F2F4] ",
style="#121110 on #F0F2F4",
justify="center",
)
# 显示大标题
MainConsole.rule(title="[bold #AB70FF]欢迎使用音·创独立转换器", characters="=", style="#26E2FF")
MainConsole.rule(
title="[bold #AB70FF]Welcome to Independent Musicreater Convernter", characters="-"
)
# 显示箴言部分
MainConsole.print(
"[#121110 on #F0F2F4]"
+ random.choice(
requests.get(
"https://gitee.com/EillesWan/Musicreater/raw/master/resources/myWords.txt"
)
.text.strip("\r\n")
.split("\r\n")
),
style="#121110 on #F0F2F4",
justify="center",
)
from typing import Any, Literal, Optional, TextIO
JustifyMethod = Literal["default", "left", "center", "right", "full"]
OverflowMethod = Literal["fold", "crop", "ellipsis", "ignore"]
# 高级的打印函数
def prt(
*objects: Any,
sep: str = " ",
end: str = "\n",
justify: Optional[JustifyMethod] = None,
overflow: Optional[OverflowMethod] = None,
no_wrap: Optional[bool] = None,
emoji: Optional[bool] = None,
markup: Optional[bool] = None,
highlight: Optional[bool] = None,
width: Optional[int] = None,
height: Optional[int] = None,
crop: bool = True,
soft_wrap: Optional[bool] = None,
new_line_start: bool = False,
) -> None:
"""打印到控制台。
Args:
objects (位置性的args): 要记录到终端的对象。
sep (str, 可选): 要在打印数据之间写入的字符串。默认为""
end (str, optio可选nal): 在打印数据结束时写入的字符串。默认值为"\\\\n"
style (Union[str, Style], 可选): 应用于输出的样式。默认为`None`。
justify (str, 可选): 校正位置,可为"default", "left", "right", "center""full". 默认为`None`。
overflow (str, 可选): 控制溢出:"ignore"忽略, "crop"裁剪, "fold"折叠, "ellipsis"省略号。默认为`None`。
no_wrap (Optional[bool], 可选): 禁用文字包装。默认为`None`。
emoji (Optional[bool], 可选): 启用表情符号代码,或使用控制台默认的`None`。默认为`None`。
markup (Optional[bool], 可选): 启用标记,或`None`使用控制台默认值。默认为`None`。
highlight (Optional[bool], 可选): 启用自动高亮,或`None`使用控制台默认值。默认为`None`。
width (Optional[int], 可选): 输出的宽度,或`None`自动检测。默认为`None`。
crop (Optional[bool], 可选): 裁剪输出到终端的宽度。默认为`True`。
soft_wrap (bool, 可选): 启用软包装模式,禁止文字包装和裁剪,或`None``用于 控制台默认值。默认为`None`。
new_line_start (bool, False): 如果输出包含多行,在开始时插入一个新行。默认值为`False`。
"""
MainConsole.print(
*objects,
sep=sep,
end=end,
style="#F0F2F4 on #121110",
justify=justify,
overflow=overflow,
no_wrap=no_wrap,
emoji=emoji,
markup=markup,
highlight=highlight,
width=width,
height=height,
crop=crop,
soft_wrap=soft_wrap,
new_line_start=new_line_start,
)
prt(f"{_('LangChd')}{_(':')}{_(currentLang)}")
# 高级的输入函数
def ipt(
*objects: Any,
sep: str = " ",
justify: Optional[JustifyMethod] = None,
overflow: Optional[OverflowMethod] = None,
no_wrap: Optional[bool] = None,
emoji: Optional[bool] = None,
markup: Optional[bool] = None,
highlight: Optional[bool] = None,
width: Optional[int] = None,
height: Optional[int] = None,
crop: bool = True,
soft_wrap: Optional[bool] = None,
new_line_start: bool = False,
password: bool = False,
stream: Optional[TextIO] = None,
) -> str:
"""显示一个提示并等待用户的输入。
它的工作方式与Python内建的 :func:`input` 函数相同如果Python内建的 :mod:`readline` 模块先前已经加载,则提供详细的行编辑和历史功能。
Args:
objects (位置性的args): 要记录到终端的对象。
sep (str, 可选): 要在打印数据之间写入的字符串。默认为""
end (str, optio可选nal): 在打印数据结束时写入的字符串。默认值为"\\\\n"
style (Union[str, Style], 可选): 应用于输出的样式。默认为`None`。
justify (str, 可选): 校正位置,可为"default", "left", "right", "center""full". 默认为`None`。
overflow (str, 可选): 控制溢出:"ignore"忽略, "crop"裁剪, "fold"折叠, "ellipsis"省略号。默认为`None`。
no_wrap (Optional[bool], 可选): 禁用文字包装。默认为`None`。
emoji (Optional[bool], 可选): 启用表情符号代码,或使用控制台默认的`None`。默认为`None`。
markup (Optional[bool], 可选): 启用标记,或`None`使用控制台默认值。默认为`None`。
highlight (Optional[bool], 可选): 启用自动高亮,或`None`使用控制台默认值。默认为`None`。
width (Optional[int], 可选): 输出的宽度,或`None`自动检测。默认为`None`。
crop (Optional[bool], 可选): 裁剪输出到终端的宽度。默认为`True`。
soft_wrap (bool, 可选): 启用软包装模式,禁止文字包装和裁剪,或`None``用于 控制台默认值。默认为`None`。
new_line_start (bool, False): 如果输出包含多行,在开始时插入一个新行。默认值为`False`。
password (bool, 可选): 隐藏已经输入的文案,默认值为`False`。
stream (TextIO, 可选): 可选从文件中读取(而非控制台),默认为 `None`。
Returns:
str: 从stdin读取的字符串
"""
MainConsole.print(
*objects,
sep=sep,
end="",
style="#F0F2F4 on #121110",
justify=justify,
overflow=overflow,
no_wrap=no_wrap,
emoji=emoji,
markup=markup,
highlight=highlight,
width=width,
height=height,
crop=crop,
soft_wrap=soft_wrap,
new_line_start=new_line_start,
)
return MainConsole.input("", password=password, stream=stream)
def formatipt(notice: str, fun, errnote: str = "", *extraArg):
'''循环输入,以某种格式
notice: 输入时的提示
fun: 格式函数
errnote: 输入不符格式时的提示
*extraArg: 对于函数的其他参数'''
while True:
result = ipt(notice)
try:
funresult = fun(result, *extraArg)
break
except:
prt(errnote)
continue
return result, funresult
# 获取midi列表
while True:
midipath = ipt(f"{_('ChoosePath')}{_(':')}").lower()
if os.path.exists(midipath):
if os.path.isfile(midipath):
midis = (midipath,)
elif os.path.isdir(midipath):
midis = tuple(
(
os.path.join(midipath, i)
for i in os.listdir(midipath)
if i.lower().endswith('.mid') or i.lower().endswith('.midi')
)
)
else:
prt(f"{_('ErrEnter')}{_(',')}{_('Re-Enter')}{_('.')}")
continue
else:
prt(f"{_('FileNotFound')}{_(',')}{_('Re-Enter')}{_('.')}")
continue
break
# 获取输出地址
outpath = formatipt(
f"{_('ChooseOutPath')}{_(':')}",
os.path.exists,
f"{_('FileNotFound')}{_(',')}{_('Re-Enter')}{_('.')}",
).lower()
# 选择输出格式
while True:
fileFormat = ipt(f"{_('ChooseFileFormat')}{_(':')}").lower()
if fileFormat in ('0', 'mcpack'):
fileFormat = 0
prt(_("EnterArgs"))
if len(midis) > 1:
prt(_("noteofArgs"))
elif fileFormat in ('1', 'bdx'):
fileFormat = 1
while True:
playerFormat = ipt(f"{_('ChoosePlayer')}{_(':')}").lower()
if playerFormat in ('0', '延迟'):
playerFormat = 0
elif playerFormat in ('1', '计分板'):
playerFormat = 1
else:
prt(f"{_('ErrEnter')}{_(',')}{_('Re-Enter')}{_('.')}")
continue
break
else:
prt(f"{_('ErrEnter')}{_(',')}{_('Re-Enter')}{_('.')}")
continue
break
if fileFormat == 0:
pass
MainConsole.input()

67
magicFun.py Normal file
View File

@@ -0,0 +1,67 @@
# -*- coding: utf-8 -*-
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 请依照 Apache 2.0 许可证进行许可
"""
音·创 库版 MIDI转换示例程序
Musicreater Package Version : Demo for Midi Conversion
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.
"""
from rich.console import Console
MainConsole = Console()
import requests
import random
# 欸嘿!
while True:
MainConsole.print(
"[#121110 on #F0F2F4] ",
style="#121110 on #F0F2F4",
justify="center",
)
MainConsole.rule(title="[bold #AB70FF]欢迎使用音·创独立转换器", characters="=", style="#26E2FF")
MainConsole.rule(
title="[bold #AB70FF]Welcome to Independent Musicreater Convernter", characters="-"
)
MainConsole.print(
"[#121110 on #F0F2F4]"
+ random.choice(
requests.get(
"https://gitee.com/EillesWan/Musicreater/raw/master/resources/myWords.txt"
)
.text.strip("\r\n")
.split("\r\n")
),
style="#121110 on #F0F2F4",
justify="center",
)
MainConsole.print()

153
mid_analyse.py Normal file
View File

@@ -0,0 +1,153 @@
# -*- coding: utf-8 -*-
##########################################################################
# Form generated from reading UI file 'mid_analyse.ui'
##
# Created by: Qt User Interface Compiler version 6.4.1
##
# WARNING! All changes made in this file will be lost when recompiling UI file!
##########################################################################
# from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
# QMetaObject, QObject, QPoint, QRect,
# QSize, QTime, QUrl, Qt)
# from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
# QFont, QFontDatabase, QGradient, QIcon,
# QImage, QKeySequence, QLinearGradient, QPainter,
# QPalette, QPixmap, QRadialGradient, QTransform)
# from PySide6.QtWidgets import (QApplication, QGroupBox, QHBoxLayout, QLabel,
# QLineEdit, QPushButton, QSizePolicy, QWidget)
import sys
from PySide6.QtWidgets import QApplication, QWidget, QGroupBox, QPushButton, \
QLabel, QLineEdit, QHBoxLayout, QFileDialog
from PySide6.QtCore import QRect, QMetaObject, Slot
class Ui_Form(QWidget):
def __init__(self):
super().__init__()
self.groupBox = None
self.horizontalLayout = None
self.horizontalLayoutWidget = None
self.close_button = None
self.fileChoseButton = None
self.input_button = None
self.note_count_label = None
self.note_count_shower = None
self.output_button = None
def setupUi(self, Form):
if not Form.objectName():
Form.setObjectName(u"Form")
Form.resize(582, 355)
self.groupBox = QGroupBox(Form)
self.groupBox.setObjectName(u"groupBox")
self.groupBox.setGeometry(QRect(10, 0, 561, 311))
self.fileChoseButton = QPushButton(self.groupBox)
self.fileChoseButton.setObjectName(u"file_chose_button")
self.fileChoseButton.setGeometry(QRect(10, 20, 75, 24))
self.note_count_label = QLabel(self.groupBox)
self.note_count_label.setObjectName(u"note_count_label")
self.note_count_label.setGeometry(QRect(20, 50, 54, 16))
self.note_count_shower = QLineEdit(self.groupBox)
self.note_count_shower.setObjectName(u"note_count_shower")
self.note_count_shower.setGeometry(QRect(70, 50, 113, 20))
self.horizontalLayoutWidget = QWidget(Form)
self.horizontalLayoutWidget.setObjectName(u"horizontalLayoutWidget")
self.horizontalLayoutWidget.setGeometry(QRect(10, 310, 561, 41))
self.horizontalLayout = QHBoxLayout(self.horizontalLayoutWidget)
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.input_button = QPushButton(self.horizontalLayoutWidget)
self.input_button.setObjectName(u"input_button")
self.horizontalLayout.addWidget(self.input_button)
self.output_button = QPushButton(self.horizontalLayoutWidget)
self.output_button.setObjectName(u"output_button")
self.horizontalLayout.addWidget(self.output_button)
self.close_button = QPushButton(self.horizontalLayoutWidget)
self.close_button.setObjectName(u"close_button")
self.horizontalLayout.addWidget(self.close_button)
Form.setWindowTitle("Mid解析器")
self.groupBox.setTitle("mid信息")
self.fileChoseButton.setText("选择文件")
self.note_count_label.setText("音符数")
self.input_button.setText("导入")
self.output_button.setText("导出分析")
self.close_button.setText("关闭")
QMetaObject.connectSlotsByName(Form)
# self.ui.btnCalculate.clicked.connect(self.fileLoading)
def fileLoading(self):
filePath, _ = QFileDialog.getOpenFileName(
self.groupBox, # 父窗口对象
"选择文件", # 标题
r"./", # 起始目录
"mid类型 (*.mid *.midi)" # 选择类型过滤项,过滤内容在括号中
)
print(filePath)
@Slot()
def on_fileChoseButton_clicked(self):
filePath, _ = QFileDialog.getOpenFileName(
self.groupBox, # 父窗口对象
"选择文件", # 标题
r"./", # 起始目录
"mid类型 (*.mid *.midi)" # 选择类型过滤项,过滤内容在括号中
)
print(filePath)
class MidAnalyseGui(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.ui.fileChoseButton.clicked.connect(self.fileLoading)
def fileLoading(self):
filePath, _ = QFileDialog.getOpenFileName(
self.ui.groupBox, # 父窗口对象
"选择文件", # 标题
r"./", # 起始目录
"mid类型 (*.mid *.midi)" # 选择类型过滤项,过滤内容在括号中
)
print(filePath)
@Slot()
def on_fileChoseButton_clicked(self):
filePath, _ = QFileDialog.getOpenFileName(
self.ui.groupBox, # 父窗口对象
"选择文件", # 标题
r"./", # 起始目录
"mid类型 (*.mid *.midi)" # 选择类型过滤项,过滤内容在括号中
)
print(filePath)
if __name__ == "__main__":
app = QApplication(sys.argv) # 创建一个QApplication也就是你要开发的软件app
# MainWindow = QMainWindow() # 创建一个QMainWindow用来装载你需要的各种组件、控件
# MainWindow = QWidget() # 创建一个QMainWindow用来装载你需要的各种组件、控件
ui = MidAnalyseGui() # ui是你创建的ui类的实例化对象
# ui.setupUi(MainWindow) # 执行类中的setupUi方法方法的参数是第二步中创建的QMainWindow
ui.show() # 执行QMainWindow的show()方法显示这个QMainWindow
sys.exit(app.exec()) # 使用exit()或者点击关闭按钮退出QApplication
if __name__ == '__main__':
app = QApplication(sys.argv)
MainWindow = QWidget()
ui = Ui_Form()
ui.setupUi(MainWindow)
ui.show()
sys.exit(app.exec())

101
mid_analyse.ui Normal file
View File

@@ -0,0 +1,101 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Form</class>
<widget class="QWidget" name="Form">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>582</width>
<height>355</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QGroupBox" name="groupBox">
<property name="geometry">
<rect>
<x>10</x>
<y>0</y>
<width>561</width>
<height>311</height>
</rect>
</property>
<property name="title">
<string>mid信息</string>
</property>
<widget class="QPushButton" name="file_chose_button">
<property name="geometry">
<rect>
<x>10</x>
<y>20</y>
<width>75</width>
<height>24</height>
</rect>
</property>
<property name="text">
<string>选择文件</string>
</property>
</widget>
<widget class="QLabel" name="note_count_label">
<property name="geometry">
<rect>
<x>20</x>
<y>50</y>
<width>54</width>
<height>16</height>
</rect>
</property>
<property name="text">
<string>音符数</string>
</property>
</widget>
<widget class="QLineEdit" name="note_count_shower">
<property name="geometry">
<rect>
<x>70</x>
<y>50</y>
<width>113</width>
<height>20</height>
</rect>
</property>
</widget>
</widget>
<widget class="QWidget" name="horizontalLayoutWidget">
<property name="geometry">
<rect>
<x>10</x>
<y>310</y>
<width>561</width>
<height>41</height>
</rect>
</property>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="input_button">
<property name="text">
<string>导入</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="output_button">
<property name="text">
<string>导出分析</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="close_button">
<property name="text">
<string>关闭</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
<resources/>
<connections/>
</ui>

34
msctPkgver/__init__.py Normal file
View File

@@ -0,0 +1,34 @@
# -*- coding: utf-8 -*-
"""一个简单的基于音·创的我的世界音频操作工具"""
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 Lisence.md
__version__ = '0.1.0'
__all__ = []
__author__ = (('金羿', 'Eilles Wan'), ('诸葛亮与八卦阵', 'bgArray'), ('鸣凤鸽子', 'MingFengPigeon'))
"""
音·创 库版 (Musicreater Package Version)
是一款免费开源的针对《我的世界基岩版》的midi音乐转换库
Musicreater pkgver (Package Version 音·创 库版)
A free open source library used for convert midi file into formats that is suitable for **Minecraft: Bedrock Edition**.
Copyright 2023 all the developers of Musicreater
开源相关声明请见 ../Lisence.md
Terms & Conditions: ../Lisence.md
"""
from .main import *
print('此Midi转换功能由音·创开发者开发版权归参与开发的人员共同所有。')
print('Copyright © 2022 all the developers of Musicreater')
print("小贴不妨试试Mid-BDX转换网页在线的多功能Midi转换器")
print("https://dislink.github.io/midi2bdx/")

60
msctPkgver/exceptions.py Normal file
View File

@@ -0,0 +1,60 @@
# -*- coding: utf-8 -*-
# 音·创 开发交流群 861684859
# Email EillesWan2006@163.com W-YI_DoctorYI@outlook.com EillesWan@outlook.com
# 版权所有 金羿("Eilles Wan") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 Lisence.md
"""
音·创 库版 (Musicreater Package Version)
是一款免费开源的针对《我的世界基岩版》的midi音乐转换库
Musicreater pkgver (Package Version 音·创 库版)
A free open source library used for convert midi file into formats that is suitable for **Minecraft: Bedrock Edition**.
Copyright 2023 all the developers of Musicreater
开源相关声明请见 ../Lisence.md
Terms & Conditions: ../Lisence.md
"""
class MSCTBaseException(Exception):
"""音·创库版本的所有错误均继承于此"""
def __init__(self, *args):
super().__init__(*args)
def (self,):
for i in self.args:
print(i+"喵!")
def crash_it(self):
raise self
class CrossNoteError(MSCTBaseException):
'''同通道下同音符交叉出现所产生的错误'''
pass
class NotDefineTempoError(MSCTBaseException):
'''没有Tempo设定导致时间无法计算的错误'''
pass
class MidiDestroyedError(MSCTBaseException):
'''Midi文件损坏'''
pass
class ChannelOverFlowError(MSCTBaseException):
'''一个midi中含有过多的通道数量应≤16'''
pass
class NotDefineProgramError(MSCTBaseException):
'''没有Program设定导致没有乐器可以选择的错误'''
pass

217
msctPkgver/magicmain.py Normal file
View File

@@ -0,0 +1,217 @@
# -*- coding: utf-8 -*-
# 音·创 开发交流群 861684859
# 版权所有 金羿("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.
"""
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
# print(msg)
if msg.is_meta:
if msg.type == "set_tempo":
tempo = msg.tempo
else:
if msg.type == "program_change":
# print("TT")
instrumentID = msg.program
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]
# ============================
import mido
class NoteMessage:
def __init__(self, channel, pitch, velocity, startT, lastT, midi, now_bpm, change_bpm=None):
self.channel = channel
self.note = pitch
self.velocity = velocity
self.startTime = startT
self.lastTime = lastT
self.tempo = now_bpm # 这里要程序实现获取bpm可以参考我的程序
def mt2gt(mt, tpb_a, bpm_a):
return mt / tpb_a / bpm_a * 60
self.startTrueTime = mt2gt(self.startTime, midi.ticks_per_beat, self.tempo) # / 20
# delete_extra_zero(round_up())
if change_bpm is not None:
self.lastTrueTime = mt2gt(self.lastTime, midi.ticks_per_beat, change_bpm) # / 20
else:
self.lastTrueTime = mt2gt(self.lastTime, midi.ticks_per_beat, self.tempo) # / 20
# delete_extra_zero(round_up())
print((self.startTime * self.tempo) / (midi.ticks_per_beat * 50000))
def __str__(self):
return "noteMessage channel=" + str(self.channel) + " note=" + str(self.note) + " velocity=" + \
str(self.velocity) + " startTime=" + str(self.startTime) + " lastTime=" + str(self.lastTime) + \
" startTrueTime=" + str(self.startTrueTime) + " lastTrueTime=" + str(self.lastTrueTime)
def load(mid: mido.MidiFile):
type_ = [False, False, False] # note_off / note_on+0 / mixed
is_tempo = False
# 预检
for i, track in enumerate(mid.tracks):
for msg in track:
# print(msg)
if msg.is_meta is not True:
if msg.type == 'note_on' and msg.velocity == 0:
type_[1] = True
elif msg.type == "note_off":
type_[0] = True
if msg.is_meta is True and msg.type == "set_tempo":
is_tempo = True
if is_tempo is not True:
raise Exception("这个mid没有可供计算时间的tempo事件")
if type_[0] is True and type_[1] is True:
type_[2] = True
type_[1] = False
type_[0] = False
print(type_)
bpm = 0
recent_change_bpm = 0
is_change_bpm = False
# 实检
for i, track in enumerate(mid.tracks):
noteOn = []
trackS = []
ticks = 0
for msg in track:
print(msg)
ticks += msg.time
print(ticks)
if msg.is_meta is True and msg.type == "set_tempo":
recent_change_bpm = bpm
bpm = 60000000 / msg.tempo
is_change_bpm = True
if msg.type == 'note_on' and msg.velocity != 0:
noteOn.append([msg, msg.note, ticks])
if type_[1] is True:
if msg.type == 'note_on' and msg.velocity == 0:
for u in noteOn:
index = 0
if u[1] == msg.note:
lastMessage = u[0]
lastTick = u[2]
break
index += 1
print(lastTick)
if is_change_bpm and recent_change_bpm != 0:
trackS.append(NoteMessage(msg.channel, msg.note, lastMessage.velocity, lastTick, ticks - lastTick,
mid, recent_change_bpm, bpm))
is_change_bpm = False
else:
trackS.append(
NoteMessage(msg.channel, msg.note, lastMessage.velocity, lastTick, ticks - lastTick,
mid, bpm))
# print(noteOn)
# print(index)
try:
noteOn.pop(index)
except IndexError:
noteOn.pop(index - 1)
print(trackS)
for j in trackS:
print(j)
if __name__ == '__main__':
load(mido.MidiFile("test.mid"))

1547
msctPkgver/main.py Normal file

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,265 +0,0 @@
# -*- coding: utf-8 -*-
"""
功能测试 若非已知 请勿更改
此文件仅供功能测试,并非实际调用的文件
请注意,此处的文件均为测试使用
不要更改 不要更改 不要更改
请注意这里的一切均需要其原作者更改
这里用于放置一些新奇的点子
用于测试
不要更改 不要更改 不要更改!
"""
# 音·创 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 版权所有 金羿("Eilles") & 诸葛亮与八卦阵("bgArray") & 鸣凤鸽子("MingFengPigeon")
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
"""
音·创 (Musicreater)
是一款免费开源的针对《我的世界》的midi音乐转换库
Musicreater (音·创)
A free open source library used for convert midi file into formats that is suitable for **Minecraft**.
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 ../License.md
Terms & Conditions: ../License.md
"""
# ============================
import mido
class NoteMessage:
def __init__(
self, channel, pitch, velocity, startT, lastT, midi, now_bpm, change_bpm=None
):
self.channel = channel
self.note = pitch
self.velocity = velocity
self.startTime = startT
self.lastTime = lastT
self.tempo = now_bpm # 这里要程序实现获取bpm可以参考我的程序
def mt2gt(mt, tpb_a, bpm_a):
return mt / tpb_a / bpm_a * 60
self.startTrueTime = mt2gt(
self.startTime, midi.ticks_per_beat, self.tempo
) # / 20
# delete_extra_zero(round_up())
if change_bpm is not None:
self.lastTrueTime = mt2gt(
self.lastTime, midi.ticks_per_beat, change_bpm
) # / 20
else:
self.lastTrueTime = mt2gt(
self.lastTime, midi.ticks_per_beat, self.tempo
) # / 20
# delete_extra_zero(round_up())
print((self.startTime * self.tempo) / (midi.ticks_per_beat * 50000))
def __str__(self):
return (
"noteMessage channel="
+ str(self.channel)
+ " note="
+ str(self.note)
+ " velocity="
+ str(self.velocity)
+ " startTime="
+ str(self.startTime)
+ " lastTime="
+ str(self.lastTime)
+ " startTrueTime="
+ str(self.startTrueTime)
+ " lastTrueTime="
+ str(self.lastTrueTime)
)
def load(mid: mido.MidiFile):
type_ = [False, False, False] # note_off / note_on+0 / mixed
is_tempo = False
# 预检
for i, track in enumerate(mid.tracks):
for msg in track:
# print(msg)
if msg.is_meta is not True:
if msg.type == "note_on" and msg.velocity == 0:
type_[1] = True
elif msg.type == "note_off":
type_[0] = True
if msg.is_meta is True and msg.type == "set_tempo":
is_tempo = True
if is_tempo is not True:
raise Exception("这个mid没有可供计算时间的tempo事件")
if type_[0] is True and type_[1] is True:
type_[2] = True
type_[1] = False
type_[0] = False
print(type_)
bpm = 0
recent_change_bpm = 0
is_change_bpm = False
# 实检
for i, track in enumerate(mid.tracks):
noteOn = []
trackS = []
ticks = 0
for msg in track:
print(msg)
ticks += msg.time
print(ticks)
if msg.is_meta is True and msg.type == "set_tempo":
recent_change_bpm = bpm
bpm = 60000000 / msg.tempo
is_change_bpm = True
if msg.type == "note_on" and msg.velocity != 0:
noteOn.append([msg, msg.note, ticks])
if type_[1] is True:
if msg.type == "note_on" and msg.velocity == 0:
for u in noteOn:
index = 0
if u[1] == msg.note:
lastMessage = u[0]
lastTick = u[2]
break
index += 1
print(lastTick)
if is_change_bpm and recent_change_bpm != 0:
trackS.append(
NoteMessage(
msg.channel,
msg.note,
lastMessage.velocity,
lastTick,
ticks - lastTick,
mid,
recent_change_bpm,
bpm,
)
)
is_change_bpm = False
else:
trackS.append(
NoteMessage(
msg.channel,
msg.note,
lastMessage.velocity,
lastTick,
ticks - lastTick,
mid,
bpm,
)
)
# print(noteOn)
# print(index)
try:
noteOn.pop(index)
except IndexError:
noteOn.pop(index - 1)
print(trackS)
for j in trackS:
print(j)
if __name__ == "__main__":
load(mido.MidiFile("test.mid"))
# ============================
from typing import Literal
from ..constants import x, y, z
# 不要用 没写完
def delay_to_note_blocks(
baseblock: str = "stone",
position_forward: Literal["x", "y", "z"] = z,
):
"""传入音符,生成以音符盒存储的红石音乐
:param:
baseblock: 中继器的下垫方块
position_forward: 结构延长方向
:return 是否生成成功
"""
from TrimMCStruct import Block, Structure
struct = Structure(
(_sideLength, max_height, _sideLength), # 声明结构大小
)
log = print
startpos = [0, 0, 0]
# 1拍 x 2.5 rt
for i in notes:
error = True
try:
struct.set_block(
[startpos[0], startpos[1] + 1, startpos[2]],
form_note_block_in_NBT_struct(height2note[i[0]], instrument),
)
struct.set_block(
startpos,
Block("universal_minecraft", instuments[i[0]][1]),
)
error = False
except ValueError:
log("无法放置音符:" + str(i) + "" + str(startpos))
struct.set_block(Block("universal_minecraft", baseblock), startpos)
struct.set_block(
Block("universal_minecraft", baseblock),
[startpos[0], startpos[1] + 1, startpos[2]],
)
finally:
if error is True:
log("无法放置音符:" + str(i) + "" + str(startpos))
struct.set_block(Block("universal_minecraft", baseblock), startpos)
struct.set_block(
Block("universal_minecraft", baseblock),
[startpos[0], startpos[1] + 1, startpos[2]],
)
delay = int(i[1] * speed + 0.5)
if delay <= 4:
startpos[0] += 1
struct.set_block(
form_repeater_in_NBT_struct(delay, "west"),
[startpos[0], startpos[1] + 1, startpos[2]],
)
struct.set_block(Block("universal_minecraft", baseblock), startpos)
else:
for j in range(int(delay / 4)):
startpos[0] += 1
struct.set_block(
form_repeater_in_NBT_struct(4, "west"),
[startpos[0], startpos[1] + 1, startpos[2]],
)
struct.set_block(Block("universal_minecraft", baseblock), startpos)
if delay % 4 != 0:
startpos[0] += 1
struct.set_block(
form_repeater_in_NBT_struct(delay % 4, "west"),
[startpos[0], startpos[1] + 1, startpos[2]],
)
struct.set_block(Block("universal_minecraft", baseblock), startpos)
startpos[0] += posadder[0]
startpos[1] += posadder[1]
startpos[2] += posadder[2]

View File

@@ -1,165 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放一些报错类型
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
class MSCTBaseException(Exception):
"""音·创 的所有错误均继承于此"""
def __init__(self, *args):
"""音·创 的所有错误均继承于此"""
super().__init__("音·创", *args)
def meow(
self,
):
for i in self.args:
print(i + "喵!")
def crash_it(self):
raise self
class MidiFormatException(MSCTBaseException):
"""音·创 的所有MIDI格式错误均继承于此"""
def __init__(self, *args):
"""音·创 的所有MIDI格式错误均继承于此"""
super().__init__("MIDI 格式错误", *args)
class MidiDestroyedError(MSCTBaseException):
"""Midi文件损坏"""
def __init__(self, *args):
"""Midi文件损坏"""
super().__init__("MIDI文件损坏无法读取 MIDI 文件", *args)
# class MidiUnboundError(MSCTBaseException):
# """未定义Midi对象无用"""
# def __init__(self, *args):
# """未绑定Midi对象"""
# super().__init__("未定义MidiFile对象你甚至没有对象就想要生孩子", *args)
# 此错误在本版本内已经不再使用
class CommandFormatError(MSCTBaseException, RuntimeError):
"""指令格式与目标格式不匹配而引起的错误"""
def __init__(self, *args):
"""指令格式与目标格式不匹配而引起的错误"""
super().__init__("指令格式不匹配", *args)
# class CrossNoteError(MidiFormatException):
# """同通道下同音符交叉出现所产生的错误"""
# def __init__(self, *args):
# """同通道下同音符交叉出现所产生的错误"""
# super().__init__("同通道下同音符交叉", *args)
# 这TM是什么错误
# 我什么时候写的这玩意?
# 我哪知道这说的是啥?
#
# 我知道这是什么了 —— 金羿 2025 0401
# 两个其他属性相同的音符在同一个通道,出现连续两个开音信息和连续两个停止信息
# 那么这两个音符的音长无法判断。这是个好问题,但是不是我现在能解决的,也不是我们现在想解决的问题
class NotDefineTempoError(MidiFormatException):
"""没有Tempo设定导致时间无法计算的错误"""
def __init__(self, *args):
"""没有Tempo设定导致时间无法计算的错误"""
super().__init__("在曲目开始时没有声明 Tempo未指定拍长", *args)
class ChannelOverFlowError(MidiFormatException):
"""一个midi中含有过多的通道"""
def __init__(self, max_channel=16, *args):
"""一个midi中含有过多的通道"""
super().__init__("含有过多的通道(数量应≤{}".format(max_channel), *args)
class NotDefineProgramError(MidiFormatException):
"""没有Program设定导致没有乐器可以选择的错误"""
def __init__(self, *args):
"""没有Program设定导致没有乐器可以选择的错误"""
super().__init__("未指定演奏乐器", *args)
class NoteOnOffMismatchError(MidiFormatException):
"""音符开音和停止不匹配的错误"""
def __init__(self, *args):
"""音符开音和停止不匹配的错误"""
super().__init__("音符不匹配", *args)
class LyricMismatchError(MSCTBaseException):
"""歌词匹配解析错误"""
def __init__(self, *args):
"""有可能产生了错误的歌词解析"""
super().__init__("歌词解析错误", *args)
# 已重构
class ZeroSpeedError(MSCTBaseException, ZeroDivisionError):
"""以0作为播放速度的错误"""
def __init__(self, *args):
"""以0作为播放速度的错误"""
super().__init__("播放速度为零", *args)
# 已重构
class IllegalMinimumVolumeError(MSCTBaseException, ValueError):
"""最小播放音量有误的错误"""
def __init__(self, *args):
"""最小播放音量错误"""
super().__init__("最小播放音量超出范围", *args)
# 已重构
class MusicSequenceDecodeError(MSCTBaseException):
"""音乐序列解码错误"""
def __init__(self, *args):
"""音乐序列无法正确解码的错误"""
super().__init__("解码音符序列文件时出现问题", *args)
# 已重构
class MusicSequenceTypeError(MSCTBaseException):
"""音乐序列类型错误"""
def __init__(self, *args):
"""无法识别音符序列字节码的类型"""
super().__init__("错误的音符序列字节类型", *args)
# 已重构
class MusicSequenceVerificationFailed(MusicSequenceDecodeError):
"""音乐序列校验失败"""
def __init__(self, *args):
"""音符序列文件与其校验值不一致"""
super().__init__("音符序列文件校验失败", *args)

View File

@@ -1,144 +0,0 @@
# -*- coding: utf-8 -*-
"""一个简单的我的世界音频转换库
音·创 (Musicreater)
是一款免费开源的《我的世界》数字音频支持库。
Musicreater(音·创)
A free open source library used for dealing with **Minecraft** digital musics.
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
音·创(“本项目”)的协议颁发者为 金羿、诸葛亮与八卦阵
The Licensor of Musicreater("this project") is Eilles, bgArray.
本项目根据 第一版 汉钰律许可协议(“本协议”)授权。
任何人皆可从以下地址获得本协议副本https://gitee.com/EillesWan/YulvLicenses。
若非因法律要求或经过了特殊准许,此作品在根据本协议“原样”提供的基础上,不予提供任何形式的担保、任何明示、任何暗示或类似承诺。也就是说,用户将自行承担因此作品的质量或性能问题而产生的全部风险。
详细的准许和限制条款请见原协议文本。
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__version__ = "2.4.2.3"
__vername__ = "音符附加信息升级"
__author__ = (
("金羿", "Eilles"),
("诸葛亮与八卦阵", "bgArray"),
("鱼旧梦", "ElapsingDreams"),
("偷吃不是Touch", "Touch"),
)
__all__ = [
# 主要类
"MusicSequence",
"MidiConvert",
# 附加类
# "SingleNote",
"MineNote",
"MineCommand",
"SingleNoteBox",
"ProgressBarStyle",
# "TimeStamp", 未来功能
# 字典键
"MIDI_PROGRAM",
"MIDI_VOLUME",
"MIDI_PAN",
# 默认值
"MIDI_DEFAULT_PROGRAM_VALUE",
"MIDI_DEFAULT_VOLUME_VALUE",
"DEFAULT_PROGRESSBAR_STYLE",
# Midi 自己的对照表
"MIDI_PITCH_NAME_TABLE",
"MIDI_PITCHED_NOTE_NAME_GROUP",
"MIDI_PITCHED_NOTE_NAME_TABLE",
"MIDI_PERCUSSION_NOTE_NAME_TABLE",
# Minecraft 自己的对照表
"MC_PERCUSSION_INSTRUMENT_LIST",
"MC_PITCHED_INSTRUMENT_LIST",
"MC_INSTRUMENT_BLOCKS_TABLE",
"MC_EILLES_RTJE12_INSTRUMENT_REPLACE_TABLE",
"MC_EILLES_RTBETA_INSTRUMENT_REPLACE_TABLE",
# Midi 与 游戏 的对照表
"MM_INSTRUMENT_RANGE_TABLE",
"MM_INSTRUMENT_DEVIATION_TABLE",
"MM_CLASSIC_PITCHED_INSTRUMENT_TABLE",
"MM_CLASSIC_PERCUSSION_INSTRUMENT_TABLE",
"MM_TOUCH_PITCHED_INSTRUMENT_TABLE",
"MM_TOUCH_PERCUSSION_INSTRUMENT_TABLE",
"MM_DISLINK_PITCHED_INSTRUMENT_TABLE",
"MM_DISLINK_PERCUSSION_INSTRUMENT_TABLE",
"MM_NBS_PITCHED_INSTRUMENT_TABLE",
"MM_NBS_PERCUSSION_INSTRUMENT_TABLE",
# 操作性函数
"velocity_2_distance_natural",
"velocity_2_distance_straight",
"panning_2_rotation_linear",
"panning_2_rotation_trigonometric",
# 工具函数
"load_decode_musicsequence_metainfo",
"load_decode_msq_flush_release",
"load_decode_fsq_flush_release",
"guess_deviation",
"mctick2timestr",
"midi_inst_to_mc_sound",
]
from .old_main import MusicSequence, MidiConvert
from .subclass import (
MineNote,
MineCommand,
SingleNoteBox,
ProgressBarStyle,
mctick2timestr,
DEFAULT_PROGRESSBAR_STYLE,
)
from .utils import (
# 兼容性函数
load_decode_musicsequence_metainfo,
load_decode_msq_flush_release,
load_decode_fsq_flush_release,
# 工具函数
guess_deviation,
midi_inst_to_mc_sound,
# 处理用函数
velocity_2_distance_natural,
velocity_2_distance_straight,
panning_2_rotation_linear,
panning_2_rotation_trigonometric,
)
from .constants import (
# 字典键
MIDI_PROGRAM,
MIDI_PAN,
MIDI_VOLUME,
# 默认值
MIDI_DEFAULT_PROGRAM_VALUE,
MIDI_DEFAULT_VOLUME_VALUE,
# MIDI 表
MIDI_PITCH_NAME_TABLE,
MIDI_PITCHED_NOTE_NAME_GROUP,
MIDI_PITCHED_NOTE_NAME_TABLE,
MIDI_PERCUSSION_NOTE_NAME_TABLE,
# 我的世界 表
MC_EILLES_RTBETA_INSTRUMENT_REPLACE_TABLE,
MC_EILLES_RTJE12_INSTRUMENT_REPLACE_TABLE,
MC_INSTRUMENT_BLOCKS_TABLE,
MC_PERCUSSION_INSTRUMENT_LIST,
MC_PITCHED_INSTRUMENT_LIST,
# MIDI 到 我的世界 表
MM_INSTRUMENT_RANGE_TABLE,
MM_INSTRUMENT_DEVIATION_TABLE,
MM_CLASSIC_PITCHED_INSTRUMENT_TABLE,
MM_CLASSIC_PERCUSSION_INSTRUMENT_TABLE,
MM_TOUCH_PITCHED_INSTRUMENT_TABLE,
MM_TOUCH_PERCUSSION_INSTRUMENT_TABLE,
MM_DISLINK_PITCHED_INSTRUMENT_TABLE,
MM_DISLINK_PERCUSSION_INSTRUMENT_TABLE,
MM_NBS_PITCHED_INSTRUMENT_TABLE,
MM_NBS_PERCUSSION_INSTRUMENT_TABLE,
)

File diff suppressed because it is too large Load Diff

View File

@@ -1,73 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放非音·创本体的附加功能件
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = [
# 通用
# "ConvertConfig",
"bottem_side_length_of_smallest_square_bottom_box",
# 打包
"compress_zipfile",
"behavior_mcpack_manifest",
# MCSTRUCTURE 函数
"antiaxis",
"forward_IER",
"command_statevalue",
"form_note_block_in_NBT_struct",
"form_repeater_in_NBT_struct",
"form_command_block_in_NBT_struct",
"commands_to_structure",
"commands_to_redstone_delay_structure",
# MCSTRUCTURE 常量
"AXIS_PARTICULAR_VALUE",
"COMPABILITY_VERSION_117",
"COMPABILITY_VERSION_119",
"COMPABILITY_VERSION_121",
# BDX 函数
"bdx_move",
"form_command_block_in_BDX_bytes",
"commands_to_BDX_bytes",
# BDX 常量
"BDX_MOVE_KEY",
]
__author__ = (("金羿", "Eilles"), ("诸葛亮与八卦阵", "bgArray"))
# from .main import ConvertConfig
from .archive import compress_zipfile, behavior_mcpack_manifest
from .bdx import (
BDX_MOVE_KEY,
bdx_move,
form_command_block_in_BDX_bytes,
commands_to_BDX_bytes,
)
from .common import bottem_side_length_of_smallest_square_bottom_box
from .mcstructure import (
antiaxis,
forward_IER,
AXIS_PARTICULAR_VALUE,
COMPABILITY_VERSION_119,
COMPABILITY_VERSION_117,
COMPABILITY_VERSION_121,
command_statevalue,
form_note_block_in_NBT_struct,
form_repeater_in_NBT_struct,
form_command_block_in_NBT_struct,
commands_to_structure,
commands_to_redstone_delay_structure,
)

View File

@@ -1,30 +0,0 @@
# -*- coding: utf-8 -*-
"""
用以生成附加包的附加功能
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = [
"to_addon_pack_in_delay",
"to_addon_pack_in_score",
"to_addon_pack_in_repeater",
"to_addon_pack_in_repeater_divided_by_instrument",
]
__author__ = (("金羿", "Eilles"),)
from .main import (
to_addon_pack_in_delay,
to_addon_pack_in_repeater,
to_addon_pack_in_score,
to_addon_pack_in_repeater_divided_by_instrument,
)

View File

@@ -1,684 +0,0 @@
# -*- coding: utf-8 -*-
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import json
import os
import shutil
from typing import Literal, Optional, Tuple
from ...old_main import MidiConvert
from ...subclass import ProgressBarStyle
from ..archive import behavior_mcpack_manifest, compress_zipfile
from ..mcstructure import (
COMPABILITY_VERSION_117,
COMPABILITY_VERSION_119,
Structure,
commands_to_redstone_delay_structure,
commands_to_structure,
form_command_block_in_NBT_struct,
)
def to_addon_pack_in_score(
midi_cvt: MidiConvert,
dist_path: str,
progressbar_style: Optional[ProgressBarStyle],
scoreboard_name: str = "mscplay",
auto_reset: bool = False,
) -> Tuple[int, int]:
"""
将midi以计分播放器形式转换为我的世界函数附加包
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
scoreboard_name: str
我的世界的计分板名称
auto_reset: bool
是否自动重置计分板
Returns
-------
tuple[int指令数量, int音乐总延迟]
"""
cmdlist, maxlen, maxscore = midi_cvt.to_command_list_in_score(
scoreboard_name=scoreboard_name,
)
# 当文件f夹{self.outputPath}/temp/functions存在时清空其下所有项目然后创建
if os.path.exists(f"{dist_path}/temp/functions/"):
shutil.rmtree(f"{dist_path}/temp/functions/")
os.makedirs(f"{dist_path}/temp/functions/mscplay")
# 写入manifest.json
with open(f"{dist_path}/temp/manifest.json", "w", encoding="utf-8") as f:
json.dump(
behavior_mcpack_manifest(
pack_description=f"{midi_cvt.music_name} 音乐播放包MCFUNCTION(MCPACK) 计分播放器 - 由 音·创 生成",
pack_name=midi_cvt.music_name + "播放",
modules_description=f"无 - 由 音·创 生成",
format_version=1 if midi_cvt.enable_old_exe_format else 2,
pack_engine_version=(
None if midi_cvt.enable_old_exe_format else [1, 19, 50]
),
),
fp=f,
indent=4,
)
# 写入stop.mcfunction
with open(
f"{dist_path}/temp/functions/stop.mcfunction", "w", encoding="utf-8"
) as f:
f.write("scoreboard players reset @a {}".format(scoreboard_name))
# 将命令列表写入文件
index_file = open(
f"{dist_path}/temp/functions/index.mcfunction", "w", encoding="utf-8"
)
for i in range(len(cmdlist)):
index_file.write(f"function mscplay/track{i + 1}\n")
with open(
f"{dist_path}/temp/functions/mscplay/track{i + 1}.mcfunction",
"w",
encoding="utf-8",
) as f:
f.write("\n".join([single_cmd.cmd for single_cmd in cmdlist[i]]))
index_file.writelines(
(
"scoreboard players add @a[scores={"
+ scoreboard_name
+ "=1..}] "
+ scoreboard_name
+ " 1\n",
(
(
"scoreboard players reset @a[scores={"
+ scoreboard_name
+ "="
+ str(maxscore + 20)
+ "..}]"
+ f" {scoreboard_name}\n"
)
if auto_reset
else ""
),
f"function mscplay/progressShow\n" if progressbar_style else "",
)
)
if progressbar_style:
with open(
f"{dist_path}/temp/functions/mscplay/progressShow.mcfunction",
"w",
encoding="utf-8",
) as f:
f.writelines(
"\n".join(
[
single_cmd.cmd
for single_cmd in midi_cvt.form_progress_bar(
maxscore, scoreboard_name, progressbar_style
)
]
)
)
index_file.close()
if os.path.exists(f"{dist_path}/{midi_cvt.music_name}.mcpack"):
os.remove(f"{dist_path}/{midi_cvt.music_name}.mcpack")
compress_zipfile(
f"{dist_path}/temp/",
f"{dist_path}/{midi_cvt.music_name}[score].mcpack",
)
shutil.rmtree(f"{dist_path}/temp/")
return maxlen, maxscore
def to_addon_pack_in_delay(
midi_cvt: MidiConvert,
dist_path: str,
progressbar_style: Optional[ProgressBarStyle],
player: str = "@a",
max_height: int = 64,
) -> Tuple[int, int]:
"""
将midi以延迟播放器形式转换为mcstructure结构文件后打包成附加包并在附加包中生成相应地导入函数
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
player: str
玩家选择器,默认为`@a`
max_height: int
生成结构最大高度
Returns
-------
tuple[int指令数量, int音乐总延迟]
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
command_list, max_delay = midi_cvt.to_command_list_in_delay(
player_selector=player,
)[:2]
if not os.path.exists(dist_path):
os.makedirs(dist_path)
# 当文件f夹{self.outputPath}/temp/存在时清空其下所有项目,然后创建
if os.path.exists(f"{dist_path}/temp/"):
shutil.rmtree(f"{dist_path}/temp/")
os.makedirs(f"{dist_path}/temp/functions/")
os.makedirs(f"{dist_path}/temp/structures/")
# 写入manifest.json
with open(f"{dist_path}/temp/manifest.json", "w", encoding="utf-8") as f:
json.dump(
behavior_mcpack_manifest(
pack_description=f"{midi_cvt.music_name} 音乐播放包MCSTRUCTURE(MCPACK) 延迟播放器 - 由 音·创 生成",
pack_name=midi_cvt.music_name + "播放",
modules_description=f"无 - 由 音·创 生成",
format_version=1 if midi_cvt.enable_old_exe_format else 2,
pack_engine_version=(
None if midi_cvt.enable_old_exe_format else [1, 19, 50]
),
),
fp=f,
indent=4,
ensure_ascii=False,
)
# 写入stop.mcfunction
with open(
f"{dist_path}/temp/functions/stop.mcfunction", "w", encoding="utf-8"
) as f:
f.write(
"gamerule commandblocksenabled false\ngamerule commandblocksenabled true"
)
# 将命令列表写入文件
index_file = open(
f"{dist_path}/temp/functions/index.mcfunction", "w", encoding="utf-8"
)
struct, size, end_pos = commands_to_structure(
command_list,
max_height - 1,
compability_version_=compability_ver,
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_main.mcstructure",
)
),
"wb+",
) as f:
struct.dump(f)
del struct
if progressbar_style:
scb_name = midi_cvt.music_name[:3] + "Pgb"
index_file.write("scoreboard objectives add {0} dummy {0}\n".format(scb_name))
struct_a = Structure((1, 1, 1), compability_version=compability_ver)
struct_a.set_block(
(0, 0, 0),
form_command_block_in_NBT_struct(
r"scoreboard players add {} {} 1".format(player, scb_name),
(0, 0, 0),
1,
1,
alwaysRun=False,
customName="显示进度条并加分",
compability_version_number=compability_ver,
),
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_start.mcstructure",
)
),
"wb+",
) as f:
struct_a.dump(f)
index_file.write(f"structure load {midi_cvt.music_name}_start ~ ~ ~1\n")
pgb_struct, pgbSize, pgbNowPos = commands_to_structure(
midi_cvt.form_progress_bar(max_delay, scb_name, progressbar_style),
max_height - 1,
compability_version_=compability_ver,
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_pgb.mcstructure",
)
),
"wb+",
) as f:
pgb_struct.dump(f)
index_file.write(f"structure load {midi_cvt.music_name}_pgb ~ ~1 ~1\n")
struct_a = Structure(
(1, 1, 1),
)
struct_a.set_block(
(0, 0, 0),
form_command_block_in_NBT_struct(
r"scoreboard players reset {} {}".format(player, scb_name),
(0, 0, 0),
1,
0,
alwaysRun=False,
customName="重置进度条计分板",
compability_version_number=compability_ver,
),
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_reset.mcstructure",
)
),
"wb+",
) as f:
struct_a.dump(f)
del struct_a, pgb_struct
index_file.write(
f"structure load {midi_cvt.music_name}_reset ~{pgbSize[0] + 2} ~ ~1\n"
)
index_file.write(
f"structure load {midi_cvt.music_name}_main ~{pgbSize[0] + 2} ~1 ~1\n"
)
else:
index_file.write(f"structure load {midi_cvt.music_name}_main ~ ~ ~1\n")
index_file.close()
if os.path.exists(f"{dist_path}/{midi_cvt.music_name}.mcpack"):
os.remove(f"{dist_path}/{midi_cvt.music_name}.mcpack")
compress_zipfile(
f"{dist_path}/temp/",
f"{dist_path}/{midi_cvt.music_name}[delay].mcpack",
)
shutil.rmtree(f"{dist_path}/temp/")
return len(command_list), max_delay
def to_addon_pack_in_repeater(
midi_cvt: MidiConvert,
dist_path: str,
progressbar_style: Optional[ProgressBarStyle],
player: str = "@a",
axis_side: Literal["z+", "z-", "Z+", "Z-", "x+", "x-", "X+", "X-"] = "z+",
basement_block: str = "concrete",
max_height: int = 65,
) -> Tuple[int, int]:
"""
将midi以中继器播放器形式转换为mcstructure结构文件后打包成附加包并在附加包中生成相应地导入函数
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
player: str
玩家选择器,默认为`@a`
max_height: int
生成结构最大高度
Returns
-------
tuple[int指令数量, int音乐总延迟]
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
command_list, max_delay, max_together = midi_cvt.to_command_list_in_delay(
player_selector=player,
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
# 当文件f夹{self.outputPath}/temp/存在时清空其下所有项目,然后创建
if os.path.exists(f"{dist_path}/temp/"):
shutil.rmtree(f"{dist_path}/temp/")
os.makedirs(f"{dist_path}/temp/functions/")
os.makedirs(f"{dist_path}/temp/structures/")
# 写入manifest.json
with open(f"{dist_path}/temp/manifest.json", "w", encoding="utf-8") as f:
json.dump(
behavior_mcpack_manifest(
pack_description=f"{midi_cvt.music_name} 音乐播放包MCSTRUCTURE(MCPACK) 中继器播放器 - 由 音·创 生成",
pack_name=midi_cvt.music_name + "播放",
modules_description=f"无 - 由 音·创 生成",
format_version=1 if midi_cvt.enable_old_exe_format else 2,
pack_engine_version=(
None if midi_cvt.enable_old_exe_format else [1, 19, 50]
),
),
fp=f,
indent=4,
)
# 写入stop.mcfunction
with open(
f"{dist_path}/temp/functions/stop.mcfunction", "w", encoding="utf-8"
) as f:
f.write(
"gamerule commandblocksenabled false\ngamerule commandblocksenabled true"
)
# 将命令列表写入文件
index_file = open(
f"{dist_path}/temp/functions/index.mcfunction", "w", encoding="utf-8"
)
struct, size, end_pos = commands_to_redstone_delay_structure(
commands=command_list,
delay_length=max_delay,
max_multicmd_length=max_together,
base_block=basement_block,
axis_=axis_side,
compability_version_=compability_ver,
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_main.mcstructure",
)
),
"wb+",
) as f:
struct.dump(f)
del struct
if progressbar_style:
scb_name = midi_cvt.music_name[:3] + "Pgb"
index_file.write("scoreboard objectives add {0} dummy {0}\n".format(scb_name))
struct_a = Structure((1, 1, 1), compability_version=compability_ver)
struct_a.set_block(
(0, 0, 0),
form_command_block_in_NBT_struct(
r"scoreboard players add {} {} 1".format(player, scb_name),
(0, 0, 0),
1,
1,
alwaysRun=False,
customName="显示进度条并加分",
compability_version_number=compability_ver,
),
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_start.mcstructure",
)
),
"wb+",
) as f:
struct_a.dump(f)
index_file.write(f"structure load {midi_cvt.music_name}_start ~ ~ ~1\n")
pgb_struct, pgbSize, pgbNowPos = commands_to_structure(
midi_cvt.form_progress_bar(max_delay, scb_name, progressbar_style),
max_height - 1,
compability_version_=compability_ver,
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_pgb.mcstructure",
)
),
"wb+",
) as f:
pgb_struct.dump(f)
index_file.write(f"structure load {midi_cvt.music_name}_pgb ~ ~1 ~1\n")
struct_a = Structure(
(1, 1, 1),
)
struct_a.set_block(
(0, 0, 0),
form_command_block_in_NBT_struct(
r"scoreboard players reset {} {}".format(player, scb_name),
(0, 0, 0),
1,
0,
alwaysRun=False,
customName="重置进度条计分板",
compability_version_number=compability_ver,
),
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
f"{midi_cvt.music_name}_reset.mcstructure",
)
),
"wb+",
) as f:
struct_a.dump(f)
del struct_a, pgb_struct
index_file.write(
f"structure load {midi_cvt.music_name}_reset ~{pgbSize[0] + 2} ~ ~1\n"
)
index_file.write(
f"structure load {midi_cvt.music_name}_main ~{pgbSize[0] + 2} ~1 ~1\n"
)
else:
index_file.write(f"structure load {midi_cvt.music_name}_main ~ ~ ~1\n")
index_file.close()
if os.path.exists(f"{dist_path}/{midi_cvt.music_name}.mcpack"):
os.remove(f"{dist_path}/{midi_cvt.music_name}.mcpack")
compress_zipfile(
f"{dist_path}/temp/",
f"{dist_path}/{midi_cvt.music_name}[repeater].mcpack",
)
shutil.rmtree(f"{dist_path}/temp/")
return len(command_list), max_delay
def to_addon_pack_in_repeater_divided_by_instrument(
midi_cvt: MidiConvert,
dist_path: str,
player: str = "@a",
max_height: int = 65,
base_block: str = "concrete",
axis_side: Literal["z+", "z-", "Z+", "Z-", "x+", "x-", "X+", "X-"] = "z+",
) -> Tuple[int, int]:
"""
将midi以中继器播放器形式转换为mcstructure结构文件后打包成附加包并在附加包中生成相应地导入函数
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
player: str
玩家选择器,默认为`@a`
max_height: int
生成结构最大高度
Returns
-------
tuple[int指令数量, int音乐总延迟]
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
# 当文件f夹{self.outputPath}/temp/存在时清空其下所有项目,然后创建
if os.path.exists(f"{dist_path}/temp/"):
shutil.rmtree(f"{dist_path}/temp/")
os.makedirs(f"{dist_path}/temp/functions/")
os.makedirs(f"{dist_path}/temp/structures/")
# 写入manifest.json
with open(f"{dist_path}/temp/manifest.json", "w", encoding="utf-8") as f:
json.dump(
behavior_mcpack_manifest(
pack_description=f"{midi_cvt.music_name} 音乐播放包MCSTRUCTURE(MCPACK) 中继器播放器(拆分) - 由 音·创 生成",
pack_name=midi_cvt.music_name + "播放",
modules_description=f"无 - 由 音·创 生成",
format_version=1 if midi_cvt.enable_old_exe_format else 2,
pack_engine_version=(
None if midi_cvt.enable_old_exe_format else [1, 19, 50]
),
),
fp=f,
indent=4,
)
# 写入stop.mcfunction
with open(
f"{dist_path}/temp/functions/stop.mcfunction", "w", encoding="utf-8"
) as f:
f.write(
"gamerule commandblocksenabled false\ngamerule commandblocksenabled true"
)
# 将命令列表写入文件
index_file = open(
f"{dist_path}/temp/functions/index.mcfunction", "w", encoding="utf-8"
)
cmd_dict, max_delay, max_multiple_cmd_count = (
midi_cvt.to_command_list_in_delay_devided_by_instrument(
player_selector=player,
)
)
base_height = 0
for inst, cmd_list in cmd_dict.items():
struct, size, end_pos = commands_to_redstone_delay_structure(
cmd_list,
max_delay,
max_multiple_cmd_count[inst],
base_block,
axis_=axis_side,
compability_version_=compability_ver,
)
bkn = "{}_{}".format(midi_cvt.music_name, inst.replace(".", "-"))
with open(
os.path.abspath(
os.path.join(
dist_path,
"temp/structures/",
"{}_main.mcstructure".format(bkn),
)
),
"wb+",
) as f:
struct.dump(f)
index_file.write("structure load {}_main ~ ~{} ~3\n".format(bkn, base_height))
base_height += 2 + size[1]
index_file.close()
if os.path.exists(f"{dist_path}/{midi_cvt.music_name}.mcpack"):
os.remove(f"{dist_path}/{midi_cvt.music_name}.mcpack")
compress_zipfile(
f"{dist_path}/temp/",
f"{dist_path}/{midi_cvt.music_name}[repeater-div].mcpack",
)
shutil.rmtree(f"{dist_path}/temp/")
return midi_cvt.total_note_count, max_delay

View File

@@ -1,104 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放关于文件打包的内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import datetime
import os
import uuid
import zipfile
from typing import List, Literal, Union
def compress_zipfile(sourceDir, outFilename, compression=8, exceptFile=None):
"""
使用指定的压缩算法将目录打包为zip文件
Parameters
------------
sourceDir: str
要压缩的源目录路径
outFilename: str
输出的zip文件路径
compression: int, 可选
压缩算法默认为8 (DEFLATED)
可用算法:
STORED = 0
DEFLATED = 8 (默认)
BZIP2 = 12
LZMA = 14
exceptFile: list[str], 可选
需要排除在压缩包外的文件名称列表(可选)
Returns
---------
None
"""
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)
arc_name = pathfile[pre_len:].strip(os.path.sep) # 相对路径
zipf.write(pathfile, arc_name)
zipf.close()
def behavior_mcpack_manifest(
format_version: Union[Literal[1], Literal[2]] = 1,
pack_description: str = "",
pack_version: Union[List[int], Literal[None]] = None,
pack_name: str = "",
pack_uuid: Union[str, Literal[None]] = None,
pack_engine_version: Union[List[int], None] = None,
modules_description: str = "",
modules_version: List[int] = [0, 0, 1],
modules_uuid: Union[str, Literal[None]] = None,
):
"""
生成一个我的世界行为包组件的定义清单文件
"""
if not pack_version:
now_date = datetime.datetime.now()
pack_version = [
now_date.year,
now_date.month * 100 + now_date.day,
now_date.hour * 100 + now_date.minute,
]
result = {
"format_version": format_version,
"header": {
"description": pack_description,
"version": pack_version,
"name": pack_name,
"uuid": str(uuid.uuid4()) if not pack_uuid else pack_uuid,
},
"modules": [
{
"description": modules_description,
"type": "data",
"version": modules_version,
"uuid": str(uuid.uuid4()) if not modules_uuid else modules_uuid,
}
],
}
if pack_engine_version:
result["header"]["min_engine_version"] = pack_engine_version
return result

View File

@@ -1,229 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放有关BDX结构操作的内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from typing import List
from ..constants import x, y, z
from ..subclass import MineCommand
from .common import bottem_side_length_of_smallest_square_bottom_box
BDX_MOVE_KEY = {
"x": [b"\x0f", b"\x0e", b"\x1c", b"\x14", b"\x15"],
"y": [b"\x11", b"\x10", b"\x1d", b"\x16", b"\x17"],
"z": [b"\x13", b"\x12", b"\x1e", b"\x18", b"\x19"],
}
"""key存储了方块移动指令的数据其中可以用key[x|y|z][0|1]来表示xyz的减或增
而key[][2+]是用来增加指定数目的"""
def bdx_move(axis: str, value: int):
if value == 0:
return b""
if abs(value) == 1:
return BDX_MOVE_KEY[axis][0 if value == -1 else 1]
pointer = sum(
[
value != -1,
value < -1 or value > 1,
value < -128 or value > 127,
value < -32768 or value > 32767,
]
)
return BDX_MOVE_KEY[axis][pointer] + value.to_bytes(
2 ** (pointer - 2), "big", signed=True
)
def form_command_block_in_BDX_bytes(
command: str,
particularValue: int,
impluse: int = 0,
condition: bool = False,
needRedstone: bool = True,
tickDelay: int = 0,
customName: str = "",
executeOnFirstTick: bool = False,
trackOutput: bool = True,
) -> bytes:
"""
使用指定参数生成指定的指令方块放置指令项
Parameters
------------
command: str
指令
particularValue: int
方块特殊值,即朝向
: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参数覆写
impluse: int (0|1|2)
方块类型
0脉冲 1循环 2连锁
condition: bool
是否有条件
needRedstone: bool
是否需要红石
tickDelay: int
执行延时
customName: str
悬浮字
lastOutput: str
命令方块的上次输出字符串,注意此处需要留空
executeOnFirstTick: bool
是否启用首刻执行循环指令方块是否激活后立即执行若为False则从激活时起延迟后第一次执行
trackOutput: bool
是否启用命令方块输出
Returns
---------
bytes
用以生成 bdx 结构的字节码
"""
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 commands_to_BDX_bytes(
commands_list: List[MineCommand],
max_height: int = 64,
):
"""
指令列表转换为用以生成 bdx 结构的字节码
Parameters
------------
commands: list[tuple[str, int]]
指令列表,每个元素为 (指令, 延迟)
max_height: int
生成结构最大高度
Returns
---------
tuple[bool, bytes, int] or tuple[bool, str]
成功与否,成功返回 (True, 未经过压缩的源, 结构占用大小),失败返回 (False, str失败原因)
"""
_sideLength = bottem_side_length_of_smallest_square_bottom_box(
len(commands_list), max_height
)
_bytes = b""
y_forward = True
z_forward = True
now_y = 0
now_z = 0
now_x = 0
for command in commands_list:
_bytes += form_command_block_in_BDX_bytes(
command.command_text,
(
(1 if y_forward else 0)
if (
((now_y != 0) and (not y_forward))
or (y_forward and (now_y != (max_height - 1)))
)
else (
(3 if z_forward else 2)
if (
((now_z != 0) and (not z_forward))
or (z_forward and (now_z != _sideLength - 1))
)
else 5
)
),
impluse=2,
condition=command.conditional,
needRedstone=False,
tickDelay=command.delay,
customName=command.annotation_text,
executeOnFirstTick=False,
trackOutput=True,
)
# (1 if y_forward else 0) if ( # 如果y+则向上,反之向下
# ((now_y != 0) and (not y_forward)) # 如果不是y轴上首个方块
# or (y_forward and (now_y != (max_height - 1))) # 如果不是y轴上末端方块
# ) else ( # 否则即是y轴末端或首个方块
# (3 if z_forward else 2) if ( # 如果z+则向z轴正方向反之负方向
# ((now_z != 0) and (not z_forward)) # 如果不是z轴上的首个方块
# or (z_forward and (now_z != _sideLength - 1)) # 如果不是z轴上的末端方块
# ) else 5 # 否则则要面向x轴正方向
# )
now_y += 1 if y_forward else -1
if ((now_y >= max_height) and y_forward) or ((now_y < 0) and (not y_forward)):
now_y -= 1 if y_forward else -1
y_forward = not y_forward
now_z += 1 if z_forward else -1
if ((now_z >= _sideLength) and z_forward) or (
(now_z < 0) and (not z_forward)
):
now_z -= 1 if z_forward else -1
z_forward = not z_forward
_bytes += BDX_MOVE_KEY[x][1]
now_x += 1
else:
_bytes += BDX_MOVE_KEY[z][int(z_forward)]
else:
_bytes += BDX_MOVE_KEY[y][int(y_forward)]
return (
_bytes,
[
now_x + 1,
max_height if now_x or now_z else now_y,
_sideLength if now_x else now_z,
],
[now_x, now_y, now_z],
)

View File

@@ -1,20 +0,0 @@
# -*- coding: utf-8 -*-
"""
用以生成BDX结构文件的附加功能
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = ["to_BDX_file_in_score", "to_BDX_file_in_delay"]
__author__ = (("金羿", "Eilles"),)
from .main import to_BDX_file_in_delay, to_BDX_file_in_score

View File

@@ -1,220 +0,0 @@
# -*- coding: utf-8 -*-
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import os
from typing import Optional
import brotli
from ...old_main import MidiConvert
from ...subclass import MineCommand, ProgressBarStyle
from ..bdx import (
bdx_move,
commands_to_BDX_bytes,
form_command_block_in_BDX_bytes,
x,
y,
z,
)
def to_BDX_file_in_score(
midi_cvt: MidiConvert,
dist_path: str,
progressbar_style: Optional[ProgressBarStyle],
scoreboard_name: str = "mscplay",
auto_reset: bool = False,
author: str = "Eilles",
max_height: int = 64,
):
"""
将midi以计分播放器形式转换为BDX结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
scoreboard_name: str
我的世界的计分板名称
auto_reset: bool
是否自动重置计分板
author: str
作者名称
max_height: int
生成结构最大高度
Returns
-------
tuple[int指令数量, int音乐总延迟, tuple[int,]结构大小, tuple[int,]终点坐标]
"""
cmdlist, command_count, max_score = midi_cvt.to_command_list_in_score(
scoreboard_name=scoreboard_name,
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[score].bdx")),
"w+",
) as f:
f.write("BD@")
_bytes = (
b"BDX\x00" + author.encode("utf-8") + b" & Musicreater\x00\x01command_block\x00"
)
cmdBytes, size, finalPos = commands_to_BDX_bytes(
midi_cvt.music_command_list
+ (
[
MineCommand(
command="scoreboard players reset @a[scores={"
+ scoreboard_name
+ "="
+ str(max_score + 20)
+ "}] "
+ scoreboard_name,
annotation="自动重置计分板",
)
]
if auto_reset
else []
),
max_height - 1,
)
if progressbar_style:
pgbBytes, pgbSize, pgbNowPos = commands_to_BDX_bytes(
midi_cvt.form_progress_bar(max_score, scoreboard_name, progressbar_style),
max_height - 1,
)
_bytes += pgbBytes
_bytes += bdx_move(y, -pgbNowPos[1])
_bytes += bdx_move(z, -pgbNowPos[2])
_bytes += bdx_move(x, 2)
size[0] += 2 + pgbSize[0]
size[1] = max(size[1], pgbSize[1])
size[2] = max(size[2], pgbSize[2])
_bytes += cmdBytes
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[score].bdx")),
"ab+",
) as f:
f.write(brotli.compress(_bytes + b"XE"))
return command_count, max_score, size, finalPos
def to_BDX_file_in_delay(
midi_cvt: MidiConvert,
dist_path: str,
progressbar_style: Optional[ProgressBarStyle],
player: str = "@a",
author: str = "Eilles",
max_height: int = 64,
):
"""
使用method指定的转换算法将midi转换为BDX结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
player: str
玩家选择器,默认为`@a`
author: str
作者名称
max_height: int
生成结构最大高度
Returns
-------
tuple[int指令数量, int音乐总延迟, tuple[int,]结构大小, tuple[int,]终点坐标]
"""
cmdlist, max_delay = midi_cvt.to_command_list_in_delay(
player_selector=player,
)[:2]
if not os.path.exists(dist_path):
os.makedirs(dist_path)
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[delay].bdx")),
"w+",
) as f:
f.write("BD@")
_bytes = (
b"BDX\x00" + author.encode("utf-8") + b" & Musicreater\x00\x01command_block\x00"
)
cmdBytes, size, finalPos = commands_to_BDX_bytes(cmdlist, max_height - 1)
if progressbar_style:
scb_name = midi_cvt.music_name[:3] + "Pgb"
_bytes += form_command_block_in_BDX_bytes(
r"scoreboard objectives add {} dummy {}".replace(r"{}", scb_name),
1,
customName="初始化进度条",
)
_bytes += bdx_move(z, 2)
_bytes += form_command_block_in_BDX_bytes(
r"scoreboard players add {} {} 1".format(player, scb_name),
1,
1,
customName="显示进度条并加分",
)
_bytes += bdx_move(y, 1)
pgbBytes, pgbSize, pgbNowPos = commands_to_BDX_bytes(
midi_cvt.form_progress_bar(max_delay, scb_name, progressbar_style),
max_height - 1,
)
_bytes += pgbBytes
_bytes += bdx_move(y, -1 - pgbNowPos[1])
_bytes += bdx_move(z, -2 - pgbNowPos[2])
_bytes += bdx_move(x, 2)
_bytes += form_command_block_in_BDX_bytes(
r"scoreboard players reset {} {}".format(player, scb_name),
1,
customName="置零进度条",
)
_bytes += bdx_move(y, 1)
size[0] += 2 + pgbSize[0]
size[1] = max(size[1], pgbSize[1])
size[2] = max(size[2], pgbSize[2])
size[1] += 1
_bytes += cmdBytes
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[delay].bdx")),
"ab+",
) as f:
f.write(brotli.compress(_bytes + b"XE"))
return len(cmdlist), max_delay, size, finalPos

View File

@@ -1,40 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放通用的普遍性的插件内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import math
def bottem_side_length_of_smallest_square_bottom_box(
_total_block_count: int, _max_height: int
):
"""
给定结构的总方块数量和规定的最大高度,返回该结构应当构成的图形,在底面的外切正方形之边长
Parameters
------------
_total_block_count: int
总方块数量
_max_height: int
规定的结构最大高度
Returns
---------
int
外切正方形的边长
"""
return math.ceil(math.sqrt(math.ceil(_total_block_count / _max_height)))

View File

@@ -1,92 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放附加内容功能
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# from dataclasses import dataclass
# from typing import Literal, Tuple, Union
# from ..subclass import DEFAULT_PROGRESSBAR_STYLE, ProgressBarStyle
# @dataclass(init=False)
# class ConvertConfig: # 必定要改
# """
# 转换通用设置存储类
# """
# progressbar_style: Union[ProgressBarStyle, None]
# """进度条样式"""
# dist_path: str
# """输出目录"""
# def __init__(
# self,
# output_path: str,
# progressbar: Union[bool, Tuple[str, Tuple[str, str]], ProgressBarStyle] = True,
# ignore_progressbar_param_error: bool = False,
# ):
# """
# 将已经转换好的数据内容指令载入MC可读格式
# Parameters
# ----------
# output_path: str
# 生成内容的输出目录
# volume: float
# 音量比率,范围为(0,1],其原理为在距离玩家 (1 / volume -1) 的地方播放音频
# speed: float
# 速度倍率,注意:这里的速度指的是播放速度倍率,其原理为在播放音频的时候,每个音符的播放时间除以 speed
# progressbar: bool|tuple[str, Tuple[str,]]
# 进度条,当此参数为 `True` 时使用默认进度条,为其他的**值为真**的参数时识别为进度条自定义参数,为其他**值为假**的时候不生成进度条
# """
# self.dist_path = output_path
# """输出目录"""
# if progressbar:
# # 此处是对于仅有 True 的参数和自定义参数的判断
# # 改这一段没🐎
# if progressbar is True:
# self.progressbar_style = DEFAULT_PROGRESSBAR_STYLE
# """进度条样式"""
# return
# elif isinstance(progressbar, ProgressBarStyle):
# self.progressbar_style = progressbar
# """进度条样式"""
# return
# elif isinstance(progressbar, tuple):
# if isinstance(progressbar[0], str) and isinstance(
# progressbar[1], tuple
# ):
# if isinstance(progressbar[1][0], str) and isinstance(
# progressbar[1][1], str
# ):
# self.progressbar_style = ProgressBarStyle(
# progressbar[0], progressbar[1][0], progressbar[1][1]
# )
# return
# if not ignore_progressbar_param_error:
# raise TypeError(
# "参数 {} 的类型 {} 与所需类型 Union[bool, Tuple[str, Tuple[str, str]], ProgressBarStyle] 不符。".format(
# progressbar, type(progressbar)
# )
# )
# self.progressbar_style = None
# """进度条样式组"""

View File

@@ -1,30 +0,0 @@
# -*- coding: utf-8 -*-
"""
用以生成单个mcstructure文件的附加功能
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = [
"to_mcstructure_file_in_delay",
"to_mcstructure_file_in_repeater",
"to_mcstructure_file_in_score",
"to_mcstructure_files_in_repeater_divided_by_instruments",
]
__author__ = (("金羿", "Eilles"),)
from .main import (
to_mcstructure_file_in_delay,
to_mcstructure_file_in_repeater,
to_mcstructure_file_in_score,
to_mcstructure_files_in_repeater_divided_by_instruments,
)

View File

@@ -1,298 +0,0 @@
# -*- coding: utf-8 -*-
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import os
from typing import Literal
from ...old_main import MidiConvert
from ...subclass import MineCommand
from ..mcstructure import (
COMPABILITY_VERSION_117,
COMPABILITY_VERSION_119,
commands_to_redstone_delay_structure,
commands_to_structure,
)
def to_mcstructure_file_in_delay(
midi_cvt: MidiConvert,
dist_path: str,
player: str = "@a",
max_height: int = 64,
):
"""
将midi以延迟播放器形式转换为mcstructure结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
player: str
玩家选择器,默认为`@a`
max_height: int
生成结构最大高度
Returns
-------
tuple[tuple[int,int,int]结构大小, int音乐总延迟]
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
cmd_list, max_delay = midi_cvt.to_command_list_in_delay(
player_selector=player,
)[:2]
if not os.path.exists(dist_path):
os.makedirs(dist_path)
struct, size, end_pos = commands_to_structure(
cmd_list, max_height - 1, compability_version_=compability_ver
)
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[delay].mcstructure")),
"wb+",
) as f:
struct.dump(f)
return size, max_delay
def to_mcstructure_file_in_score(
midi_cvt: MidiConvert,
dist_path: str,
scoreboard_name: str = "mscplay",
auto_reset: bool = False,
max_height: int = 64,
):
"""
将midi以延迟播放器形式转换为mcstructure结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
scoreboard_name: str
我的世界的计分板名称
auto_reset: bool
是否自动重置计分板
max_height: int
生成结构最大高度
Returns
-------
tuple[tuple[int,int,int]结构大小, int音乐总延迟, int指令数量
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
cmd_list, cmd_count, max_delay = midi_cvt.to_command_list_in_score(
scoreboard_name=scoreboard_name,
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
struct, size, end_pos = commands_to_structure(
midi_cvt.music_command_list
+ (
[
MineCommand(
command="scoreboard players reset @a[scores={"
+ scoreboard_name
+ "="
+ str(max_delay + 20)
+ "}] "
+ scoreboard_name,
annotation="自动重置计分板",
)
]
if auto_reset
else []
),
max_height - 1,
compability_version_=compability_ver,
)
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[score].mcstructure")),
"wb+",
) as f:
struct.dump(f)
return size, max_delay, cmd_count
def to_mcstructure_file_in_repeater(
midi_cvt: MidiConvert,
dist_path: str,
player: str = "@a",
axis_side: Literal["z+", "z-", "Z+", "Z-", "x+", "x-", "X+", "X-"] = "z+",
basement_block: str = "concrete",
):
"""
将midi以延迟播放器形式转换为mcstructure结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
player: str
玩家选择器,默认为`@a`
axis_side: Literal["z+","z-","Z+","Z-","x+","x-","X+","X-"]
生成结构的延展方向
basement_block: str
结构的基底方块
Returns
-------
tuple[tuple[int,int,int]结构大小, int音乐总延迟]
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
cmd_list, max_delay, max_multiple_cmd = midi_cvt.to_command_list_in_delay(
player_selector=player,
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
struct, size, end_pos = commands_to_redstone_delay_structure(
cmd_list,
max_delay,
max_multiple_cmd,
basement_block,
axis_side,
compability_version_=compability_ver,
)
with open(
os.path.abspath(os.path.join(dist_path, f"{midi_cvt.music_name}[repeater].mcstructure")),
"wb+",
) as f:
struct.dump(f)
return size, max_delay
def to_mcstructure_files_in_repeater_divided_by_instruments(
midi_cvt: MidiConvert,
dist_path: str,
player: str = "@a",
axis_side: Literal["z+", "z-", "Z+", "Z-", "x+", "x-", "X+", "X-"] = "z+",
basement_block: str = "concrete",
):
"""
将midi以延迟播放器形式转换为mcstructure结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
player: str
玩家选择器,默认为`@a`
axis_side: Literal["z+","z-","Z+","Z-","x+","x-","X+","X-"]
生成结构的延展方向
basement_block: str
结构的基底方块
Returns
-------
int音乐总延迟
"""
compability_ver = (
COMPABILITY_VERSION_117
if midi_cvt.enable_old_exe_format
else COMPABILITY_VERSION_119
)
cmd_dict, max_delay, max_multiple_cmd_count = (
midi_cvt.to_command_list_in_delay_devided_by_instrument(
player_selector=player,
)
)
if not os.path.exists(dist_path):
os.makedirs(dist_path)
for inst, cmd_list in cmd_dict.items():
struct, size, end_pos = commands_to_redstone_delay_structure(
cmd_list,
max_delay,
max_multiple_cmd_count[inst],
basement_block,
axis_side,
compability_version_=compability_ver,
)
with open(
os.path.abspath(
os.path.join(
dist_path,
"{}[repeater-div]_{}.mcstructure".format(
midi_cvt.music_name, inst.replace(".", "-")
),
)
),
"wb+",
) as f:
struct.dump(f)
return max_delay
def to_mcstructure_file_in_blocks(
midi_cvt: MidiConvert,
dist_path: str,
player: str = "@a",
):
"""
将midi以方块形式转换为mcstructure结构文件
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
player: str
玩家选择器,默认为`@a`
Returns
-------
int音乐总延迟
"""
pass

View File

@@ -1,543 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放有关MCSTRUCTURE结构操作的内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from typing import List, Literal, Tuple
from TrimMCStruct import Block, Structure, TAG_Byte, TAG_Long
from ..constants import x, y, z
from ..subclass import MineCommand
from .common import bottem_side_length_of_smallest_square_bottom_box
def antiaxis(axis: Literal["x", "z", "X", "Z"]):
return z if axis == x else x
def forward_IER(forward: bool):
return 1 if forward else -1
AXIS_PARTICULAR_VALUE = {
x: {
True: 5,
False: 4,
},
y: {
True: 1,
False: 0,
},
z: {
True: 3,
False: 2,
},
}
# 1.19的结构兼容版本号
COMPABILITY_VERSION_119: int = 17959425
"""
Minecraft 1.19 兼容版本号
"""
# 1.17的结构兼容版本号
COMPABILITY_VERSION_117: int = 17879555
"""
Minecraft 1.17 兼容版本号
"""
COMPABILITY_VERSION_121: int = 18168865
"""
Minecraft 1.21 兼容版本号
"""
def command_statevalue(axis_: Literal["x", "y", "z", "X", "Y", "Z"], forward_: bool):
return AXIS_PARTICULAR_VALUE[axis_.lower()][forward_]
def form_note_block_in_NBT_struct(
note: int,
coordinate: Tuple[int, int, int],
instrument: str = "note.harp",
powered: bool = False,
compability_version_number: int = COMPABILITY_VERSION_119,
) -> Block:
"""
生成音符盒方块
Parameters
------------
note: int (0~24)
音符的音高
coordinate: tuple[int, int, int]
此方块所在之相对坐标
instrument: str
音符盒的乐器
powered: bool
是否已被激活
Returns
-------
Block
生成的方块对象
"""
return Block(
"minecraft",
"noteblock",
{
"instrument": instrument.replace("note.", ""),
"note": note,
"powered": powered,
},
{
"block_entity_data": {
"note": TAG_Byte(note),
"id": "noteblock",
"x": coordinate[0],
"y": coordinate[1],
"z": coordinate[2],
} # type: ignore
},
compability_version=compability_version_number,
)
def form_repeater_in_NBT_struct(
delay: int,
facing: int,
compability_version_number: int = COMPABILITY_VERSION_119,
) -> Block:
"""
生成中继器方块
Parameters
----------
facing: int (0~3)
朝向:
Z- 北 0
X- 东 1
Z+ 南 2
X+ 西 3
delay: int (0~3)
信号延迟
Returns
-------
Block
生成的方块对象
"""
return Block(
"minecraft",
"unpowered_repeater",
{
"repeater_delay": delay,
"direction": facing,
},
compability_version=compability_version_number,
)
def form_command_block_in_NBT_struct(
command: str,
coordinate: tuple,
particularValue: int,
impluse: int = 0,
condition: bool = False,
alwaysRun: bool = True,
tickDelay: int = 0,
customName: str = "",
executeOnFirstTick: bool = False,
trackOutput: bool = True,
compability_version_number: int = COMPABILITY_VERSION_119,
) -> Block:
"""
使用指定参数生成指令方块
Parameters
----------
command: str
指令
coordinate: tuple[int,int,int]
此方块所在之相对坐标
particularValue: int
方块特殊值,即朝向
: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参数覆写
impluse: int (0|1|2)
方块类型
0脉冲 1循环 2连锁
condition: bool
是否有条件
alwaysRun: bool
是否始终执行
tickDelay: int
执行延时
customName: str
悬浮字
executeOnFirstTick: bool
是否启用首刻执行循环指令方块是否激活后立即执行若为False则从激活时起延迟后第一次执行
trackOutput: bool
是否启用命令方块输出
compability_version_number: int
版本兼容代号
Returns
-------
Block
生成的方块对象
"""
return Block(
"minecraft",
(
"command_block"
if impluse == 0
else ("repeating_command_block" if impluse == 1 else "chain_command_block")
),
states={"conditional_bit": condition, "facing_direction": particularValue},
extra_data={
"block_entity_data": {
"Command": command,
"CustomName": customName,
"ExecuteOnFirstTick": executeOnFirstTick,
"LPCommandMode": 0,
"LPCondionalMode": False,
"LPRedstoneMode": False,
"LastExecution": TAG_Long(0),
"LastOutput": "",
"LastOutputParams": [],
"SuccessCount": 0,
"TickDelay": tickDelay,
"TrackOutput": trackOutput,
"Version": (
25 if compability_version_number <= COMPABILITY_VERSION_119 else 43
),
"auto": alwaysRun,
"conditionMet": False, # 是否已经满足条件
"conditionalMode": condition,
"id": "CommandBlock",
"isMovable": True,
"powered": False, # 是否已激活
"x": coordinate[0],
"y": coordinate[1],
"z": coordinate[2],
} # type: ignore
},
compability_version=compability_version_number,
)
def commands_to_structure(
commands: List[MineCommand],
max_height: int = 64,
compability_version_: int = COMPABILITY_VERSION_119,
):
"""
由指令列表生成(纯指令方块)结构
Parameters
------------
commands: list
指令列表
max_height: int
生成结构最大高度
Returns
---------
Structure, tuple[int, int, int], tuple[int, int, int]
结构类, 结构占用大小, 终点坐标
"""
_sideLength = bottem_side_length_of_smallest_square_bottom_box(
len(commands), max_height
)
struct = Structure(
size=(_sideLength, max_height, _sideLength), # 声明结构大小
compability_version=compability_version_,
)
y_forward = True
z_forward = True
now_y = 0
now_z = 0
now_x = 0
for command in commands:
coordinate = (now_x, now_y, now_z)
struct.set_block(
coordinate,
form_command_block_in_NBT_struct(
command=command.command_text,
coordinate=coordinate,
particularValue=(
(1 if y_forward else 0)
if (
((now_y != 0) and (not y_forward))
or (y_forward and (now_y != (max_height - 1)))
)
else (
(3 if z_forward else 2)
if (
((now_z != 0) and (not z_forward))
or (z_forward and (now_z != _sideLength - 1))
)
else 5
)
),
impluse=2,
condition=False,
alwaysRun=True,
tickDelay=command.delay,
customName=command.annotation_text,
executeOnFirstTick=False,
trackOutput=True,
compability_version_number=compability_version_,
),
)
now_y += 1 if y_forward else -1
if ((now_y >= max_height) and y_forward) or ((now_y < 0) and (not y_forward)):
now_y -= 1 if y_forward else -1
y_forward = not y_forward
now_z += 1 if z_forward else -1
if ((now_z >= _sideLength) and z_forward) or (
(now_z < 0) and (not z_forward)
):
now_z -= 1 if z_forward else -1
z_forward = not z_forward
now_x += 1
return (
struct,
(
now_x + 1,
max_height if now_x or now_z else now_y,
_sideLength if now_x else now_z,
),
(now_x, now_y, now_z),
)
def commands_to_redstone_delay_structure(
commands: List[MineCommand],
delay_length: int,
max_multicmd_length: int,
base_block: str = "concrete",
axis_: Literal["z+", "z-", "Z+", "Z-", "x+", "x-", "X+", "X-"] = "z+",
compability_version_: int = COMPABILITY_VERSION_119,
) -> Tuple[Structure, Tuple[int, int, int], Tuple[int, int, int]]:
"""
由指令列表生成由红石中继器延迟的结构
Parameters
------------
commands: list
指令列表
delay_length: int
延时总长
max_multicmd_length: int
最大同时播放的音符数量
base_block: Block
生成结构的基底方块
axis_: str
生成结构的延展方向
Returns
---------
Structure, tuple[int, int, int], tuple[int, int, int]
结构类, 结构占用大小, 终点坐标
"""
if axis_ in ["z+", "Z+"]:
extensioon_direction = z
aside_direction = x
repeater_facing = 2
forward = True
elif axis_ in ["z-", "Z-"]:
extensioon_direction = z
aside_direction = x
repeater_facing = 0
forward = False
elif axis_ in ["x+", "X+"]:
extensioon_direction = x
aside_direction = z
repeater_facing = 3
forward = True
elif axis_ in ["x-", "X-"]:
extensioon_direction = x
aside_direction = z
repeater_facing = 1
forward = False
else:
raise ValueError(f"axis_({axis_}) 参数错误。")
goahead = forward_IER(forward)
command_actually_length = sum([int(bool(cmd.delay)) for cmd in commands])
a = 1
a_max = 0
total_cmd = 0
for cmd in commands:
# print("\r 正在进行处理:",end="")
if cmd.delay > 2:
a_max = max(a, a_max)
total_cmd += (a := 1)
else:
a += 1
struct = Structure(
size=(
round(delay_length / 2 + total_cmd) if extensioon_direction == x else a_max,
3,
round(delay_length / 2 + total_cmd) if extensioon_direction == z else a_max,
),
fill=Block("minecraft", "air", compability_version=compability_version_),
compability_version=compability_version_,
)
pos_now = {
x: ((1 if extensioon_direction == x else 0) if forward else struct.size[0]),
y: 0,
z: ((1 if extensioon_direction == z else 0) if forward else struct.size[2]),
}
chain_list = 0
# print("结构元信息设定完毕")
for cmd in commands:
# print("\r 正在进行处理:",end="")
if cmd.delay > 1:
# print("\rdelay > 0",end='')
single_repeater_value = int(cmd.delay / 2) % 4 - 1
additional_repeater = int(cmd.delay / 2 // 4)
for i in range(additional_repeater):
struct.set_block(
tuple(pos_now.values()), # type: ignore
Block(
"minecraft",
base_block,
compability_version=compability_version_,
),
)
struct.set_block(
(pos_now[x], 1, pos_now[z]),
form_repeater_in_NBT_struct(
delay=3,
facing=repeater_facing,
compability_version_number=compability_version_,
),
)
pos_now[extensioon_direction] += goahead
if single_repeater_value >= 0:
struct.set_block(
tuple(pos_now.values()), # type: ignore
Block(
"minecraft",
base_block,
compability_version=compability_version_,
),
)
struct.set_block(
(pos_now[x], 1, pos_now[z]),
form_repeater_in_NBT_struct(
delay=single_repeater_value,
facing=repeater_facing,
compability_version_number=compability_version_,
),
)
pos_now[extensioon_direction] += goahead
struct.set_block(
(pos_now[x], 1, pos_now[z]),
form_command_block_in_NBT_struct(
command=cmd.command_text,
coordinate=(pos_now[x], 1, pos_now[z]),
particularValue=command_statevalue(extensioon_direction, forward),
# impluse= (0 if first_impluse else 2),
impluse=0,
condition=False,
alwaysRun=False,
tickDelay=cmd.delay % 2,
customName=cmd.annotation_text,
compability_version_number=compability_version_,
),
)
struct.set_block(
(pos_now[x], 2, pos_now[z]),
Block(
"minecraft",
"redstone_wire",
compability_version=compability_version_,
),
)
pos_now[extensioon_direction] += goahead
chain_list = 1
else:
# print(pos_now)
now_pos_copy = pos_now.copy()
now_pos_copy[extensioon_direction] -= goahead
now_pos_copy[aside_direction] += chain_list
# print(pos_now,"\n=========")
struct.set_block(
(now_pos_copy[x], 1, now_pos_copy[z]),
form_command_block_in_NBT_struct(
command=cmd.command_text,
coordinate=(now_pos_copy[x], 1, now_pos_copy[z]),
particularValue=command_statevalue(extensioon_direction, forward),
# impluse= (0 if first_impluse else 2),
impluse=0,
condition=False,
alwaysRun=False,
tickDelay=cmd.delay % 2,
customName=cmd.annotation_text,
compability_version_number=compability_version_,
),
)
struct.set_block(
(now_pos_copy[x], 2, now_pos_copy[z]),
Block(
"minecraft",
"redstone_wire",
compability_version=compability_version_,
),
)
chain_list += 1
return struct, struct.size, tuple(pos_now.values()) # type: ignore

View File

@@ -1,117 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放有关红石音乐生成操作的内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from ..old_exceptions import NotDefineProgramError, ZeroSpeedError
from ..old_main import MidiConvert
from ..subclass import MineCommand
from ..utils import inst_to_sould_with_deviation, perc_inst_to_soundID_withX
# 你以为写完了吗?其实并没有
def to_note_list(
midi_cvt: MidiConvert,
speed: float = 1.0,
) -> list:
"""
使用金羿的转换思路将midi转换为我的世界音符盒所用的音高列表并输出每个音符之后的延迟
Parameters
----------
speed: float
速度,注意:这里的速度指的是播放倍率,其原理为在播放音频的时候,每个音符的播放时间除以 speed
Returns
-------
tuple( list[tuple(str指令, int距离上一个指令的延迟 ),...], int音乐时长游戏刻 )
"""
if speed == 0:
raise ZeroSpeedError("播放速度仅可为正实数")
midi_channels = (
midi_cvt.to_music_channels() if not midi_cvt.channels else midi_cvt.channels
)
tracks = {}
# 此处 我们把通道视为音轨
for i in midi_channels.keys():
# 如果当前通道为空 则跳过
if not midi_channels[i]:
continue
# 第十通道是打击乐通道
SpecialBits = True if i == 9 else False
# nowChannel = []
for track_no, track in midi_channels[i].items():
for msg in track:
if msg[0] == "PgmC":
InstID = msg[1]
elif msg[0] == "NoteS":
try:
soundID, _X = (
perc_inst_to_soundID_withX(InstID)
if SpecialBits
else inst_to_sould_with_deviation(InstID)
)
except UnboundLocalError as E:
soundID, _X = (
perc_inst_to_soundID_withX(-1)
if SpecialBits
else inst_to_sould_with_deviation(-1)
)
score_now = round(msg[-1] / float(speed) / 50)
# print(score_now)
try:
tracks[score_now].append(
self.execute_cmd_head.format(player)
+ f"playsound {soundID} @s ^ ^ ^{1 / MaxVolume - 1} {msg[2] / 128} "
f"{2 ** ((msg[1] - 60 - _X) / 12)}"
)
except KeyError:
tracks[score_now] = [
self.execute_cmd_head.format(player)
+ f"playsound {soundID} @s ^ ^ ^{1 / MaxVolume - 1} {msg[2] / 128} "
f"{2 ** ((msg[1] - 60 - _X) / 12)}"
]
all_ticks = list(tracks.keys())
all_ticks.sort()
results = []
for i in range(len(all_ticks)):
for j in range(len(tracks[all_ticks[i]])):
results.append(
(
tracks[all_ticks[i]][j],
(
0
if j != 0
else (
all_ticks[i] - all_ticks[i - 1] if i != 0 else all_ticks[i]
)
),
)
)
return [results, max(all_ticks)]

View File

@@ -1,18 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放有关Schematic结构生成的内容
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
# import nbtschematic

View File

@@ -1,22 +0,0 @@
# -*- coding: utf-8 -*-
"""
用以生成Schematic结构的附加功能
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = [
]
__author__ = (("金羿", "Eilles"),)
from .main import *

View File

@@ -1,14 +0,0 @@
# -*- coding: utf-8 -*-
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from ..schematic import *

View File

@@ -1,21 +0,0 @@
# -*- coding: utf-8 -*-
"""
用以启动WebSocket服务器播放的附加功能
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
__all__ = []
__author__ = (("金羿", "Eilles"),)
from .main import *

View File

@@ -1,142 +0,0 @@
# -*- coding: utf-8 -*-
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
import asyncio
import time
import uuid
from typing import List, Literal, Optional, Tuple
import fcwslib
from ...old_main import MidiConvert
from ...subclass import MineCommand, ProgressBarStyle
def to_websocket_server(
midi_cvt_lst: List[MidiConvert],
server_dist: str,
server_port: int,
progressbar_style: Optional[ProgressBarStyle],
) -> None:
"""
将midi以延迟播放器形式转换为mcstructure结构文件后打包成附加包并在附加包中生成相应地导入函数
Parameters
----------
midi_cvt: List[MidiConvert]
一组用于转换的MidiConvert对象
server_dist: str
WebSocket播放服务器开启地址
server_port: str
WebSocket播放服务器开启端口
progressbar_style: ProgressBarStyle 对象
进度条对象
Returns
-------
None
"""
replacement = str(uuid.uuid4())
musics = dict(
[
(k.music_name, k.to_command_list_in_delay(replacement)[:2])
for k in midi_cvt_lst
]
)
class Plugin(fcwslib.Plugin):
async def on_connect(self) -> None:
print("已成功获连接")
await self.send_command("list", callback=self.cmd_feedback)
await self.subscribe("PlayerMessage", callback=self.player_message)
async def on_disconnect(self) -> None:
print("连接已然终止")
await self.disconnect()
async def on_receive(self, response) -> None:
print("已收取非已知列回复 {}".format(response))
async def cmd_feedback(self, response) -> None:
print("已收取指令执行回复 {}".format(response))
async def player_message(self, response) -> None:
print("已收取玩家事件回复 {}".format(response))
if response["body"]["message"].startswith(("。播放", ".play")):
whom_to_play: str = response["body"]["sender"]
music_to_play: str = (
response["body"]["message"]
.replace("。播放", "")
.replace(".play", "")
.strip()
)
if music_to_play in musics.keys():
self.check_play = True
delay_of_now = 0
now_played_cmd = 0
_time = time.time()
for i in range(musics[music_to_play][1]):
if not self.check_play:
break
await asyncio.sleep((0.05 - (time.time() - _time)) % 0.05)
_time = time.time()
if progressbar_style:
await self.send_command(
"title {} actionbar {}".format(
whom_to_play,
progressbar_style.play_output(
played_delays=i,
total_delays=musics[music_to_play][1],
music_name=music_to_play,
),
),
callback=self.cmd_feedback,
)
delay_of_now += 1
if (
delay_of_now
>= (cmd := musics[music_to_play][0][now_played_cmd]).delay
):
await self.send_command(
cmd.command_text.replace(replacement, whom_to_play),
callback=self.cmd_feedback,
)
now_played_cmd += 1
delay_of_now = 0
else:
await self.send_command(
"tellraw {} {}{}{}".format(
whom_to_play,
r'{"rawtext":[{"text":"§c§l所选歌曲',
music_to_play,
'无法播放:播放列表不存在之"}]}',
),
callback=self.cmd_feedback,
)
elif response["body"]["message"].startswith(
("。停止播放", ".stopplay", ".stoplay")
):
self.check_play = False
elif response["body"]["message"].startswith(
("。终止连接", ".terminate", ".endconnection")
):
await self.disconnect()
server = fcwslib.Server(server=server_dist, port=server_port, debug_mode=True)
server.add_plugin(Plugin)
asyncio.run(server.run_forever())

View File

@@ -1,73 +0,0 @@
# -*- coding: utf-8 -*-
"""
存放数据类型的定义
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from typing import Callable, Dict, List, Literal, Mapping, Tuple, Union
from .subclass import MineNote
MidiNoteNameTableType = Mapping[int, Tuple[str, ...]]
"""
Midi音符名称对照表类型
"""
MidiInstrumentTableType = Mapping[int, str]
"""
Midi乐器对照表类型
"""
FittingFunctionType = Callable[[float], float]
"""
拟合函数类型
"""
ChannelType = Dict[
int,
Dict[
int,
List[
Union[
Tuple[Literal["PgmC"], int, int],
Tuple[Literal["NoteS"], int, int, int],
Tuple[Literal["NoteE"], int, int],
]
],
],
]
"""
以字典所标记的通道信息类型(已弃用)
Dict[int,Dict[int,List[Union[Tuple[Literal["PgmC"], int, int],Tuple[Literal["NoteS"], int, int, int],Tuple[Literal["NoteE"], int, int],]],],]
"""
MineNoteChannelType = Mapping[
int,
List[MineNote,],
]
"""
我的世界通道信息类型
Dict[int,Dict[int,List[MineNote,],],]
"""
MineNoteTrackType = Mapping[
int,
List[MineNote,],
]

View File

@@ -1,861 +0,0 @@
# -*- coding: utf-8 -*-
"""
存储音·创附属子类
"""
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
# 睿乐组织 开发交流群 861684859
# Email TriM-Organization@hotmail.com
# 若需转载或借鉴 许可声明请查看仓库目录下的 License.md
from math import sin, cos, asin, radians, degrees, sqrt, atan
from dataclasses import dataclass
from typing import Optional, Any, List, Tuple, Union, Dict, Sequence
from .constants import MC_PITCHED_INSTRUMENT_LIST
@dataclass(init=False)
class MineNote:
"""存储单个音符的类"""
sound_name: str
"""乐器ID"""
note_pitch: int
"""midi音高"""
velocity: int
"""力度"""
start_tick: int
"""开始之时 命令刻"""
duration: int
"""音符持续时间 命令刻"""
high_precision_time: int
"""高精度开始时间偏量 1/1250 秒"""
percussive: bool
"""是否作为打击乐器启用"""
sound_distance: float
"""声源距离 方块"""
sound_azimuth: Tuple[float, float]
"""声源方位 角度"""
extra_info: Dict[str, Any]
"""你觉得放什么好?"""
def __init__(
self,
mc_sound_name: str,
midi_pitch: Optional[int],
midi_velocity: int,
start_time: int,
last_time: int,
mass_precision_time: int = 0,
is_percussion: Optional[bool] = None,
distance: Optional[float] = None,
azimuth: Optional[Tuple[float, float]] = None,
extra_information: Dict[str, Any] = {},
):
"""
用于存储单个音符的类
Parameters
------------
mc_sound_name: str
《我的世界》声音ID
midi_pitch: int
midi音高
midi_velocity: int
midi响度(力度)
start_time: int
开始之时(命令刻)
注:此处的时间是用从乐曲开始到当前的刻数
last_time: int
音符延续时间(命令刻)
mass_precision_time: int
高精度的开始时间偏移量(1/1250秒)
is_percussion: bool
是否作为打击乐器
distance: float
发声源距离玩家的距离(半径 `r`
注:距离越近,音量越高,默认为 0。此参数可以与音量成某种函数关系。
azimuth: tuple[float, float]
声源方位
此参数为tuple包含两个元素分别表示
`rV` 发声源在竖直(上下)轴上,从玩家视角正前方开始,向顺时针旋转的角度
`rH` 发声源在水平(左右)轴上,从玩家视角正前方开始,向上(到达玩家正上方顶点后变为向下,以此类推的旋转)旋转的角度
extra_information: Dict[str, Any]
附加信息,尽量存储为字典
Returns
---------
MineNote 类
"""
self.sound_name: str = mc_sound_name
"""乐器ID"""
self.note_pitch: int = 66 if midi_pitch is None else midi_pitch
"""midi音高"""
self.velocity: int = midi_velocity
"""响度(力度)"""
self.start_tick: int = start_time
"""开始之时 命令刻"""
self.duration: int = last_time
"""音符持续时间 命令刻"""
self.high_precision_time: int = mass_precision_time
"""高精度开始时间偏量 0.4 毫秒"""
self.percussive = (
(mc_sound_name not in MC_PITCHED_INSTRUMENT_LIST)
if (is_percussion is None)
else is_percussion
)
"""是否为打击乐器"""
self.sound_azimuth = (azimuth[0] % 360, azimuth[1] % 360) if azimuth else (0, 0)
"""声源方位"""
# 如果指定为零,那么为零,但如果不指定或者指定为负数,则为 0.01 的距离
self.sound_distance = (
(16 if distance > 16 else (distance if distance >= 0 else 0.01))
if distance is not None
else 0.01
)
"""声源距离"""
self.extra_info = extra_information if extra_information else {}
@classmethod
def from_traditional(
cls,
mc_sound_name: str,
midi_pitch: Optional[int],
midi_velocity: int,
start_time: int,
last_time: int,
mass_precision_time: int = 0,
is_percussion: Optional[bool] = None,
displacement: Optional[Tuple[float, float, float]] = None,
extra_information: Optional[Any] = None,
):
"""
从传统音像位移格式传参,写入用于存储单个音符的类
Parameters
------------
mc_sound_name: str
《我的世界》声音ID
midi_pitch: int
midi音高
midi_velocity: int
midi响度(力度)
start_time: int
开始之时(命令刻)
注:此处的时间是用从乐曲开始到当前的刻数
last_time: int
音符延续时间(命令刻)
mass_precision_time: int
高精度的开始时间偏移量(1/1250秒)
is_percussion: bool
是否作为打击乐器
displacement: tuple[float, float, float]
声像位移
extra_information: Any
附加信息,尽量为字典。
Returns
---------
MineNote 类
"""
if displacement is None:
displacement = (0, 0, 0)
r = 0
alpha_v = 0
beta_h = 0
else:
r = sqrt(displacement[0] ** 2 + displacement[1] ** 2 + displacement[2] ** 2)
if r == 0:
alpha_v = 0
beta_h = 0
else:
beta_h = round(degrees(asin(displacement[1] / r)), 8)
if displacement[2] == 0:
alpha_v = -90 if displacement[0] > 0 else 90
else:
alpha_v = round(
degrees(atan(-displacement[0] / displacement[2])), 8
)
return cls(
mc_sound_name=mc_sound_name,
midi_pitch=midi_pitch,
midi_velocity=midi_velocity,
start_time=start_time,
last_time=last_time,
mass_precision_time=mass_precision_time,
is_percussion=is_percussion,
distance=r,
azimuth=(alpha_v, beta_h),
extra_information=(
(
extra_information
if isinstance(extra_information, dict)
else {"EXTRA_INFO": extra_information}
)
if extra_information
else {}
),
)
@property
def position_displacement(self) -> Tuple[float, float, float]:
"""声像位移"""
dk1 = self.sound_distance * round(cos(radians(self.sound_azimuth[1])), 8)
return (
-dk1 * round(sin(radians(self.sound_azimuth[0])), 8),
self.sound_distance * round(sin(radians(self.sound_azimuth[1])), 8),
dk1 * round(cos(radians(self.sound_azimuth[0])), 8),
)
@classmethod
def decode(cls, code_buffer: bytes, is_high_time_precision: bool = True):
"""自字节码析出 MineNote 类"""
group_1 = int.from_bytes(code_buffer[:6], "big")
percussive_ = bool(group_1 & 0b1)
duration_ = (group_1 := group_1 >> 1) & 0b11111111111111111
start_tick_ = (group_1 := group_1 >> 17) & 0b11111111111111111
note_pitch_ = (group_1 := group_1 >> 17) & 0b1111111
sound_name_length = group_1 >> 7
if code_buffer[6] & 0b1:
distance_ = (
code_buffer[8 + sound_name_length]
if is_high_time_precision
else code_buffer[7 + sound_name_length]
) / 15
group_2 = int.from_bytes(
(
code_buffer[9 + sound_name_length : 14 + sound_name_length]
if is_high_time_precision
else code_buffer[8 + sound_name_length : 13 + sound_name_length]
),
"big",
)
azimuth_ = ((group_2 >> 20) / 2912, (group_2 & 0xFFFFF) / 2912)
else:
distance_ = 0
azimuth_ = (0, 0)
try:
return cls(
mc_sound_name=(
o := (
code_buffer[8 : 8 + sound_name_length]
if is_high_time_precision
else code_buffer[7 : 7 + sound_name_length]
)
).decode(encoding="GB18030"),
midi_pitch=note_pitch_,
midi_velocity=code_buffer[6] >> 1,
start_time=start_tick_,
last_time=duration_,
mass_precision_time=code_buffer[7] if is_high_time_precision else 0,
is_percussion=percussive_,
distance=distance_,
azimuth=azimuth_,
)
except:
print(code_buffer, "\n", o)
raise
def encode(
self, is_displacement_included: bool = True, is_high_time_precision: bool = True
) -> bytes:
"""
将数据打包为字节码
Parameters
------------
is_displacement_included: bool
是否包含声像偏移数据,默认为**是**
is_high_time_precision: bool
是否启用高精度,默认为**是**
Returns
---------
bytes
打包好的字节码
"""
# MineNote 的字节码共有三个顺次版本分别如下
# 字符串长度 6 位 支持到 63
# note_pitch 7 位 支持到 127
# start_tick 17 位 支持到 131071 即 109.22583 分钟 合 1.8204305 小时
# duration 17 位 支持到 131071 即 109.22583 分钟 合 1.8204305 小时
# percussive 长度 1 位 支持到 1
# 共 48 位 合 6 字节
# +++
# velocity 长度 7 位 支持到 127
# is_displacement_included 长度 1 位 支持到 1
# 共 8 位 合 1 字节
# +++
# (在第二版中已舍弃)
# track_no 长度 8 位 支持到 255 合 1 字节
# (在第二版中新增)
# high_time_precision可选长度 8 位 支持到 255 合 1 字节 支持 1/1250 秒
# +++
# sound_name 长度最多 63 支持到 31 个中文字符 或 63 个西文字符
# 第一版编码: UTF-8
# 第二版编码: GB18030
# +++
# (在第三版中已废弃)
# position_displacement 每个元素长 16 位 合 2 字节
# 共 48 位 合 6 字节 支持存储三位小数和两位整数,其值必须在 [0, 65.535] 之间
# (在第三版中新增)
# sound_distance 8 位 支持到 255 即 16 格 合 1 字节(按值放大 15 倍存储,精度可达 1 / 15
# sound_azimuth 每个元素长 20 位 共 40 位 合 5 字节。每个值放大 2912 倍存储,即支持到 360.08756868131866 度,精度同理
return (
(
(
(
(
(
(
(
(
len(
r := self.sound_name.encode(
encoding="GB18030"
)
)
<< 7
)
+ self.note_pitch
)
<< 17
)
+ self.start_tick
)
<< 17
)
+ self.duration
)
<< 1
)
+ self.percussive
).to_bytes(6, "big")
+ ((self.velocity << 1) + is_displacement_included).to_bytes(1, "big")
# + self.track_no.to_bytes(1, "big")
+ (
self.high_precision_time.to_bytes(1, "big")
if is_high_time_precision
else b""
)
+ r
+ (
(
round(self.sound_distance * 15).to_bytes(1, "big")
+ (
(round(self.sound_azimuth[0] * 2912) << 20)
+ round(self.sound_azimuth[1] * 2912)
).to_bytes(5, "big")
)
if is_displacement_included
else b""
)
)
def set_info(self, key: Union[str, Sequence[str]], value: Any):
"""设置附加信息"""
if isinstance(key, str):
self.extra_info[key] = value
elif (
isinstance(key, Sequence)
and isinstance(value, Sequence)
and (k := len(key)) == len(value)
):
for i in range(k):
self.extra_info[key[i]] = value[i]
else:
# 提供简单报错就行了,如果放一堆 if 语句,降低处理速度
raise TypeError("参数类型错误;键:`{}` 值:`{}`".format(key, value))
def get_info(self, key: str) -> Any:
"""获取附加信息"""
if key in self.extra_info:
return self.extra_info[key]
elif "EXTRA_INFO" in self.extra_info:
if (
isinstance(self.extra_info["EXTRA_INFO"], dict)
and key in self.extra_info["EXTRA_INFO"]
):
return self.extra_info["EXTRA_INFO"].get(key)
else:
return self.extra_info["EXTRA_INFO"]
else:
return None
def stringize(
self, include_displacement: bool = False, include_extra_data: bool = False
) -> str:
return (
"{}Note(Instrument = {}, {}Velocity = {}, StartTick = {}, Duration = {}{}".format(
"Percussive" if self.percussive else "",
self.sound_name,
"" if self.percussive else "NotePitch = {}, ".format(self.note_pitch),
self.velocity,
self.start_tick,
self.duration,
)
+ (
", SoundDistance = `r`{}, SoundAzimuth = (`αV`{}, `βH`{})".format(
self.sound_distance, *self.sound_azimuth
)
if include_displacement
else ""
)
+ (", ExtraData = {}".format(self.extra_info) if include_extra_data else "")
+ ")"
)
def tuplize(self, is_displacement: bool = False):
tuplized = self.__tuple__()
return tuplized[:-2] + (tuplized[-2:] if is_displacement else ())
def __list__(self) -> List:
return (
[
self.percussive,
self.sound_name,
self.velocity,
self.start_tick,
self.duration,
self.sound_distance,
self.sound_azimuth,
]
if self.percussive
else [
self.percussive,
self.sound_name,
self.note_pitch,
self.velocity,
self.start_tick,
self.duration,
self.sound_distance,
self.sound_azimuth,
]
)
def __tuple__(
self,
) -> Union[
Tuple[bool, str, int, int, int, int, float, Tuple[float, float]],
Tuple[bool, str, int, int, int, float, Tuple[float, float]],
]:
return (
(
self.percussive,
self.sound_name,
self.velocity,
self.start_tick,
self.duration,
self.sound_distance,
self.sound_azimuth,
)
if self.percussive
else (
self.percussive,
self.sound_name,
self.note_pitch,
self.velocity,
self.start_tick,
self.duration,
self.sound_distance,
self.sound_azimuth,
)
)
def __dict__(self):
return (
{
"Percussive": self.percussive,
"Instrument": self.sound_name,
"Velocity": self.velocity,
"StartTick": self.start_tick,
"Duration": self.duration,
"SoundDistance": self.sound_distance,
"SoundAzimuth": self.sound_azimuth,
"ExtraData": self.extra_info,
}
if self.percussive
else {
"Percussive": self.percussive,
"Instrument": self.sound_name,
"Pitch": self.note_pitch,
"Velocity": self.velocity,
"StartTick": self.start_tick,
"Duration": self.duration,
"SoundDistance": self.sound_distance,
"SoundAzimuth": self.sound_azimuth,
"ExtraData": self.extra_info,
}
)
def __eq__(self, other) -> bool:
if not isinstance(other, self.__class__):
return False
return self.tuplize() == other.tuplize()
@dataclass(init=False)
class MineCommand:
"""存储单个指令的类"""
command_text: str
"""指令文本"""
conditional: bool
"""执行是否有条件"""
delay: int
"""执行的延迟"""
annotation_text: str
"""指令注释"""
def __init__(
self,
command: str,
condition: bool = False,
tick_delay: int = 0,
annotation: str = "",
):
"""
存储单个指令的类
Parameters
----------
command: str
指令
condition: bool
是否有条件
tick_delay: int
执行延时
annotation: str
注释
"""
self.command_text = command
self.conditional = condition
self.delay = tick_delay
self.annotation_text = annotation
def copy(self):
return MineCommand(
command=self.command_text,
condition=self.conditional,
tick_delay=self.delay,
annotation=self.annotation_text,
)
@property
def cmd(self) -> str:
"""
我的世界函数字符串(包含注释)
"""
return self.__str__()
def __str__(self) -> str:
"""
转为我的世界函数文件格式(包含注释)
"""
return "# {cdt}<{delay}> {ant}\n{cmd}".format(
cdt="[CDT]" if self.conditional else "",
delay=self.delay,
ant=self.annotation_text,
cmd=self.command_text,
)
def __eq__(self, other) -> bool:
if not isinstance(other, self.__class__):
return False
return self.__str__() == other.__str__()
@dataclass(init=False)
class SingleNoteBox:
"""存储单个音符盒"""
instrument_block: str
"""乐器方块"""
note_value: int
"""音符盒音高"""
annotation_text: str
"""音符注释"""
is_percussion: bool
"""是否为打击乐器"""
def __init__(
self,
instrument_block_: str,
note_value_: int,
percussion: Optional[bool] = None,
annotation: str = "",
):
"""
用于存储单个音符盒的类
Parameters
------------
instrument_block_: str
音符盒演奏所使用的乐器方块
note_value_: int
音符盒的演奏音高
percussion: bool
此音符盒乐器是否作为打击乐处理
注:若为空,则自动识别是否为打击乐器
annotation: Any
音符注释
Returns
---------
SingleNoteBox 类
"""
self.instrument_block = instrument_block_
"""乐器方块"""
self.note_value = note_value_
"""音符盒音高"""
self.annotation_text = annotation
"""音符注释"""
if percussion is None:
self.is_percussion = percussion not in MC_PITCHED_INSTRUMENT_LIST
else:
self.is_percussion = percussion
@property
def inst(self) -> str:
"""获取音符盒下的乐器方块"""
return self.instrument_block
@inst.setter
def inst(self, inst_):
self.instrument_block = inst_
@property
def note(self) -> int:
"""获取音符盒音调特殊值"""
return self.note_value
@note.setter
def note(self, note_):
self.note_value = note_
@property
def annotation(self) -> str:
"""获取音符盒的备注"""
return self.annotation_text
@annotation.setter
def annotation(self, annotation_):
self.annotation_text = annotation_
def copy(self):
return SingleNoteBox(
instrument_block_=self.instrument_block,
note_value_=self.note_value,
annotation=self.annotation_text,
)
def __str__(self) -> str:
return f"Note(inst = {self.inst}, note = {self.note}, )"
def __tuple__(self) -> tuple:
return self.inst, self.note, self.annotation
def __dict__(self) -> dict:
return {
"inst": self.inst,
"note": self.note,
"annotation": self.annotation,
}
def __eq__(self, other) -> bool:
if not isinstance(other, self.__class__):
return False
return self.__str__() == other.__str__()
@dataclass(init=False)
class ProgressBarStyle:
"""进度条样式类"""
base_style: str
"""基础样式"""
to_play_style: str
"""未播放之样式"""
played_style: str
"""已播放之样式"""
def __init__(
self,
base_s: Optional[str] = None,
to_play_s: Optional[str] = None,
played_s: Optional[str] = None,
):
"""
用于存储进度条样式的类
| 标识符 | 指定的可变量 |
|---------|----------------|
| `%%N` | 乐曲名(即传入的文件名)|
| `%%s` | 当前计分板值 |
| `%^s` | 计分板最大值 |
| `%%t` | 当前播放时间 |
| `%^t` | 曲目总时长 |
| `%%%` | 当前进度比率 |
| `_` | 用以表示进度条占位|
Parameters
------------
base_s: str
基础样式,用以定义进度条整体
to_play_s: str
进度条样式:尚未播放的样子
played_s: str
已经播放的样子
Returns
---------
ProgressBarStyle 类
"""
self.base_style = (
base_s if base_s else r"%%N [ %%s/%^s %%% §e__________§r %%t|%^t ]"
)
self.to_play_style = to_play_s if to_play_s else r"§7="
self.played_style = played_s if played_s else r"="
@classmethod
def from_tuple(cls, tuplized_style: Optional[Tuple[str, Tuple[str, str]]]):
"""自旧版进度条元组表示法读入数据(已不建议使用)"""
if tuplized_style is None:
return cls(
r"%%N [ %%s/%^s %%% §e__________§r %%t|%^t ]",
r"§7=",
r"=",
)
if isinstance(tuplized_style, tuple):
if isinstance(tuplized_style[0], str) and isinstance(
tuplized_style[1], tuple
):
if isinstance(tuplized_style[1][0], str) and isinstance(
tuplized_style[1][1], str
):
return cls(
tuplized_style[0], tuplized_style[1][0], tuplized_style[1][1]
)
raise ValueError(
"元组表示的进度条样式组 {} 格式错误,已不建议使用此功能,请尽快更换。".format(
tuplized_style
)
)
def set_base_style(self, value: str):
"""设置基础样式"""
self.base_style = value
def set_to_play_style(self, value: str):
"""设置未播放之样式"""
self.to_play_style = value
def set_played_style(self, value: str):
"""设置已播放之样式"""
self.played_style = value
def copy(self):
dst = ProgressBarStyle(self.base_style, self.to_play_style, self.played_style)
return dst
def play_output(
self,
played_delays: int,
total_delays: int,
music_name: str = "无题",
) -> str:
"""
直接依照此格式输出一个进度条
Parameters
------------
played_delays: int
当前播放进度积分值
total_delays: int
乐器总延迟数(计分板值)
music_name: str
曲名
Returns
---------
str
进度条字符串
"""
return (
self.base_style.replace(r"%%N", music_name)
.replace(r"%%s", str(played_delays))
.replace(r"%^s", str(total_delays))
.replace(r"%%t", mctick2timestr(played_delays))
.replace(r"%^t", mctick2timestr(total_delays))
.replace(
r"%%%",
"{:0>5.2f}%".format(int(10000 * played_delays / total_delays) / 100),
)
.replace(
"_",
self.played_style,
(played_delays * self.base_style.count("_") // total_delays) + 1,
)
.replace("_", self.to_play_style)
)
def mctick2timestr(mc_tick: int) -> str:
"""
将《我的世界》的游戏刻计转为表示时间的字符串
"""
return "{:0>2d}:{:0>2d}".format(mc_tick // 1200, (mc_tick // 20) % 60)
DEFAULT_PROGRESSBAR_STYLE = ProgressBarStyle(
r"%%N [ %%s/%^s %%% §e__________§r %%t|%^t ]",
r"§7=",
r"=",
)
"""
默认的进度条样式
"""

File diff suppressed because it is too large Load Diff

Binary file not shown.

Binary file not shown.

View File

@@ -1 +0,0 @@
q@v,fxіБ<D196>Еџ<D095>лцmЩ5]Ќs"ЏџЦбBMXi<58>ЈnНхч<D185>Z8О=Г<7F>4<EFBFBD>PTUБQЈфджG<D0B6>жu_цп<D186>DS№|

View File

@@ -1,68 +0,0 @@
import Musicreater.old_init as old_init
import Musicreater.experiment
import Musicreater.old_plugin
# import Musicreater.previous
from Musicreater.old_plugin.addonpack import (
to_addon_pack_in_delay,
to_addon_pack_in_repeater,
to_addon_pack_in_score,
)
from Musicreater.old_plugin.bdxfile import to_BDX_file_in_delay, to_BDX_file_in_score
from Musicreater.old_plugin.mcstructfile import (
to_mcstructure_file_in_delay,
to_mcstructure_file_in_repeater,
to_mcstructure_file_in_score,
)
MSCT_MAIN = (
old_init,
old_init.experiment,
# Musicreater.previous,
)
MSCT_PLUGIN = (old_init.old_plugin,)
MSCT_PLUGIN_FUNCTION = (
to_addon_pack_in_delay,
to_addon_pack_in_repeater,
to_addon_pack_in_score,
to_mcstructure_file_in_delay,
to_mcstructure_file_in_repeater,
to_mcstructure_file_in_score,
to_BDX_file_in_delay,
to_BDX_file_in_score,
)
import hashlib
import brotli
import dill
def enpack_msct_pack(sth, to_dist: str):
packing_bytes = brotli.compress(
dill.dumps(
sth,
)
)
with open(
to_dist,
"wb",
) as f:
f.write(packing_bytes)
return hashlib.sha256(packing_bytes)
with open("./Packer/checksum.txt", "w", encoding="utf-8") as f:
f.write("MSCT_MAIN:\n")
f.write(enpack_msct_pack(MSCT_MAIN, "./Packer/MSCT_MAIN.MPK").hexdigest())
f.write("\nMSCT_PLUGIN:\n")
f.write(enpack_msct_pack(MSCT_PLUGIN, "./Packer/MSCT_PLUGIN.MPK").hexdigest())
f.write("\nMSCT_PLUGIN_FUNCTION:\n")
f.write(
enpack_msct_pack(
MSCT_PLUGIN_FUNCTION, "./Packer/MSCT_PLUGIN_FUNCTION.MPK"
).hexdigest()
)

View File

@@ -1,6 +0,0 @@
MSCT_MAIN:
6b9f5a97d50beb07c834e375104c67ae44c57ae40f73fb71075b3668899029c7
MSCT_PLUGIN:
c280413a394a539438a5d10078c9b55f04bcd4cf6869c59a3f7a026039748cfc
MSCT_PLUGIN_FUNCTION:
40697f1d9b293268fe142fa3e9bffee2923a8f4811ec7bbdf7b14afb98723ef2

View File

@@ -1,67 +0,0 @@
import mido
import numpy
'''
bpm
bites per minutes
每分钟的拍数
'''
def mt2gt(mt, tpb_a, bpm_a):
return round(mt / tpb_a / bpm_a * 60)
def get(mid:mido.MidiFile) -> int:
'''传入一个 MidiFile, 返回其音乐的bpm
:param mid : mido.MidFile
mido库识别的midi文件数据
:return bpm : int
'''
# mid = mido.MidiFile(mf)
length = mid.length
tpb = mid.ticks_per_beat
bpm = 20
gotV = 0
for track in mid.tracks:
global_time = 0
for msg in track:
global_time += msg.time
if msg.type == "note_on" and msg.velocity > 0:
gotV = mt2gt(global_time, tpb, bpm)
errorV = numpy.fabs(gotV - length)
last_dic = {bpm: errorV}
if last_dic.get(bpm) > errorV:
last_dic = {bpm: errorV}
bpm += 2
while True:
for track in mid.tracks:
global_time = 0
for msg in track:
global_time += msg.time
if msg.type == "note_on" and msg.velocity > 0:
gotV = mt2gt(global_time, tpb, bpm)
errorV = numpy.fabs(gotV - length)
try:
if last_dic.get(bpm - 2) > errorV:
last_dic = {bpm: errorV}
except TypeError:
pass
bpm += 2
if bpm >= 252:
break
print(list(last_dic.keys())[0])
return list(last_dic.keys())[0]
def compute(mid:mido.MidiFile):
answer = 60000000/mid.ticks_per_beat
print(answer)
return answer
if __name__ == '__main__':
mid = mido.MidiFile(r"C:\Users\lc\Documents\MuseScore3\乐谱\乐谱\Bad style - Time back.mid")
get(mid)
compute(mid)

View File

@@ -1,40 +0,0 @@
def round_up(num, power=0):
"""
实现精确四舍五入,包含正、负小数多种场景
:param num: 需要四舍五入的小数
:param power: 四舍五入位数支持0-∞
:return: 返回四舍五入后的结果
"""
try:
print(1 / 0)
except ZeroDivisionError:
digit = 10 ** power
num2 = float(int(num * digit))
# 处理正数power不为0的情况
if num >= 0 and power != 0:
tag = num * digit - num2 + 1 / (digit * 10)
if tag >= 0.5:
return (num2 + 1) / digit
else:
return num2 / digit
# 处理正数power为0取整的情况
elif num >= 0 and power == 0:
tag = num * digit - int(num)
if tag >= 0.5:
return (num2 + 1) / digit
else:
return num2 / digit
# 处理负数power为0取整的情况
elif power == 0 and num < 0:
tag = num * digit - int(num)
if tag <= -0.5:
return (num2 - 1) / digit
else:
return num2 / digit
# 处理负数power不为0的情况
else:
tag = num * digit - num2 - 1 / (digit * 10)
if tag <= -0.5:
return (num2 - 1) / digit
else:
return num2 / digit

View File

@@ -1,130 +0,0 @@
instrument_list = {
"0": "harp",
"1": "harp",
"2": "pling",
"3": "harp",
"4": "pling",
"5": "pling",
"6": "harp",
"7": "harp",
"8": "share",
"9": "harp",
"10": "didgeridoo",
"11": "harp",
"12": "xylophone",
"13": "chime",
"14": "harp",
"15": "harp",
"16": "bass",
"17": "harp",
"18": "harp",
"19": "harp",
"20": "harp",
"21": "harp",
"22": "harp",
"23": "guitar",
"24": "guitar",
"25": "guitar",
"26": "guitar",
"27": "guitar",
"28": "guitar",
"29": "guitar",
"30": "guitar",
"31": "bass",
"32": "bass",
"33": "bass",
"34": "bass",
"35": "bass",
"36": "bass",
"37": "bass",
"38": "bass",
"39": "bass",
"40": "harp",
"41": "harp",
"42": "harp",
"43": "harp",
"44": "iron_xylophone",
"45": "guitar",
"46": "harp",
"47": "harp",
"48": "guitar",
"49": "guitar",
"50": "bit",
"51": "bit",
"52": "harp",
"53": "harp",
"54": "bit",
"55": "flute",
"56": "flute",
"57": "flute",
"58": "flute",
"59": "flute",
"60": "flute",
"61": "flute",
"62": "flute",
"63": "flute",
"64": "bit",
"65": "bit",
"66": "bit",
"67": "bit",
"68": "flute",
"69": "harp",
"70": "harp",
"71": "flute",
"72": "flute",
"73": "flute",
"74": "harp",
"75": "flute",
"76": "harp",
"77": "harp",
"78": "harp",
"79": "harp",
"80": "bit",
"81": "bit",
"82": "bit",
"83": "bit",
"84": "bit",
"85": "bit",
"86": "bit",
"87": "bit",
"88": "bit",
"89": "bit",
"90": "bit",
"91": "bit",
"92": "bit",
"93": "bit",
"94": "bit",
"95": "bit",
"96": "bit",
"97": "bit",
"98": "bit",
"99": "bit",
"100": "bit",
"101": "bit",
"102": "bit",
"103": "bit",
"104": "harp",
"105": "banjo",
"106": "harp",
"107": "harp",
"108": "harp",
"109": "harp",
"110": "harp",
"111": "guitar",
"112": "harp",
"113": "bell",
"114": "harp",
"115": "cow_bell",
"116": "basedrum",
"117": "bass",
"118": "bit",
"119": "basedrum",
"120": "guitar",
"121": "harp",
"122": "harp",
"123": "harp",
"124": "harp",
"125": "hat",
"126": "basedrum",
"127": "snare",
}

View File

@@ -1,250 +0,0 @@
zip_name = {
-1: "-1.Acoustic_Kit_打击乐.zip",
0: "0.Acoustic_Grand_Piano_大钢琴.zip",
1: "1.Bright_Acoustic_Piano_亮音大钢琴.zip",
10: "10.Music_Box_八音盒.zip",
100: "100.FX_brightness_合成特效-亮音.zip",
101: "101.FX_goblins_合成特效-小妖.zip",
102: "102.FX_echoes_合成特效-回声.zip",
103: "103.FX_sci-fi_合成特效-科幻.zip",
104: "104.Sitar_锡塔尔.zip",
105: "105.Banjo_班卓.zip",
106: "106.Shamisen_三味线.zip",
107: "107.Koto_筝.zip",
108: "108.Kalimba_卡林巴.zip",
109: "109.Bagpipe_风笛.zip",
11: "11.Vibraphone_电颤琴.zip",
110: "110.Fiddle_古提琴.zip",
111: "111.Shanai_唢呐.zip",
112: "112.Tinkle_Bell_铃铛.zip",
113: "113.Agogo_拉丁打铃.zip",
114: "114.Steel_Drums_钢鼓.zip",
115: "115.Woodblock_木块.zip",
116: "116.Taiko_Drum_太鼓.zip",
117: "117.Melodic_Tom_嗵鼓.zip",
118: "118.Synth_Drum_合成鼓.zip",
119: "119.Reverse_Cymbal_镲波形反转.zip",
12: "12.Marimba_马林巴.zip",
13: "13.Xylophone_木琴.zip",
14: "14.Tubular_Bells_管钟.zip",
15: "15.Dulcimer_扬琴.zip",
16: "16.Drawbar_Organ_击杆风琴.zip",
17: "17.Percussive_Organ_打击型风琴.zip",
18: "18.Rock_Organ_摇滚风琴.zip",
19: "19.Church_Organ_管风琴.zip",
2: "2.Electric_Grand_Piano_电子大钢琴.zip",
20: "20.Reed_Organ_簧风琴.zip",
21: "21.Accordion_手风琴.zip",
22: "22.Harmonica_口琴.zip",
23: "23.Tango_Accordian_探戈手风琴.zip",
24: "24.Acoustic_Guitar_(nylon)_尼龙弦吉他.zip",
25: "25.Acoustic_Guitar(steel)_钢弦吉他.zip",
26: "26.Electric_Guitar_(jazz)_爵士乐电吉他.zip",
27: "27.Electric_Guitar_(clean)_清音电吉他.zip",
28: "28.Electric_Guitar_(muted)_弱音电吉他.zip",
29: "29.Overdriven_Guitar_驱动音效吉他.zip",
3: "3.Honky-Tonk_Piano_酒吧钢琴.zip",
30: "30.Distortion_Guitar_失真音效吉他.zip",
31: "31.Guitar_Harmonics_吉他泛音.zip",
32: "32.Acoustic_Bass_原声贝司.zip",
33: "33.Electric_Bass(finger)_指拨电贝司.zip",
34: "34.Electric_Bass(pick)_拨片拨电贝司.zip",
35: "35.Fretless_Bass_无品贝司.zip",
36: "36.Slap_Bass_A_击弦贝司A.zip",
37: "37.Slap_Bass_B_击弦贝司B.zip",
38: "38.Synth_Bass_A_合成贝司A.zip",
39: "39.Synth_Bass_B_合成贝司B.zip",
4: "4.Electric_Piano_1_电钢琴A.zip",
40: "40.Violin_小提琴.zip",
41: "41.Viola_中提琴.zip",
42: "42.Cello_大提琴.zip",
43: "43.Contrabass_低音提琴.zip",
44: "44.Tremolo_Strings_弦乐震音.zip",
45: "45.Pizzicato_Strings_弦乐拨奏.zip",
46: "46.Orchestral_Harp_竖琴.zip",
47: "47.Timpani_定音鼓.zip",
48: "48.String_Ensemble_A_弦乐合奏A.zip",
49: "49.String_Ensemble_B_弦乐合奏B.zip",
5: "5.Electric_Piano_2_电钢琴B.zip",
50: "50.SynthStrings_A_合成弦乐A.zip",
51: "51.SynthStrings_B_合成弦乐B.zip",
52: "52.Choir_Aahs_合唱“啊”音.zip",
53: "53.Voice_Oohs_人声“哦”音.zip",
54: "54.Synth_Voice_合成人声.zip",
55: "55.Orchestra_Hit_乐队打击乐.zip",
56: "56.Trumpet_小号.zip",
57: "57.Trombone_长号.zip",
58: "58.Tuba_大号.zip",
59: "59.Muted_Trumpet_弱音小号.zip",
6: "6.Harpsichord_拨弦古钢琴.zip",
60: "60.French_Horn_圆号.zip",
61: "61.Brass_Section_铜管组.zip",
62: "62.Synth_Brass_A_合成铜管A.zip",
63: "63.Synth_Brass_A_合成铜管B.zip",
64: "64.Soprano_Sax_高音萨克斯.zip",
65: "65.Alto_Sax_中音萨克斯.zip",
66: "66.Tenor_Sax_次中音萨克斯.zip",
67: "67.Baritone_Sax_上低音萨克斯.zip",
68: "68.Oboe_双簧管.zip",
69: "69.English_Horn_英国管.zip",
7: "7.Clavinet_击弦古钢琴.zip",
70: "70.Bassoon_大管.zip",
71: "71.Clarinet_单簧管.zip",
72: "72.Piccolo_短笛.zip",
73: "73.Flute_长笛.zip",
74: "74.Recorder_竖笛.zip",
75: "75.Pan_Flute_排笛.zip",
76: "76.Bottle_Blow_吹瓶口.zip",
77: "77.Skakuhachi_尺八.zip",
78: "78.Whistle_哨.zip",
79: "79.Ocarina_洋埙.zip",
8: "8.Celesta_钢片琴.zip",
80: "80.Lead_square_合成主音-方波.zip",
81: "81.Lead_sawtooth_合成主音-锯齿波.zip",
82: "82.Lead_calliope_lead_合成主音-汽笛风琴.zip",
83: "83.Lead_chiff_lead_合成主音-吹管.zip",
84: "84.Lead_charang_合成主音5-吉他.zip",
85: "85.Lead_voice_合成主音-人声.zip",
86: "86.Lead_fifths_合成主音-五度.zip",
87: "87.Lead_bass+lead_合成主音-低音加主音.zip",
88: "88.Pad_new_age_合成柔音-新时代.zip",
89: "89.Pad_warm_合成柔音-暖音.zip",
9: "9.Glockenspiel_钟琴.zip",
90: "90.Pad_polysynth_合成柔音-复合成.zip",
91: "91.Pad_choir_合成柔音-合唱.zip",
92: "92.Pad_bowed_合成柔音-弓弦.zip",
93: "93.Pad_metallic_合成柔音-金属.zip",
94: "94.Pad_halo_合成柔音-光环.zip",
95: "95.Pad_sweep_合成柔音-扫弦.zip",
96: "96.FX_rain_合成特效-雨.zip",
97: "97.FX_soundtrack_合成特效-音轨.zip",
98: "98.FX_crystal_合成特效-水晶.zip",
99: "99.FX_atmosphere_合成特效-大气.zip",
}
mcpack_name = {
-1: "-1.Acoustic_Kit_打击乐.mcpack",
0: "0.Acoustic_Grand_Piano_大钢琴.mcpack",
1: "1.Bright_Acoustic_Piano_亮音大钢琴.mcpack",
10: "10.Music_Box_八音盒.mcpack",
100: "100.FX_brightness_合成特效-亮音.mcpack",
101: "101.FX_goblins_合成特效-小妖.mcpack",
102: "102.FX_echoes_合成特效-回声.mcpack",
103: "103.FX_sci-fi_合成特效-科幻.mcpack",
104: "104.Sitar_锡塔尔.mcpack",
105: "105.Banjo_班卓.mcpack",
106: "106.Shamisen_三味线.mcpack",
107: "107.Koto_筝.mcpack",
108: "108.Kalimba_卡林巴.mcpack",
109: "109.Bagpipe_风笛.mcpack",
11: "11.Vibraphone_电颤琴.mcpack",
110: "110.Fiddle_古提琴.mcpack",
111: "111.Shanai_唢呐.mcpack",
112: "112.Tinkle_Bell_铃铛.mcpack",
113: "113.Agogo_拉丁打铃.mcpack",
114: "114.Steel_Drums_钢鼓.mcpack",
115: "115.Woodblock_木块.mcpack",
116: "116.Taiko_Drum_太鼓.mcpack",
117: "117.Melodic_Tom_嗵鼓.mcpack",
118: "118.Synth_Drum_合成鼓.mcpack",
119: "119.Reverse_Cymbal_镲波形反转.mcpack",
12: "12.Marimba_马林巴.mcpack",
13: "13.Xylophone_木琴.mcpack",
14: "14.Tubular_Bells_管钟.mcpack",
15: "15.Dulcimer_扬琴.mcpack",
16: "16.Drawbar_Organ_击杆风琴.mcpack",
17: "17.Percussive_Organ_打击型风琴.mcpack",
18: "18.Rock_Organ_摇滚风琴.mcpack",
19: "19.Church_Organ_管风琴.mcpack",
2: "2.Electric_Grand_Piano_电子大钢琴.mcpack",
20: "20.Reed_Organ_簧风琴.mcpack",
21: "21.Accordion_手风琴.mcpack",
22: "22.Harmonica_口琴.mcpack",
23: "23.Tango_Accordian_探戈手风琴.mcpack",
24: "24.Acoustic_Guitar_(nylon)_尼龙弦吉他.mcpack",
25: "25.Acoustic_Guitar(steel)_钢弦吉他.mcpack",
26: "26.Electric_Guitar_(jazz)_爵士乐电吉他.mcpack",
27: "27.Electric_Guitar_(clean)_清音电吉他.mcpack",
28: "28.Electric_Guitar_(muted)_弱音电吉他.mcpack",
29: "29.Overdriven_Guitar_驱动音效吉他.mcpack",
3: "3.Honky-Tonk_Piano_酒吧钢琴.mcpack",
30: "30.Distortion_Guitar_失真音效吉他.mcpack",
31: "31.Guitar_Harmonics_吉他泛音.mcpack",
32: "32.Acoustic_Bass_原声贝司.mcpack",
33: "33.Electric_Bass(finger)_指拨电贝司.mcpack",
34: "34.Electric_Bass(pick)_拨片拨电贝司.mcpack",
35: "35.Fretless_Bass_无品贝司.mcpack",
36: "36.Slap_Bass_A_击弦贝司A.mcpack",
37: "37.Slap_Bass_B_击弦贝司B.mcpack",
38: "38.Synth_Bass_A_合成贝司A.mcpack",
39: "39.Synth_Bass_B_合成贝司B.mcpack",
4: "4.Electric_Piano_1_电钢琴A.mcpack",
40: "40.Violin_小提琴.mcpack",
41: "41.Viola_中提琴.mcpack",
42: "42.Cello_大提琴.mcpack",
43: "43.Contrabass_低音提琴.mcpack",
44: "44.Tremolo_Strings_弦乐震音.mcpack",
45: "45.Pizzicato_Strings_弦乐拨奏.mcpack",
46: "46.Orchestral_Harp_竖琴.mcpack",
47: "47.Timpani_定音鼓.mcpack",
48: "48.String_Ensemble_A_弦乐合奏A.mcpack",
49: "49.String_Ensemble_B_弦乐合奏B.mcpack",
5: "5.Electric_Piano_2_电钢琴B.mcpack",
50: "50.SynthStrings_A_合成弦乐A.mcpack",
51: "51.SynthStrings_B_合成弦乐B.mcpack",
52: "52.Choir_Aahs_合唱“啊”音.mcpack",
53: "53.Voice_Oohs_人声“哦”音.mcpack",
54: "54.Synth_Voice_合成人声.mcpack",
55: "55.Orchestra_Hit_乐队打击乐.mcpack",
56: "56.Trumpet_小号.mcpack",
57: "57.Trombone_长号.mcpack",
58: "58.Tuba_大号.mcpack",
59: "59.Muted_Trumpet_弱音小号.mcpack",
6: "6.Harpsichord_拨弦古钢琴.mcpack",
60: "60.French_Horn_圆号.mcpack",
61: "61.Brass_Section_铜管组.mcpack",
62: "62.Synth_Brass_A_合成铜管A.mcpack",
63: "63.Synth_Brass_A_合成铜管B.mcpack",
64: "64.Soprano_Sax_高音萨克斯.mcpack",
65: "65.Alto_Sax_中音萨克斯.mcpack",
66: "66.Tenor_Sax_次中音萨克斯.mcpack",
67: "67.Baritone_Sax_上低音萨克斯.mcpack",
68: "68.Oboe_双簧管.mcpack",
69: "69.English_Horn_英国管.mcpack",
7: "7.Clavinet_击弦古钢琴.mcpack",
70: "70.Bassoon_大管.mcpack",
71: "71.Clarinet_单簧管.mcpack",
72: "72.Piccolo_短笛.mcpack",
73: "73.Flute_长笛.mcpack",
74: "74.Recorder_竖笛.mcpack",
75: "75.Pan_Flute_排笛.mcpack",
76: "76.Bottle_Blow_吹瓶口.mcpack",
77: "77.Skakuhachi_尺八.mcpack",
78: "78.Whistle_哨.mcpack",
79: "79.Ocarina_洋埙.mcpack",
8: "8.Celesta_钢片琴.mcpack",
80: "80.Lead_square_合成主音-方波.mcpack",
81: "81.Lead_sawtooth_合成主音-锯齿波.mcpack",
82: "82.Lead_calliope_lead_合成主音-汽笛风琴.mcpack",
83: "83.Lead_chiff_lead_合成主音-吹管.mcpack",
84: "84.Lead_charang_合成主音5-吉他.mcpack",
85: "85.Lead_voice_合成主音-人声.mcpack",
86: "86.Lead_fifths_合成主音-五度.mcpack",
87: "87.Lead_bass+lead_合成主音-低音加主音.mcpack",
88: "88.Pad_new_age_合成柔音-新时代.mcpack",
89: "89.Pad_warm_合成柔音-暖音.mcpack",
9: "9.Glockenspiel_钟琴.mcpack",
90: "90.Pad_polysynth_合成柔音-复合成.mcpack",
91: "91.Pad_choir_合成柔音-合唱.mcpack",
92: "92.Pad_bowed_合成柔音-弓弦.mcpack",
93: "93.Pad_metallic_合成柔音-金属.mcpack",
94: "94.Pad_halo_合成柔音-光环.mcpack",
95: "95.Pad_sweep_合成柔音-扫弦.mcpack",
96: "96.FX_rain_合成特效-雨.mcpack",
97: "97.FX_soundtrack_合成特效-音轨.mcpack",
98: "98.FX_crystal_合成特效-水晶.mcpack",
99: "99.FX_atmosphere_合成特效-大气.mcpack",
}
if __name__ == "__main__":
print(zip_name[0])

View File

@@ -1,134 +0,0 @@
pitch = {
"0": "0.0220970869120796",
"1": "0.0234110480761981",
"2": "0.0248031414370031",
"3": "0.0262780129766786",
"4": "0.0278405849418856",
"5": "0.0294960722713029",
"6": "0.03125",
"7": "0.033108221698728",
"8": "0.0350769390096679",
"9": "0.037162722343835",
"10": "0.0393725328092148",
"11": "0.0417137454428136",
"12": "0.0441941738241592",
"13": "0.0468220961523963",
"14": "0.0496062828740062",
"15": "0.0525560259533572",
"16": "0.0556811698837712",
"17": "0.0589921445426059",
"18": "0.0625",
"19": "0.066216443397456",
"20": "0.0701538780193358",
"21": "0.0743254446876701",
"22": "0.0787450656184296",
"23": "0.0834274908856271",
"24": "0.0883883476483184",
"25": "0.0936441923047926",
"26": "0.0992125657480125",
"27": "0.105112051906714",
"28": "0.111362339767542",
"29": "0.117984289085212",
"30": "0.125",
"31": "0.132432886794912",
"32": "0.140307756038672",
"33": "0.14865088937534",
"34": "0.157490131236859",
"35": "0.166854981771254",
"36": "0.176776695296637",
"37": "0.187288384609585",
"38": "0.198425131496025",
"39": "0.210224103813429",
"40": "0.222724679535085",
"41": "0.235968578170423",
"42": "0.25",
"43": "0.264865773589824",
"44": "0.280615512077343",
"45": "0.29730177875068",
"46": "0.314980262473718",
"47": "0.333709963542509",
"48": "0.353553390593274",
"49": "0.37457676921917",
"50": "0.39685026299205",
"51": "0.420448207626857",
"52": "0.44544935907017",
"53": "0.471937156340847",
"54": "0.5",
"55": "0.529731547179648",
"56": "0.561231024154687",
"57": "0.594603557501361",
"58": "0.629960524947437",
"59": "0.667419927085017",
"60": "0.707106781186548",
"61": "0.749153538438341",
"62": "0.7937005259841",
"63": "0.840896415253715",
"64": "0.890898718140339",
"65": "0.943874312681694",
"66": "1",
"67": "1.0594630943593",
"68": "1.12246204830937",
"69": "1.18920711500272",
"70": "1.25992104989487",
"71": "1.33483985417003",
"72": "1.4142135623731",
"73": "1.49830707687668",
"74": "1.5874010519682",
"75": "1.68179283050743",
"76": "1.78179743628068",
"77": "1.88774862536339",
"78": "2",
"79": "2.11892618871859",
"80": "2.24492409661875",
"81": "2.37841423000544",
"82": "2.51984209978975",
"83": "2.66967970834007",
"84": "2.82842712474619",
"85": "2.99661415375336",
"86": "3.1748021039364",
"87": "3.36358566101486",
"88": "3.56359487256136",
"89": "3.77549725072677",
"90": "4",
"91": "4.23785237743718",
"92": "4.48984819323749",
"93": "4.75682846001088",
"94": "5.03968419957949",
"95": "5.33935941668014",
"96": "5.65685424949238",
"97": "5.99322830750673",
"98": "6.3496042078728",
"99": "6.72717132202972",
"100": "7.12718974512272",
"101": "7.55099450145355",
"102": "8",
"103": "8.47570475487436",
"104": "8.97969638647498",
"105": "9.51365692002177",
"106": "10.079368399159",
"107": "10.6787188333603",
"108": "11.3137084989848",
"109": "11.9864566150135",
"110": "12.6992084157456",
"111": "13.4543426440594",
"112": "14.2543794902454",
"113": "15.1019890029071",
"114": "16",
"115": "16.9514095097487",
"116": "17.95939277295",
"117": "19.0273138400435",
"118": "20.158736798318",
"119": "21.3574376667206",
"120": "22.6274169979695",
"121": "23.9729132300269",
"122": "25.3984168314912",
"123": "26.9086852881189",
"124": "28.5087589804909",
"125": "30.2039780058142",
"126": "32",
"127": "33.9028190194974",
"128": "35.9187855458999",
"129": "38.0546276800871",
"130": "40.3174735966359",
"131": "42.7148753334411",
}

View File

@@ -1,208 +0,0 @@
# -*- coding: utf-8 -*-
# from nmcsup.log import log
import pickle
class Note:
def __init__(self, channel, pitch, velocity, time, time_position, instrument):
self.channel = channel
self.pitch = pitch
self.velocity = velocity
self.delay = time
self.time_position = time_position
self.instrument = instrument
self.CD = "d"
def get_CD(self, start, end):
if end - start > 1.00:
self.CD = "c"
else:
self.CD = "d"
def midiNewReader(midfile: str):
import mido
# from msctspt.threadOpera import NewThread
from bgArrayLib.bpm import get
def Time(mt, tpb_a, bpm_a):
return round(mt / tpb_a / bpm_a * 60 * 20)
Notes = []
tracks = []
note_list = []
close = []
on = []
off = []
instruments = []
isPercussion = False
try:
mid = mido.MidiFile(midfile)
except Exception:
print("找不到文件或无法读取文件" + midfile)
return False
tpb = mid.ticks_per_beat
bpm = get(mid)
# 解析
# def loadMidi(track1):
for track in mid.tracks:
overallTime = 0.0
instrument = 0
for i in track:
overallTime += i.time
try:
if i.channel != 9:
# try:
# log("event_type(事件): " + str(i.type) + " channel(音轨): " + str(i.channel) +
# " note/pitch(音高): " +
# str(i[2]) +
# " velocity(力度): " + str(i.velocity) + " time(间隔时间): " + str(i.time) +
# " overallTime/globalTime/timePosition: " + str(overallTime) + " \n")
# except AttributeError:
# log("event_type(事件): " + str(i.type) + " thing(内容)" + str(i) + " \n")
if "program_change" in str(i):
instrument = i.program
if instrument > 119: # 音色不够
pass
else:
instruments.append(i.program)
if "note_on" in str(i) and i.velocity > 0:
print(i)
# print(i.note)
# print([Note(i.channel, i.note, i.velocity, i.time, Time(overallTime, tpb, bpm), instrument)])
tracks.append(
[
Note(
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
instrument,
)
]
)
note_list.append(
[
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
instrument,
]
)
on.append([i.note, Time(overallTime, tpb, bpm)])
# return [Note(i.channel, i, i.velocity, i.time, Time(overallTime, tpb, bpm))]
if "note_off" in str(i) or "note_on" in str(i) and i.velocity == 0:
# print(i)
# print([Note(i.channel, i.note, i.velocity, i.time, Time(overallTime, tpb, bpm))])
close.append(
[
Note(
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
instrument,
)
]
)
off.append([i.note, Time(overallTime, tpb, bpm)])
# return [Note(i.channel, i, i.velocity, i.time, Time(overallTime, tpb, bpm))]
except AttributeError:
pass
if "note_on" in str(i) and i.channel == 9:
if "note_on" in str(i) and i.velocity > 0:
print(i)
# print(i.note)
# print([Note(i.channel, i.note, i.velocity, i.time, Time(overallTime, tpb, bpm), -1)])
tracks.append(
[
Note(
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
-1,
)
]
)
note_list.append(
[
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
-1,
]
)
on.append([i.note, Time(overallTime, tpb, bpm)])
isPercussion = True
# return [Note(i.channel, i, i.velocity, i.time, Time(overallTime, tpb, bpm))]
Notes.append(tracks)
if instruments is []:
instruments.append(0)
instruments = list(set(instruments))
with open("1.pkl", "wb") as b:
pickle.dump([instruments, isPercussion], b)
# for j, track in enumerate(mid.tracks):
# th = NewThread(loadMidi, (track,))
# th.start()
# Notes.append(th.getResult())
# print(Notes)
print(Notes.__len__())
# print(note_list)
print(instruments)
return Notes
# return [Notes, note_list]
def midiClassReader(midfile: str):
import mido
from bgArrayLib.bpm import get
def Time(mt, tpb_a, bpm_a):
return round(mt / tpb_a / bpm_a * 60 * 20)
Notes = []
tracks = []
try:
mid = mido.MidiFile(filename=midfile, clip=True)
except Exception:
print("找不到文件或无法读取文件" + midfile)
return False
print("midi已经载入了。")
tpb = mid.ticks_per_beat
bpm = get(mid)
for track in mid.tracks:
overallTime = 0.0
instrument = 0
for i in track:
overallTime += i.time
if "note_on" in str(i) and i.velocity > 0:
print(i)
tracks.append(
[
Note(
i.channel,
i.note,
i.velocity,
i.time,
Time(overallTime, tpb, bpm),
instrument,
)
]
)
Notes.append(tracks)
print(Notes.__len__())
return Notes

View File

@@ -1,147 +0,0 @@
import os
import pickle
import shutil
# import tkinter.filedialog
# from namesConstant import zip_name
# from namesConstant import mcpack_name
import bgArrayLib.namesConstant
zipN = bgArrayLib.namesConstant.zip_name
mpN = bgArrayLib.namesConstant.mcpack_name
manifest = {
"format_version": 1,
"header": {
"name": "羽音缭绕-midiout_25.5--音创使用",
"description": "羽音缭绕-midiout_25.0--音创使用",
"uuid": "c1adbda4-3b3e-4e5b-a57e-cde8ac80ee19",
"version": [25, 5, 0],
},
"modules": [
{
"description": "羽音缭绕-midiout_25.0--音创使用",
"type": "resources",
"uuid": "c13455d5-b9f3-47f2-9706-c05ad86b3180 ",
"version": [25, 5, 0],
}
],
}
def resources_pathSetting(newPath: str = ""):
if not os.path.isfile("./bgArrayLib/resourcesPath.rpposi") and newPath == "":
return [False, 1] # 1:没有路径文件
elif newPath != "": # not os.path.isfile("./bgArrayLib/resourcesPath.rpposi") and
path = newPath
print(path)
with open("./bgArrayLib/resourcesPath.rpposi", "w") as w:
w.write(path)
if "mcpack(国际版推荐)格式_25.0" in os.listdir(
path
) and "zip格式_25.0" in os.listdir(path):
return [True, path, 1] # 1:都有
elif "mcpack(国际版推荐)格式_25.0" in os.listdir(
path
) and "zip格式_25.0" not in os.listdir(path):
return [True, path, 2] # 2:有pack
elif "mcpack(国际版推荐)格式_25.0" not in os.listdir(
path
) and "zip格式_25.0" in os.listdir(path):
return [True, path, 3] # 3:有zip
else:
return [False, 2] # 2:路径文件指示错误
if os.path.isfile("./bgArrayLib/resourcesPath.rpposi") and newPath == "":
with open("./bgArrayLib/resourcesPath.rpposi", "r") as f:
path = f.read()
if "mcpack(国际版推荐)格式_25.0" in os.listdir(
path
) and "zip格式_25.0" in os.listdir(path):
return [True, path, 1] # 1:都有
elif "mcpack(国际版推荐)格式_25.0" in os.listdir(
path
) and "zip格式_25.0" not in os.listdir(path):
return [True, path, 2] # 2:有pack
elif "mcpack(国际版推荐)格式_25.0" not in os.listdir(
path
) and "zip格式_25.0" in os.listdir(path):
return [True, path, 3] # 3:有zip
else:
return [False, 2] # 2:路径文件指示错误
raise
def choose_resources():
global zipN
global mpN
back_list = []
try:
with open(r"1.pkl", "rb") as rb:
instrument = list(pickle.load(rb))
print(instrument)
except FileNotFoundError:
with open(r"./nmcsup/1.pkl", "rb") as rb:
instrument = list(pickle.load(rb))
print(instrument)
path = resources_pathSetting()
if path.__len__() == 2:
return path
else:
dataT = path[2]
pathT = path[1]
if dataT == 1:
if instrument[1] is True: # 是否存在打击乐器
index = zipN.get(-1, "")
percussion_instrument = str(pathT) + "\\zip格式_25.0\\" + index
# print(percussion_instrument)
back_list.append(percussion_instrument)
for i in instrument[0]:
ins_p = str(pathT) + "\\zip格式_25.0\\" + str(zipN.get(i))
# print(ins_p)
back_list.append(ins_p)
print(back_list)
return back_list
elif dataT == 2:
if instrument[1] is True:
index = mpN.get(-1, "")
percussion_instrument = (
str(pathT) + "\\mcpack(国际版推荐)格式_25.0\\" + index
)
# print(percussion_instrument)
back_list.append(percussion_instrument)
for i in instrument[0]:
ins_p = str(pathT) + "\\mcpack(国际版推荐)格式_25.0\\" + str(mpN.get(i))
# print(ins_p)
back_list.append(ins_p)
print(back_list)
return back_list
elif dataT == 3:
if instrument[1] is True:
index = zipN.get(-1, "")
percussion_instrument = str(pathT) + "\\zip格式_25.0\\" + index
# print(percussion_instrument)
back_list.append(percussion_instrument)
for i in instrument[0]:
ins_p = str(pathT) + "\\zip格式_25.0\\" + str(zipN.get(i))
# print(ins_p)
back_list.append(ins_p)
print(back_list)
return back_list
raise
def scatteredPack(path):
pack_list = choose_resources()
print(pack_list)
print(path)
# os.close("L:/0WorldMusicCreater-MFMS new edition")
# shutil.copy("L:\\shenyu\\音源的资源包\\羽音缭绕-midiout_25.0\\mcpack(国际版推荐)格式_25.0\\0.Acoustic_Grand_Piano_大钢琴.mcpack",
# "L:/0WorldMusicCreater-MFMS new edition")
for i in pack_list:
shutil.copy(i, path)
if __name__ == "__main__":
# print(resources_pathSetting(r"L:\shenyu\音源的资源包\羽音缭绕-midiout_25.0"))
choose_resources()

View File

@@ -1,248 +0,0 @@
# -*- coding: utf-8 -*-
# 伶伦 开发交流群 861684859
"""
音·创 (Musicreater) 演示程序
是一款免费开源的针对《我的世界》的midi音乐转换库
Musicreater (音·创)
A free open source library used for convert midi file into formats that is suitable for **Minecraft**.
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 ./License.md
Terms & Conditions: ./License.md
"""
import os
import Musicreater.old_init as old_init
from Musicreater.old_plugin.addonpack import (
to_addon_pack_in_delay,
to_addon_pack_in_repeater,
to_addon_pack_in_score,
)
from Musicreater.old_plugin.mcstructfile import (
to_mcstructure_file_in_delay,
to_mcstructure_file_in_repeater,
to_mcstructure_file_in_score,
)
from Musicreater.old_plugin.bdxfile import to_BDX_file_in_delay, to_BDX_file_in_score
# 获取midi列表
midi_path = input(f"请输入MIDI路径")
# 获取输出地址
out_path = input(f"请输入输出路径:")
# 选择输出格式
fileFormat = int(
input(f"请输入输出格式[MCSTRUCTURE(2) 或 BDX(1) 或 MCPACK(0)]").lower()
)
playerFormat = int(input(f"请选择播放方式[红石(2) 或 计分板(1) 或 延迟(0)]").lower())
# 真假字符串判断
def bool_str(sth: str):
try:
return bool(float(sth))
except:
if str(sth).lower() in ("true", "", "", "y", "t"):
return True
elif str(sth).lower() in ("false", "", "", "f", "n"):
return False
else:
raise ValueError("非法逻辑字串")
def isin(sth: str, range_list: dict):
sth = sth.lower()
for bool_value, res_list in range_list.items():
if sth in res_list:
return bool_value
raise ValueError(
"不在可选范围内:{}".format([j for i in range_list.values() for j in i])
)
if os.path.exists("./demo_config.json"):
import json
prompts = json.load(open("./demo_config.json", "r", encoding="utf-8"))
else:
prompts = []
# 提示语 检测函数 错误提示语
for args in [
(
f"最小播放音量:",
float,
),
(
f"播放速度:",
float,
),
(
f"是否启用进度条:",
bool_str,
),
(
(
f"计分板名称:",
str,
)
if playerFormat == 1
else (
f"玩家选择器:",
str,
)
),
(
(
f"是否自动重置计分板:",
bool_str,
)
if playerFormat == 1
else ()
),
(
(
f"BDX作者署名",
str,
)
if fileFormat == 1
else (
(
"结构延展方向:",
lambda a: isin(
a,
{
"z+": ["z+", "Z+"],
"x+": ["X+", "x+"],
"z-": ["Z-", "z-"],
"x-": ["x-", "X-"],
},
),
)
if (playerFormat == 2 and fileFormat == 2)
else ()
)
),
(
()
if playerFormat == 1
else (
(
"基础空白方块:",
str,
)
if (playerFormat == 2 and fileFormat == 2)
else (
f"最大结构高度:",
int,
)
)
),
]:
if args:
try:
prompts.append(args[1](input(args[0])))
except Exception:
print(args)
print(f"正在处理 {midi_path} ")
cvt_mid = old_init.MidiConvert.from_midi_file(
midi_path, old_exe_format=False, min_volume=prompts[0], play_speed=prompts[1]
)
if fileFormat == 0:
if playerFormat == 1:
cvt_method = to_addon_pack_in_score
elif playerFormat == 0:
cvt_method = to_addon_pack_in_delay
elif playerFormat == 2:
cvt_method = to_addon_pack_in_repeater
elif fileFormat == 2:
if playerFormat == 1:
cvt_method = to_mcstructure_file_in_score
elif playerFormat == 0:
cvt_method = to_mcstructure_file_in_delay
elif playerFormat == 2:
cvt_method = to_mcstructure_file_in_repeater
# 测试
# print(cvt_mid)
print(
" 指令总长:{},最高延迟:{}".format(
*(
cvt_method(
cvt_mid,
out_path,
old_init.DEFAULT_PROGRESSBAR_STYLE if prompts[2] else None, # type: ignore
*prompts[3:],
)
)
)
if fileFormat == 0
else (
" 指令总长:{},最高延迟:{},结构大小{},终点坐标{}".format(
*(
to_BDX_file_in_score(
cvt_mid,
out_path,
old_init.DEFAULT_PROGRESSBAR_STYLE if prompts[2] else None,
*prompts[3:],
)
if playerFormat == 1
else to_BDX_file_in_delay(
cvt_mid,
out_path,
old_init.DEFAULT_PROGRESSBAR_STYLE if prompts[2] else None,
*prompts[3:],
)
)
)
if fileFormat == 1
else (
" 结构大小:{},延迟总数:{},指令数量:{}".format(
*(
cvt_method(
cvt_mid,
out_path,
*prompts[3:],
)
)
)
if playerFormat == 1
else " 结构大小:{},延迟总数:{}".format(
*(
cvt_method(
cvt_mid,
out_path,
# Musicreater.DEFAULT_PROGRESSBAR_STYLE if prompts[2] else None, # type: ignore
*prompts[3:],
)
)
)
)
)
)
exitSth = input("回车退出").lower()
if exitSth == "record":
import json
with open("./demo_config.json", "w", encoding="utf-8") as f:
json.dump(prompts, f)
elif exitSth == "delrec":
os.remove("./demo_config.json")

View File

@@ -1,14 +0,0 @@
import Musicreater.experiment
import Musicreater.old_plugin
import Musicreater.old_plugin.mcstructfile
print(
Musicreater.old_plugin.mcstructfile.to_mcstructure_file_in_delay(
Musicreater.experiment.FutureMidiConvertM4.from_midi_file(
input("midi路径:"), old_exe_format=False
),
input("输出路径:"),
# Musicreater.plugin.ConvertConfig(input("输出路径:"),),
max_height=32,
)
)

View File

@@ -1,16 +0,0 @@
import Musicreater.old_init as old_init
import Musicreater.old_plugin
import Musicreater.old_plugin.mcstructfile
print(
old_init.old_plugin.mcstructfile.to_mcstructure_file_in_delay(
old_init.MidiConvert.from_midi_file(
input("midi路径:"),
old_exe_format=False,
# note_table_replacement={"note.harp": "note.flute"},
),
input("输出路径:"),
# Musicreater.plugin.ConvertConfig(input("输出路径:"),),
# max_height=32,
)
)

View File

@@ -1,24 +0,0 @@
import Musicreater.old_init as old_init
import Musicreater.old_plugin
import Musicreater.old_plugin.websocket
import os
dire = input("midi目录")
print(
old_init.old_plugin.websocket.to_websocket_server(
[
old_init.MidiConvert.from_midi_file(
os.path.join(dire, names), old_exe_format=False
)
for names in os.listdir(
dire,
)
if names.endswith((".mid", ".midi"))
],
input("服务器地址:"),
int(input("服务器端口:")),
old_init.DEFAULT_PROGRESSBAR_STYLE,
)
)

View File

@@ -1 +0,0 @@
SEE: https://mingfengpigeon.mit-license.org/

View File

@@ -1,5 +0,0 @@
__all__ = ['Server', 'Plugin', 'build_header']
__version__ = '3.0.1'
__author__ = ['mingfengpigeon <mingfengpigeon@gmail.com>',"Eilles Wan <EillesWan@outlook.com>"]
from .server import Server, Plugin, build_header

View File

@@ -1,142 +0,0 @@
import asyncio
import copy
import json
import uuid
import websockets
class Server:
sent_commands = {}
subscribed_events = {}
_plugins = []
_connections = []
def __init__(self, server='0.0.0.0', port=8000, debug_mode=False):
self._server = server
self._port = port
self._debug_mode = debug_mode
def handler(self):
return copy.deepcopy(self._plugins)
def add_plugin(self, plugin):
if self._plugins:
for connection in self._connections:
plugin_ = plugin()
asyncio.create_task(plugin_.on_connect())
connection.append(plugin_)
self._plugins.append(plugin)
def remove_plugin(self, plugin):
if self._connections:
for connection in self._connections:
for plugin_ in connection.plugins:
if isinstance(plugin_, plugin):
plugin_.remove(plugin_)
break
self._plugins.remove(plugin)
async def run_forever(self):
self.running = True
async with websockets.serve(self._on_connect, self._server, self._port):
await asyncio.Future()
async def _on_connect(self, websocket, path):
plugins = []
self._connections.append({
"websocket": websocket,
"path": path,
"plugins": plugins,
})
for plugin in self._plugins:
plugins.append(plugin(websocket, path, self, self._debug_mode))
for plugin in plugins:
asyncio.create_task(plugin.on_connect())
while self.running:
try:
response = json.loads(await websocket.recv())
except (websockets.exceptions.ConnectionClosedOK, websockets.exceptions.ConnectionClosedError):
tasks = []
for plugin in plugins:
tasks.append(plugin.on_disconnect())
for task in tasks:
await task
break
else:
message_purpose = response['header']['messagePurpose']
if message_purpose == 'commandResponse':
request_id = response['header']['requestId']
if request_id in self.sent_commands:
asyncio.create_task(self.sent_commands[request_id](response))
del self.sent_commands[request_id]
else:
try:
event_name = response['header']['eventName']
asyncio.create_task(self.subscribed_events[event_name](response))
except KeyError:
print("ERROR EVENT NAME:\n{}".format(response))
async def disconnect(self, websocket: websockets.WebSocketServerProtocol):
self.running = False
await websocket.close_connection()
for number in range(len(self._connections) - 1):
connection = self._connections[number]
if connection['websocket'] == websocket:
del self._connections[number]
class Plugin:
def __init__(self, websocket, path, server, debug_mode=False):
self._websocket = websocket
self._path = path
self._server = server
self._debug_mode = debug_mode
async def on_connect(self):
pass
async def on_disconnect(self):
pass
async def on_receive(self, response):
pass
async def send_command(self, command, callback=None):
request = {
'body': {'commandLine': command},
'header': build_header('commandRequest')
}
if callback:
self._server.sent_commands[request['header']['requestId']] = callback
await self._websocket.send(json.dumps(request, **{'indent': 4} if self._debug_mode else {}))
async def subscribe(self, event_name, callback):
request = {
'body': {'eventName': event_name},
'header': build_header('subscribe')
}
self._server.subscribed_events[event_name] = callback
await self._websocket.send(json.dumps(request, **{'indent': 4} if self._debug_mode else {}))
async def unsubscribe(self, event_name):
request = {
'body': {'eventName': event_name},
'header': build_header('unsubscribe')
}
del self._server.subscribed_events[event_name]
await self._websocket.send(json.dumps(request, **{'indent': 4} if self._debug_mode else {}))
async def disconnect(self):
await self._server.disconnect(self._websocket)
def build_header(message_purpose, request_id=None):
if not request_id:
request_id = str(uuid.uuid4())
return {
'requestId': request_id,
'messagePurpose': message_purpose,
'version': '1',
'messageType': 'commandRequest',
}

View File

@@ -1,163 +0,0 @@
"""
版权所有 © 2025 金羿 & 诸葛亮与八卦阵
Copyright © 2025 Eilles & bgArray
开源相关声明请见 仓库根目录下的 License.md
Terms & Conditions: License.md in the root directory
"""
import os
import shutil
from typing import Optional, Tuple
import Musicreater.experiment
from Musicreater.old_plugin.archive import compress_zipfile
from Musicreater.utils import guess_deviation, is_in_diapason
def to_zip_pack_in_score(
midi_cvt: Musicreater.experiment.FutureMidiConvertJavaE,
dist_path: str,
progressbar_style: Optional[Musicreater.experiment.ProgressBarStyle],
scoreboard_name: str = "mscplay",
sound_source: str = "ambient",
auto_reset: bool = False,
) -> Tuple[int, int]:
"""
将midi以计分播放器形式转换为我的世界函数附加包
Parameters
----------
midi_cvt: MidiConvert 对象
用于转换的MidiConvert对象
dist_path: str
转换结果输出的目标路径
progressbar_style: ProgressBarStyle 对象
进度条对象
scoreboard_name: str
我的世界的计分板名称
auto_reset: bool
是否自动重置计分板
Returns
-------
tuple[int指令数量, int音乐总延迟]
"""
cmdlist, maxlen, maxscore = midi_cvt.to_command_list_in_java_score(
scoreboard_name=scoreboard_name,
source_of_sound=sound_source,
)
# 当文件f夹{self.outputPath}/temp/mscplyfuncs存在时清空其下所有项目然后创建
if os.path.exists(f"{dist_path}/temp/mscplyfuncs/"):
shutil.rmtree(f"{dist_path}/temp/mscplyfuncs/")
os.makedirs(f"{dist_path}/temp/mscplyfuncs/mscplay")
# 写入stop.mcfunction
with open(
f"{dist_path}/temp/mscplyfuncs/stop.mcfunction", "w", encoding="utf-8"
) as f:
f.write("scoreboard players reset @a {}".format(scoreboard_name))
# 将命令列表写入文件
index_file = open(
f"{dist_path}/temp/mscplyfuncs/index.mcfunction", "w", encoding="utf-8"
)
for i in range(len(cmdlist)):
index_file.write(f"function mscplyfuncs:mscplay/track{i + 1}\n")
with open(
f"{dist_path}/temp/mscplyfuncs/mscplay/track{i + 1}.mcfunction",
"w",
encoding="utf-8",
) as f:
f.write("\n".join([single_cmd.cmd for single_cmd in cmdlist[i]]))
index_file.writelines(
(
"scoreboard players add @a[score_{0}_min=1] {0} 1\n".format(
scoreboard_name
),
(
"scoreboard players reset @a[score_{0}_min={1}] {0}\n".format(
scoreboard_name, maxscore + 20
)
if auto_reset
else ""
),
f"function mscplyfuncs:mscplay/progressShow\n" if progressbar_style else "",
)
)
if progressbar_style:
with open(
f"{dist_path}/temp/mscplyfuncs/mscplay/progressShow.mcfunction",
"w",
encoding="utf-8",
) as f:
f.writelines(
"\n".join(
[
single_cmd.cmd
for single_cmd in midi_cvt.form_java_progress_bar(
maxscore, scoreboard_name, progressbar_style
)
]
)
)
index_file.close()
if os.path.exists(f"{dist_path}/{midi_cvt.music_name}.zip"):
os.remove(f"{dist_path}/{midi_cvt.music_name}.zip")
compress_zipfile(
f"{dist_path}/temp/",
f"{dist_path}/{midi_cvt.music_name}[JEscore].zip",
)
shutil.rmtree(f"{dist_path}/temp/")
return maxlen, maxscore
msc_cvt = Musicreater.experiment.FutureMidiConvertJavaE.from_midi_file(
input("midi路径"),
play_speed=float(input("播放速度:")),
old_exe_format=True,
note_table_replacement=Musicreater.old_init.MC_EILLES_RTJE12_INSTRUMENT_REPLACE_TABLE,
# pitched_note_table=Musicreater.MM_NBS_PITCHED_INSTRUMENT_TABLE,
)
msc_cvt.set_deviation(
guess_deviation(
msc_cvt.total_note_count,
len(msc_cvt.note_count_per_instrument),
msc_cvt.note_count_per_instrument,
music_channels=msc_cvt.channels,
)
)
in_diapason_count = 0
for this_note in [k for j in msc_cvt.channels.values() for k in j]:
if is_in_diapason(
this_note.note_pitch + msc_cvt.music_deviation, this_note.sound_name
):
in_diapason_count += 1
zip_res = to_zip_pack_in_score(
msc_cvt,
input("输出路径:"),
Musicreater.experiment.ProgressBarStyle(),
# Musicreater.plugin.ConvertConfig(input("输出路径:"),),
scoreboard_name=input("计分板名称:"),
sound_source=input("发音源:"),
auto_reset=True,
)
print(
"符合音符播放音高的音符数量:{}/{}({:.2f}%)".format(
in_diapason_count,
msc_cvt.total_note_count,
in_diapason_count * 100 / msc_cvt.total_note_count,
),
"\n指令数量:{};音乐总延迟:{}".format(*zip_res),
)

View File

@@ -1,39 +0,0 @@
from rich.pretty import pprint
import Musicreater.old_init as old_init
from Musicreater.utils import (
load_decode_fsq_flush_release,
load_decode_musicsequence_metainfo,
)
msc_seq = old_init.MusicSequence.from_mido(
old_init.mido.MidiFile(
"./resources/测试片段.mid",
),
"TEST-测试片段",
)
pprint("音乐源取入成功:")
pprint(msc_seq)
with open("test.fsq", "wb") as f:
f.write(fsq_bytes := msc_seq.encode_dump(flowing_codec_support=True))
with open("test.fsq", "rb") as f:
msc_seq_r = old_init.MusicSequence.load_decode(f.read(), verify=True)
pprint("FSQ 传入类成功:")
pprint(msc_seq_r)
with open("test.fsq", "rb") as f:
pprint("流式 FSQ 元数据:")
pprint(metas := load_decode_musicsequence_metainfo(f))
pprint("流式 FSQ 音符序列:")
cnt = 0
for i in load_decode_fsq_flush_release(f, metas[-2], metas[-3], metas[-1]):
pprint(
i,
)
cnt += 1
pprint(f"{cnt} 个音符")

View File

@@ -1,33 +0,0 @@
import Musicreater.experiment
import Musicreater.old_plugin
import Musicreater.old_plugin.mcstructfile
msct = Musicreater.experiment.FutureMidiConvertKamiRES.from_midi_file(
input("midi路径:"), old_exe_format=False
)
opt = input("输出路径:")
print(
"乐器使用情况",
)
for name in sorted(
set(
[
n.split(".")[0].replace("c", "").replace("d", "")
for n in msct.note_count_per_instrument.keys()
]
)
):
print("\t", name, flush=True)
print(
"\n输出:",
Musicreater.old_plugin.mcstructfile.to_mcstructure_file_in_delay(
msct,
opt,
# Musicreater.plugin.ConvertConfig(input("输出路径:"),),
max_height=32,
),
)

View File

@@ -1,33 +0,0 @@
import Musicreater.experiment
import Musicreater.old_plugin
import Musicreater.old_plugin.mcstructfile
msct = Musicreater.experiment.FutureMidiConvertLyricSupport.from_midi_file(
input("midi路径:"), old_exe_format=False
)
opt = input("输出路径:")
# print(
# "乐器使用情况",
# )
# for name in sorted(
# set(
# [
# n.split(".")[0].replace("c", "").replace("d", "")
# for n in msct.note_count_per_instrument.keys()
# ]
# )
# ):
# print("\t", name, flush=True)
print(
"\n输出:",
Musicreater.old_plugin.mcstructfile.to_mcstructure_file_in_delay(
msct,
opt,
# Musicreater.plugin.ConvertConfig(input("输出路径:"),),
max_height=32,
),
)

View File

@@ -1,34 +0,0 @@
from rich.pretty import pprint
import Musicreater.old_init as old_init
from Musicreater.utils import (
load_decode_msq_flush_release,
load_decode_musicsequence_metainfo,
)
msc_seq = old_init.MusicSequence.from_mido(
old_init.mido.MidiFile(
"./resources/测试片段.mid",
),
"TEST-测试片段",
)
pprint("音乐源取入成功:")
pprint(msc_seq)
with open("test.msq", "wb") as f:
f.write(msq_bytes := msc_seq.encode_dump())
with open("test.msq", "rb") as f:
msc_seq_r = old_init.MusicSequence.load_decode(f.read())
pprint("常规 MSQ 读取成功:")
pprint(msc_seq_r)
with open("test.msq", "rb") as f:
pprint("流式 MSQ 元数据:")
pprint(metas := load_decode_musicsequence_metainfo(f))
pprint("流式 MSQ 音符序列:")
for i in load_decode_msq_flush_release(f, metas[-2], metas[-3], metas[-1]):
pprint(i)

47
poem.txt Normal file
View File

@@ -0,0 +1,47 @@
> 是谁把科技的领域布满政治的火药
>
> 是谁把纯净的蓝天染上暗淡的沉灰
>
> 中国人民无不热爱自己伟大的祖国
>
> 我们不会忘记屈辱历史留下的惨痛
>
> 我们希望世界和平
>
> 我们希望获得世界的尊重
>
> 愿世上再也没有战争
>
> 无论是热还是冷
>
> 无论是经济还是政治
>
> 让美妙的和平的优雅的音乐响彻世界
>
> ——金羿
> 2022 5 7
> Who has dropped political gunpowder into the technology
>
> Who has dyed clear blue sky into the dark grey
>
> All Chinese people love our great homeland
>
> We *WILL* remember the remain pain of the humiliating history
>
> We love the whole world but in peace
>
> We love everyone but under respect
>
> It is to be hoped that the war ends forever
>
> Whatever it is cold or hot
>
> Whatever it is economical or political
>
> Just let the wonderful music of peace surround the world
>
> ---- Eilles Wan
> 7/5 2022

580
pp.py Normal file
View File

@@ -0,0 +1,580 @@
# -*- coding: utf-8 -*-
##########################################################################
# Form generated from reading UI file 'PySide6-Pkg.ui'
##
# Created by: Qt User Interface Compiler version 6.4.1
##
# WARNING! All changes made in this file will be lost when recompiling UI file!
##########################################################################
from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
QMetaObject, QObject, QPoint, QRect,
QSize, QTime, QUrl, Qt)
from PySide6.QtGui import (QAction, QBrush, QColor, QConicalGradient,
QCursor, QFont, QFontDatabase, QGradient,
QIcon, QImage, QKeySequence, QLinearGradient,
QPainter, QPalette, QPixmap, QRadialGradient,
QTransform)
from PySide6.QtWidgets import (
QApplication,
QCheckBox,
QComboBox,
QHBoxLayout,
QHeaderView,
QLabel,
QMainWindow,
QMenu,
QMenuBar,
QSizePolicy,
QSlider,
QSpinBox,
QStatusBar,
QTabWidget,
QTableWidget,
QTableWidgetItem,
QTextEdit,
QToolButton,
QVBoxLayout,
QWidget)
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
if not MainWindow.objectName():
MainWindow.setObjectName(u"MainWindow")
MainWindow.resize(800, 600)
self.action = QAction(MainWindow)
self.action.setObjectName(u"action")
icon = QIcon()
iconThemeName = u"document-open"
if QIcon.hasThemeIcon(iconThemeName):
icon = QIcon.fromTheme(iconThemeName)
else:
icon.addFile(u".", QSize(), QIcon.Normal, QIcon.Off)
self.action.setIcon(icon)
self.action_Input = QAction(MainWindow)
self.action_Input.setObjectName(u"action_Input")
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName(u"centralwidget")
self.verticalLayoutWidget = QWidget(self.centralwidget)
self.verticalLayoutWidget.setObjectName(u"verticalLayoutWidget")
self.verticalLayoutWidget.setGeometry(QRect(0, 0, 951, 611))
self.verticalLayout = QVBoxLayout(self.verticalLayoutWidget)
self.verticalLayout.setObjectName(u"verticalLayout")
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.tabO = QTabWidget(self.verticalLayoutWidget)
self.tabO.setObjectName(u"tabO")
self.tab = QWidget()
self.tab.setObjectName(u"tab")
self.verticalLayoutWidget_2 = QWidget(self.tab)
self.verticalLayoutWidget_2.setObjectName(u"verticalLayoutWidget_2")
self.verticalLayoutWidget_2.setGeometry(QRect(0, 0, 881, 591))
self.verticalLayout_2 = QVBoxLayout(self.verticalLayoutWidget_2)
self.verticalLayout_2.setObjectName(u"verticalLayout_2")
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.tableWidget = QTableWidget(self.verticalLayoutWidget_2)
self.tableWidget.setObjectName(u"tableWidget")
self.verticalLayout_2.addWidget(self.tableWidget)
self.tabO.addTab(self.tab, "")
self.tab_2 = QWidget()
self.tab_2.setObjectName(u"tab_2")
self.label = QLabel(self.tab_2)
self.label.setObjectName(u"label")
self.label.setGeometry(QRect(10, 10, 71, 16))
self.widget = QWidget(self.tab_2)
self.widget.setObjectName(u"widget")
self.widget.setGeometry(QRect(0, 30, 281, 131))
self.verticalLayoutWidget_3 = QWidget(self.widget)
self.verticalLayoutWidget_3.setObjectName(u"verticalLayoutWidget_3")
self.verticalLayoutWidget_3.setGeometry(QRect(10, 0, 271, 131))
self.verticalLayout_3 = QVBoxLayout(self.verticalLayoutWidget_3)
self.verticalLayout_3.setObjectName(u"verticalLayout_3")
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.label_2 = QLabel(self.verticalLayoutWidget_3)
self.label_2.setObjectName(u"label_2")
self.verticalLayout_3.addWidget(self.label_2)
self.label_4 = QLabel(self.verticalLayoutWidget_3)
self.label_4.setObjectName(u"label_4")
self.verticalLayout_3.addWidget(self.label_4)
self.label_5 = QLabel(self.verticalLayoutWidget_3)
self.label_5.setObjectName(u"label_5")
self.verticalLayout_3.addWidget(self.label_5)
self.label_7 = QLabel(self.verticalLayoutWidget_3)
self.label_7.setObjectName(u"label_7")
self.verticalLayout_3.addWidget(self.label_7)
self.label_6 = QLabel(self.verticalLayoutWidget_3)
self.label_6.setObjectName(u"label_6")
self.verticalLayout_3.addWidget(self.label_6)
self.label_3 = QLabel(self.verticalLayoutWidget_3)
self.label_3.setObjectName(u"label_3")
self.verticalLayout_3.addWidget(self.label_3)
self.widget_2 = QWidget(self.tab_2)
self.widget_2.setObjectName(u"widget_2")
self.widget_2.setGeometry(QRect(280, 30, 281, 131))
self.verticalLayoutWidget_4 = QWidget(self.widget_2)
self.verticalLayoutWidget_4.setObjectName(u"verticalLayoutWidget_4")
self.verticalLayoutWidget_4.setGeometry(QRect(10, 0, 271, 131))
self.verticalLayout_4 = QVBoxLayout(self.verticalLayoutWidget_4)
self.verticalLayout_4.setObjectName(u"verticalLayout_4")
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.label_9 = QLabel(self.verticalLayoutWidget_4)
self.label_9.setObjectName(u"label_9")
self.verticalLayout_4.addWidget(self.label_9)
self.label_8 = QLabel(self.verticalLayoutWidget_4)
self.label_8.setObjectName(u"label_8")
self.verticalLayout_4.addWidget(self.label_8)
self.label_10 = QLabel(self.verticalLayoutWidget_4)
self.label_10.setObjectName(u"label_10")
self.verticalLayout_4.addWidget(self.label_10)
self.label_12 = QLabel(self.verticalLayoutWidget_4)
self.label_12.setObjectName(u"label_12")
self.verticalLayout_4.addWidget(self.label_12)
self.label_13 = QLabel(self.verticalLayoutWidget_4)
self.label_13.setObjectName(u"label_13")
self.verticalLayout_4.addWidget(self.label_13)
self.label_11 = QLabel(self.verticalLayoutWidget_4)
self.label_11.setObjectName(u"label_11")
self.verticalLayout_4.addWidget(self.label_11)
self.widget_3 = QWidget(self.tab_2)
self.widget_3.setObjectName(u"widget_3")
self.widget_3.setGeometry(QRect(10, 160, 781, 191))
self.verticalLayoutWidget_5 = QWidget(self.widget_3)
self.verticalLayoutWidget_5.setObjectName(u"verticalLayoutWidget_5")
self.verticalLayoutWidget_5.setGeometry(QRect(0, 0, 781, 191))
self.verticalLayout_5 = QVBoxLayout(self.verticalLayoutWidget_5)
self.verticalLayout_5.setObjectName(u"verticalLayout_5")
self.verticalLayout_5.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.label_14 = QLabel(self.verticalLayoutWidget_5)
self.label_14.setObjectName(u"label_14")
self.horizontalLayout.addWidget(self.label_14)
self.comboBox = QComboBox(self.verticalLayoutWidget_5)
self.comboBox.setObjectName(u"comboBox")
self.horizontalLayout.addWidget(self.comboBox)
self.toolButton = QToolButton(self.verticalLayoutWidget_5)
self.toolButton.setObjectName(u"toolButton")
self.horizontalLayout.addWidget(self.toolButton)
self.verticalLayout_5.addLayout(self.horizontalLayout)
self.horizontalLayout_5 = QHBoxLayout()
self.horizontalLayout_5.setObjectName(u"horizontalLayout_5")
self.horizontalLayout_4 = QHBoxLayout()
self.horizontalLayout_4.setObjectName(u"horizontalLayout_4")
self.horizontalLayout_2 = QHBoxLayout()
self.horizontalLayout_2.setObjectName(u"horizontalLayout_2")
self.label_15 = QLabel(self.verticalLayoutWidget_5)
self.label_15.setObjectName(u"label_15")
self.horizontalLayout_2.addWidget(self.label_15)
self.horizontalSlider = QSlider(self.verticalLayoutWidget_5)
self.horizontalSlider.setObjectName(u"horizontalSlider")
self.horizontalSlider.setOrientation(Qt.Horizontal)
self.horizontalLayout_2.addWidget(self.horizontalSlider)
self.horizontalLayout_4.addLayout(self.horizontalLayout_2)
self.label_17 = QLabel(self.verticalLayoutWidget_5)
self.label_17.setObjectName(u"label_17")
self.horizontalLayout_4.addWidget(self.label_17)
self.horizontalSlider_3 = QSlider(self.verticalLayoutWidget_5)
self.horizontalSlider_3.setObjectName(u"horizontalSlider_3")
self.horizontalSlider_3.setOrientation(Qt.Horizontal)
self.horizontalLayout_4.addWidget(self.horizontalSlider_3)
self.horizontalLayout_5.addLayout(self.horizontalLayout_4)
self.horizontalLayout_9 = QHBoxLayout()
self.horizontalLayout_9.setObjectName(u"horizontalLayout_9")
self.label_21 = QLabel(self.verticalLayoutWidget_5)
self.label_21.setObjectName(u"label_21")
self.horizontalLayout_9.addWidget(self.label_21)
self.spinBox = QSpinBox(self.verticalLayoutWidget_5)
self.spinBox.setObjectName(u"spinBox")
self.horizontalLayout_9.addWidget(self.spinBox)
self.horizontalLayout_5.addLayout(self.horizontalLayout_9)
self.verticalLayout_5.addLayout(self.horizontalLayout_5)
self.horizontalLayout_16 = QHBoxLayout()
self.horizontalLayout_16.setObjectName(u"horizontalLayout_16")
self.horizontalLayout_13 = QHBoxLayout()
self.horizontalLayout_13.setObjectName(u"horizontalLayout_13")
self.label_24 = QLabel(self.verticalLayoutWidget_5)
self.label_24.setObjectName(u"label_24")
self.horizontalLayout_13.addWidget(self.label_24)
self.comboBox_3 = QComboBox(self.verticalLayoutWidget_5)
self.comboBox_3.setObjectName(u"comboBox_3")
self.horizontalLayout_13.addWidget(self.comboBox_3)
self.horizontalLayout_6 = QHBoxLayout()
self.horizontalLayout_6.setObjectName(u"horizontalLayout_6")
self.label_18 = QLabel(self.verticalLayoutWidget_5)
self.label_18.setObjectName(u"label_18")
self.horizontalLayout_6.addWidget(self.label_18)
self.textEdit = QTextEdit(self.verticalLayoutWidget_5)
self.textEdit.setObjectName(u"textEdit")
self.textEdit.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_6.addWidget(self.textEdit)
self.horizontalLayout_8 = QHBoxLayout()
self.horizontalLayout_8.setObjectName(u"horizontalLayout_8")
self.label_20 = QLabel(self.verticalLayoutWidget_5)
self.label_20.setObjectName(u"label_20")
self.label_20.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_8.addWidget(self.label_20)
self.textEdit_2 = QTextEdit(self.verticalLayoutWidget_5)
self.textEdit_2.setObjectName(u"textEdit_2")
self.textEdit_2.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_8.addWidget(self.textEdit_2)
self.horizontalLayout_6.addLayout(self.horizontalLayout_8)
self.horizontalLayout_13.addLayout(self.horizontalLayout_6)
self.horizontalLayout_16.addLayout(self.horizontalLayout_13)
self.verticalLayout_5.addLayout(self.horizontalLayout_16)
self.horizontalLayout_7 = QHBoxLayout()
self.horizontalLayout_7.setObjectName(u"horizontalLayout_7")
self.label_19 = QLabel(self.verticalLayoutWidget_5)
self.label_19.setObjectName(u"label_19")
self.label_19.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_7.addWidget(self.label_19)
self.textEdit1 = QTextEdit(self.verticalLayoutWidget_5)
self.textEdit1.setObjectName(u"textEdit1")
self.textEdit1.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_7.addWidget(self.textEdit1)
self.horizontalLayout_11 = QHBoxLayout()
self.horizontalLayout_11.setObjectName(u"horizontalLayout_11")
self.checkBox_2 = QCheckBox(self.verticalLayoutWidget_5)
self.checkBox_2.setObjectName(u"checkBox_2")
self.horizontalLayout_11.addWidget(self.checkBox_2)
self.checkBox = QCheckBox(self.verticalLayoutWidget_5)
self.checkBox.setObjectName(u"checkBox")
self.horizontalLayout_11.addWidget(self.checkBox)
self.label_22 = QLabel(self.verticalLayoutWidget_5)
self.label_22.setObjectName(u"label_22")
self.horizontalLayout_11.addWidget(self.label_22)
self.textEdit_3 = QTextEdit(self.verticalLayoutWidget_5)
self.textEdit_3.setObjectName(u"textEdit_3")
self.textEdit_3.setMaximumSize(QSize(16777215, 22))
self.horizontalLayout_11.addWidget(self.textEdit_3)
self.horizontalLayout_7.addLayout(self.horizontalLayout_11)
self.verticalLayout_5.addLayout(self.horizontalLayout_7)
self.horizontalLayout_18 = QHBoxLayout()
self.horizontalLayout_18.setObjectName(u"horizontalLayout_18")
self.verticalLayout_5.addLayout(self.horizontalLayout_18)
self.horizontalLayout_12 = QHBoxLayout()
self.horizontalLayout_12.setObjectName(u"horizontalLayout_12")
self.label_23 = QLabel(self.verticalLayoutWidget_5)
self.label_23.setObjectName(u"label_23")
self.label_23.setMaximumSize(QSize(120, 16777215))
self.horizontalLayout_12.addWidget(self.label_23)
self.comboBox_2 = QComboBox(self.verticalLayoutWidget_5)
self.comboBox_2.setObjectName(u"comboBox_2")
self.comboBox_2.setMaximumSize(QSize(200, 16777215))
self.horizontalLayout_12.addWidget(self.comboBox_2)
self.horizontalLayout_14 = QHBoxLayout()
self.horizontalLayout_14.setObjectName(u"horizontalLayout_14")
self.label_25 = QLabel(self.verticalLayoutWidget_5)
self.label_25.setObjectName(u"label_25")
self.horizontalLayout_14.addWidget(self.label_25)
self.comboBox_4 = QComboBox(self.verticalLayoutWidget_5)
self.comboBox_4.setObjectName(u"comboBox_4")
self.horizontalLayout_14.addWidget(self.comboBox_4)
self.horizontalLayout_12.addLayout(self.horizontalLayout_14)
self.verticalLayout_5.addLayout(self.horizontalLayout_12)
self.horizontalLayout_15 = QHBoxLayout()
self.horizontalLayout_15.setObjectName(u"horizontalLayout_15")
self.label_26 = QLabel(self.verticalLayoutWidget_5)
self.label_26.setObjectName(u"label_26")
self.horizontalLayout_15.addWidget(self.label_26)
self.comboBox_5 = QComboBox(self.verticalLayoutWidget_5)
self.comboBox_5.setObjectName(u"comboBox_5")
self.horizontalLayout_15.addWidget(self.comboBox_5)
self.verticalLayout_5.addLayout(self.horizontalLayout_15)
self.tabO.addTab(self.tab_2, "")
self.tab_3 = QWidget()
self.tab_3.setObjectName(u"tab_3")
self.tabO.addTab(self.tab_3, "")
self.tab_4 = QWidget()
self.tab_4.setObjectName(u"tab_4")
self.tabO.addTab(self.tab_4, "")
self.verticalLayout.addWidget(self.tabO)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setObjectName(u"menubar")
self.menubar.setGeometry(QRect(0, 0, 800, 26))
self.menu = QMenu(self.menubar)
self.menu.setObjectName(u"menu")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName(u"statusbar")
MainWindow.setStatusBar(self.statusbar)
self.menubar.addAction(self.menu.menuAction())
self.menu.addAction(self.action)
self.menu.addAction(self.action_Input)
self.retranslateUi(MainWindow)
self.tabO.setCurrentIndex(1)
QMetaObject.connectSlotsByName(MainWindow)
# setupUi
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(
QCoreApplication.translate(
"MainWindow", u"MainWindow", None))
self.action.setText(
QCoreApplication.translate(
"MainWindow",
u"\u6253\u5f00 Open",
None))
self.action_Input.setText(
QCoreApplication.translate(
"MainWindow",
u"\u5bfc\u5165 Input",
None))
self.tabO.setTabText(
self.tabO.indexOf(
self.tab), QCoreApplication.translate(
"MainWindow", u"Tab 1", None))
self.label.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_2.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_4.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_5.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_7.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_6.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_3.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_9.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_8.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_10.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_12.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_13.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_11.setText(
QCoreApplication.translate(
"MainWindow", u"TextLabel", None))
self.label_14.setText(
QCoreApplication.translate(
"MainWindow",
u"\u9ed8\u8ba4\u4fdd\u5b58\u8def\u5f84\uff1a",
None))
self.toolButton.setText(
QCoreApplication.translate(
"MainWindow", u"...", None))
self.label_15.setText(
QCoreApplication.translate(
"MainWindow",
u"\u901f\u5ea6\u500d\u7387",
None))
self.label_17.setText(
QCoreApplication.translate(
"MainWindow",
u"\u97f3\u91cf\u500d\u7387",
None))
self.label_21.setText(
QCoreApplication.translate(
"MainWindow",
u"\u6700\u5927\u6307\u4ee4\u751f\u6210\u9ad8\u5ea6",
None))
self.label_24.setText(
QCoreApplication.translate(
"MainWindow",
u"\u9009\u62e9\u5668\u6a21\u5f0f",
None))
self.label_18.setText(
QCoreApplication.translate(
"MainWindow",
u"\u8ba1\u5206\u677f\u540d\u79f0",
None))
self.label_20.setText(
QCoreApplication.translate(
"MainWindow",
u"\u73a9\u5bb6\u9009\u62e9\u5668",
None))
self.label_19.setText(
QCoreApplication.translate(
"MainWindow",
u"bdx\u4f5c\u8005\u540d\u79f0",
None))
self.checkBox_2.setText(
QCoreApplication.translate(
"MainWindow",
u"\u662f\u5426\u542f\u7528\u8fdb\u5ea6\u6761",
None))
self.checkBox.setText(
QCoreApplication.translate(
"MainWindow",
u"\u662f\u5426\u81ea\u5b9a\u4e49\u8fdb\u5ea6\u6761",
None))
self.label_22.setText(
QCoreApplication.translate(
"MainWindow",
u"\u81ea\u5b9a\u4e49\u8fdb\u5ea6\u6761\u5185\u5bb9\uff1a",
None))
self.label_23.setText(
QCoreApplication.translate(
"MainWindow",
u"\u9009\u62e9\u547d\u4ee4\u683c\u5f0f\u7248\u672c",
None))
self.label_25.setText(
QCoreApplication.translate(
"MainWindow",
u"\u9009\u62e9\u8f6c\u6362\u7b97\u6cd5\u7248\u672c",
None))
self.label_26.setText(
QCoreApplication.translate(
"MainWindow",
u"\u9009\u62e9\u5bfc\u51fa\u6a21\u5f0f",
None))
self.tabO.setTabText(
self.tabO.indexOf(
self.tab_2), QCoreApplication.translate(
"MainWindow", u"Tab 2", None))
self.tabO.setTabText(
self.tabO.indexOf(
self.tab_3), QCoreApplication.translate(
"MainWindow", u"\u9875", None))
self.tabO.setTabText(
self.tabO.indexOf(
self.tab_4), QCoreApplication.translate(
"MainWindow", u"\u9875", None))
self.menu.setTitle(
QCoreApplication.translate(
"MainWindow",
u"\u6587\u4ef6",
None))
# retranslateUi
# Error: PySide6-Pkg.ui: Warning: The name 'textEdit' (QTextEdit) is already in use, defaulting to 'textEdit1'.
#
#
# while executing
# 'C:\Users\lc\AppData\Roaming\Python\Python39\site-packages\PySide6\uic
# -g python PySide6-Pkg.ui'
if __name__ == "__main__":
import sys
from PySide6 import QtWidgets
app = QtWidgets.QApplication(sys.argv) # 创建一个QApplication也就是你要开发的软件app
MainWindow = QtWidgets.QMainWindow() # 创建一个QMainWindow用来装载你需要的各种组件、控件
# MainWindow = QtWidgets.QWidget() # 创建一个QMainWindow用来装载你需要的各种组件、控件
ui = Ui_MainWindow() # ui是你创建的ui类的实例化对象
ui.setupUi(MainWindow) # 执行类中的setupUi方法方法的参数是第二步中创建的QMainWindow
MainWindow.show() # 执行QMainWindow的show()方法显示这个QMainWindow
sys.exit(app.exec_()) # 使用exit()或者点击关闭按钮退出QApplication

47
pp_main_write.py Normal file
View File

@@ -0,0 +1,47 @@
import sys
from PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QLabel, QPushButton
from PySide6.QtCore import Qt
from PySide6.QtGui import QPixmap
class MusicreaterGUI:
def __init__(self):
self.button, self.label = None, None
def setupUi(self, window):
window.setWindowTitle("音·创") # 窗口标题
window.resize(300, 150) # 重置大小
self.label = QLabel(window) # 在窗口上创建实例化label
string = "welcome to musicreater"
self.label.setText(string)
self.label.setGeometry(80, 50, 150, 20)
self.button = QPushButton(window)
self.button.setText("close")
self.button.setGeometry(120, 100, 50, 20)
self.button.clicked.connect(window.close)
class MusicreaterWidget(QWidget, MusicreaterGUI): # 很棒的继承,请 体会
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
if __name__ == '__main__':
app = QApplication(sys.argv) # 创建应用程序实例对象
app.setApplicationDisplayName("Musicreater-pp")
app.setApplicationVersion("v0.0.1")
app.setEffectEnabled(Qt.UI_AnimateCombo)
app.setWindowIcon(QPixmap(r"logo_done_c_Finish_C_Done_CCC_1024px.ico"))
window_ = MusicreaterWidget() # 窗口实例化
window_.show()
n = app.exec()
print(n)
try:
sys.exit(n)
except SystemExit:
print("hi, error")

Some files were not shown because too many files have changed in this diff Show More