diff --git a/_saves/Eustia_autoSave b/_saves/Eustia_autoSave
index 7b86e5a..a0e7916 100644
--- a/_saves/Eustia_autoSave
+++ b/_saves/Eustia_autoSave
@@ -1 +1 @@
-N4IgZgNg9lBOCSATEAuEBPAlgRwK4CYQAaEACwFNYpVRMBbAQwHNzUzKoA6Ad3ICMADsRAMAdvQYAXVijAMIAZ3IlRDOjJABhBvWEQAbqgCMJUgMYAPYwAZbpoSiO3rJRqss3XYhqhcjJANaeIIjkYMF0oeGOfnRQouToviTkFg5+5HiY5uSikqgA2gC6JJjSdAo0IADG8QqSYpKVKKB8MEGOJJBJjgC+JJIwilXo5BDQ3ADSiagALCR8ELjk0z1G/SCZuNnNwL0b0NVVVigAnCQ98yGYsOTVkpjxbLhCG5DMuyBl5HQAIuQNTAQVCSWDLEi4JQAIQBvFyABlMExSPkUKDwSAAPqYpTkRDY4z4ADMRlmADZ8GSyQB2EjY2BifGYwkk8mUmkkBi3BjNAqgdwaAA6uFm5GsfGFAFZqrNCF4BLytDo6KQoOoQEV+vy1EKRWKJbhpbLhIwFYUQAArTC4Ji4MQarUgAVsYWi8VSmVykCmxWTAAqADUHURteq0MLqZT8BH8GAjCaGGaUAUQP6AwAxQiakNOnUu3CRikxuMJpMpphQCCIAIzbOh3Vug1Gr0+818TCkSG4ah13NhkCusUMD3G+WKq0MKANURMYP1/Nu4eGz2lxUKCgz0T6VXq3vO8N66xL5ur83rzBbnesPd5g+F6MF2Pxsfmq14ydzvu6+/F5/exNrqC5AAtYf71LcIFeraYhMNUpAwcI0EznBMFehYmCTuhMGgcIWFQFhM7WGhGH4RhM5EsIWB4H+VEEJ++6iLg4wvsmGA4LgFE3mGjHMf+ZZsXgsz0bePEQCxKa0ZKwncUxYl8YqtFktJMiieJAkFspqCqfJ5q0QAHJpKDaa2rG0achnGQBunsU4DolCACgBNkqByIoyhkFyyAoH42LwbAiCaJWcAEmgtzIHSmLfHQAASF6SCFxQRRA5AMPo5DwlA1QhaAtHxi01y3PcjyiM8QgkCcfg9NS+wRfomAKN8TIjDZIJgu5tGEGibUbHwsLAaIACCkgNNUAS/FIPhGbJEWIPVDCLHi2XqZ1BQFEYRiSkQ63zE4LjrUSRBkiY1KzCUxTZh5QFefgJCOUCwLebdTnjAAcreA64GSkpiiAbyVhMlC8vZ9TkEmZJeIEyQOQIwFeU4t2gsEzCYMEcXBLUJUxF4TCYEcsjyEoCNSPVDzVJ8gwNBAfr0DIkbWFSpycKczMs8zsybTUuCwLA1NhgzjN6c4Qu2LMtJkOkCxSJIyXGK48QzI9mxpFDfBS8l42MCwUMCFA9XxBrzAyBkFiggwBta4rcRpb8Nx3NLPTg18TCiHA5AAMrSEm+Bi/UXKolSkqzKcZKcLMNUef5bCnvlHVVKahQuInRAuAUAC0Jjp0QmfZxnudZ3nLg5/nZ1F6Xedl8n+dV+nJQpxX9flyYheNyXjfV23RdJ83teV4nmobFQuDSGw8LwFCTAABoDdFA3YAomgALKSEwADy3BQgAogN6ADQGK+SgA4rgAYKAN8KTKfABS6DppKARb7gACqACaACKA0ALxf8I+jyMsuwbDSrABqTwDynHIESRAUo+CSmsBGBgpwoG4FOEROBho9KBw9NYMAwpg5GHCCQW0mAvIgBpHwWYswjD4ElJiIk5B8D4ExLMBBNCYGIHxNScgkoA5EgYEaAhIAHhhiMNSIkZI9JfVONSawelqR6V6EAA=
+N4IgZgNg9lBOCSATEAuEBnALrApjzADAIwgA0IAFjrFKqAJYC2AhgOY6qXVQB0A7jgBGABzIhmAOybNMHFGGYR0OchOaM5IAMLMmYiADdURchWEsAHqgCct66dEoiBF+RZrLqALQmQ75qgE5DIA1sauIIg4YOFBflExKHHownjISW5QEjgAnoHkOBaOcTgAjgCu9OY4EpioANoAuuT0sozodCAAxllYkpgdKKCCMGFO5JB5TgC+5JgwSnSzIGWVwoOg6HxwiCQzy9BdnYj0uF2Y9Fmc5aLkVigArORTzsuQbBsgrTiMACL4uggqGw5RUIHKygAQvgBDUADL0VgUOooEFggD66OUOEQmOMAHYAGwEawADgATOSACxxTGwSS49EE4lkyk04K4ZiDeqgDyaAA65SpOAIgkFDy6VPJYhY6wa2l0jAoUA0IEas156gFQpFYvKEqlMuYcpQ9RAACt6OVWOVJGqNSA+ZxBcLReLJdK3MbuSAANIAFQAavbSJrVWhBfjyYTyZHyWASF6TWaA4GAGLS9Whx1a53lKMxuMJo3JkCsKAQRAhXIhsPa116g2evze+WCegUCHlWhZut513Md2GpM+y3MKCYSSsWs58MgF0iwf6j0ln3oKgSVgSAzK1W92f1xdD5uytcUejb3ccfdOiP56Ox+/Fkfyy048cz2/z++Fp+JlullguD4MQYhAXghDNjaU5dBQU5iNBm6wVOzYWPQ45oVOoF3OhUCYZuBCobh+GsAAzJ+uYoBI5QQBAL6miAOT0BUJA3pR1G0fRZpMRUmYOreHF0QBPo8eU5FseGglcYxzFChRkk0UJp7yqJDzyXIUnCSpsmEupqCacpDGifielUYp0miaSpkGa2RmydY1nmVpdksQQ9rNBgIRVKgChKGCcGwOktLogFiBaBWcB4mguDIOQmLfIwAASF6YFFTRxeiEA4MwBg4HCUBdFFwDLJiBj0Og3yMp04EgXsaLLIIMJ4BIACCmCTl0IS/DIARmZxICYswOD0GlHmYic6DMIIWVVUMGDYBBoGmvURCkQ8zRNOqbwVtAAiwNyHlYDgJq+H0FxYPQXSfPMk4QP6TByOSDxEEQUpRjwhJ2C91hPN05SwLA93hkQDxUtYPCkXYUNQ4SDj5CAggyJgWXw4wWQ1hkKxFPDiPtVl3UsOw8PCFA5VZATbByCUFjYMwFNE5jaO5b8pw4OcEBTHEiISHAOAAMqyCaySTrAKKElSDykTwVLTMsoWcKu1ULbVnSyg0QQa6Qmva1ruv1D4pAG0bJgG0ExuGyblsWxbzQa1t5A0OUsicL6UAZloVKsAAvGIBiKKCGzLLl+2XBIebWDgpGIOKggPAQkbMNY0flNYhHx/qpKg+6BBgIK1iEkQMTkDa9DpCA5LMIghKEog1iFYgYBgFS6JUqSifooIVKEmA6JgIgU0EDgNJV3gYgXMD+KkficfWKRBBSi40xAA==
diff --git a/project/enemys.js b/project/enemys.js
index 931f40a..1989be8 100644
--- a/project/enemys.js
+++ b/project/enemys.js
@@ -1,7 +1,7 @@
 var enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = 
 {
-	"greenSlime": {"name":"绿头怪","hp":0,"atk":0,"def":0,"money":0,"exp":0,"point":0,"special":0},
-	"redSlime": {"name":"红头怪","hp":0,"atk":0,"def":0,"money":0,"exp":0,"point":0,"special":[],"value":10},
+	"greenSlime": {"name":"绿头怪","hp":0,"atk":0,"def":0,"money":0,"exp":0,"point":0,"special":0,"magic":false},
+	"redSlime": {"name":"红头怪","hp":0,"atk":0,"def":0,"money":0,"exp":0,"point":0,"special":[],"value":10,"magic":false},
 	"blackSlime": {"name":"青头怪","hp":0,"atk":0,"def":0,"money":0,"exp":0,"point":0,"special":0},
 	"slimelord": {"name":"怪王","hp":100,"atk":120,"def":0,"money":10,"exp":0,"point":0,"special":[1,9]},
 	"bat": {"name":"小蝙蝠","hp":100,"atk":120,"def":0,"money":2,"exp":0,"point":0,"special":[1]},
diff --git a/project/functions.js b/project/functions.js
index e90a843..ed051d3 100644
--- a/project/functions.js
+++ b/project/functions.js
@@ -531,15 +531,21 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
 		hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
 		hero_def = core.getRealStatusOrDefault(hero, 'def'),
-		hero_mdef = core.getRealStatusOrDefault(hero, 'mdef');
+		hero_mdef = core.getRealStatusOrDefault(hero, 'mdef'),
+		hero_speed = core.getRealStatusOrDefault(hero, 'speed');
 
 	var mon_hp = core.getEnemyValue(enemy, 'hp', x, y, floorId),
 		mon_atk = core.getEnemyValue(enemy, 'atk', x, y, floorId),
 		mon_def = core.getEnemyValue(enemy, 'def', x, y, floorId),
+		mon_mdef = core.getEnemyValue(enemy, 'mdef', x, y, floorId),
+		mon_speed = core.getEnemyValue(enemy, 'speed', x, y, floorId),
 		mon_special = core.getEnemyValue(enemy, 'special', x, y, floorId);
 	var mon_money = core.getEnemyValue(enemy, 'money', x, y, floorId),
 		mon_exp = core.getEnemyValue(enemy, 'exp', x, y, floorId),
 		mon_point = core.getEnemyValue(enemy, 'point', x, y, floorId);
+	var mon_barrier = 0,
+		mon_absorb_damage = 0,
+		mon_magic = core.getEnemyValue(enemy, 'magic', x, y, floorId);
 	// 模仿
 	if (core.hasSpecial(mon_special, 10)) {
 		mon_atk = hero_atk;
@@ -633,10 +639,15 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		"hp": Math.floor(mon_hp),
 		"atk": Math.floor(mon_atk),
 		"def": Math.floor(mon_def),
+		"mdef": Math.floor(mon_mdef),
+		"speed": Math.floor(mon_speed),
+		"barrier": Math.floor(mon_barrier),
+		"absorb": Math.floor(mon_absorb_damage),
 		"money": Math.floor(mon_money),
 		"exp": Math.floor(mon_exp),
 		"point": Math.floor(mon_point),
 		"special": mon_special,
+		"magic": mon_magic,
 		"guards": guards, // 返回支援情况
 	};
 },
@@ -655,15 +666,13 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
 		hero_def = core.getRealStatusOrDefault(hero, 'def'),
 		hero_mdef = core.getRealStatusOrDefault(hero, 'mdef'),
+		hero_speed = core.getRealStatusOrDefault(hero, 'speed'),
+		hero_magic = core.getRealStatusOrDefault(hero, 'magic'),
 		origin_hero_hp = core.getStatusOrDefault(hero, 'hp'),
 		origin_hero_atk = core.getStatusOrDefault(hero, 'atk'),
 		origin_hero_def = core.getStatusOrDefault(hero, 'def');
 
-	// 勇士的负属性都按0计算
-	hero_hp = Math.max(0, hero_hp);
-	hero_atk = Math.max(0, hero_atk);
-	hero_def = Math.max(0, hero_def);
-	hero_mdef = Math.max(0, hero_mdef);
+
 
 	// 怪物的各项数据
 	// 对坚固模仿等处理扔到了脚本编辑-getEnemyInfo之中
@@ -671,23 +680,34 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	var mon_hp = enemyInfo.hp,
 		mon_atk = enemyInfo.atk,
 		mon_def = enemyInfo.def,
-		mon_special = enemyInfo.special;
+		mon_mdef = enemyInfo.mdef,
+		mon_speed = enemyInfo.speed,
+		mon_special = enemyInfo.special,
+		mon_absorb_damage = enemyInfo.absorb,
+		mon_barrier = enemyInfo.barrier;
 
+	//---第一部分：静态属性修正---
+	//此处写入静态影响勇士属性的勇士或怪物技能（静态影响怪物属性的技能于getEnemyInfo中写入）
 	// 技能的处理
 	if (core.getFlag('skill', 0) == 1) { // 开启了技能1：二倍斩
 		hero_atk *= 2; // 计算时攻击力翻倍	
 	}
+	//勇士属性取整
+	hero_atk = Math.max(0, Math.floor(hero_atk));
+	hero_def = Math.max(0, Math.floor(hero_def));
+	hero_mdef = Math.max(0, Math.floor(hero_mdef));
+	hero_speed = Math.max(0, Math.floor(hero_speed));
 
 	// 如果是无敌属性，且勇士未持有十字架
 	if (core.hasSpecial(mon_special, 20) && !core.hasItem("cross"))
 		return null; // 不可战斗
 
 	// 战前造成的额外伤害（可被护盾抵消）
-	var init_damage = 0;
+	let init_damage = 0;
 
 	// 吸血
 	if (core.hasSpecial(mon_special, 11)) {
-		var vampire_damage = hero_hp * enemy.vampire;
+		let vampire_damage = hero_hp * enemy.vampire;
 
 		// 如果有神圣盾免疫吸血等可以在这里写
 		// 也可以用hasItem和hasEquip来判定装备
@@ -701,17 +721,60 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		init_damage += vampire_damage;
 	}
 
+	//——第二部分：变量定义和初始赋值——
 	// 每回合怪物对勇士造成的战斗伤害
-	var per_damage = mon_atk - hero_def;
+	let per_damage = Math.max(mon_atk - hero_def, 0);
+	if (enemyInfo.magic) per_damage = Math.max(mon_atk - hero_mdef, 0);
 
-	// 战斗伤害不能为负值
-	if (per_damage < 0) per_damage = 0;
+	//
+	let hero_per_damage = Math.max(hero_atk - mon_def, 0);
+	if (hero_magic) hero_per_damage = Math.max(hero_atk - mon_mdef, 0);
 
+	let damage = 0,
+		hero_turn = 0,
+		mon_turn = 0;
+	//---第三部分：递归开始---
+	let length = hero_speed * mon_speed;
+
+	for (let now_mon_hp = mon_hp, last_mon_hp = mon_hp, mon_length = length, hero_length = length, mon_time = 0, hero_time = 0; now_mon_hp > 0;) { //勇士和怪物的长度
+		mon_time = mon_length / mon_speed;
+		hero_time = hero_length / hero_speed;
+		if ((mon_time < hero_time) || ((mon_time = hero_time) && (mon_speed > hero_speed))) { //怪物攻击的回合
+			//这里计算怪物攻击时发生的各种变化
+
+			//伤害与回合增加
+			damage += per_damage;
+			if (core.hasSpecial(mon_special, 6)) {
+				mon_turn += enemy.n;
+			} else {
+				mon_turn += 1;
+			}
+			//重新为长度赋值
+			mon_length = length;
+			hero_length = hero_length - mon_time * hero_speed;
+		} else { //勇士攻击的回合
+			// 这里计算勇士攻击时发生的各种变化
+
+			// 伤害与回合数增加
+			now_mon_hp -= hero_per_damage;
+			hero_turn += 1; //勇士回合+1，如果有勇士每回合多次攻击的情况，在这里写判断
+			// 无法战斗计算
+			if (hero_turn % 50 == 0) {
+				if (now_mon_hp >= last_mon_hp) return null;
+				last_mon_hp = now_mon_hp;
+			}
+			//重新为长度赋值
+			hero_length = length;
+			mon_length = mon_length - hero_time * mon_speed;
+		}
+	}
+
+	//下面这些还没修改
 	// 连击
 	if (core.hasSpecial(mon_special, 6)) per_damage *= (enemy.n || 2);
 
 	// 每回合的反击伤害；反击是按照勇士的攻击次数来计算回合
-	var counterDamage = 0;
+	let counterDamage = 0;
 	if (core.hasSpecial(mon_special, 8))
 		counterDamage += Math.floor((enemy.counterAttack || core.values.counterAttack) * hero_atk);
 
@@ -725,19 +788,14 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 	// 净化
 	if (core.hasSpecial(mon_special, 9))
 		init_damage += Math.floor((enemy.purify || core.values.purify) * hero_mdef);
-
-	// 勇士每回合对怪物造成的伤害
-	var hero_per_damage = Math.max(hero_atk - mon_def, 0);
-
-	// 如果没有破防，则不可战斗
-	if (hero_per_damage <= 0) return null;
-
-	// 勇士的攻击回合数；为怪物生命除以每回合伤害向上取整
-	var turn = Math.ceil(mon_hp / hero_per_damage);
+	//上面这些还没修改
+	//勇士护盾计算
+	let barrier = hero_mdef;
+	if (enemyInfo.magic) barrier = hero_def;
 
 	// ------ 支援 ----- //
 	// 这个递归最好想明白为什么，flag:__extraTurn__是怎么用的
-	var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards);
+	/*var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards);
 	var guard_before_current_enemy = false; // ------ 支援怪是先打(true)还是后打(false)？
 	turn += core.getFlag("__extraTurn__", 0);
 	if (guards.length > 0) {
@@ -764,13 +822,13 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 			turn += core.getFlag("__extraTurn__", 0);
 		}
 	}
-	core.removeFlag("__extraTurn__");
+	core.removeFlag("__extraTurn__");*/
 	// ------ 支援END ------ //
 
 	// 最终伤害：初始伤害 + 怪物对勇士造成的伤害 + 反击伤害
-	var damage = init_damage + (turn - 1) * per_damage + turn * counterDamage;
+	damage += init_damage + hero_turn * counterDamage;
 	// 再扣去护盾
-	damage -= hero_mdef;
+	damage -= barrier;
 
 	// 检查是否允许负伤
 	if (!core.flags.enableNegativeDamage)
@@ -788,12 +846,18 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
 		"mon_hp": Math.floor(mon_hp),
 		"mon_atk": Math.floor(mon_atk),
 		"mon_def": Math.floor(mon_def),
+		"mon_mdef": Math.floor(mon_mdef),
 		"init_damage": Math.floor(init_damage),
 		"per_damage": Math.floor(per_damage),
 		"hero_per_damage": Math.floor(hero_per_damage),
-		"turn": Math.floor(turn),
+		"turn": Math.floor(hero_turn),
+		"mon_turn": Math.floor(mon_turn),
 		"damage": Math.floor(damage)
 	};
+	/*TODO:怪物手册的修改（需要修改这里return的内容以及一些战后判断）
+	1. 显示怪物是魔攻还是物攻（在怪物名字上做颜色变化，物攻是黄色，魔攻是蓝色）
+	2. 一防减伤是物防还是魔防（由怪物是物攻还是魔攻来转换）
+	3. 特殊战斗的怪物，在怪物手册里“伤害”写为“特殊战”*/
 }
     },
     "actions": {
diff --git a/project/plugins.js b/project/plugins.js
index 009ae14..cd0125a 100644
--- a/project/plugins.js
+++ b/project/plugins.js
@@ -1,6 +1,5 @@
-var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = 
-{
-    "init": function () {
+var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = {
+  init: function () {
     this._afterLoadResources = function () {
       // 本函数将在所有资源加载完毕后，游戏开启前被执行
       core.ui.statusBar.init();
@@ -221,7 +220,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       });
     };
   },
-    "drawLight": function () {
+  drawLight: function () {
     // 绘制灯光/漆黑层效果。调用方式 core.plugin.drawLight(...)
     // 【参数说明】
     // name：必填，要绘制到的画布名；可以是一个系统画布，或者是个自定义画布；如果不存在则创建
@@ -287,7 +286,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       // 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为  core.plugin.xxx();
     };
   },
-    "shop": function () {
+  shop: function () {
     // 【全局商店】相关的功能
     //
     // 打开一个全局商店
@@ -563,7 +562,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       60
     );
   },
-    "removeMap": function () {
+  removeMap: function () {
     // 高层塔砍层插件，删除后不会存入存档，不可浏览地图也不可飞到。
     // 推荐用法：
     // 对于超高层或分区域塔，当在1区时将2区以后的地图删除；1区结束时恢复2区，进二区时删除1区地图，以此类推
@@ -652,7 +651,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       });
     };
   },
-    "fiveLayers": function () {
+  fiveLayers: function () {
     // 是否启用五图层（增加背景2层和前景2层） 将__enable置为true即会启用；启用后请保存后刷新编辑器
     // 背景层2将会覆盖背景层 被事件层覆盖 前景层2将会覆盖前景层
     // 另外 请注意加入两个新图层 会让大地图的性能降低一些
@@ -854,7 +853,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       };
     };
   },
-    "itemShop": function () {
+  itemShop: function () {
     // 道具商店相关的插件
     // 可在全塔属性-全局商店中使用「道具商店」事件块进行编辑（如果找不到可以在入口方块中找）
 
@@ -1256,7 +1255,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       ]);
     };
   },
-    "enemyLevel": function () {
+  enemyLevel: function () {
     // 此插件将提供怪物手册中的怪物境界显示
     // 使用此插件需要先给每个怪物定义境界，方法如下：
     // 点击怪物的【配置表格】，找到“【怪物】相关的表格配置”，然后在【名称】仿照增加境界定义：
@@ -1424,7 +1423,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       );
     };
   },
-    "multiHeros": function () {
+  multiHeros: function () {
     // 多角色插件
     // Step 1: 启用本插件
     // Step 2: 定义每个新的角色各项初始数据（参见下方注释）
@@ -1578,7 +1577,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       core.setFlag("heroId", toHeroId); // 保存切换到的角色ID
     };
   },
-    "heroFourFrames": function () {
+  heroFourFrames: function () {
     // 样板的勇士/跟随者移动时只使用2、4两帧，观感较差。本插件可以将四帧全用上。
 
     // 是否启用本插件
@@ -1641,7 +1640,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       return false;
     };
   },
-    "routeFixing": function () {
+  routeFixing: function () {
     // 是否开启本插件，true 表示启用，false 表示禁用。
     var __enable = true;
     if (!__enable) return;
@@ -1765,7 +1764,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       100
     );
   },
-    "numpad": function () {
+  numpad: function () {
     // 样板自带的整数输入事件为白屏弹窗且可以误输入任意非法内容但不支持负整数，观感较差。本插件可以将其美化成仿RM样式，使其支持负整数同时带有音效
     // 另一方面，4399等第三方平台不允许使用包括 core.myprompt() 和 core.myconfirm() 在内的弹窗，因此也需要此插件来替代，不然类似生命魔杖的道具就不好实现了
     // 关于负整数输入，V2.8.2原生支持其录像的压缩和解压，只是默认的 core.events._action_input() 函数将负数取了绝对值，可以只复写下面的 core.isReplaying() 部分来取消
@@ -2022,7 +2021,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "sprites": function () {
+  sprites: function () {
     // 基于canvas的sprite化，摘编整理自万宁魔塔
     //
     // ---------------------------------------- 第一部分 js代码 （必装） --------------------------------------- //
@@ -2226,7 +2225,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
 
     window.Sprite = Sprite;
   },
-    "hotReload": function () {
+  hotReload: function () {
     /* ---------- 功能说明 ---------- *
 
 	1. 当 libs/ main.js index.html 中的任意一个文件被更改后，会自动刷新塔的页面
@@ -2483,7 +2482,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     })();
   },
-    "statusBar": function () {
+  statusBar: function () {
     main.dom.floorMsgGroup.style.display = "none";
     main.dom.statusBar.style.display = "none";
     main.dom.toolBar.style.display = "none";
@@ -3688,7 +3687,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
     };
     // init() called in `afterLoadResources`.
   },
-    "override": function () {
+  override: function () {
     core.statusBar.icons = {
       floor: 0,
       name: null,
@@ -4038,7 +4037,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       ctx.fillText(text, x, y);
     };
   },
-    "额外信息": function () {
+  额外信息: function () {
     /* 宝石血瓶左下角显示数值
      * 注意！！！不要在道具属性中直接操作flags，使用core.status.hero.flags或core.setFlag系列函数代替！
      * 需要将 变量：itemDetail改为true才可正常运行
@@ -4195,7 +4194,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     }
   },
-    "编辑器显伤": function () {
+  编辑器显伤: function () {
     // 在此增加新插件
     /////// 用户设置 ///////
     // 将__enable置为false将关闭插件
@@ -4469,7 +4468,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "手册区分特殊属性": function () {
+  手册区分特殊属性: function () {
     // 在此增加新插件
     this.arrsame = function (Arraya, Arrayb) {
       let a = Arraya || [];
@@ -4821,7 +4820,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       return [enemy, texts];
     };
   },
-    "一防减伤": function () {
+  一防减伤: function () {
     // 在此增加新插件
     ui.prototype._drawBook_drawRow3 = function (
       index,
@@ -4895,7 +4894,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       return this.getDefDamage(enemy, null, x, y, floorId);
     };
   },
-    "新道具栏/装备栏": function () {
+  "新道具栏/装备栏": function () {
     // 在此增加新插件
     // 注：///// *** 裹起来的区域： 该区域内参数可以随意更改调整ui绘制 不会影响总体布局
     // 请尽量修改该区域而不是其他区域 修改的时候最好可以对照现有ui修改
@@ -6332,7 +6331,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
     core.registerReplayAction("equip", core.control._replayAction_equip);
     core.registerReplayAction("unEquip", core.control._replayAction_unEquip);
   },
-    "技能树": function () {
+  技能树: function () {
     // 在此增加新插件
     //
     // 已学习的技能等级     flags._hasSkill_
@@ -7134,7 +7133,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
     };
     core.registerReplayAction("skill", control.prototype._replayAction_skill);
   },
-    "animate": function () {
+  animate: function () {
     // -------------------- 插件说明 -------------------- //
 
     // github仓库：https://github.com/unanmed/animate
@@ -8008,7 +8007,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       inverseTrigo: N,
     };
   },
-    "func": function () {
+  func: function () {
     // 功能函数集，具体有哪些函数看每个函数前的注释即可
     // 安装方式：直接复制到插件里面，注意新建插件自带的 function () { } 不能删
     // 使用方式：可以直接使用对象解构按需引入
@@ -8448,9 +8447,9 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "音频系统": function () {
-	// 在此增加新插件
-	/*首先，在造塔群下载所需的库文件，然后放置在塔目录下的 libs/thirdparty 或其他目录下，之后在 index.html 的最后加上下面这几行：
+  音频系统: function () {
+    // 在此增加新插件
+    /*首先，在造塔群下载所需的库文件，然后放置在塔目录下的 libs/thirdparty 或其他目录下，之后在 index.html 的最后加上下面这几行：
 	
 	<script src="libs/thirdparty/ogg-vorbis-decoder.min.js"></script>
 
@@ -8458,2097 +8457,2099 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
 
 	<script src="libs/thirdparty/codec-parser.min.js"></script>
 	*/
-	// 将__enable置为false将关闭插件
-	let __enable = true;
-	if (!__enable || main.mode === "editor") return;
-	const { OggOpusDecoderWebWorker } = window["ogg-opus-decoder"];
-	const { OggVorbisDecoderWebWorker } = window["ogg-vorbis-decoder"];
-	const { CodecParser } = window.CodecParser;
-	const { Transition, linear } = core.plugin.animate;
-
-	const audio = new Audio();
-	const AudioStatus = {
-		Playing: 0,
-		Pausing: 1,
-		Paused: 2,
-		Stoping: 3,
-		Stoped: 4,
-	};
-	const supportMap = new Map();
-	const AudioType = {
-		Mp3: "audio/mpeg",
-		Wav: 'audio/wav; codecs="1"',
-		Flac: "audio/flac",
-		Opus: 'audio/ogg; codecs="opus"',
-		Ogg: 'audio/ogg; codecs="vorbis"',
-		Aac: "audio/aac",
-	};
-	/**
-	 * 检查一种音频类型是否能被播放
-	 * @param type 音频类型 AudioType
-	 */
-	function isAudioSupport(type) {
-		if (supportMap.has(type)) return supportMap.get(type);
-		else {
-			const support = audio.canPlayType(type);
-			const canPlay = support === "maybe" || support === "probably";
-			supportMap.set(type, canPlay);
-			return canPlay;
-		}
-	}
-
-	const typeMap = new Map([
-		["ogg", AudioType.Ogg],
-		["mp3", AudioType.Mp3],
-		["wav", AudioType.Wav],
-		["flac", AudioType.Flac],
-		["opus", AudioType.Opus],
-		["aac", AudioType.Aac],
-	]);
-
-	/**
-	 * 根据文件名拓展猜测其类型
-	 * @param file 文件名 string
-	 */
-	function guessTypeByExt(file) {
-		const ext = /\.[a-zA-Z\d]+$/.exec(file);
-		if (!ext?.[0]) return "";
-		const type = ext[0].slice(1);
-		return typeMap.get(type.toLocaleLowerCase()) ?? "";
-	}
-
-	isAudioSupport(AudioType.Ogg);
-	isAudioSupport(AudioType.Mp3);
-	isAudioSupport(AudioType.Wav);
-	isAudioSupport(AudioType.Flac);
-	isAudioSupport(AudioType.Opus);
-	isAudioSupport(AudioType.Aac);
-
-	function isNil(value) {
-		return value === void 0 || value === null;
-	}
-
-	function sleep(time) {
-		return new Promise((res) => setTimeout(res, time));
-	}
-	class AudioEffect {
-		constructor(ac) {}
-		/**
-		 * 连接至其他效果器
-		 * @param target 目标输入 IAudioInput
-		 * @param output 当前效果器输出通道 Number
-		 * @param input 目标效果器的输入通道 Number
-		 */
-		connect(target, output, input) {
-			this.output.connect(target.input, output, input);
-		}
-
-		/**
-		 * 与其他效果器取消连接
-		 * @param target 目标输入 IAudioInput
-		 * @param output 当前效果器输出通道 Number
-		 * @param input 目标效果器的输入通道 Number
-		 */
-		disconnect(target, output, input) {
-			if (!target) {
-				if (!isNil(output)) {
-					this.output.disconnect(output);
-				} else {
-					this.output.disconnect();
-				}
-			} else {
-				if (!isNil(output)) {
-					if (!isNil(input)) {
-						this.output.disconnect(target.input, output, input);
-					} else {
-						this.output.disconnect(target.input, output);
-					}
-				} else {
-					this.output.disconnect(target.input);
-				}
-			}
-		}
-	}
-
-	class StereoEffect extends AudioEffect {
-		constructor(ac) {
-			super(ac);
-			const panner = ac.createPanner();
-			this.input = panner;
-			this.output = panner;
-		}
-
-		/**
-		 * 设置音频朝向，x正方形水平向右，y正方形垂直于地面向上，z正方向垂直屏幕远离用户
-		 * @param x 朝向x坐标 Number
-		 * @param y 朝向y坐标 Number
-		 * @param z 朝向z坐标 Number
-		 */
-		setOrientation(x, y, z) {
-			this.output.orientationX.value = x;
-			this.output.orientationY.value = y;
-			this.output.orientationZ.value = z;
-		}
-		/**
-		 * 设置音频位置，x正方形水平向右，y正方形垂直于地面向上，z正方向垂直屏幕远离用户
-		 * @param x 位置x坐标 Number
-		 * @param y 位置y坐标 Number
-		 * @param z 位置z坐标 Number
-		 */
-		setPosition(x, y, z) {
-			this.output.positionX.value = x;
-			this.output.positionY.value = y;
-			this.output.positionZ.value = z;
-		}
-		end() {}
-
-		start() {}
-	}
-	class VolumeEffect extends AudioEffect {
-		constructor(ac) {
-			super(ac);
-			const gain = ac.createGain();
-			this.input = gain;
-			this.output = gain;
-		}
-
-		/**
-		 * 设置音量大小
-		 * @param volume 音量大小 Number
-		 */
-		setVolume(volume) {
-			this.output.gain.value = volume;
-		}
-
-		/**
-		 * 获取音量大小 Number
-		 */
-		getVolume() {
-			return this.output.gain.value;
-		}
-
-		end() {}
-
-		start() {}
-	}
-	class ChannelVolumeEffect extends AudioEffect {
-		/** 所有的音量控制节点 */
-
-		constructor(ac) {
-			super(ac);
-			/** 所有的音量控制节点 */
-			this.gain = [];
-			const splitter = ac.createChannelSplitter();
-			const merger = ac.createChannelMerger();
-			this.output = merger;
-			this.input = splitter;
-			for (let i = 0; i < 6; i++) {
-				const gain = ac.createGain();
-				splitter.connect(gain, i);
-				gain.connect(merger, 0, i);
-				this.gain.push(gain);
-			}
-		}
-
-		/**
-		 * 设置某个声道的音量大小
-		 * @param channel 要设置的声道，可填0-5 Number
-		 * @param volume 这个声道的音量大小 Number
-		 */
-		setVolume(channel, volume) {
-			if (!this.gain[channel]) return;
-			this.gain[channel].gain.value = volume;
-		}
-
-		/**
-		 * 获取某个声道的音量大小，可填0-5
-		 * @param channel 要获取的声道 Number
-		 */
-		getVolume(channel) {
-			if (!this.gain[channel]) return 0;
-			return this.gain[channel].gain.value;
-		}
-
-		end() {}
-
-		start() {}
-	}
-	class DelayEffect extends AudioEffect {
-		constructor(ac) {
-			super(ac);
-
-			const delay = ac.createDelay();
-			this.input = delay;
-			this.output = delay;
-		}
-
-		/**
-		 * 设置延迟时长
-		 * @param delay 延迟时长，单位秒 Number
-		 */
-		setDelay(delay) {
-			this.output.delayTime.value = delay;
-		}
-
-		/**
-		 * 获取延迟时长
-		 */
-		getDelay() {
-			return this.output.delayTime.value;
-		}
-
-		end() {}
-
-		start() {}
-	}
-	class EchoEffect extends AudioEffect {
-		constructor(ac) {
-			super(ac);
-			/** 当前增益 */
-			this.gain = 0.5;
-			/** 是否正在播放 */
-			this.playing = false;
-			const delay = ac.createDelay();
-			const gain = ac.createGain();
-			gain.gain.value = 0.5;
-			delay.delayTime.value = 0.05;
-			delay.connect(gain);
-			gain.connect(delay);
-			/** 延迟节点 */
-			this.delay = delay;
-			/** 反馈增益节点 */
-			this.gainNode = gain;
-
-			this.input = gain;
-			this.output = gain;
-		}
-
-		/**
-		 * 设置回声反馈增益大小
-		 * @param gain 增益大小，范围 0-1，大于等于1的视为0.5，小于0的视为0 Number
-		 */
-		setFeedbackGain(gain) {
-			const resolved = gain >= 1 ? 0.5 : gain < 0 ? 0 : gain;
-			this.gain = resolved;
-			if (this.playing) this.gainNode.gain.value = resolved;
-		}
-
-		/**
-		 * 设置回声间隔时长
-		 * @param delay 回声时长，范围 0.01-Infinity，小于0.01的视为0.01 Number
-		 */
-		setEchoDelay(delay) {
-			const resolved = delay < 0.01 ? 0.01 : delay;
-			this.delay.delayTime.value = resolved;
-		}
-
-		/**
-		 * 获取反馈节点增益
-		 */
-		getFeedbackGain() {
-			return this.gain;
-		}
-
-		/**
-		 * 获取回声间隔时长
-		 */
-		getEchoDelay() {
-			return this.delay.delayTime.value;
-		}
-
-		end() {
-			this.playing = false;
-			const echoTime = Math.ceil(Math.log(0.001) / Math.log(this.gain)) + 10;
-			sleep(this.delay.delayTime.value * echoTime).then(() => {
-				if (!this.playing) this.gainNode.gain.value = 0;
-			});
-		}
-
-		start() {
-			this.playing = true;
-			this.gainNode.gain.value = this.gain;
-		}
-	}
-
-	class StreamLoader {
-		constructor(url) {
-			/** 传输目标  Set<IStreamReader>*/
-			this.target = new Set();
-			this.loading = false;
-		}
-
-		/**
-		 * 将加载流传递给字节流读取对象
-		 * @param reader 字节流读取对象 IStreamReader
-		 */
-		pipe(reader) {
-			if (this.loading) {
-				console.warn(
-					"Cannot pipe new StreamReader object when stream is loading."
-				);
-				return;
-			}
-			this.target.add(reader);
-			reader.piped(this);
-			return this;
-		}
-
-		async start() {
-			if (this.loading) return;
-			this.loading = true;
-			const response = await window.fetch(this.url);
-			const stream = response.body;
-			if (!stream) {
-				console.error("Cannot get reader when fetching '" + this.url + "'.");
-				return;
-			}
-			// 获取读取器
-			/** 读取流对象 */
-			this.stream = stream;
-			const reader = response.body?.getReader();
-			const targets = [...this.target];
-
-			await Promise.all(targets.map((v) => v.start(stream, this, response)));
-			if (reader && reader.read) {
-				// 开始流传输
-				while (true) {
-					const { value, done } = await reader.read();
-					await Promise.all(
-						targets.map((v) => v.pump(value, done, response))
-					);
-					if (done) break;
-				}
-			} else {
-				// 如果不支持流传输
-				const buffer = await response.arrayBuffer();
-				const data = new Uint8Array(buffer);
-				await Promise.all(targets.map((v) => v.pump(data, true, response)));
-			}
-			// 开始流传输
-			while (true) {
-				const { value, done } = await reader.read();
-				await Promise.all(targets.map((v) => v.pump(value, done, response)));
-				if (done) break;
-			}
-
-			this.loading = false;
-			targets.forEach((v) => v.end(true));
-
-			//
-		}
-
-		cancel(reason) {
-			if (!this.stream) return;
-			this.stream.cancel(reason);
-			this.loading = false;
-			this.target.forEach((v) => v.end(false, reason));
-		}
-	}
-	const fileSignatures = [
-		[AudioType.Mp3, [0x49, 0x44, 0x33]],
-		[AudioType.Ogg, [0x4f, 0x67, 0x67, 0x53]],
-		[AudioType.Wav, [0x52, 0x49, 0x46, 0x46]],
-		[AudioType.Flac, [0x66, 0x4c, 0x61, 0x43]],
-		[AudioType.Aac, [0xff, 0xf1]],
-		[AudioType.Aac, [0xff, 0xf9]],
-	];
-	const oggHeaders = [
-		[AudioType.Opus, [0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64]],
-	];
-
-	function checkAudioType(data) {
-		let audioType = "";
-		// 检查头文件获取音频类型，仅检查前256个字节
-		const toCheck = data.slice(0, 256);
-		for (const [type, value] of fileSignatures) {
-			if (value.every((v, i) => toCheck[i] === v)) {
-				audioType = type;
-				break;
-			}
-		}
-		if (audioType === AudioType.Ogg) {
-			// 如果是ogg的话，进一步判断是不是opus
-			for (const [key, value] of oggHeaders) {
-				const has = toCheck.some((_, i) => {
-					return value.every((v, ii) => toCheck[i + ii] === v);
-				});
-				if (has) {
-					audioType = key;
-					break;
-				}
-			}
-		}
-
-		return audioType;
-	}
-	class AudioDecoder {
-		/**
-		 * 注册一个解码器
-		 * @param type 要注册的解码器允许解码的类型
-		 * @param decoder 解码器对象
-		 */
-		static registerDecoder(type, decoder) {
-			if (!this.decoderMap) this.decoderMap = new Map();
-			if (this.decoderMap.has(type)) {
-				console.warn(
-					"Audio stream decoder for audio type '" +
-					type +
-					"' has already existed."
-				);
-				return;
-			}
-
-			this.decoderMap.set(type, decoder);
-		}
-
-		/**
-		 * 解码音频数据
-		 * @param data 音频文件数据
-		 * @param player AudioPlayer实例
-		 */
-		static async decodeAudioData(data, player) {
-			// 检查头文件获取音频类型，仅检查前256个字节
-			const toCheck = data.slice(0, 256);
-			const type = checkAudioType(data);
-			if (type === "") {
-				console.error(
-					"Unknown audio type. Header: '" + [...toCheck]
-					.map((v) => v.toString().padStart(2, "0"))
-					.join(" ")
-					.toUpperCase() +
-					"'"
-				);
-				return null;
-			}
-			if (isAudioSupport(type)) {
-				if (data.buffer instanceof ArrayBuffer) {
-					return player.ac.decodeAudioData(data.buffer);
-				} else {
-					return null;
-				}
-			} else {
-				const Decoder = this.decoderMap.get(type);
-				if (!Decoder) {
-					return null;
-				} else {
-					const decoder = new Decoder();
-					await decoder.create();
-					const decodedData = await decoder.decode(data);
-					if (!decodedData) return null;
-					const buffer = player.ac.createBuffer(
-						decodedData.channelData.length,
-						decodedData.channelData[0].length,
-						decodedData.sampleRate
-					);
-					decodedData.channelData.forEach((v, i) => {
-						buffer.copyToChannel(v, i);
-					});
-					decoder.destroy();
-					return buffer;
-				}
-			}
-		}
-	}
-
-	class VorbisDecoder {
-		/**
-		 * 创建音频解码器
-		 */
-		async create() {
-			this.decoder = new OggVorbisDecoderWebWorker();
-			await this.decoder.ready;
-		}
-		/**
-		 * 摧毁这个解码器
-		 */
-		destroy() {
-			this.decoder?.free();
-		}
-		/**
-		 * 解码流数据
-		 * @param data 流数据
-		 */
-
-		async decode(data) {
-			return this.decoder?.decode(data);
-		}
-		/**
-		 * 解码整个文件
-		 * @param data 文件数据
-		 */
-		async decodeAll(data) {
-			return this.decoder?.decodeFile(data);
-		}
-		/**
-		 * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
-		 */
-		async flush() {
-			return this.decoder?.flush();
-		}
-	}
-
-	class OpusDecoder {
-		/**
-		 * 创建音频解码器
-		 */
-		async create() {
-			this.decoder = new OggOpusDecoderWebWorker();
-			await this.decoder.ready;
-		}
-		/**
-		 * 摧毁这个解码器
-		 */
-		destroy() {
-			this.decoder?.free();
-		}
-		/**
-		 * 解码流数据
-		 * @param data 流数据
-		 */
-		async decode(data) {
-			return this.decoder?.decode(data);
-		}
-		/**
-		 * 解码整个文件
-		 * @param data 文件数据
-		 */
-		async decodeAll(data) {
-			return this.decoder?.decodeFile(data);
-		}
-		/**
-		 * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
-		 */
-		async flush() {
-			return await this.decoder?.flush();
-		}
-	}
-	const mimeTypeMap = {
-		[AudioType.Aac]: "audio/aac",
-		[AudioType.Flac]: "audio/flac",
-		[AudioType.Mp3]: "audio/mpeg",
-		[AudioType.Ogg]: "application/ogg",
-		[AudioType.Opus]: "application/ogg",
-		[AudioType.Wav]: "application/ogg",
-	};
-
-	function isOggPage(data) {
-		return !isNil(data.isFirstPage);
-	}
-	class AudioStreamSource {
-		constructor(context) {
-			this.output = context.createBufferSource();
-			/** 是否已经完全加载完毕 */
-			this.loaded = false;
-			/** 是否正在播放 */
-			this.playing = false;
-			/** 已经缓冲了多长时间，如果缓冲完那么跟歌曲时长一致 */
-			this.buffered = 0;
-			/** 已经缓冲的采样点数量 */
-			this.bufferedSamples = 0;
-			/** 歌曲时长，加载完毕之前保持为 0 */
-			this.duration = 0;
-			/** 在流传输阶段，至少缓冲多长时间的音频之后才开始播放，单位秒 */
-			this.bufferPlayDuration = 1;
-			/** 音频的采样率，未成功解析出之前保持为 0 */
-			this.sampleRate = 0;
-			//是否循环播放
-			this.loop = false;
-			/** 上一次播放是从何时开始的 */
-			this.lastStartWhen = 0;
-			/** 开始播放时刻 */
-			this.lastStartTime = 0;
-			/** 上一次播放的缓存长度 */
-			this.lastBufferSamples = 0;
-
-			/** 是否已经获取到头文件 */
-			this.headerRecieved = false;
-			/** 音频类型 */
-			this.audioType = "";
-			/** 每多长时间组成一个缓存 Float32Array */
-			this.bufferChunkSize = 10;
-			/** 缓存音频数据，每 bufferChunkSize 秒钟组成一个 Float32Array，用于流式解码 */
-			this.audioData = [];
-
-			this.errored = false;
-			this.ac = context;
-		}
-		/** 当前已经播放了多长时间 */
-		get currentTime() {
-			return this.ac.currentTime - this.lastStartTime + this.lastStartWhen;
-		}
-		/**
-		 * 设置每个缓存数据的大小，默认为10秒钟一个缓存数据
-		 * @param size 每个缓存数据的时长，单位秒
-		 */
-		setChunkSize(size) {
-			if (this.controller?.loading || this.loaded) return;
-			this.bufferChunkSize = size;
-		}
-		on(event, fn, context) {}
-		piped(controller) {
-			this.controller = controller;
-		}
-
-		async pump(data, done) {
-			if (!data || this.errored) return;
-			if (!this.headerRecieved) {
-				// 检查头文件获取音频类型，仅检查前256个字节
-				const toCheck = data.slice(0, 256);
-				this.audioType = checkAudioType(data);
-				if (!this.audioType) {
-					console.error(
-						"Unknown audio type. Header: '" + [...toCheck]
-						.map((v) => v.toString(16).padStart(2, "0"))
-						.join(" ")
-						.toUpperCase() +
-						"'"
-					);
-					return;
-				}
-				// 创建解码器
-				const Decoder = AudioDecoder.decoderMap.get(this.audioType);
-				if (!Decoder) {
-					this.errored = true;
-					console.error(
-						"Cannot decode stream source type of '" +
-						this.audioType +
-						"', since there is no registered decoder for that type."
-					);
-					return Promise.reject(
-						`Cannot decode stream source type of '${this.audioType}', since there is no registered decoder for that type.`
-					);
-				}
-				this.decoder = new Decoder();
-				// 创建数据解析器
-				const mime = mimeTypeMap[this.audioType];
-				const parser = new CodecParser(mime);
-				this.parser = parser;
-				await this.decoder.create();
-				this.headerRecieved = true;
-			}
-
-			const decoder = this.decoder;
-			const parser = this.parser;
-			if (!decoder || !parser) {
-				this.errored = true;
-				return Promise.reject(
-					"No parser or decoder attached in this AudioStreamSource"
-				);
-			}
-
-			await this.decodeData(data, decoder, parser);
-			if (done) await this.decodeFlushData(decoder, parser);
-			this.checkBufferedPlay();
-		}
-
-		/**
-		 * 检查采样率，如果还未解析出采样率，那么将设置采样率，如果当前采样率与之前不同，那么发出警告
-		 */
-		checkSampleRate(info) {
-			for (const one of info) {
-				const frame = isOggPage(one) ? one.codecFrames[0] : one;
-				if (frame) {
-					const rate = frame.header.sampleRate;
-					if (this.sampleRate === 0) {
-						this.sampleRate = rate;
-						break;
-					} else {
-						if (rate !== this.sampleRate) {
-							console.warn("Sample rate in stream audio must be constant.");
-						}
-					}
-				}
-			}
-		}
-
-		/**
-		 * 解析音频数据
-		 */
-		async decodeData(data, decoder, parser) {
-			// 解析音频数据
-			const audioData = await decoder.decode(data);
-			if (!audioData) return;
-			// @ts-expect-error 库类型声明错误
-			const audioInfo = [...parser.parseChunk(data)];
-
-			// 检查采样率
-			this.checkSampleRate(audioInfo);
-			// 追加音频数据
-			this.appendDecodedData(audioData, audioInfo);
-		}
-
-		/**
-		 * 解码剩余数据
-		 */
-		async decodeFlushData(decoder, parser) {
-			const audioData = await decoder.flush();
-			if (!audioData) return;
-			// @ts-expect-error 库类型声明错误
-			const audioInfo = [...parser.flush()];
-
-			this.checkSampleRate(audioInfo);
-			this.appendDecodedData(audioData, audioInfo);
-		}
-
-		/**
-		 * 追加音频数据
-		 */
-		appendDecodedData(data, info) {
-			const channels = data.channelData.length;
-			if (channels === 0) return;
-			if (this.audioData.length !== channels) {
-				this.audioData = [];
-				for (let i = 0; i < channels; i++) {
-					this.audioData.push([]);
-				}
-			}
-			// 计算出应该放在哪
-			const chunk = this.sampleRate * this.bufferChunkSize;
-			const sampled = this.bufferedSamples;
-			const pushIndex = Math.floor(sampled / chunk);
-			const bufferIndex = sampled % chunk;
-			const dataLength = data.channelData[0].length;
-			let buffered = 0;
-			let nowIndex = pushIndex;
-			let toBuffer = bufferIndex;
-			while (buffered < dataLength) {
-				const rest = toBuffer !== 0 ? chunk - bufferIndex : chunk;
-
-				for (let i = 0; i < channels; i++) {
-					const audioData = this.audioData[i];
-					if (!audioData[nowIndex]) {
-						audioData.push(new Float32Array(chunk));
-					}
-					const toPush = data.channelData[i].slice(buffered, buffered + rest);
-
-					audioData[nowIndex].set(toPush, toBuffer);
-				}
-				buffered += rest;
-				nowIndex++;
-				toBuffer = 0;
-			}
-
-			this.buffered +=
-				info.reduce((prev, curr) => prev + curr.duration, 0) / 1000;
-			this.bufferedSamples += info.reduce(
-				(prev, curr) => prev + curr.samples,
-				0
-			);
-		}
-
-		/**
-		 * 检查已缓冲内容，并在未开始播放时播放
-		 */
-		checkBufferedPlay() {
-			if (this.playing || this.sampleRate === 0) return;
-			const played = this.lastBufferSamples / this.sampleRate;
-			const dt = this.buffered - played;
-			if (this.loaded) {
-				this.playAudio(played);
-				return;
-			}
-			if (dt < this.bufferPlayDuration) return;
-
-			this.lastBufferSamples = this.bufferedSamples;
-			// 需要播放
-			this.mergeBuffers();
-			if (!this.buffer) return;
-			if (this.playing) this.output.stop();
-			this.createSourceNode(this.buffer);
-			this.output.loop = false;
-			this.output.start(0, played);
-			this.lastStartTime = this.ac.currentTime;
-			this.playing = true;
-			this.output.addEventListener("ended", () => {
-				this.playing = false;
-				this.checkBufferedPlay();
-			});
-		}
-
-		mergeBuffers() {
-			const buffer = this.ac.createBuffer(
-				this.audioData.length,
-				this.bufferedSamples,
-				this.sampleRate
-			);
-			const chunk = this.sampleRate * this.bufferChunkSize;
-			const bufferedChunks = Math.floor(this.bufferedSamples / chunk);
-			const restLength = this.bufferedSamples % chunk;
-			for (let i = 0; i < this.audioData.length; i++) {
-				const audio = this.audioData[i];
-				const data = new Float32Array(this.bufferedSamples);
-				for (let j = 0; j < bufferedChunks; j++) {
-					data.set(audio[j], chunk * j);
-				}
-				if (restLength !== 0) {
-					data.set(
-						audio[bufferedChunks].slice(0, restLength),
-						chunk * bufferedChunks
-					);
-				}
-
-				buffer.copyToChannel(data, i, 0);
-			}
-			this.buffer = buffer;
-		}
-
-		async start() {
-			delete this.buffer;
-			this.headerRecieved = false;
-			this.audioType = "";
-			this.errored = false;
-			this.buffered = 0;
-			this.sampleRate = 0;
-			this.bufferedSamples = 0;
-			this.duration = 0;
-			this.loaded = false;
-			if (this.playing) this.output.stop();
-			this.playing = false;
-			this.lastStartTime = this.ac.currentTime;
-		}
-
-		end(done, reason) {
-			if (done && this.buffer) {
-				this.loaded = true;
-				delete this.controller;
-				this.mergeBuffers();
-
-				this.duration = this.buffered;
-				this.audioData = [];
-				this.decoder?.destroy();
-				delete this.decoder;
-				delete this.parser;
-			} else {
-				console.warn(
-					"Unexpected end when loading stream audio, reason: '" +
-					(reason ?? "") +
-					"'"
-				);
-			}
-		}
-
-		playAudio(when) {
-			if (!this.buffer) return;
-			this.lastStartTime = this.ac.currentTime;
-			if (this.playing) this.output.stop();
-			if (this.player.status !== AudioStatus.Playing) {
-				this.player.status = AudioStatus.Playing;
-			}
-			this.createSourceNode(this.buffer);
-			this.output.start(0, when);
-			this.playing = true;
-
-			this.output.addEventListener("ended", () => {
-				this.playing = false;
-				if (this.player.status === AudioStatus.Playing) {
-					this.player.status = AudioStatus.Stoped;
-				}
-				if (this.loop && !this.output.loop) this.play(0);
-			});
-		}
-		/**
-		 * 开始播放这个音频源
-		 */
-		play(when) {
-			if (this.playing || this.errored) return;
-			if (this.loaded && this.buffer) {
-				this.playing = true;
-				this.playAudio(when);
-			} else {
-				this.controller?.start();
-			}
-		}
-
-		createSourceNode(buffer) {
-			if (!this.target) return;
-			const node = this.ac.createBufferSource();
-			node.buffer = buffer;
-			if (this.playing) this.output.stop();
-			this.playing = false;
-			this.output = node;
-			node.connect(this.target.input);
-			node.loop = this.loop;
-		}
-		/**
-		 * 停止播放这个音频源
-		 * @returns 音频暂停的时刻 number
-		 */
-		stop() {
-			if (this.playing) this.output.stop();
-			this.playing = false;
-			return this.ac.currentTime - this.lastStartTime;
-		}
-		/**
-		 * 连接到音频路由图上，每次调用播放的时候都会执行一次
-		 * @param target 连接至的目标 IAudioInput
-		 */
-		connect(target) {
-			this.target = target;
-		}
-		/**
-		 * 设置是否循环播放
-		 * @param loop 是否循环 boolean)
-		 */
-		setLoop(loop) {
-			this.loop = loop;
-		}
-	}
-	class AudioElementSource {
-		constructor(context) {
-			const audio = new Audio();
-			audio.preload = "none";
-			this.output = context.createMediaElementSource(audio);
-			this.audio = audio;
-			this.ac = context;
-			audio.addEventListener("play", () => {
-				this.playing = true;
-				if (this.player.status !== AudioStatus.Playing) {
-					this.player.status = AudioStatus.Playing;
-				}
-			});
-			audio.addEventListener("ended", () => {
-				this.playing = false;
-				if (this.player.status === AudioStatus.Playing) {
-					this.player.status = AudioStatus.Stoped;
-				}
-			});
-		}
-		get duration() {
-			return this.audio.duration;
-		}
-		get currentTime() {
-			return this.audio.currentTime;
-		}
-		/**
-		 * 设置音频源的路径
-		 * @param url 音频路径
-		 */
-		setSource(url) {
-			this.audio.src = url;
-		}
-
-		play(when = 0) {
-			if (this.playing) return;
-			this.audio.currentTime = when;
-			this.audio.play();
-		}
-
-		stop() {
-			this.audio.pause();
-			this.playing = false;
-			if (this.player.status === AudioStatus.Playing) {
-				this.player.status = AudioStatus.Stoped;
-			}
-			return this.audio.currentTime;
-		}
-
-		connect(target) {
-			this.output.connect(target.input);
-		}
-
-		setLoop(loop) {
-			this.audio.loop = loop;
-		}
-	}
-	class AudioBufferSource {
-		constructor(context) {
-			this.output = context.createBufferSource();
-			/** 是否循环 */
-			this.loop = false;
-			/** 上一次播放是从何时开始的 */
-			this.lastStartWhen = 0;
-			/** 播放开始时刻 */
-			this.lastStartTime = 0;
-			this.duration = 0;
-			this.ac = context;
-		}
-		get currentTime() {
-			return this.ac.currentTime - this.lastStartTime + this.lastStartWhen;
-		}
-
-		/**
-		 * 设置音频源数据
-		 * @param buffer 音频源，可以是未解析的 ArrayBuffer，也可以是已解析的 AudioBuffer
-		 */
-		async setBuffer(buffer) {
-			if (buffer instanceof ArrayBuffer) {
-				this.buffer = await this.ac.decodeAudioData(buffer);
-			} else {
-				this.buffer = buffer;
-			}
-			this.duration = this.buffer.duration;
-		}
-
-		play(when) {
-			if (this.playing || !this.buffer) return;
-			this.playing = true;
-			this.lastStartTime = this.ac.currentTime;
-			if (this.player.status !== AudioStatus.Playing) {
-				this.player.status = AudioStatus.Playing;
-			}
-			this.createSourceNode(this.buffer);
-			this.output.start(0, when);
-			this.output.addEventListener("ended", () => {
-				this.playing = false;
-				if (this.player.status === AudioStatus.Playing) {
-					this.player.status = AudioStatus.Stoped;
-				}
-				if (this.loop && !this.output.loop) this.play(0);
-			});
-		}
-
-		createSourceNode(buffer) {
-			if (!this.target) return;
-			const node = this.ac.createBufferSource();
-			node.buffer = buffer;
-			this.output = node;
-			node.connect(this.target.input);
-			node.loop = this.loop;
-		}
-
-		stop() {
-			this.output.stop();
-			return this.ac.currentTime - this.lastStartTime;
-		}
-
-		connect(target) {
-			this.target = target;
-		}
-
-		setLoop(loop) {
-			this.loop = loop;
-		}
-	}
-	class AudioPlayer {
-		constructor() {
-			/** 音频播放上下文 */
-			this.ac = new AudioContext();
-			/** 音量节点 */
-			this.gain = this.ac.createGain();
-			this.gain.connect(this.ac.destination);
-			this.audioRoutes = new Map();
-		}
-		/**
-		 * 解码音频数据
-		 * @param data 音频数据
-		 */
-		decodeAudioData(data) {
-			return AudioDecoder.decodeAudioData(data, this);
-		}
-		/**
-		 * 设置音量
-		 * @param volume 音量
-		 */
-		setVolume(volume) {
-			this.gain.gain.value = volume;
-		}
-
-		/**
-		 * 获取音量
-		 */
-		getVolume() {
-			return this.gain.gain.value;
-		}
-
-		/**
-		 * 创建一个音频源
-		 * @param Source 音频源类
-		 */
-		createSource(Source) {
-			return new Source(this.ac);
-		}
-
-		/**
-		 * 创建一个兼容流式音频源，可以与流式加载相结合，主要用于处理 opus ogg 不兼容的情况
-		 */
-		createStreamSource() {
-			return new AudioStreamSource(this.ac);
-		}
-
-		/**
-		 * 创建一个通过 audio 元素播放的音频源
-		 */
-		createElementSource() {
-			return new AudioElementSource(this.ac);
-		}
-
-		/**
-		 * 创建一个通过 AudioBuffer 播放的音频源
-		 */
-		createBufferSource() {
-			return new AudioBufferSource(this.ac);
-		}
-
-		/**
-		 * 获取音频目的地
-		 */
-		getDestination() {
-			return this.gain;
-		}
-
-		/**
-		 * 创建一个音频效果器
-		 * @param Effect 效果器类
-		 */
-		createEffect(Effect) {
-			return new Effect(this.ac);
-		}
-
-		/**
-		 * 创建一个修改音量的效果器
-		 * ```txt
-		 *             |----------|
-		 * Input ----> | GainNode | ----> Output
-		 *             |----------|
-		 * ```
-		 */
-		createVolumeEffect() {
-			return new VolumeEffect(this.ac);
-		}
-
-		/**
-		 * 创建一个立体声效果器
-		 * ```txt
-		 *             |------------|
-		 * Input ----> | PannerNode | ----> Output
-		 *             |------------|
-		 * ```
-		 */
-		createStereoEffect() {
-			return new StereoEffect(this.ac);
-		}
-
-		/**
-		 * 创建一个修改单个声道音量的效果器
-		 * ```txt
-		 *                                  |----------|
-		 *                               -> | GainNode | \
-		 *             |--------------| /   |----------|  -> |------------|
-		 * Input ----> | SplitterNode |        ......        | MergerNode | ----> Output
-		 *             |--------------| \   |----------|  -> |------------|
-		 *                               -> | GainNode | /
-		 *                                  |----------|
-		 * ```
-		 */
-		createChannelVolumeEffect() {
-			return new ChannelVolumeEffect(this.ac);
-		}
-
-		/**
-		 * 创建一个延迟效果器
-		 *             |-----------|
-		 * Input ----> | DelayNode | ----> Output
-		 *             |-----------|
-		 */
-		createDelay() {
-			return new DelayEffect(this.ac);
-		}
-
-		/**
-		 * 创建一个回声效果器
-		 * ```txt
-		 *             |----------|
-		 * Input ----> | GainNode | ----> Output
-		 *        ^    |----------|   |
-		 *        |                   |
-		 *        |   |------------|  ↓
-		 *        |-- | Delay Node | <--
-		 *            |------------|
-		 * ```
-		 */
-		createEchoEffect() {
-			return new EchoEffect(this.ac);
-		}
-
-		/**
-		 * 创建一个音频播放路由
-		 * @param source 音频源
-		 */
-		createRoute(source) {
-			return new AudioRoute(source, this);
-		}
-
-		/**
-		 * 添加一个音频播放路由，可以直接被播放
-		 * @param id 这个音频播放路由的名称
-		 * @param route 音频播放路由对象
-		 */
-		addRoute(id, route) {
-			if (!this.audioRoutes) this.audioRoutes = new Map();
-			if (this.audioRoutes.has(id)) {
-				console.warn(
-					"Audio route with id of '" +
-					id +
-					"' has already existed. New route will override old route."
-				);
-			}
-			this.audioRoutes.set(id, route);
-		}
-
-		/**
-		 * 根据名称获取音频播放路由对象
-		 * @param id 音频播放路由的名称
-		 */
-		getRoute(id) {
-			return this.audioRoutes.get(id);
-		}
-		/**
-		 * 移除一个音频播放路由
-		 * @param id 要移除的播放路由的名称
-		 */
-		removeRoute(id) {
-			this.audioRoutes.delete(id);
-		}
-		/**
-		 * 播放音频
-		 * @param id 音频名称
-		 * @param when 从音频的哪个位置开始播放，单位秒
-		 */
-		play(id, when) {
-			const route = this.getRoute(id);
-			if (!route) {
-				console.warn(
-					"Cannot play audio route '" +
-					id +
-					"', since there is not added route named it."
-				);
-				return;
-			}
-
-			route.play(when);
-		}
-
-		/**
-		 * 暂停音频播放
-		 * @param id 音频名称
-		 * @returns 当音乐真正停止时兑现
-		 */
-		pause(id) {
-			const route = this.getRoute(id);
-			if (!route) {
-				console.warn(
-					"Cannot pause audio route '" +
-					id +
-					"', since there is not added route named it."
-				);
-				return;
-			}
-			return route.pause();
-		}
-
-		/**
-		 * 停止音频播放
-		 * @param id 音频名称
-		 * @returns 当音乐真正停止时兑现
-		 */
-		stop(id) {
-			const route = this.getRoute(id);
-			if (!route) {
-				console.warn(
-					"Cannot stop audio route '" +
-					id +
-					"', since there is not added route named it."
-				);
-				return;
-			}
-			return route.stop();
-		}
-
-		/**
-		 * 继续音频播放
-		 * @param id 音频名称
-		 */
-		resume(id) {
-			const route = this.getRoute(id);
-			if (!route) {
-				console.warn(
-					"Cannot pause audio route '" +
-					id +
-					"', since there is not added route named it."
-				);
-				return;
-			}
-			route.resume();
-		}
-
-		/**
-		 * 设置听者位置，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
-		 * @param x 位置x坐标
-		 * @param y 位置y坐标
-		 * @param z 位置z坐标
-		 */
-		setListenerPosition(x, y, z) {
-			const listener = this.ac.listener;
-			listener.positionX.value = x;
-			listener.positionY.value = y;
-			listener.positionZ.value = z;
-		}
-
-		/**
-		 * 设置听者朝向，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
-		 * @param x 朝向x坐标
-		 * @param y 朝向y坐标
-		 * @param z 朝向z坐标
-		 */
-		setListenerOrientation(x, y, z) {
-			const listener = this.ac.listener;
-			listener.forwardX.value = x;
-			listener.forwardY.value = y;
-			listener.forwardZ.value = z;
-		}
-
-		/**
-		 * 设置听者头顶朝向，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
-		 * @param x 头顶朝向x坐标
-		 * @param y 头顶朝向y坐标
-		 * @param z 头顶朝向z坐标
-		 */
-		setListenerUp(x, y, z) {
-			const listener = this.ac.listener;
-			listener.upX.value = x;
-			listener.upY.value = y;
-			listener.upZ.value = z;
-		}
-	}
-	class AudioRoute {
-		constructor(source, player) {
-			this.output = source.output;
-
-			/** 效果器路由图 */
-			this.effectRoute = [];
-
-			/** 结束时长，当音频暂停或停止时，会经过这么长时间之后才真正终止播放，期间可以做音频淡入淡出等效果 */
-			this.endTime = 0;
-			/** 暂停时播放了多长时间 */
-			this.pauseCurrentTime = 0;
-			/** 当前播放状态 */
-			this.player = player;
-			this.player.status = AudioStatus.Stoped;
-			this.shouldStop = false;
-			/**
-			 * 每次暂停或停止时自增，用于判断当前正在处理的情况。
-			 * 假如暂停后很快播放，然后很快暂停，那么需要根据这个来判断实际是否应该执行暂停后操作
-			 */
-			this.stopIdentifier = 0;
-			/** 暂停时刻 */
-			this.pauseTime = 0;
-			this.source = source;
-			this.source.player = player;
-		}
-		/** 音频时长，单位秒 */
-		get duration() {
-			return this.source.duration;
-		}
-		/** 当前播放了多长时间，单位秒 */
-		get currentTime() {
-			if (this.player.status === AudioStatus.Paused) {
-				return this.pauseCurrentTime;
-			} else {
-				return this.source.currentTime;
-			}
-		}
-		set currentTime(time) {
-			this.source.stop();
-			this.source.play(time);
-		}
-		/**
-		 * 设置结束时间，暂停或停止时，会经过这么长时间才终止音频的播放，这期间可以做一下音频淡出的效果。
-		 * @param time 暂停或停止时，经过多长时间之后才会结束音频的播放
-		 */
-		setEndTime(time) {
-			this.endTime = time;
-		}
-
-		/**
-		 * 当音频播放时执行的函数，可以用于音频淡入效果
-		 * @param fn 音频开始播放时执行的函数
-		 */
-		onStart(fn) {
-			this.audioStartHook = fn;
-		}
-
-		/**
-		 * 当音频暂停或停止时执行的函数，可以用于音频淡出效果
-		 * @param fn 音频在暂停或停止时执行的函数，不填时表示取消这个钩子。
-		 *           包含两个参数，第一个参数是结束时长，第二个参数是当前音频播放路由对象
-		 */
-		onEnd(fn) {
-			this.audioEndHook = fn;
-		}
-
-		/**
-		 * 开始播放这个音频
-		 * @param when 从音频的什么时候开始播放，单位秒
-		 */
-		play(when = 0) {
-			if (this.player.status === AudioStatus.Playing) return;
-			this.link();
-			if (this.effectRoute.length > 0) {
-				const first = this.effectRoute[0];
-				this.source.connect(first);
-				const last = this.effectRoute.at(-1);
-				last.connect({ input: this.player.getDestination() });
-			} else {
-				this.source.connect({ input: this.player.getDestination() });
-			}
-			this.source.play(when);
-			this.player.status = AudioStatus.Playing;
-			this.pauseTime = 0;
-			this.audioStartHook?.(this);
-			this.startAllEffect();
-			if (this.source.player.status !== AudioStatus.Playing) {
-				this.source.player.status = AudioStatus.Playing;
-			}
-		}
-
-		/**
-		 * 暂停音频播放
-		 */
-		async pause() {
-			if (this.player.status !== AudioStatus.Playing) return;
-			this.player.status = AudioStatus.Pausing;
-			this.stopIdentifier++;
-			const identifier = this.stopIdentifier;
-			if (this.audioEndHook) {
-				this.audioEndHook(this.endTime, this);
-				await sleep(this.endTime);
-			}
-			if (
-				this.player.status !== AudioStatus.Pausing ||
-				this.stopIdentifier !== identifier
-			) {
-				return;
-			}
-			this.pauseCurrentTime = this.source.currentTime;
-			const time = this.source.stop();
-			this.pauseTime = time;
-			if (this.shouldStop) {
-				this.player.status = AudioStatus.Stoped;
-				this.endAllEffect();
-
-				this.shouldStop = false;
-			} else {
-				this.player.status = AudioStatus.Paused;
-				this.endAllEffect();
-			}
-			this.endAllEffect();
-		}
-
-		/**
-		 * 继续音频播放
-		 */
-		resume() {
-			if (this.player.status === AudioStatus.Playing) return;
-			if (
-				this.player.status === AudioStatus.Pausing ||
-				this.player.status === AudioStatus.Stoping
-			) {
-				this.audioStartHook?.(this);
-
-				return;
-			}
-			if (this.player.status === AudioStatus.Paused) {
-				this.play(this.pauseTime);
-			} else {
-				this.play(0);
-			}
-			this.player.status = AudioStatus.Playing;
-			this.pauseTime = 0;
-			this.audioStartHook?.(this);
-			this.startAllEffect();
-		}
-
-		/**
-		 * 停止音频播放
-		 */
-		async stop() {
-			if (this.status !== AudioStatus.Playing) {
-				if (this.status === AudioStatus.Pausing) {
-					this.shouldStop = true;
-				}
-				return;
-			}
-			this.status = AudioStatus.Stoping;
-			this.stopIdentifier++;
-			const identifier = this.stopIdentifier;
-			if (this.audioEndHook) {
-				this.audioEndHook(this.endTime, this);
-				await sleep(this.endTime);
-			}
-			if (
-				this.status !== AudioStatus.Stoping ||
-				this.stopIdentifier !== identifier
-			) {
-				return;
-			}
-			this.source.stop();
-			this.status = AudioStatus.Stoped;
-			this.pauseTime = 0;
-			this.endAllEffect();
-		}
-
-		/**
-		 * 添加效果器
-		 * @param effect 要添加的效果，可以是数组，表示一次添加多个
-		 * @param index 从哪个位置开始添加，如果大于数组长度，那么加到末尾，如果小于0，那么将会从后面往前数。默认添加到末尾
-		 */
-		addEffect(effect, index) {
-			if (isNil(index)) {
-				if (effect instanceof Array) {
-					this.effectRoute.push(...effect);
-				} else {
-					this.effectRoute.push(effect);
-				}
-			} else {
-				if (effect instanceof Array) {
-					this.effectRoute.splice(index, 0, ...effect);
-				} else {
-					this.effectRoute.splice(index, 0, effect);
-				}
-			}
-			this.setOutput();
-			if (this.source.playing) this.link();
-		}
-
-		/**
-		 * 移除一个效果器
-		 * @param effect 要移除的效果
-		 */
-		removeEffect(effect) {
-			const index = this.effectRoute.indexOf(effect);
-			if (index === -1) return;
-			this.effectRoute.splice(index, 1);
-			effect.disconnect();
-			this.setOutput();
-			if (this.source.playing) this.link();
-		}
-
-		setOutput() {
-			const effect = this.effectRoute.at(-1);
-			if (!effect) this.output = this.source.output;
-			else this.output = effect.output;
-		}
-
-		/**
-		 * 连接音频路由图
-		 */
-		link() {
-			this.effectRoute.forEach((v) => v.disconnect());
-			this.effectRoute.forEach((v, i) => {
-				const next = this.effectRoute[i + 1];
-				if (next) {
-					v.connect(next);
-				}
-			});
-		}
-
-		startAllEffect() {
-			this.effectRoute.forEach((v) => v.start());
-		}
-
-		endAllEffect() {
-			this.effectRoute.forEach((v) => v.end());
-		}
-	}
-
-	const audioPlayer = new AudioPlayer();
-
-	class BgmController {
-		constructor(player) {
-			this.mainGain = player.createVolumeEffect();
-			this.player = player;
-			/** bgm音频名称的前缀 */
-			this.prefix = "bgms.";
-			/** 每个 bgm 的音量控制器 */
-			this.gain = new Map();
-
-			/** 正在播放的 bgm */
-			this.playingBgm = "";
-			/** 是否正在播放 */
-			this.playing = false;
-
-			/** 是否已经启用 */
-			this.enabled = true;
-			/** 是否屏蔽所有的音乐切换 */
-			this.blocking = false;
-			/** 渐变时长 */
-			this.transitionTime = 2000;
-		}
-
-		/**
-		 * 设置音频渐变时长
-		 * @param time 渐变时长
-		 */
-		setTransitionTime(time) {
-			this.transitionTime = time;
-			for (const [, value] of this.gain) {
-				value.transition.time(time);
-			}
-		}
-
-		/**
-		 * 屏蔽音乐切换
-		 */
-		blockChange() {
-			this.blocking = true;
-		}
-
-		/**
-		 * 取消屏蔽音乐切换
-		 */
-		unblockChange() {
-			this.blocking = false;
-		}
-
-		/**
-		 * 设置总音量大小
-		 * @param volume 音量大小
-		 */
-		setVolume(volume) {
-			this.mainGain.setVolume(volume);
-			this._volume = volume;
-		}
-		/**
-		 * 获取总音量大小
-		 */
-		getVolume() {
-			return this.mainGain.getVolume();
-		}
-		/**
-		 * 设置是否启用
-		 * @param enabled 是否启用
-		 */
-		setEnabled(enabled) {
-			if (enabled) this.resume();
-			else this.stop();
-			this.enabled = enabled;
-		}
-
-		/**
-		 * 设置 bgm 音频名称的前缀
-		 */
-		setPrefix(prefix) {
-			this.prefix = prefix;
-		}
-
-		getId(name) {
-			return `${this.prefix}${name}`;
-		}
-
-		/**
-		 * 根据 bgm 名称获取其 AudioRoute 实例
-		 * @param id 音频名称
-		 */
-		get(id) {
-			return this.player.getRoute(this.getId(id));
-		}
-
-		/**
-		 * 添加一个 bgm
-		 * @param id 要添加的 bgm 的名称
-		 * @param url 指定 bgm 的加载地址
-		 */
-		addBgm(id, url = `project/bgms/${id}`) {
-			const type = guessTypeByExt(id);
-			if (!type) {
-				console.warn(
-					"Unknown audio extension name: '" +
-					id.split(".").slice(0, -1).join(".") +
-					"'"
-				);
-				return;
-			}
-			const gain = this.player.createVolumeEffect();
-			if (isAudioSupport(type)) {
-				const source = audioPlayer.createElementSource();
-				source.setSource(url);
-				source.setLoop(true);
-				const route = new AudioRoute(source, audioPlayer);
-				route.addEffect([gain, this.mainGain]);
-				audioPlayer.addRoute(this.getId(id), route);
-				this.setTransition(id, route, gain);
-			} else {
-				const source = audioPlayer.createStreamSource();
-				const stream = new StreamLoader(url);
-				stream.pipe(source);
-				source.setLoop(true);
-				const route = new AudioRoute(source, audioPlayer);
-				route.addEffect([gain, this.mainGain]);
-				audioPlayer.addRoute(this.getId(id), route);
-				this.setTransition(id, route, gain);
-			}
-		}
-
-		/**
-		 * 移除一个 bgm
-		 * @param id 要移除的 bgm 的名称
-		 */
-		removeBgm(id) {
-			this.player.removeRoute(this.getId(id));
-			const gain = this.gain.get(id);
-			gain?.transition.ticker.destroy();
-			this.gain.delete(id);
-		}
-
-		setTransition(id, route, gain) {
-			const transition = new Transition();
-			transition
-				.time(this.transitionTime)
-				.mode(linear())
-				.transition("volume", 0);
-
-			const tick = () => {
-				gain.setVolume(transition.value.volume);
-			};
-
-			/**
-			 * @param expect 在结束时应该是正在播放还是停止
-			 */
-			const setTick = async (expect) => {
-				transition.ticker.remove(tick);
-				transition.ticker.add(tick);
-				const identifier = route.stopIdentifier;
-				await sleep(this.transitionTime + 500);
-				if (route.status === expect && identifier === route.stopIdentifier) {
-					transition.ticker.remove(tick);
-					if (route.status === AudioStatus.Playing) {
-						gain.setVolume(1);
-					} else {
-						gain.setVolume(0);
-					}
-				}
-			};
-
-			route.onStart(async () => {
-				transition.transition("volume", 1);
-				setTick(AudioStatus.Playing);
-			});
-			route.onEnd(() => {
-				transition.transition("volume", 0);
-				setTick(AudioStatus.Paused);
-			});
-			route.setEndTime(this.transitionTime);
-
-			this.gain.set(id, { effect: gain, transition });
-		}
-
-		/**
-		 * 播放一个 bgm
-		 * @param id 要播放的 bgm 名称
-		 */
-		play(id, when) {
-			if (this.blocking) return;
-			if (id !== this.playingBgm && this.playingBgm) {
-				this.player.pause(this.getId(this.playingBgm));
-			}
-			this.playingBgm = id;
-			if (!this.enabled) return;
-			this.player.play(this.getId(id), when);
-			this.playing = true;
-			if (this.player.status !== AudioStatus.Playing) {
-				this.player.status = AudioStatus.Playing;
-			}
-		}
-
-		/**
-		 * 继续当前的 bgm
-		 */
-		resume() {
-			if (this.blocking || !this.enabled || this.playing) return;
-			if (this.playingBgm) {
-				this.player.resume(this.getId(this.playingBgm));
-			}
-			this.playing = true;
-		}
-
-		/**
-		 * 暂停当前的 bgm
-		 */
-		pause() {
-			if (this.blocking || !this.enabled) return;
-			if (this.playingBgm) {
-				this.player.pause(this.getId(this.playingBgm));
-			}
-			this.playing = false;
-		}
-
-		/**
-		 * 停止当前的 bgm
-		 */
-		stop() {
-			if (this.blocking || !this.enabled) return;
-			if (this.playingBgm) {
-				this.player.stop(this.getId(this.playingBgm));
-			}
-			this.playing = false;
-		}
-	}
-	const bgmController = new BgmController(audioPlayer);
-
-	class SoundPlayer {
-		constructor(player) {
-			/** 每个音效的唯一标识符 */
-			this.num = 0;
-			this.enabled = true;
-			this.gain = player.createVolumeEffect();
-			/** 每个音效的数据 */
-			this.buffer = new Map();
-			/** 所有正在播放的音乐 */
-			this.playing = new Set();
-			this.player = player;
-		}
-		/**
-		 * 设置是否启用音效
-		 * @param enabled 是否启用音效
-		 */
-		setEnabled(enabled) {
-			if (!enabled) this.stopAllSounds();
-			this.enabled = enabled;
-		}
-
-		/**
-		 * 设置音量大小
-		 * @param volume 音量大小
-		 */
-		setVolume(volume) {
-			this.gain.setVolume(volume);
-		}
-		/**
-		 * 获取音量大小
-		 */
-		getVolume() {
-			return this.gain.getVolume();
-		}
-		/**
-		 * 添加一个音效
-		 * @param id 音效名称
-		 * @param data 音效的Uint8Array数据
-		 */
-		async add(id, data) {
-			const buffer = await this.player.decodeAudioData(data);
-			if (!buffer) {
-				console.warn(
-					"Cannot decode sound '" +
-					id +
-					"', since audio file may not supported by 2.b."
-				);
-				return;
-			}
-			this.buffer.set(id, buffer);
-		}
-
-		/**
-		 * 播放一个音效
-		 * @param id 音效名称
-		 * @param position 音频位置，[0, 0, 0]表示正中心，x轴指向水平向右，y轴指向水平向上，z轴指向竖直向上
-		 * @param orientation 音频朝向，[0, 1, 0]表示朝向前方
-		 */
-		play(id, position = [0, 0, 0], orientation = [1, 0, 0]) {
-			if (!this.enabled) return -1;
-			const buffer = this.buffer.get(id);
-			if (!buffer) {
-				console.warn(
-					"Cannot play sound '" +
-					id +
-					"', since there is no added data named it."
-				);
-				return -1;
-			}
-			const soundNum = this.num++;
-
-			const source = this.player.createBufferSource();
-			source.setBuffer(buffer);
-			const route = this.player.createRoute(source);
-			const stereo = this.player.createStereoEffect();
-			stereo.setPosition(position[0], position[1], position[2]);
-			stereo.setOrientation(orientation[0], orientation[1], orientation[2]);
-			route.addEffect([stereo, this.gain]);
-			this.player.addRoute(`sounds.${soundNum}`, route);
-			route.play();
-			source.output.addEventListener("ended", () => {
-				this.playing.delete(soundNum);
-			});
-			this.playing.add(soundNum);
-			return soundNum;
-		}
-
-		/**
-		 * 停止一个音效
-		 * @param num 音效的唯一 id
-		 */
-		stop(num) {
-			const id = `sounds.${num}`;
-			const route = this.player.getRoute(id);
-			if (route) {
-				route.stop();
-				this.player.removeRoute(id);
-				this.playing.delete(num);
-			}
-		}
-
-		/**
-		 * 停止播放所有音效
-		 */
-		stopAllSounds() {
-			this.playing.forEach((v) => {
-				const id = `sounds.${v}`;
-				const route = this.player.getRoute(id);
-				if (route) {
-					route.stop();
-					this.player.removeRoute(id);
-				}
-			});
-			this.playing.clear();
-		}
-	}
-	const soundPlayer = new SoundPlayer(audioPlayer);
-
-	function loadAllBgm() {
-		const data = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
-		for (const bgm of data.main.bgms) {
-			bgmController.addBgm(bgm);
-		}
-	}
-	loadAllBgm();
-	AudioDecoder.registerDecoder(AudioType.Ogg, VorbisDecoder);
-	AudioDecoder.registerDecoder(AudioType.Opus, OpusDecoder);
-
-	core.plugin.audioSystem = {
-		AudioType,
-		AudioDecoder,
-		AudioStatus,
-		checkAudioType,
-		isAudioSupport,
-		audioPlayer,
-		soundPlayer,
-		bgmController,
-		guessTypeByExt,
-		BgmController,
-		SoundPlayer,
-		EchoEffect,
-		DelayEffect,
-		ChannelVolumeEffect,
-		VolumeEffect,
-		StereoEffect,
-		AudioEffect,
-		AudioPlayer,
-		AudioRoute,
-		AudioStreamSource,
-		AudioElementSource,
-		AudioBufferSource,
-		loadAllBgm,
-		StreamLoader,
-	};
-	//bgm相关复写
-	control.prototype.playBgm = (bgm, when) => {
-		bgmController.play(bgm, when);
-		core.setMusicBtn();
-	};
-	control.prototype.pauseBgm = () => {
-		bgmController.pause();
-		core.setMusicBtn();
-	};
-
-	control.prototype.resumeBgm = function () {
-		bgmController.resume();
-		core.setMusicBtn();
-	};
-	control.prototype.checkBgm = function () {
-		if (bgmController.playing) return;
-		if (core.musicStatus.bgmStatus) {
-			if (bgmController.playingBgm) {
-				bgmController.play(bgmController.playingBgm);
-			} else {
-				play(main.startBgm, 0);
-			}
-		} else {
-			pause();
-		}
-	};
-	control.prototype.triggerBgm = function () {
-		core.musicStatus.bgmStatus = !core.musicStatus.bgmStatus;
-		if (bgmController.playing) bgmController.pause();
-		else bgmController.resume();
-		core.setMusicBtn();
-		core.setLocalStorage("bgmStatus", core.musicStatus.bgmStatus);
-	};
-	//sound相关复写
-	control.prototype.playSound = function (
-		sound,
-		_pitch,
-		callback,
-		position,
-		orientation
-	) {
-		if (main.mode != "play" || !core.musicStatus.soundStatus) return;
-		const name = core.getMappedName(sound);
-		const num = soundPlayer.play(name, position, orientation);
-		const route = audioPlayer.getRoute(`sounds.${num}`);
-		if (!route) {
-			callback?.();
-			return -1;
-		} else {
-			sleep(route.duration).then(() => callback?.());
-			return num;
-		}
-	};
-	control.prototype.stopSound = function (id) {
-		if (isNil(id)) {
-			soundPlayer.stopAllSounds();
-		} else {
-			soundPlayer.stop(id);
-		}
-	};
-	control.prototype.getPlayingSounds = function () {
-		return [...soundPlayer.playing];
-	};
-	//sound加载复写
-	loader.prototype._loadOneSound_decodeData = function (name, data) {
-		if (data instanceof Blob) {
-			var blobReader = new zip.BlobReader(data);
-			blobReader.init(function () {
-				blobReader.readUint8Array(0, blobReader.size, function (uint8) {
-					//core.loader._loadOneSound_decodeData(name, uint8.buffer);
-					soundPlayer.add(name, uint8);
-				});
-			});
-			return;
-		}
-		if (data instanceof ArrayBuffer) {
-			const uint8 = new Uint8Array(data);
-			soundPlayer.add(name, uint8);
-		}
-	};
-	//音量控制复写
-	soundPlayer.setVolume(
-		core.musicStatus.userVolume * core.musicStatus.designVolume
-	);
-	bgmController.setVolume(
-		core.musicStatus.userVolume * core.musicStatus.designVolume
-	);
-	actions.prototype._clickSwitchs_sounds_userVolume = function (delta) {
-		var value = Math.round(Math.sqrt(100 * core.musicStatus.userVolume));
-		if (value == 0 && delta < 0) return;
-		core.musicStatus.userVolume = core.clamp(
-			Math.pow(value + delta, 2) / 100,
-			0,
-			1
-		);
-		//audioContext 音效 不受designVolume 影响
-		if (core.musicStatus.gainNode != null)
-			core.musicStatus.gainNode.gain.value = core.musicStatus.userVolume;
-		soundPlayer.setVolume(
-			core.musicStatus.userVolume * core.musicStatus.designVolume
-		);
-		bgmController.setVolume(
-			core.musicStatus.userVolume * core.musicStatus.designVolume
-		);
-		core.setLocalStorage("userVolume", core.musicStatus.userVolume);
-		core.playSound("确定");
-		core.ui._drawSwitchs_sounds();
-	};
-},
-    "怪物碎裂特效": function () {
+    // 将__enable置为false将关闭插件
+    let __enable = true;
+    if (!__enable || main.mode === "editor") return;
+    const { OggOpusDecoderWebWorker } = window["ogg-opus-decoder"];
+    const { OggVorbisDecoderWebWorker } = window["ogg-vorbis-decoder"];
+    const { CodecParser } = window.CodecParser;
+    const { Transition, linear } = core.plugin.animate;
+
+    const audio = new Audio();
+    const AudioStatus = {
+      Playing: 0,
+      Pausing: 1,
+      Paused: 2,
+      Stoping: 3,
+      Stoped: 4,
+    };
+    const supportMap = new Map();
+    const AudioType = {
+      Mp3: "audio/mpeg",
+      Wav: 'audio/wav; codecs="1"',
+      Flac: "audio/flac",
+      Opus: 'audio/ogg; codecs="opus"',
+      Ogg: 'audio/ogg; codecs="vorbis"',
+      Aac: "audio/aac",
+    };
+    /**
+     * 检查一种音频类型是否能被播放
+     * @param type 音频类型 AudioType
+     */
+    function isAudioSupport(type) {
+      if (supportMap.has(type)) return supportMap.get(type);
+      else {
+        const support = audio.canPlayType(type);
+        const canPlay = support === "maybe" || support === "probably";
+        supportMap.set(type, canPlay);
+        return canPlay;
+      }
+    }
+
+    const typeMap = new Map([
+      ["ogg", AudioType.Ogg],
+      ["mp3", AudioType.Mp3],
+      ["wav", AudioType.Wav],
+      ["flac", AudioType.Flac],
+      ["opus", AudioType.Opus],
+      ["aac", AudioType.Aac],
+    ]);
+
+    /**
+     * 根据文件名拓展猜测其类型
+     * @param file 文件名 string
+     */
+    function guessTypeByExt(file) {
+      const ext = /\.[a-zA-Z\d]+$/.exec(file);
+      if (!ext?.[0]) return "";
+      const type = ext[0].slice(1);
+      return typeMap.get(type.toLocaleLowerCase()) ?? "";
+    }
+
+    isAudioSupport(AudioType.Ogg);
+    isAudioSupport(AudioType.Mp3);
+    isAudioSupport(AudioType.Wav);
+    isAudioSupport(AudioType.Flac);
+    isAudioSupport(AudioType.Opus);
+    isAudioSupport(AudioType.Aac);
+
+    function isNil(value) {
+      return value === void 0 || value === null;
+    }
+
+    function sleep(time) {
+      return new Promise((res) => setTimeout(res, time));
+    }
+    class AudioEffect {
+      constructor(ac) {}
+      /**
+       * 连接至其他效果器
+       * @param target 目标输入 IAudioInput
+       * @param output 当前效果器输出通道 Number
+       * @param input 目标效果器的输入通道 Number
+       */
+      connect(target, output, input) {
+        this.output.connect(target.input, output, input);
+      }
+
+      /**
+       * 与其他效果器取消连接
+       * @param target 目标输入 IAudioInput
+       * @param output 当前效果器输出通道 Number
+       * @param input 目标效果器的输入通道 Number
+       */
+      disconnect(target, output, input) {
+        if (!target) {
+          if (!isNil(output)) {
+            this.output.disconnect(output);
+          } else {
+            this.output.disconnect();
+          }
+        } else {
+          if (!isNil(output)) {
+            if (!isNil(input)) {
+              this.output.disconnect(target.input, output, input);
+            } else {
+              this.output.disconnect(target.input, output);
+            }
+          } else {
+            this.output.disconnect(target.input);
+          }
+        }
+      }
+    }
+
+    class StereoEffect extends AudioEffect {
+      constructor(ac) {
+        super(ac);
+        const panner = ac.createPanner();
+        this.input = panner;
+        this.output = panner;
+      }
+
+      /**
+       * 设置音频朝向，x正方形水平向右，y正方形垂直于地面向上，z正方向垂直屏幕远离用户
+       * @param x 朝向x坐标 Number
+       * @param y 朝向y坐标 Number
+       * @param z 朝向z坐标 Number
+       */
+      setOrientation(x, y, z) {
+        this.output.orientationX.value = x;
+        this.output.orientationY.value = y;
+        this.output.orientationZ.value = z;
+      }
+      /**
+       * 设置音频位置，x正方形水平向右，y正方形垂直于地面向上，z正方向垂直屏幕远离用户
+       * @param x 位置x坐标 Number
+       * @param y 位置y坐标 Number
+       * @param z 位置z坐标 Number
+       */
+      setPosition(x, y, z) {
+        this.output.positionX.value = x;
+        this.output.positionY.value = y;
+        this.output.positionZ.value = z;
+      }
+      end() {}
+
+      start() {}
+    }
+    class VolumeEffect extends AudioEffect {
+      constructor(ac) {
+        super(ac);
+        const gain = ac.createGain();
+        this.input = gain;
+        this.output = gain;
+      }
+
+      /**
+       * 设置音量大小
+       * @param volume 音量大小 Number
+       */
+      setVolume(volume) {
+        this.output.gain.value = volume;
+      }
+
+      /**
+       * 获取音量大小 Number
+       */
+      getVolume() {
+        return this.output.gain.value;
+      }
+
+      end() {}
+
+      start() {}
+    }
+    class ChannelVolumeEffect extends AudioEffect {
+      /** 所有的音量控制节点 */
+
+      constructor(ac) {
+        super(ac);
+        /** 所有的音量控制节点 */
+        this.gain = [];
+        const splitter = ac.createChannelSplitter();
+        const merger = ac.createChannelMerger();
+        this.output = merger;
+        this.input = splitter;
+        for (let i = 0; i < 6; i++) {
+          const gain = ac.createGain();
+          splitter.connect(gain, i);
+          gain.connect(merger, 0, i);
+          this.gain.push(gain);
+        }
+      }
+
+      /**
+       * 设置某个声道的音量大小
+       * @param channel 要设置的声道，可填0-5 Number
+       * @param volume 这个声道的音量大小 Number
+       */
+      setVolume(channel, volume) {
+        if (!this.gain[channel]) return;
+        this.gain[channel].gain.value = volume;
+      }
+
+      /**
+       * 获取某个声道的音量大小，可填0-5
+       * @param channel 要获取的声道 Number
+       */
+      getVolume(channel) {
+        if (!this.gain[channel]) return 0;
+        return this.gain[channel].gain.value;
+      }
+
+      end() {}
+
+      start() {}
+    }
+    class DelayEffect extends AudioEffect {
+      constructor(ac) {
+        super(ac);
+
+        const delay = ac.createDelay();
+        this.input = delay;
+        this.output = delay;
+      }
+
+      /**
+       * 设置延迟时长
+       * @param delay 延迟时长，单位秒 Number
+       */
+      setDelay(delay) {
+        this.output.delayTime.value = delay;
+      }
+
+      /**
+       * 获取延迟时长
+       */
+      getDelay() {
+        return this.output.delayTime.value;
+      }
+
+      end() {}
+
+      start() {}
+    }
+    class EchoEffect extends AudioEffect {
+      constructor(ac) {
+        super(ac);
+        /** 当前增益 */
+        this.gain = 0.5;
+        /** 是否正在播放 */
+        this.playing = false;
+        const delay = ac.createDelay();
+        const gain = ac.createGain();
+        gain.gain.value = 0.5;
+        delay.delayTime.value = 0.05;
+        delay.connect(gain);
+        gain.connect(delay);
+        /** 延迟节点 */
+        this.delay = delay;
+        /** 反馈增益节点 */
+        this.gainNode = gain;
+
+        this.input = gain;
+        this.output = gain;
+      }
+
+      /**
+       * 设置回声反馈增益大小
+       * @param gain 增益大小，范围 0-1，大于等于1的视为0.5，小于0的视为0 Number
+       */
+      setFeedbackGain(gain) {
+        const resolved = gain >= 1 ? 0.5 : gain < 0 ? 0 : gain;
+        this.gain = resolved;
+        if (this.playing) this.gainNode.gain.value = resolved;
+      }
+
+      /**
+       * 设置回声间隔时长
+       * @param delay 回声时长，范围 0.01-Infinity，小于0.01的视为0.01 Number
+       */
+      setEchoDelay(delay) {
+        const resolved = delay < 0.01 ? 0.01 : delay;
+        this.delay.delayTime.value = resolved;
+      }
+
+      /**
+       * 获取反馈节点增益
+       */
+      getFeedbackGain() {
+        return this.gain;
+      }
+
+      /**
+       * 获取回声间隔时长
+       */
+      getEchoDelay() {
+        return this.delay.delayTime.value;
+      }
+
+      end() {
+        this.playing = false;
+        const echoTime = Math.ceil(Math.log(0.001) / Math.log(this.gain)) + 10;
+        sleep(this.delay.delayTime.value * echoTime).then(() => {
+          if (!this.playing) this.gainNode.gain.value = 0;
+        });
+      }
+
+      start() {
+        this.playing = true;
+        this.gainNode.gain.value = this.gain;
+      }
+    }
+
+    class StreamLoader {
+      constructor(url) {
+        /** 传输目标  Set<IStreamReader>*/
+        this.target = new Set();
+        this.loading = false;
+      }
+
+      /**
+       * 将加载流传递给字节流读取对象
+       * @param reader 字节流读取对象 IStreamReader
+       */
+      pipe(reader) {
+        if (this.loading) {
+          console.warn(
+            "Cannot pipe new StreamReader object when stream is loading."
+          );
+          return;
+        }
+        this.target.add(reader);
+        reader.piped(this);
+        return this;
+      }
+
+      async start() {
+        if (this.loading) return;
+        this.loading = true;
+        const response = await window.fetch(this.url);
+        const stream = response.body;
+        if (!stream) {
+          console.error("Cannot get reader when fetching '" + this.url + "'.");
+          return;
+        }
+        // 获取读取器
+        /** 读取流对象 */
+        this.stream = stream;
+        const reader = response.body?.getReader();
+        const targets = [...this.target];
+
+        await Promise.all(targets.map((v) => v.start(stream, this, response)));
+        if (reader && reader.read) {
+          // 开始流传输
+          while (true) {
+            const { value, done } = await reader.read();
+            await Promise.all(
+              targets.map((v) => v.pump(value, done, response))
+            );
+            if (done) break;
+          }
+        } else {
+          // 如果不支持流传输
+          const buffer = await response.arrayBuffer();
+          const data = new Uint8Array(buffer);
+          await Promise.all(targets.map((v) => v.pump(data, true, response)));
+        }
+        // 开始流传输
+        while (true) {
+          const { value, done } = await reader.read();
+          await Promise.all(targets.map((v) => v.pump(value, done, response)));
+          if (done) break;
+        }
+
+        this.loading = false;
+        targets.forEach((v) => v.end(true));
+
+        //
+      }
+
+      cancel(reason) {
+        if (!this.stream) return;
+        this.stream.cancel(reason);
+        this.loading = false;
+        this.target.forEach((v) => v.end(false, reason));
+      }
+    }
+    const fileSignatures = [
+      [AudioType.Mp3, [0x49, 0x44, 0x33]],
+      [AudioType.Ogg, [0x4f, 0x67, 0x67, 0x53]],
+      [AudioType.Wav, [0x52, 0x49, 0x46, 0x46]],
+      [AudioType.Flac, [0x66, 0x4c, 0x61, 0x43]],
+      [AudioType.Aac, [0xff, 0xf1]],
+      [AudioType.Aac, [0xff, 0xf9]],
+    ];
+    const oggHeaders = [
+      [AudioType.Opus, [0x4f, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64]],
+    ];
+
+    function checkAudioType(data) {
+      let audioType = "";
+      // 检查头文件获取音频类型，仅检查前256个字节
+      const toCheck = data.slice(0, 256);
+      for (const [type, value] of fileSignatures) {
+        if (value.every((v, i) => toCheck[i] === v)) {
+          audioType = type;
+          break;
+        }
+      }
+      if (audioType === AudioType.Ogg) {
+        // 如果是ogg的话，进一步判断是不是opus
+        for (const [key, value] of oggHeaders) {
+          const has = toCheck.some((_, i) => {
+            return value.every((v, ii) => toCheck[i + ii] === v);
+          });
+          if (has) {
+            audioType = key;
+            break;
+          }
+        }
+      }
+
+      return audioType;
+    }
+    class AudioDecoder {
+      /**
+       * 注册一个解码器
+       * @param type 要注册的解码器允许解码的类型
+       * @param decoder 解码器对象
+       */
+      static registerDecoder(type, decoder) {
+        if (!this.decoderMap) this.decoderMap = new Map();
+        if (this.decoderMap.has(type)) {
+          console.warn(
+            "Audio stream decoder for audio type '" +
+              type +
+              "' has already existed."
+          );
+          return;
+        }
+
+        this.decoderMap.set(type, decoder);
+      }
+
+      /**
+       * 解码音频数据
+       * @param data 音频文件数据
+       * @param player AudioPlayer实例
+       */
+      static async decodeAudioData(data, player) {
+        // 检查头文件获取音频类型，仅检查前256个字节
+        const toCheck = data.slice(0, 256);
+        const type = checkAudioType(data);
+        if (type === "") {
+          console.error(
+            "Unknown audio type. Header: '" +
+              [...toCheck]
+                .map((v) => v.toString().padStart(2, "0"))
+                .join(" ")
+                .toUpperCase() +
+              "'"
+          );
+          return null;
+        }
+        if (isAudioSupport(type)) {
+          if (data.buffer instanceof ArrayBuffer) {
+            return player.ac.decodeAudioData(data.buffer);
+          } else {
+            return null;
+          }
+        } else {
+          const Decoder = this.decoderMap.get(type);
+          if (!Decoder) {
+            return null;
+          } else {
+            const decoder = new Decoder();
+            await decoder.create();
+            const decodedData = await decoder.decode(data);
+            if (!decodedData) return null;
+            const buffer = player.ac.createBuffer(
+              decodedData.channelData.length,
+              decodedData.channelData[0].length,
+              decodedData.sampleRate
+            );
+            decodedData.channelData.forEach((v, i) => {
+              buffer.copyToChannel(v, i);
+            });
+            decoder.destroy();
+            return buffer;
+          }
+        }
+      }
+    }
+
+    class VorbisDecoder {
+      /**
+       * 创建音频解码器
+       */
+      async create() {
+        this.decoder = new OggVorbisDecoderWebWorker();
+        await this.decoder.ready;
+      }
+      /**
+       * 摧毁这个解码器
+       */
+      destroy() {
+        this.decoder?.free();
+      }
+      /**
+       * 解码流数据
+       * @param data 流数据
+       */
+
+      async decode(data) {
+        return this.decoder?.decode(data);
+      }
+      /**
+       * 解码整个文件
+       * @param data 文件数据
+       */
+      async decodeAll(data) {
+        return this.decoder?.decodeFile(data);
+      }
+      /**
+       * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
+       */
+      async flush() {
+        return this.decoder?.flush();
+      }
+    }
+
+    class OpusDecoder {
+      /**
+       * 创建音频解码器
+       */
+      async create() {
+        this.decoder = new OggOpusDecoderWebWorker();
+        await this.decoder.ready;
+      }
+      /**
+       * 摧毁这个解码器
+       */
+      destroy() {
+        this.decoder?.free();
+      }
+      /**
+       * 解码流数据
+       * @param data 流数据
+       */
+      async decode(data) {
+        return this.decoder?.decode(data);
+      }
+      /**
+       * 解码整个文件
+       * @param data 文件数据
+       */
+      async decodeAll(data) {
+        return this.decoder?.decodeFile(data);
+      }
+      /**
+       * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
+       */
+      async flush() {
+        return await this.decoder?.flush();
+      }
+    }
+    const mimeTypeMap = {
+      [AudioType.Aac]: "audio/aac",
+      [AudioType.Flac]: "audio/flac",
+      [AudioType.Mp3]: "audio/mpeg",
+      [AudioType.Ogg]: "application/ogg",
+      [AudioType.Opus]: "application/ogg",
+      [AudioType.Wav]: "application/ogg",
+    };
+
+    function isOggPage(data) {
+      return !isNil(data.isFirstPage);
+    }
+    class AudioStreamSource {
+      constructor(context) {
+        this.output = context.createBufferSource();
+        /** 是否已经完全加载完毕 */
+        this.loaded = false;
+        /** 是否正在播放 */
+        this.playing = false;
+        /** 已经缓冲了多长时间，如果缓冲完那么跟歌曲时长一致 */
+        this.buffered = 0;
+        /** 已经缓冲的采样点数量 */
+        this.bufferedSamples = 0;
+        /** 歌曲时长，加载完毕之前保持为 0 */
+        this.duration = 0;
+        /** 在流传输阶段，至少缓冲多长时间的音频之后才开始播放，单位秒 */
+        this.bufferPlayDuration = 1;
+        /** 音频的采样率，未成功解析出之前保持为 0 */
+        this.sampleRate = 0;
+        //是否循环播放
+        this.loop = false;
+        /** 上一次播放是从何时开始的 */
+        this.lastStartWhen = 0;
+        /** 开始播放时刻 */
+        this.lastStartTime = 0;
+        /** 上一次播放的缓存长度 */
+        this.lastBufferSamples = 0;
+
+        /** 是否已经获取到头文件 */
+        this.headerRecieved = false;
+        /** 音频类型 */
+        this.audioType = "";
+        /** 每多长时间组成一个缓存 Float32Array */
+        this.bufferChunkSize = 10;
+        /** 缓存音频数据，每 bufferChunkSize 秒钟组成一个 Float32Array，用于流式解码 */
+        this.audioData = [];
+
+        this.errored = false;
+        this.ac = context;
+      }
+      /** 当前已经播放了多长时间 */
+      get currentTime() {
+        return this.ac.currentTime - this.lastStartTime + this.lastStartWhen;
+      }
+      /**
+       * 设置每个缓存数据的大小，默认为10秒钟一个缓存数据
+       * @param size 每个缓存数据的时长，单位秒
+       */
+      setChunkSize(size) {
+        if (this.controller?.loading || this.loaded) return;
+        this.bufferChunkSize = size;
+      }
+      on(event, fn, context) {}
+      piped(controller) {
+        this.controller = controller;
+      }
+
+      async pump(data, done) {
+        if (!data || this.errored) return;
+        if (!this.headerRecieved) {
+          // 检查头文件获取音频类型，仅检查前256个字节
+          const toCheck = data.slice(0, 256);
+          this.audioType = checkAudioType(data);
+          if (!this.audioType) {
+            console.error(
+              "Unknown audio type. Header: '" +
+                [...toCheck]
+                  .map((v) => v.toString(16).padStart(2, "0"))
+                  .join(" ")
+                  .toUpperCase() +
+                "'"
+            );
+            return;
+          }
+          // 创建解码器
+          const Decoder = AudioDecoder.decoderMap.get(this.audioType);
+          if (!Decoder) {
+            this.errored = true;
+            console.error(
+              "Cannot decode stream source type of '" +
+                this.audioType +
+                "', since there is no registered decoder for that type."
+            );
+            return Promise.reject(
+              `Cannot decode stream source type of '${this.audioType}', since there is no registered decoder for that type.`
+            );
+          }
+          this.decoder = new Decoder();
+          // 创建数据解析器
+          const mime = mimeTypeMap[this.audioType];
+          const parser = new CodecParser(mime);
+          this.parser = parser;
+          await this.decoder.create();
+          this.headerRecieved = true;
+        }
+
+        const decoder = this.decoder;
+        const parser = this.parser;
+        if (!decoder || !parser) {
+          this.errored = true;
+          return Promise.reject(
+            "No parser or decoder attached in this AudioStreamSource"
+          );
+        }
+
+        await this.decodeData(data, decoder, parser);
+        if (done) await this.decodeFlushData(decoder, parser);
+        this.checkBufferedPlay();
+      }
+
+      /**
+       * 检查采样率，如果还未解析出采样率，那么将设置采样率，如果当前采样率与之前不同，那么发出警告
+       */
+      checkSampleRate(info) {
+        for (const one of info) {
+          const frame = isOggPage(one) ? one.codecFrames[0] : one;
+          if (frame) {
+            const rate = frame.header.sampleRate;
+            if (this.sampleRate === 0) {
+              this.sampleRate = rate;
+              break;
+            } else {
+              if (rate !== this.sampleRate) {
+                console.warn("Sample rate in stream audio must be constant.");
+              }
+            }
+          }
+        }
+      }
+
+      /**
+       * 解析音频数据
+       */
+      async decodeData(data, decoder, parser) {
+        // 解析音频数据
+        const audioData = await decoder.decode(data);
+        if (!audioData) return;
+        // @ts-expect-error 库类型声明错误
+        const audioInfo = [...parser.parseChunk(data)];
+
+        // 检查采样率
+        this.checkSampleRate(audioInfo);
+        // 追加音频数据
+        this.appendDecodedData(audioData, audioInfo);
+      }
+
+      /**
+       * 解码剩余数据
+       */
+      async decodeFlushData(decoder, parser) {
+        const audioData = await decoder.flush();
+        if (!audioData) return;
+        // @ts-expect-error 库类型声明错误
+        const audioInfo = [...parser.flush()];
+
+        this.checkSampleRate(audioInfo);
+        this.appendDecodedData(audioData, audioInfo);
+      }
+
+      /**
+       * 追加音频数据
+       */
+      appendDecodedData(data, info) {
+        const channels = data.channelData.length;
+        if (channels === 0) return;
+        if (this.audioData.length !== channels) {
+          this.audioData = [];
+          for (let i = 0; i < channels; i++) {
+            this.audioData.push([]);
+          }
+        }
+        // 计算出应该放在哪
+        const chunk = this.sampleRate * this.bufferChunkSize;
+        const sampled = this.bufferedSamples;
+        const pushIndex = Math.floor(sampled / chunk);
+        const bufferIndex = sampled % chunk;
+        const dataLength = data.channelData[0].length;
+        let buffered = 0;
+        let nowIndex = pushIndex;
+        let toBuffer = bufferIndex;
+        while (buffered < dataLength) {
+          const rest = toBuffer !== 0 ? chunk - bufferIndex : chunk;
+
+          for (let i = 0; i < channels; i++) {
+            const audioData = this.audioData[i];
+            if (!audioData[nowIndex]) {
+              audioData.push(new Float32Array(chunk));
+            }
+            const toPush = data.channelData[i].slice(buffered, buffered + rest);
+
+            audioData[nowIndex].set(toPush, toBuffer);
+          }
+          buffered += rest;
+          nowIndex++;
+          toBuffer = 0;
+        }
+
+        this.buffered +=
+          info.reduce((prev, curr) => prev + curr.duration, 0) / 1000;
+        this.bufferedSamples += info.reduce(
+          (prev, curr) => prev + curr.samples,
+          0
+        );
+      }
+
+      /**
+       * 检查已缓冲内容，并在未开始播放时播放
+       */
+      checkBufferedPlay() {
+        if (this.playing || this.sampleRate === 0) return;
+        const played = this.lastBufferSamples / this.sampleRate;
+        const dt = this.buffered - played;
+        if (this.loaded) {
+          this.playAudio(played);
+          return;
+        }
+        if (dt < this.bufferPlayDuration) return;
+
+        this.lastBufferSamples = this.bufferedSamples;
+        // 需要播放
+        this.mergeBuffers();
+        if (!this.buffer) return;
+        if (this.playing) this.output.stop();
+        this.createSourceNode(this.buffer);
+        this.output.loop = false;
+        this.output.start(0, played);
+        this.lastStartTime = this.ac.currentTime;
+        this.playing = true;
+        this.output.addEventListener("ended", () => {
+          this.playing = false;
+          this.checkBufferedPlay();
+        });
+      }
+
+      mergeBuffers() {
+        const buffer = this.ac.createBuffer(
+          this.audioData.length,
+          this.bufferedSamples,
+          this.sampleRate
+        );
+        const chunk = this.sampleRate * this.bufferChunkSize;
+        const bufferedChunks = Math.floor(this.bufferedSamples / chunk);
+        const restLength = this.bufferedSamples % chunk;
+        for (let i = 0; i < this.audioData.length; i++) {
+          const audio = this.audioData[i];
+          const data = new Float32Array(this.bufferedSamples);
+          for (let j = 0; j < bufferedChunks; j++) {
+            data.set(audio[j], chunk * j);
+          }
+          if (restLength !== 0) {
+            data.set(
+              audio[bufferedChunks].slice(0, restLength),
+              chunk * bufferedChunks
+            );
+          }
+
+          buffer.copyToChannel(data, i, 0);
+        }
+        this.buffer = buffer;
+      }
+
+      async start() {
+        delete this.buffer;
+        this.headerRecieved = false;
+        this.audioType = "";
+        this.errored = false;
+        this.buffered = 0;
+        this.sampleRate = 0;
+        this.bufferedSamples = 0;
+        this.duration = 0;
+        this.loaded = false;
+        if (this.playing) this.output.stop();
+        this.playing = false;
+        this.lastStartTime = this.ac.currentTime;
+      }
+
+      end(done, reason) {
+        if (done && this.buffer) {
+          this.loaded = true;
+          delete this.controller;
+          this.mergeBuffers();
+
+          this.duration = this.buffered;
+          this.audioData = [];
+          this.decoder?.destroy();
+          delete this.decoder;
+          delete this.parser;
+        } else {
+          console.warn(
+            "Unexpected end when loading stream audio, reason: '" +
+              (reason ?? "") +
+              "'"
+          );
+        }
+      }
+
+      playAudio(when) {
+        if (!this.buffer) return;
+        this.lastStartTime = this.ac.currentTime;
+        if (this.playing) this.output.stop();
+        if (this.player.status !== AudioStatus.Playing) {
+          this.player.status = AudioStatus.Playing;
+        }
+        this.createSourceNode(this.buffer);
+        this.output.start(0, when);
+        this.playing = true;
+
+        this.output.addEventListener("ended", () => {
+          this.playing = false;
+          if (this.player.status === AudioStatus.Playing) {
+            this.player.status = AudioStatus.Stoped;
+          }
+          if (this.loop && !this.output.loop) this.play(0);
+        });
+      }
+      /**
+       * 开始播放这个音频源
+       */
+      play(when) {
+        if (this.playing || this.errored) return;
+        if (this.loaded && this.buffer) {
+          this.playing = true;
+          this.playAudio(when);
+        } else {
+          this.controller?.start();
+        }
+      }
+
+      createSourceNode(buffer) {
+        if (!this.target) return;
+        const node = this.ac.createBufferSource();
+        node.buffer = buffer;
+        if (this.playing) this.output.stop();
+        this.playing = false;
+        this.output = node;
+        node.connect(this.target.input);
+        node.loop = this.loop;
+      }
+      /**
+       * 停止播放这个音频源
+       * @returns 音频暂停的时刻 number
+       */
+      stop() {
+        if (this.playing) this.output.stop();
+        this.playing = false;
+        return this.ac.currentTime - this.lastStartTime;
+      }
+      /**
+       * 连接到音频路由图上，每次调用播放的时候都会执行一次
+       * @param target 连接至的目标 IAudioInput
+       */
+      connect(target) {
+        this.target = target;
+      }
+      /**
+       * 设置是否循环播放
+       * @param loop 是否循环 boolean)
+       */
+      setLoop(loop) {
+        this.loop = loop;
+      }
+    }
+    class AudioElementSource {
+      constructor(context) {
+        const audio = new Audio();
+        audio.preload = "none";
+        this.output = context.createMediaElementSource(audio);
+        this.audio = audio;
+        this.ac = context;
+        audio.addEventListener("play", () => {
+          this.playing = true;
+          if (this.player.status !== AudioStatus.Playing) {
+            this.player.status = AudioStatus.Playing;
+          }
+        });
+        audio.addEventListener("ended", () => {
+          this.playing = false;
+          if (this.player.status === AudioStatus.Playing) {
+            this.player.status = AudioStatus.Stoped;
+          }
+        });
+      }
+      get duration() {
+        return this.audio.duration;
+      }
+      get currentTime() {
+        return this.audio.currentTime;
+      }
+      /**
+       * 设置音频源的路径
+       * @param url 音频路径
+       */
+      setSource(url) {
+        this.audio.src = url;
+      }
+
+      play(when = 0) {
+        if (this.playing) return;
+        this.audio.currentTime = when;
+        this.audio.play();
+      }
+
+      stop() {
+        this.audio.pause();
+        this.playing = false;
+        if (this.player.status === AudioStatus.Playing) {
+          this.player.status = AudioStatus.Stoped;
+        }
+        return this.audio.currentTime;
+      }
+
+      connect(target) {
+        this.output.connect(target.input);
+      }
+
+      setLoop(loop) {
+        this.audio.loop = loop;
+      }
+    }
+    class AudioBufferSource {
+      constructor(context) {
+        this.output = context.createBufferSource();
+        /** 是否循环 */
+        this.loop = false;
+        /** 上一次播放是从何时开始的 */
+        this.lastStartWhen = 0;
+        /** 播放开始时刻 */
+        this.lastStartTime = 0;
+        this.duration = 0;
+        this.ac = context;
+      }
+      get currentTime() {
+        return this.ac.currentTime - this.lastStartTime + this.lastStartWhen;
+      }
+
+      /**
+       * 设置音频源数据
+       * @param buffer 音频源，可以是未解析的 ArrayBuffer，也可以是已解析的 AudioBuffer
+       */
+      async setBuffer(buffer) {
+        if (buffer instanceof ArrayBuffer) {
+          this.buffer = await this.ac.decodeAudioData(buffer);
+        } else {
+          this.buffer = buffer;
+        }
+        this.duration = this.buffer.duration;
+      }
+
+      play(when) {
+        if (this.playing || !this.buffer) return;
+        this.playing = true;
+        this.lastStartTime = this.ac.currentTime;
+        if (this.player.status !== AudioStatus.Playing) {
+          this.player.status = AudioStatus.Playing;
+        }
+        this.createSourceNode(this.buffer);
+        this.output.start(0, when);
+        this.output.addEventListener("ended", () => {
+          this.playing = false;
+          if (this.player.status === AudioStatus.Playing) {
+            this.player.status = AudioStatus.Stoped;
+          }
+          if (this.loop && !this.output.loop) this.play(0);
+        });
+      }
+
+      createSourceNode(buffer) {
+        if (!this.target) return;
+        const node = this.ac.createBufferSource();
+        node.buffer = buffer;
+        this.output = node;
+        node.connect(this.target.input);
+        node.loop = this.loop;
+      }
+
+      stop() {
+        this.output.stop();
+        return this.ac.currentTime - this.lastStartTime;
+      }
+
+      connect(target) {
+        this.target = target;
+      }
+
+      setLoop(loop) {
+        this.loop = loop;
+      }
+    }
+    class AudioPlayer {
+      constructor() {
+        /** 音频播放上下文 */
+        this.ac = new AudioContext();
+        /** 音量节点 */
+        this.gain = this.ac.createGain();
+        this.gain.connect(this.ac.destination);
+        this.audioRoutes = new Map();
+      }
+      /**
+       * 解码音频数据
+       * @param data 音频数据
+       */
+      decodeAudioData(data) {
+        return AudioDecoder.decodeAudioData(data, this);
+      }
+      /**
+       * 设置音量
+       * @param volume 音量
+       */
+      setVolume(volume) {
+        this.gain.gain.value = volume;
+      }
+
+      /**
+       * 获取音量
+       */
+      getVolume() {
+        return this.gain.gain.value;
+      }
+
+      /**
+       * 创建一个音频源
+       * @param Source 音频源类
+       */
+      createSource(Source) {
+        return new Source(this.ac);
+      }
+
+      /**
+       * 创建一个兼容流式音频源，可以与流式加载相结合，主要用于处理 opus ogg 不兼容的情况
+       */
+      createStreamSource() {
+        return new AudioStreamSource(this.ac);
+      }
+
+      /**
+       * 创建一个通过 audio 元素播放的音频源
+       */
+      createElementSource() {
+        return new AudioElementSource(this.ac);
+      }
+
+      /**
+       * 创建一个通过 AudioBuffer 播放的音频源
+       */
+      createBufferSource() {
+        return new AudioBufferSource(this.ac);
+      }
+
+      /**
+       * 获取音频目的地
+       */
+      getDestination() {
+        return this.gain;
+      }
+
+      /**
+       * 创建一个音频效果器
+       * @param Effect 效果器类
+       */
+      createEffect(Effect) {
+        return new Effect(this.ac);
+      }
+
+      /**
+       * 创建一个修改音量的效果器
+       * ```txt
+       *             |----------|
+       * Input ----> | GainNode | ----> Output
+       *             |----------|
+       * ```
+       */
+      createVolumeEffect() {
+        return new VolumeEffect(this.ac);
+      }
+
+      /**
+       * 创建一个立体声效果器
+       * ```txt
+       *             |------------|
+       * Input ----> | PannerNode | ----> Output
+       *             |------------|
+       * ```
+       */
+      createStereoEffect() {
+        return new StereoEffect(this.ac);
+      }
+
+      /**
+       * 创建一个修改单个声道音量的效果器
+       * ```txt
+       *                                  |----------|
+       *                               -> | GainNode | \
+       *             |--------------| /   |----------|  -> |------------|
+       * Input ----> | SplitterNode |        ......        | MergerNode | ----> Output
+       *             |--------------| \   |----------|  -> |------------|
+       *                               -> | GainNode | /
+       *                                  |----------|
+       * ```
+       */
+      createChannelVolumeEffect() {
+        return new ChannelVolumeEffect(this.ac);
+      }
+
+      /**
+       * 创建一个延迟效果器
+       *             |-----------|
+       * Input ----> | DelayNode | ----> Output
+       *             |-----------|
+       */
+      createDelay() {
+        return new DelayEffect(this.ac);
+      }
+
+      /**
+       * 创建一个回声效果器
+       * ```txt
+       *             |----------|
+       * Input ----> | GainNode | ----> Output
+       *        ^    |----------|   |
+       *        |                   |
+       *        |   |------------|  ↓
+       *        |-- | Delay Node | <--
+       *            |------------|
+       * ```
+       */
+      createEchoEffect() {
+        return new EchoEffect(this.ac);
+      }
+
+      /**
+       * 创建一个音频播放路由
+       * @param source 音频源
+       */
+      createRoute(source) {
+        return new AudioRoute(source, this);
+      }
+
+      /**
+       * 添加一个音频播放路由，可以直接被播放
+       * @param id 这个音频播放路由的名称
+       * @param route 音频播放路由对象
+       */
+      addRoute(id, route) {
+        if (!this.audioRoutes) this.audioRoutes = new Map();
+        if (this.audioRoutes.has(id)) {
+          console.warn(
+            "Audio route with id of '" +
+              id +
+              "' has already existed. New route will override old route."
+          );
+        }
+        this.audioRoutes.set(id, route);
+      }
+
+      /**
+       * 根据名称获取音频播放路由对象
+       * @param id 音频播放路由的名称
+       */
+      getRoute(id) {
+        return this.audioRoutes.get(id);
+      }
+      /**
+       * 移除一个音频播放路由
+       * @param id 要移除的播放路由的名称
+       */
+      removeRoute(id) {
+        this.audioRoutes.delete(id);
+      }
+      /**
+       * 播放音频
+       * @param id 音频名称
+       * @param when 从音频的哪个位置开始播放，单位秒
+       */
+      play(id, when) {
+        const route = this.getRoute(id);
+        if (!route) {
+          console.warn(
+            "Cannot play audio route '" +
+              id +
+              "', since there is not added route named it."
+          );
+          return;
+        }
+
+        route.play(when);
+      }
+
+      /**
+       * 暂停音频播放
+       * @param id 音频名称
+       * @returns 当音乐真正停止时兑现
+       */
+      pause(id) {
+        const route = this.getRoute(id);
+        if (!route) {
+          console.warn(
+            "Cannot pause audio route '" +
+              id +
+              "', since there is not added route named it."
+          );
+          return;
+        }
+        return route.pause();
+      }
+
+      /**
+       * 停止音频播放
+       * @param id 音频名称
+       * @returns 当音乐真正停止时兑现
+       */
+      stop(id) {
+        const route = this.getRoute(id);
+        if (!route) {
+          console.warn(
+            "Cannot stop audio route '" +
+              id +
+              "', since there is not added route named it."
+          );
+          return;
+        }
+        return route.stop();
+      }
+
+      /**
+       * 继续音频播放
+       * @param id 音频名称
+       */
+      resume(id) {
+        const route = this.getRoute(id);
+        if (!route) {
+          console.warn(
+            "Cannot pause audio route '" +
+              id +
+              "', since there is not added route named it."
+          );
+          return;
+        }
+        route.resume();
+      }
+
+      /**
+       * 设置听者位置，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
+       * @param x 位置x坐标
+       * @param y 位置y坐标
+       * @param z 位置z坐标
+       */
+      setListenerPosition(x, y, z) {
+        const listener = this.ac.listener;
+        listener.positionX.value = x;
+        listener.positionY.value = y;
+        listener.positionZ.value = z;
+      }
+
+      /**
+       * 设置听者朝向，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
+       * @param x 朝向x坐标
+       * @param y 朝向y坐标
+       * @param z 朝向z坐标
+       */
+      setListenerOrientation(x, y, z) {
+        const listener = this.ac.listener;
+        listener.forwardX.value = x;
+        listener.forwardY.value = y;
+        listener.forwardZ.value = z;
+      }
+
+      /**
+       * 设置听者头顶朝向，x正方向水平向右，y正方向垂直于地面向上，z正方向垂直屏幕远离用户
+       * @param x 头顶朝向x坐标
+       * @param y 头顶朝向y坐标
+       * @param z 头顶朝向z坐标
+       */
+      setListenerUp(x, y, z) {
+        const listener = this.ac.listener;
+        listener.upX.value = x;
+        listener.upY.value = y;
+        listener.upZ.value = z;
+      }
+    }
+    class AudioRoute {
+      constructor(source, player) {
+        this.output = source.output;
+
+        /** 效果器路由图 */
+        this.effectRoute = [];
+
+        /** 结束时长，当音频暂停或停止时，会经过这么长时间之后才真正终止播放，期间可以做音频淡入淡出等效果 */
+        this.endTime = 0;
+        /** 暂停时播放了多长时间 */
+        this.pauseCurrentTime = 0;
+        /** 当前播放状态 */
+        this.player = player;
+        this.player.status = AudioStatus.Stoped;
+        this.shouldStop = false;
+        /**
+         * 每次暂停或停止时自增，用于判断当前正在处理的情况。
+         * 假如暂停后很快播放，然后很快暂停，那么需要根据这个来判断实际是否应该执行暂停后操作
+         */
+        this.stopIdentifier = 0;
+        /** 暂停时刻 */
+        this.pauseTime = 0;
+        this.source = source;
+        this.source.player = player;
+      }
+      /** 音频时长，单位秒 */
+      get duration() {
+        return this.source.duration;
+      }
+      /** 当前播放了多长时间，单位秒 */
+      get currentTime() {
+        if (this.player.status === AudioStatus.Paused) {
+          return this.pauseCurrentTime;
+        } else {
+          return this.source.currentTime;
+        }
+      }
+      set currentTime(time) {
+        this.source.stop();
+        this.source.play(time);
+      }
+      /**
+       * 设置结束时间，暂停或停止时，会经过这么长时间才终止音频的播放，这期间可以做一下音频淡出的效果。
+       * @param time 暂停或停止时，经过多长时间之后才会结束音频的播放
+       */
+      setEndTime(time) {
+        this.endTime = time;
+      }
+
+      /**
+       * 当音频播放时执行的函数，可以用于音频淡入效果
+       * @param fn 音频开始播放时执行的函数
+       */
+      onStart(fn) {
+        this.audioStartHook = fn;
+      }
+
+      /**
+       * 当音频暂停或停止时执行的函数，可以用于音频淡出效果
+       * @param fn 音频在暂停或停止时执行的函数，不填时表示取消这个钩子。
+       *           包含两个参数，第一个参数是结束时长，第二个参数是当前音频播放路由对象
+       */
+      onEnd(fn) {
+        this.audioEndHook = fn;
+      }
+
+      /**
+       * 开始播放这个音频
+       * @param when 从音频的什么时候开始播放，单位秒
+       */
+      play(when = 0) {
+        if (this.player.status === AudioStatus.Playing) return;
+        this.link();
+        if (this.effectRoute.length > 0) {
+          const first = this.effectRoute[0];
+          this.source.connect(first);
+          const last = this.effectRoute.at(-1);
+          last.connect({ input: this.player.getDestination() });
+        } else {
+          this.source.connect({ input: this.player.getDestination() });
+        }
+        this.source.play(when);
+        this.player.status = AudioStatus.Playing;
+        this.pauseTime = 0;
+        this.audioStartHook?.(this);
+        this.startAllEffect();
+        if (this.source.player.status !== AudioStatus.Playing) {
+          this.source.player.status = AudioStatus.Playing;
+        }
+      }
+
+      /**
+       * 暂停音频播放
+       */
+      async pause() {
+        if (this.player.status !== AudioStatus.Playing) return;
+        this.player.status = AudioStatus.Pausing;
+        this.stopIdentifier++;
+        const identifier = this.stopIdentifier;
+        if (this.audioEndHook) {
+          this.audioEndHook(this.endTime, this);
+          await sleep(this.endTime);
+        }
+        if (
+          this.player.status !== AudioStatus.Pausing ||
+          this.stopIdentifier !== identifier
+        ) {
+          return;
+        }
+        this.pauseCurrentTime = this.source.currentTime;
+        const time = this.source.stop();
+        this.pauseTime = time;
+        if (this.shouldStop) {
+          this.player.status = AudioStatus.Stoped;
+          this.endAllEffect();
+
+          this.shouldStop = false;
+        } else {
+          this.player.status = AudioStatus.Paused;
+          this.endAllEffect();
+        }
+        this.endAllEffect();
+      }
+
+      /**
+       * 继续音频播放
+       */
+      resume() {
+        if (this.player.status === AudioStatus.Playing) return;
+        if (
+          this.player.status === AudioStatus.Pausing ||
+          this.player.status === AudioStatus.Stoping
+        ) {
+          this.audioStartHook?.(this);
+
+          return;
+        }
+        if (this.player.status === AudioStatus.Paused) {
+          this.play(this.pauseTime);
+        } else {
+          this.play(0);
+        }
+        this.player.status = AudioStatus.Playing;
+        this.pauseTime = 0;
+        this.audioStartHook?.(this);
+        this.startAllEffect();
+      }
+
+      /**
+       * 停止音频播放
+       */
+      async stop() {
+        if (this.status !== AudioStatus.Playing) {
+          if (this.status === AudioStatus.Pausing) {
+            this.shouldStop = true;
+          }
+          return;
+        }
+        this.status = AudioStatus.Stoping;
+        this.stopIdentifier++;
+        const identifier = this.stopIdentifier;
+        if (this.audioEndHook) {
+          this.audioEndHook(this.endTime, this);
+          await sleep(this.endTime);
+        }
+        if (
+          this.status !== AudioStatus.Stoping ||
+          this.stopIdentifier !== identifier
+        ) {
+          return;
+        }
+        this.source.stop();
+        this.status = AudioStatus.Stoped;
+        this.pauseTime = 0;
+        this.endAllEffect();
+      }
+
+      /**
+       * 添加效果器
+       * @param effect 要添加的效果，可以是数组，表示一次添加多个
+       * @param index 从哪个位置开始添加，如果大于数组长度，那么加到末尾，如果小于0，那么将会从后面往前数。默认添加到末尾
+       */
+      addEffect(effect, index) {
+        if (isNil(index)) {
+          if (effect instanceof Array) {
+            this.effectRoute.push(...effect);
+          } else {
+            this.effectRoute.push(effect);
+          }
+        } else {
+          if (effect instanceof Array) {
+            this.effectRoute.splice(index, 0, ...effect);
+          } else {
+            this.effectRoute.splice(index, 0, effect);
+          }
+        }
+        this.setOutput();
+        if (this.source.playing) this.link();
+      }
+
+      /**
+       * 移除一个效果器
+       * @param effect 要移除的效果
+       */
+      removeEffect(effect) {
+        const index = this.effectRoute.indexOf(effect);
+        if (index === -1) return;
+        this.effectRoute.splice(index, 1);
+        effect.disconnect();
+        this.setOutput();
+        if (this.source.playing) this.link();
+      }
+
+      setOutput() {
+        const effect = this.effectRoute.at(-1);
+        if (!effect) this.output = this.source.output;
+        else this.output = effect.output;
+      }
+
+      /**
+       * 连接音频路由图
+       */
+      link() {
+        this.effectRoute.forEach((v) => v.disconnect());
+        this.effectRoute.forEach((v, i) => {
+          const next = this.effectRoute[i + 1];
+          if (next) {
+            v.connect(next);
+          }
+        });
+      }
+
+      startAllEffect() {
+        this.effectRoute.forEach((v) => v.start());
+      }
+
+      endAllEffect() {
+        this.effectRoute.forEach((v) => v.end());
+      }
+    }
+
+    const audioPlayer = new AudioPlayer();
+
+    class BgmController {
+      constructor(player) {
+        this.mainGain = player.createVolumeEffect();
+        this.player = player;
+        /** bgm音频名称的前缀 */
+        this.prefix = "bgms.";
+        /** 每个 bgm 的音量控制器 */
+        this.gain = new Map();
+
+        /** 正在播放的 bgm */
+        this.playingBgm = "";
+        /** 是否正在播放 */
+        this.playing = false;
+
+        /** 是否已经启用 */
+        this.enabled = true;
+        /** 是否屏蔽所有的音乐切换 */
+        this.blocking = false;
+        /** 渐变时长 */
+        this.transitionTime = 2000;
+      }
+
+      /**
+       * 设置音频渐变时长
+       * @param time 渐变时长
+       */
+      setTransitionTime(time) {
+        this.transitionTime = time;
+        for (const [, value] of this.gain) {
+          value.transition.time(time);
+        }
+      }
+
+      /**
+       * 屏蔽音乐切换
+       */
+      blockChange() {
+        this.blocking = true;
+      }
+
+      /**
+       * 取消屏蔽音乐切换
+       */
+      unblockChange() {
+        this.blocking = false;
+      }
+
+      /**
+       * 设置总音量大小
+       * @param volume 音量大小
+       */
+      setVolume(volume) {
+        this.mainGain.setVolume(volume);
+        this._volume = volume;
+      }
+      /**
+       * 获取总音量大小
+       */
+      getVolume() {
+        return this.mainGain.getVolume();
+      }
+      /**
+       * 设置是否启用
+       * @param enabled 是否启用
+       */
+      setEnabled(enabled) {
+        if (enabled) this.resume();
+        else this.stop();
+        this.enabled = enabled;
+      }
+
+      /**
+       * 设置 bgm 音频名称的前缀
+       */
+      setPrefix(prefix) {
+        this.prefix = prefix;
+      }
+
+      getId(name) {
+        return `${this.prefix}${name}`;
+      }
+
+      /**
+       * 根据 bgm 名称获取其 AudioRoute 实例
+       * @param id 音频名称
+       */
+      get(id) {
+        return this.player.getRoute(this.getId(id));
+      }
+
+      /**
+       * 添加一个 bgm
+       * @param id 要添加的 bgm 的名称
+       * @param url 指定 bgm 的加载地址
+       */
+      addBgm(id, url = `project/bgms/${id}`) {
+        const type = guessTypeByExt(id);
+        if (!type) {
+          console.warn(
+            "Unknown audio extension name: '" +
+              id.split(".").slice(0, -1).join(".") +
+              "'"
+          );
+          return;
+        }
+        const gain = this.player.createVolumeEffect();
+        if (isAudioSupport(type)) {
+          const source = audioPlayer.createElementSource();
+          source.setSource(url);
+          source.setLoop(true);
+          const route = new AudioRoute(source, audioPlayer);
+          route.addEffect([gain, this.mainGain]);
+          audioPlayer.addRoute(this.getId(id), route);
+          this.setTransition(id, route, gain);
+        } else {
+          const source = audioPlayer.createStreamSource();
+          const stream = new StreamLoader(url);
+          stream.pipe(source);
+          source.setLoop(true);
+          const route = new AudioRoute(source, audioPlayer);
+          route.addEffect([gain, this.mainGain]);
+          audioPlayer.addRoute(this.getId(id), route);
+          this.setTransition(id, route, gain);
+        }
+      }
+
+      /**
+       * 移除一个 bgm
+       * @param id 要移除的 bgm 的名称
+       */
+      removeBgm(id) {
+        this.player.removeRoute(this.getId(id));
+        const gain = this.gain.get(id);
+        gain?.transition.ticker.destroy();
+        this.gain.delete(id);
+      }
+
+      setTransition(id, route, gain) {
+        const transition = new Transition();
+        transition
+          .time(this.transitionTime)
+          .mode(linear())
+          .transition("volume", 0);
+
+        const tick = () => {
+          gain.setVolume(transition.value.volume);
+        };
+
+        /**
+         * @param expect 在结束时应该是正在播放还是停止
+         */
+        const setTick = async (expect) => {
+          transition.ticker.remove(tick);
+          transition.ticker.add(tick);
+          const identifier = route.stopIdentifier;
+          await sleep(this.transitionTime + 500);
+          if (route.status === expect && identifier === route.stopIdentifier) {
+            transition.ticker.remove(tick);
+            if (route.status === AudioStatus.Playing) {
+              gain.setVolume(1);
+            } else {
+              gain.setVolume(0);
+            }
+          }
+        };
+
+        route.onStart(async () => {
+          transition.transition("volume", 1);
+          setTick(AudioStatus.Playing);
+        });
+        route.onEnd(() => {
+          transition.transition("volume", 0);
+          setTick(AudioStatus.Paused);
+        });
+        route.setEndTime(this.transitionTime);
+
+        this.gain.set(id, { effect: gain, transition });
+      }
+
+      /**
+       * 播放一个 bgm
+       * @param id 要播放的 bgm 名称
+       */
+      play(id, when) {
+        if (this.blocking) return;
+        if (id !== this.playingBgm && this.playingBgm) {
+          this.player.pause(this.getId(this.playingBgm));
+        }
+        this.playingBgm = id;
+        if (!this.enabled) return;
+        this.player.play(this.getId(id), when);
+        this.playing = true;
+        if (this.player.status !== AudioStatus.Playing) {
+          this.player.status = AudioStatus.Playing;
+        }
+      }
+
+      /**
+       * 继续当前的 bgm
+       */
+      resume() {
+        if (this.blocking || !this.enabled || this.playing) return;
+        if (this.playingBgm) {
+          this.player.resume(this.getId(this.playingBgm));
+        }
+        this.playing = true;
+      }
+
+      /**
+       * 暂停当前的 bgm
+       */
+      pause() {
+        if (this.blocking || !this.enabled) return;
+        if (this.playingBgm) {
+          this.player.pause(this.getId(this.playingBgm));
+        }
+        this.playing = false;
+      }
+
+      /**
+       * 停止当前的 bgm
+       */
+      stop() {
+        if (this.blocking || !this.enabled) return;
+        if (this.playingBgm) {
+          this.player.stop(this.getId(this.playingBgm));
+        }
+        this.playing = false;
+      }
+    }
+    const bgmController = new BgmController(audioPlayer);
+
+    class SoundPlayer {
+      constructor(player) {
+        /** 每个音效的唯一标识符 */
+        this.num = 0;
+        this.enabled = true;
+        this.gain = player.createVolumeEffect();
+        /** 每个音效的数据 */
+        this.buffer = new Map();
+        /** 所有正在播放的音乐 */
+        this.playing = new Set();
+        this.player = player;
+      }
+      /**
+       * 设置是否启用音效
+       * @param enabled 是否启用音效
+       */
+      setEnabled(enabled) {
+        if (!enabled) this.stopAllSounds();
+        this.enabled = enabled;
+      }
+
+      /**
+       * 设置音量大小
+       * @param volume 音量大小
+       */
+      setVolume(volume) {
+        this.gain.setVolume(volume);
+      }
+      /**
+       * 获取音量大小
+       */
+      getVolume() {
+        return this.gain.getVolume();
+      }
+      /**
+       * 添加一个音效
+       * @param id 音效名称
+       * @param data 音效的Uint8Array数据
+       */
+      async add(id, data) {
+        const buffer = await this.player.decodeAudioData(data);
+        if (!buffer) {
+          console.warn(
+            "Cannot decode sound '" +
+              id +
+              "', since audio file may not supported by 2.b."
+          );
+          return;
+        }
+        this.buffer.set(id, buffer);
+      }
+
+      /**
+       * 播放一个音效
+       * @param id 音效名称
+       * @param position 音频位置，[0, 0, 0]表示正中心，x轴指向水平向右，y轴指向水平向上，z轴指向竖直向上
+       * @param orientation 音频朝向，[0, 1, 0]表示朝向前方
+       */
+      play(id, position = [0, 0, 0], orientation = [1, 0, 0]) {
+        if (!this.enabled) return -1;
+        const buffer = this.buffer.get(id);
+        if (!buffer) {
+          console.warn(
+            "Cannot play sound '" +
+              id +
+              "', since there is no added data named it."
+          );
+          return -1;
+        }
+        const soundNum = this.num++;
+
+        const source = this.player.createBufferSource();
+        source.setBuffer(buffer);
+        const route = this.player.createRoute(source);
+        const stereo = this.player.createStereoEffect();
+        stereo.setPosition(position[0], position[1], position[2]);
+        stereo.setOrientation(orientation[0], orientation[1], orientation[2]);
+        route.addEffect([stereo, this.gain]);
+        this.player.addRoute(`sounds.${soundNum}`, route);
+        route.play();
+        source.output.addEventListener("ended", () => {
+          this.playing.delete(soundNum);
+        });
+        this.playing.add(soundNum);
+        return soundNum;
+      }
+
+      /**
+       * 停止一个音效
+       * @param num 音效的唯一 id
+       */
+      stop(num) {
+        const id = `sounds.${num}`;
+        const route = this.player.getRoute(id);
+        if (route) {
+          route.stop();
+          this.player.removeRoute(id);
+          this.playing.delete(num);
+        }
+      }
+
+      /**
+       * 停止播放所有音效
+       */
+      stopAllSounds() {
+        this.playing.forEach((v) => {
+          const id = `sounds.${v}`;
+          const route = this.player.getRoute(id);
+          if (route) {
+            route.stop();
+            this.player.removeRoute(id);
+          }
+        });
+        this.playing.clear();
+      }
+    }
+    const soundPlayer = new SoundPlayer(audioPlayer);
+
+    function loadAllBgm() {
+      const data = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
+      for (const bgm of data.main.bgms) {
+        bgmController.addBgm(bgm);
+      }
+    }
+    loadAllBgm();
+    AudioDecoder.registerDecoder(AudioType.Ogg, VorbisDecoder);
+    AudioDecoder.registerDecoder(AudioType.Opus, OpusDecoder);
+
+    core.plugin.audioSystem = {
+      AudioType,
+      AudioDecoder,
+      AudioStatus,
+      checkAudioType,
+      isAudioSupport,
+      audioPlayer,
+      soundPlayer,
+      bgmController,
+      guessTypeByExt,
+      BgmController,
+      SoundPlayer,
+      EchoEffect,
+      DelayEffect,
+      ChannelVolumeEffect,
+      VolumeEffect,
+      StereoEffect,
+      AudioEffect,
+      AudioPlayer,
+      AudioRoute,
+      AudioStreamSource,
+      AudioElementSource,
+      AudioBufferSource,
+      loadAllBgm,
+      StreamLoader,
+    };
+    //bgm相关复写
+    control.prototype.playBgm = (bgm, when) => {
+      bgmController.play(bgm, when);
+      core.setMusicBtn();
+    };
+    control.prototype.pauseBgm = () => {
+      bgmController.pause();
+      core.setMusicBtn();
+    };
+
+    control.prototype.resumeBgm = function () {
+      bgmController.resume();
+      core.setMusicBtn();
+    };
+    control.prototype.checkBgm = function () {
+      if (bgmController.playing) return;
+      if (core.musicStatus.bgmStatus) {
+        if (bgmController.playingBgm) {
+          bgmController.play(bgmController.playingBgm);
+        } else {
+          play(main.startBgm, 0);
+        }
+      } else {
+        pause();
+      }
+    };
+    control.prototype.triggerBgm = function () {
+      core.musicStatus.bgmStatus = !core.musicStatus.bgmStatus;
+      if (bgmController.playing) bgmController.pause();
+      else bgmController.resume();
+      core.setMusicBtn();
+      core.setLocalStorage("bgmStatus", core.musicStatus.bgmStatus);
+    };
+    //sound相关复写
+    control.prototype.playSound = function (
+      sound,
+      _pitch,
+      callback,
+      position,
+      orientation
+    ) {
+      if (main.mode != "play" || !core.musicStatus.soundStatus) return;
+      const name = core.getMappedName(sound);
+      const num = soundPlayer.play(name, position, orientation);
+      const route = audioPlayer.getRoute(`sounds.${num}`);
+      if (!route) {
+        callback?.();
+        return -1;
+      } else {
+        sleep(route.duration).then(() => callback?.());
+        return num;
+      }
+    };
+    control.prototype.stopSound = function (id) {
+      if (isNil(id)) {
+        soundPlayer.stopAllSounds();
+      } else {
+        soundPlayer.stop(id);
+      }
+    };
+    control.prototype.getPlayingSounds = function () {
+      return [...soundPlayer.playing];
+    };
+    //sound加载复写
+    loader.prototype._loadOneSound_decodeData = function (name, data) {
+      if (data instanceof Blob) {
+        var blobReader = new zip.BlobReader(data);
+        blobReader.init(function () {
+          blobReader.readUint8Array(0, blobReader.size, function (uint8) {
+            //core.loader._loadOneSound_decodeData(name, uint8.buffer);
+            soundPlayer.add(name, uint8);
+          });
+        });
+        return;
+      }
+      if (data instanceof ArrayBuffer) {
+        const uint8 = new Uint8Array(data);
+        soundPlayer.add(name, uint8);
+      }
+    };
+    //音量控制复写
+    soundPlayer.setVolume(
+      core.musicStatus.userVolume * core.musicStatus.designVolume
+    );
+    bgmController.setVolume(
+      core.musicStatus.userVolume * core.musicStatus.designVolume
+    );
+    actions.prototype._clickSwitchs_sounds_userVolume = function (delta) {
+      var value = Math.round(Math.sqrt(100 * core.musicStatus.userVolume));
+      if (value == 0 && delta < 0) return;
+      core.musicStatus.userVolume = core.clamp(
+        Math.pow(value + delta, 2) / 100,
+        0,
+        1
+      );
+      //audioContext 音效 不受designVolume 影响
+      if (core.musicStatus.gainNode != null)
+        core.musicStatus.gainNode.gain.value = core.musicStatus.userVolume;
+      soundPlayer.setVolume(
+        core.musicStatus.userVolume * core.musicStatus.designVolume
+      );
+      bgmController.setVolume(
+        core.musicStatus.userVolume * core.musicStatus.designVolume
+      );
+      core.setLocalStorage("userVolume", core.musicStatus.userVolume);
+      core.playSound("确定");
+      core.ui._drawSwitchs_sounds();
+    };
+  },
+  怪物碎裂特效: function () {
     // 在此增加新插件
     // -------------------- 安装说明 -------------------- //
     // 先安装两个在插件简介中说明的前置插件
@@ -10793,7 +10794,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       applyFragWith,
     };
   },
-    "自定义常用事件": function () {
+  自定义常用事件: function () {
     // editorBlocklyconfigPlus.js
     // 自訂常見事件模板插件
     // 本插件引用了通用函數插件(Utility.js)
@@ -12082,7 +12083,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
         .split("// end mark sfergsvae")[0];
     }
   },
-    "夹击激光动画": function () {
+  夹击激光动画: function () {
     function createCanvas(name, zIndex) {
       if (!name) return;
       var canvas = document.createElement("canvas");
@@ -12313,7 +12314,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "瞬移轨迹": function () {
+  瞬移轨迹: function () {
     // 在此增加新插件
     function popMove() {
       var ctx = core.getContextByName("popMove");
@@ -12389,7 +12390,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "墓碑（编辑器）": function () {
+  "墓碑（编辑器）": function () {
     // 在此增加新插件
     if (main.mode != "editor") return; // 编辑器模式下使用
     var mapData = null;
@@ -12460,7 +12461,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       core.setAlpha("event2", alpha);
     };
   },
-    "小地图": function () {
+  小地图: function () {
     // 在此增加新插件
     // ----- 不可自定义 杂七杂八的变量
     /** @type {{[x: string]: BFSResult}} */
@@ -12879,7 +12880,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "楼传": function () {
+  楼传: function () {
     // 在此增加新插件
 
     core.canMoveFloor = function () {
@@ -13987,7 +13988,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       0
     );
   },
-    "CG回廊": function () {
+  CG回廊: function () {
     // 在此增加新插件
     const CGUI = document.createElement("canvas"); //CGui画布设置
     CGUI.style.position = "absolute";
@@ -14490,7 +14491,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       main.core.ui.CG.update();
     };
   },
-    "光标设置": function () {
+  光标设置: function () {
     // 在此增加新插件
     this.changeMouse = function (
       icon,
@@ -14527,7 +14528,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       core.dom[div].style.cursor = "auto";
     };
   },
-    "信息弹出": function () {
+  信息弹出: function () {
     // 在此增加新插件
     /* 弹出显示某个内容
      * 使用方法：core.addPop(px, py, value, color, boldColor, left, jump, time, show, font, speed)
@@ -14634,7 +14635,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       else core.status.pop.push(data);
     };
   },
-    "warning": function () {
+  warning: function () {
     // 在此增加新插件
     // 默认音效名
     var defaultSound = "jingbao.opus";
@@ -14697,7 +14698,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }, 1600);
     };
   },
-    "立体声音效": function () {
+  立体声音效: function () {
     // 在此增加新插件
     // 音效双声道播放
     var can = true;
@@ -14801,7 +14802,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }, 10);
     };
   },
-    "滑动转场": function () {
+  滑动转场: function () {
     // 在此增加新插件
     const defaultChange = {
       left: "leftPortal", // 左箭头
@@ -14991,7 +14992,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }, 25);
     };
   },
-    "剧情cg": function () {
+  剧情cg: function () {
     // 在此增加新插件
     const cg = document.createElement("canvas"); //cg画布设置
     cg.style.position = "absolute";
@@ -15520,7 +15521,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
     }
     core.ui.cgText = new cgText();
   },
-    "旁白": function () {
+  旁白: function () {
     // 在此增加新插件
     const over = document.createElement("canvas"); //over画布设置
     over.style.position = "absolute";
@@ -16010,7 +16011,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "回合制boss战": function () {
+  回合制boss战: function () {
     // 在此增加新插件
     const boss = document.createElement("canvas"); //boss战画布设置
     boss.style.position = "absolute";
@@ -16058,7 +16059,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
     }
     core.ui.boss = new boss1();
   },
-    "剧情视频引用": function () {
+  剧情视频引用: function () {
     // 在此增加新插件
     let a;
     let bgm;
@@ -16242,7 +16243,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       });
     };
   },
-    "帧动画/图片叠拼": function () {
+  "帧动画/图片叠拼": function () {
     // 在此增加新插件
     this.animationDrawable = function (
       allFarme,
@@ -16364,943 +16365,940 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       );
     };
   },
-    "musicMode": function () {
-	// 在此增加新插件
-	const music = document.createElement("canvas");
-	music.style.position = "absolute";
-	music.style.zIndex = 300;
-	music.style.display = "none";
-	music.id = "music";
-	main.dom.gameGroup.insertAdjacentElement("afterend", music);
-	music.style.top = "50%";
-	music.style.left = "50%";
-	music.style.transform = "translate(-50%,-50%)";
-	const ctx = music.getContext("2d");
-	main.dom.music = music;
-
-	const audio = core.plugin.audioSystem.bgmController;
-
-	let page = 0; //初始页面
-
-	let isvolume = false;
-
-	function shuffle(arr) {
-		let n = arr.length,
-			random;
-		while (n) {
-			random = (Math.random() * n--) >>> 0;
-			[arr[n], arr[random]] = [arr[random], arr[n]];
-		}
-		return arr;
-	}
-	music.addEventListener("mousedown", function (e) {
-		e.stopPropagation();
-		const left = core.dom.gameGroup.offsetLeft;
-		const top = core.dom.gameGroup.offsetTop;
-		const px = Math.floor((e.clientX - left) / core.domStyle.scale),
-			py = Math.floor((e.clientY - top) / core.domStyle.scale);
-		core.ui.music.mousedown(px * 3, py * 3);
-	});
-	music.addEventListener("mousemove", function (e) {
-		e.stopPropagation();
-		const left = core.dom.gameGroup.offsetLeft;
-		const top = core.dom.gameGroup.offsetTop;
-		const px = Math.floor((e.clientX - left) / core.domStyle.scale),
-			py = Math.floor((e.clientY - top) / core.domStyle.scale);
-		core.ui.music.mousemove(px * 3, py * 3);
-	});
-	music.addEventListener("mouseup", function (e) {
-		e.stopPropagation();
-
-		isvolume = false;
-	});
-	music.addEventListener("mouseleave", function (e) {
-		e.stopPropagation();
-
-		isvolume = false;
-	});
-	music.addEventListener("touchstart", function (e) {
-		e.preventDefault();
-		const left = core.dom.gameGroup.offsetLeft;
-		const top = core.dom.gameGroup.offsetTop;
-		const px = Math.floor(
-				(e.touches[0].clientX - left) / core.domStyle.scale
-			),
-			py = Math.floor((e.touches[0].clientY - top) / core.domStyle.scale);
-		core.ui.music.mousedown(px * 3, py * 3);
-	});
-	music.addEventListener("touchmove", function (e) {
-		e.stopPropagation();
-		const left = core.dom.gameGroup.offsetLeft;
-		const top = core.dom.gameGroup.offsetTop;
-		const px = Math.floor(
-				(e.touches[0].clientX - left) / core.domStyle.scale
-			),
-			py = Math.floor((e.touches[0].clientY - top) / core.domStyle.scale);
-		core.ui.music.mousemove(px * 3, py * 3);
-	});
-	music.addEventListener("touchend", function (e) {
-		e.stopPropagation();
-
-		isvolume = false;
-	});
-	music.addEventListener("touchcancel", function (e) {
-		e.stopPropagation();
-
-		isvolume = false;
-	});
-
-	class musicclass {
-		constructor() {
-			//music列表
-			//需全塔属性注册并保存在bgms文件夹,每个数组为显示的一页内容
-			this.musicMx = [
-				["Asphodelus_Ceui.opus", "Blind_Alley.opus"],
-				["Crawler.opus", "op.opus", "theme.opus"],
-			];
-			//音乐别名（将在播放器内显示的音乐名，music列表内的都要有对应歌名）
-			this.musicname = {
-				"Asphodelus_Ceui.opus": "Asphodelus",
-				"Blind_Alley.opus": "Blind",
-				"Crawler.opus": "Crawler",
-				"op.opus": "op",
-				"theme.opus": "theme",
-			};
-			this.selection = [0, 0];
-			this.stop = false;
-			this.type = "xunhuan";
-			this.randomList = [];
-			this.random = 0;
-		}
-
-		//更新
-		update() {
-			this.background();
-			this.drawUI();
-		}
-		background() {
-			//画布大小设置
-			if (core.domStyle.isVertical) {
-				music.width = 1248;
-				music.height = 2028;
-			} else {
-				music.width = 2028;
-				music.height = 1248;
-			}
-		}
-		mousedown(px, py) {
-			//鼠标按下时
-
-			const makeBox = ([x, y], [w, h]) => {
-				return [
-					[x, y],
-					[x + w, y + h],
-				];
-			};
-			const inRect = ([x, y], [
-				[sx, sy],
-				[dx, dy]
-			]) => {
-				return sx <= x && x <= dx && sy <= y && y <= dy;
-			};
-			const pos = [px, py];
-			const backbox = makeBox([15, 35], [210, 90]);
-			if (inRect(pos, backbox)) {
-				//离开按钮是一致的，其余的记区分横竖屏
-				music.style.display = "none";
-				core.clearMap(ctx);
-
-				core.unregisterAnimationFrame("music");
-				core.restart();
-
-				return;
-			}
-			if (core.domStyle.isVertical) {
-				//竖屏
-
-				const pageupbox = makeBox([100, 1230], [200, 100]);
-				const pagedownbox = makeBox([950, 1230], [200, 100]);
-				const musicbox = makeBox(
-					[100, 200],
-					[1048, this.musicMx[page].length * 100]
-				);
-				const beforebox = makeBox([120, 1620], [100, 100]);
-				const afterbox = makeBox([780, 1620], [100, 100]);
-				const playbox = makeBox([420, 1580], [200, 200]);
-				const typebox = makeBox([1040, 1600], [120, 120]);
-
-				const volumebox = makeBox([250, 1940], [1050, 20]);
-				if (inRect(pos, pageupbox)) {
-					if (page !== 0) page -= 1;
-					return;
-				}
-				if (inRect(pos, pagedownbox)) {
-					if (page !== this.musicMx.length - 1) page += 1;
-					return;
-				}
-				if (inRect(pos, playbox)) {
-					if (this.stop) {
-						this.stop = !this.stop;
-
-						core.resumeBgm();
-					} else {
-						this.stop = !this.stop;
-						core.pauseBgm();
-					}
-					return;
-				}
-				if (inRect(pos, beforebox)) {
-					this.stop = false;
-					switch (this.type) {
-					case "danqu":
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						page = this.selection[0];
-
-						break;
-					case "xunhuan":
-						if (this.selection[1] === 0) {
-							if (this.selection[0] === 0) {
-								this.selection[0] = this.musicMx.length - 1;
-								this.selection[1] =
-									this.musicMx[this.selection[0]].length - 1;
-							} else {
-								this.selection[0] -= 1;
-								this.selection[1] =
-									this.musicMx[this.selection[0]].length - 1;
-							}
-						} else {
-							this.selection[1] -= 1;
-						}
-						this.randomList.indexOf(
-							this.musicMx[this.selection[0]][this.selection[1]]
-						);
-						page = this.selection[0];
-
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						break;
-					case "suiji":
-						if (this.random > 0) {
-							this.random -= 1;
-						} else {
-							this.random = this.randomList.length - 1;
-						}
-						this.selection[0] = this.musicMx.findIndex((v) =>
-							v.includes(this.randomList[this.random])
-						);
-						this.selection[1] = this.musicMx[this.selection[0]].indexOf(
-							this.randomList[this.random]
-						);
-
-						page = this.selection[0];
-
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, afterbox)) {
-					this.stop = false;
-					switch (this.type) {
-					case "danqu":
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						page = this.selection[0];
-						break;
-					case "xunhuan":
-						if (
-							this.selection[1] ===
-							this.musicMx[this.selection[0]].length - 1
-						) {
-							if (this.selection[0] === this.musicMx.length - 1) {
-								this.selection[0] = 0;
-								this.selection[1] = 0;
-							} else {
-								this.selection[0] += 1;
-								this.selection[1] = 0;
-							}
-						} else {
-							this.selection[1] += 1;
-						}
-						this.random = this.randomList.indexOf(
-							this.musicMx[this.selection[0]][this.selection[1]]
-						);
-						page = this.selection[0];
-
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						break;
-					case "suiji":
-						if (this.random < this.randomList.length - 1) {
-							this.random += 1;
-						} else {
-							this.random = 0;
-						}
-						this.selection[0] = this.musicMx.findIndex((v) =>
-							v.includes(this.randomList[this.random])
-						);
-						this.selection[1] = this.musicMx[this.selection[0]].indexOf(
-							this.randomList[this.random]
-						);
-
-						page = this.selection[0];
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, typebox)) {
-					switch (this.type) {
-					case "danqu":
-						this.type = "xunhuan";
-						break;
-					case "xunhuan":
-						this.type = "suiji";
-						break;
-					case "suiji":
-						this.type = "danqu";
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, musicbox)) {
-					const index = Math.floor((py - 200) / 100);
-					if (page !== this.selection[0] || index !== this.selection[1]) {
-						this.selection[0] = page;
-						this.selection[1] = index;
-						this.randomList.indexOf(
-							this.musicMx[this.selection[0]][this.selection[1]]
-						);
-
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-
-						this.stop = false;
-					} else {
-						if (this.stop) {
-							this.stop = !this.stop;
-							core.resumeBgm();
-						} else {
-							this.stop = !this.stop;
-							core.pauseBgm();
-						}
-					}
-					return;
-				}
-
-				if (inRect(pos, volumebox)) {
-					const time = Math.min(Math.max((px - 250) / 800, 0), 1);
-					audio.setVolume(time);
-					core.plugin.audioSystem.soundPlayer.setVolume(time);
-					isvolume = true;
-				}
-			} else {
-				//横屏
-				const pageupbox = makeBox([1050, 1100], [200, 100]);
-				const pagedownbox = makeBox([1550, 1100], [200, 100]);
-				const musicbox = makeBox(
-					[900, 100],
-					[1000, this.musicMx[page].length * 100]
-				);
-				const beforebox = makeBox([60, 620], [100, 100]);
-				const afterbox = makeBox([450, 620], [100, 100]);
-				const playbox = makeBox([200, 570], [200, 200]);
-				const typebox = makeBox([620, 600], [120, 120]);
-
-				const volumebox = makeBox([100, 990], [600, 20]);
-				if (inRect(pos, pageupbox)) {
-					if (page !== 0) page -= 1;
-					return;
-				}
-				if (inRect(pos, pagedownbox)) {
-					if (page !== this.musicMx.length - 1) page += 1;
-					return;
-				}
-				if (inRect(pos, playbox)) {
-					if (this.stop) {
-						this.stop = !this.stop;
-						core.resumeBgm();
-					} else {
-						this.stop = !this.stop;
-						core.pauseBgm();
-					}
-					return;
-				}
-				if (inRect(pos, beforebox)) {
-					this.stop = false;
-					switch (this.type) {
-					case "danqu":
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						page = this.selection[0];
-
-						break;
-					case "xunhuan":
-						if (this.selection[1] === 0) {
-							if (this.selection[0] === 0) {
-								this.selection[0] = this.musicMx.length - 1;
-								this.selection[1] =
-									this.musicMx[this.selection[0]].length - 1;
-							} else {
-								this.selection[0] -= 1;
-								this.selection[1] =
-									this.musicMx[this.selection[0]].length - 1;
-							}
-						} else {
-							this.selection[1] -= 1;
-						}
-						this.random = this.randomList.indexOf(
-							this.musicMx[this.selection[0]][this.selection[1]]
-						);
-						page = this.selection[0];
-
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						break;
-					case "suiji":
-						if (this.random > 0) {
-							this.random -= 1;
-						} else {
-							this.random = this.randomList.length - 1;
-						}
-						this.selection[0] = this.musicMx.findIndex((v) =>
-							v.includes(this.randomList[this.random])
-						);
-						this.selection[1] = this.musicMx[this.selection[0]].indexOf(
-							this.randomList[this.random]
-						);
-
-						page = this.selection[0];
-
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, afterbox)) {
-					this.stop = false;
-					switch (this.type) {
-					case "danqu":
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						page = this.selection[0];
-						break;
-					case "xunhuan":
-						if (
-							this.selection[1] ===
-							this.musicMx[this.selection[0]].length - 1
-						) {
-							if (this.selection[0] === this.musicMx.length - 1) {
-								this.selection[0] = 0;
-								this.selection[1] = 0;
-							} else {
-								this.selection[0] += 1;
-								this.selection[1] = 0;
-							}
-						} else {
-							this.selection[1] += 1;
-						}
-						this.randomList.findIndex(
-							(v) =>
-							v === this.musicMx[this.selection[0]][this.selection[1]]
-						);
-						page = this.selection[0];
-
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						break;
-					case "suiji":
-						if (this.random < this.randomList.length - 1) {
-							this.random += 1;
-						} else {
-							this.random = 0;
-						}
-						this.selection[0] = this.musicMx.findIndex((v) =>
-							v.includes(this.randomList[this.random])
-						);
-						this.selection[1] = this.musicMx[this.selection[0]].indexOf(
-							main.core.ui.music.randomList[main.core.ui.music.random]
-						);
-
-						page = this.selection[0];
-						if (!this.stop)
-							core.playBgm(
-								main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-									main.core.ui.music.selection[1]
-								]
-							);
-
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, typebox)) {
-					switch (this.type) {
-					case "danqu":
-						this.type = "xunhuan";
-						break;
-					case "xunhuan":
-						this.type = "suiji";
-						break;
-					case "suiji":
-						this.type = "danqu";
-						break;
-					}
-					return;
-				}
-				if (inRect(pos, musicbox)) {
-					const index = Math.floor((py - 100) / 100);
-					if (page !== this.selection[0] || index !== this.selection[1]) {
-						this.selection[0] = page;
-						this.selection[1] = index;
-						this.randomList.indexOf(
-							(v) => v === this.musicMx[this.selection[0]][this.selection[1]]
-						);
-
-						core.playBgm(
-							main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-								main.core.ui.music.selection[1]
-							]
-						);
-						this.stop = false;
-					} else {
-						if (this.stop) {
-							this.stop = !this.stop;
-							core.resumeBgm();
-						} else {
-							this.stop = !this.stop;
-							core.pauseBgm();
-						}
-					}
-					return;
-				}
-
-				if (inRect(pos, volumebox)) {
-					const time = Math.min(Math.max((px - 100) / 600, 0), 1);
-					audio.setVolume(time);
-					core.plugin.audioSystem.soundPlayer.setVolume(time);
-					isvolume = true;
-				}
-			}
-		}
-		mousemove(px, py) {
-			if (isvolume) {
-				if (core.domStyle.isVertical) {
-					const time = Math.min(Math.max((px - 250) / 800, 0), 1);
-					audio.setVolume(time);
-					core.plugin.audioSystem.soundPlayer.setVolume(time);
-				} else {
-					const time = Math.min(Math.max((px - 100) / 600, 0), 1);
-					audio.setVolume(time);
-					core.plugin.audioSystem.soundPlayer.setVolume(time);
-				}
-			}
-		}
-
-		drawUI() {
-			//绘制页面
-			core.clearMap(music);
-			const bgVertical = core.material.images.images["bg_2010.webp"]; //竖屏背景
-			const bg = core.material.images.images["bg_5043.webp"]; //竖屏背景
-			if (core.domStyle.isVertical) {
-				//竖屏
-
-				core.fillRect(ctx, 0, 0, 1248, 2028, "#000000"); //黑色背景
-				ctx.globalAlpha = 0.3; //透明度
-				if (bgVertical)
-					ctx.drawImage(bgVertical, 0, 0, 1280, 1500, 0, 0, 1248, 2028); //绘制半透明背景图片
-				ctx.globalAlpha = 1; //恢复为不透明
-
-				core.setTextAlign(ctx, "center");
-				core.fillBoldText1(
-					ctx,
-					"◀离开",
-					110,
-					100,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-
-				ctx.strokeStyle = "#FFFFFF";
-				ctx.lineWidth = 3;
-				ctx.beginPath();
-				ctx.moveTo(100, 200);
-				ctx.lineTo(1148, 200);
-
-				ctx.stroke();
-				let posy = 300;
-				const indexList = this.musicMx[page];
-				core.setTextAlign(ctx, "left");
-				for (let i = 0; i < indexList.length; i++) {
-					const text = this.musicname[indexList[i]];
-					core.fillBoldText1(
-						ctx,
-						text,
-						150,
-						posy - 30,
-						page === this.selection[0] && i === this.selection[1] ?
-						"#FFFFFF" :
-						"#444444",
-						"#000000",
-						6,
-						core.ui._buildFont(66, true)
-					);
-					ctx.strokeStyle = "#FFFFFF";
-					ctx.lineWidth = 3;
-					ctx.beginPath();
-					ctx.moveTo(100, posy);
-					ctx.lineTo(1148, posy);
-					ctx.stroke();
-					posy += 100;
-				}
-				ctx.beginPath();
-				ctx.moveTo(100, 1210);
-				ctx.lineTo(1148, 1210);
-				ctx.moveTo(100, 1200);
-				ctx.lineTo(1148, 1200);
-				ctx.stroke();
-
-				core.fillBoldText1(
-					ctx,
-					"上一页",
-					100,
-					1300,
-					page === 0 ? "#444444" : "#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-
-				core.fillBoldText1(
-					ctx,
-					page + 1 + "/" + this.musicMx.length,
-					580,
-					1300,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-				core.fillBoldText1(
-					ctx,
-					"下一页",
-					950,
-					1300,
-					page === this.musicMx.length - 1 ? "#444444" : "#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-
-				ctx.strokeStyle = "#ffffff";
-				ctx.lineWidth = 3;
-
-				ctx.fillStyle = "#ffffff";
-				ctx.font = "bold 96px Verdana";
-				ctx.fillText("|", 100, 1697);
-				ctx.fillText("◀", 115, 1700);
-				ctx.beginPath();
-				ctx.arc(505, 1670, 80, 0, 3 * Math.PI);
-				ctx.stroke();
-				ctx.fillText("|", 835, 1697);
-				ctx.fillText("▶", 785, 1700);
-				if (this.stop) {
-					ctx.fillText("▶", 473, 1697);
-				} else {
-					ctx.fillText("||", 453, 1694);
-				}
-
-				const img = core.material.images.images[this.type + ".webp"];
-				if (img) ctx.drawImage(img, 1000, 1555, 200, 200);
-				core.setTextAlign(ctx, "center");
-				ctx.font = "bold 52px Verdana";
-				ctx.fillText("当前歌曲", 625, 1397);
-				ctx.fillText(
-					this.musicname[this.musicMx[this.selection[0]][this.selection[1]]],
-					625,
-					1507
-				);
-
-				ctx.fillStyle = "#ffffff";
-				ctx.font = "bold 48px Verdana";
-				ctx.fillText("音量", 150, 1970);
-				ctx.lineWidth = 3;
-				ctx.beginPath();
-				ctx.moveTo(250, 1950);
-				ctx.lineTo(1050, 1950);
-				ctx.stroke();
-				ctx.strokeStyle = "#ffffff";
-				ctx.lineWidth = 9;
-				ctx.fillStyle = "rgba(255,255,255,0.5)";
-
-				ctx.beginPath();
-				ctx.moveTo(250, 1950);
-				ctx.lineTo(800 * audio.getVolume() + 250, 1950);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(800 * audio.getVolume() + 250, 1950, 10, 0, 2 * Math.PI);
-				ctx.fill();
-				core.fillBoldText1(
-					ctx,
-					Math.floor(100 * audio.getVolume()),
-					1120,
-					1970,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(56, true)
-				);
-			} else {
-				//横屏
-
-				core.fillRect(ctx, 0, 0, 2028, 1248, "#000000"); //黑色背景
-				ctx.globalAlpha = 0.5; //透明度
-				if (bg) ctx.drawImage(bg, 0, 0, 1280, 720, 0, 0, 2028, 1248); //绘制半透明背景图片
-				ctx.globalAlpha = 1; //恢复为不透明
-				core.setTextAlign(ctx, "center");
-
-				core.fillBoldText1(
-					ctx,
-					"◀离开",
-					110,
-					100,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-
-				ctx.strokeStyle = "#FFFFFF";
-				ctx.lineWidth = 3;
-				ctx.beginPath();
-				ctx.moveTo(800, 100);
-				ctx.lineTo(800, 1148);
-				ctx.moveTo(900, 100);
-				ctx.lineTo(1900, 100);
-				ctx.stroke();
-				let posy = 200;
-				const indexList = this.musicMx[page];
-				core.setTextAlign(ctx, "left");
-				for (let i = 0; i < indexList.length; i++) {
-					const text = this.musicname[indexList[i]];
-					core.fillBoldText1(
-						ctx,
-						text,
-						950,
-						posy - 30,
-						page === this.selection[0] && i === this.selection[1] ?
-						"#FFFFFF" :
-						"#444444",
-						"#000000",
-						6,
-						core.ui._buildFont(66, true)
-					);
-					ctx.strokeStyle = "#FFFFFF";
-					ctx.lineWidth = 3;
-					ctx.beginPath();
-					ctx.moveTo(900, posy);
-					ctx.lineTo(1900, posy);
-					ctx.stroke();
-					posy += 100;
-				}
-				core.fillBoldText1(
-					ctx,
-					"上一页",
-					1050,
-					1200 - 30,
-					page === 0 ? "#444444" : "#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-
-				core.fillBoldText1(
-					ctx,
-					page + 1 + "/" + this.musicMx.length,
-					1350,
-					1200 - 30,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-				core.fillBoldText1(
-					ctx,
-					"下一页",
-					1550,
-					1200 - 30,
-					page === this.musicMx.length - 1 ? "#444444" : "#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(66, true)
-				);
-				ctx.strokeStyle = "#ffffff";
-				ctx.lineWidth = 3;
-
-				ctx.fillStyle = "#ffffff";
-				ctx.font = "bold 96px Verdana";
-				ctx.fillText("|", 60, 697);
-				ctx.fillText("◀", 70, 700);
-				ctx.beginPath();
-				ctx.arc(295, 670, 80, 0, 2 * Math.PI);
-				ctx.stroke();
-				if (this.stop) {
-					ctx.fillText("▶", 245, 697);
-				} else {
-					ctx.fillText("||", 245, 694);
-				}
-
-				ctx.fillText("|", 490, 697);
-				ctx.fillText("▶", 450, 700);
-				ctx.font = "bold 48px Verdana";
-				ctx.fillText("音量", 350, 900);
-				ctx.beginPath();
-				ctx.moveTo(100, 1000);
-				ctx.lineTo(700, 1000);
-				ctx.stroke();
-				ctx.strokeStyle = "#ffffff";
-				ctx.lineWidth = 9;
-				ctx.fillStyle = "rgba(255,255,255,0.5)";
-
-				ctx.beginPath();
-				ctx.moveTo(100, 1000);
-				ctx.lineTo(600 * audio.getVolume() + 100, 1000);
-				ctx.stroke();
-				ctx.beginPath();
-				ctx.arc(600 * audio.getVolume() + 100, 1000, 10, 0, 2 * Math.PI);
-				ctx.fill();
-				core.fillBoldText1(
-					ctx,
-					Math.floor(100 * audio.getVolume()),
-					720,
-					1010,
-					"#FFFFFF",
-					"#000000",
-					6,
-					core.ui._buildFont(56, true)
-				);
-				const img = core.material.images.images[this.type + ".webp"];
-				if (img) ctx.drawImage(img, 580, 560, 200, 200);
-				core.setTextAlign(ctx, "center");
-				ctx.font = "bold 48px Verdana";
-				ctx.fillText("当前歌曲", 400, 297);
-				ctx.fillText(
-					this.musicname[this.musicMx[this.selection[0]][this.selection[1]]],
-					400,
-					397
-				);
-			}
-		}
-	}
-	core.ui.music = new musicclass();
-	main.dom.musicMode.onclick = function () {
-		//点击开始页面的CG MODE进入cg回廊
-
-		core.playBgm(
-			main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-				main.core.ui.music.selection[1]
-			]
-		);
-
-		const arr = main.core.ui.music.musicMx.flat(Infinity);
-		main.core.ui.music.randomList = shuffle(arr);
-		main.core.ui.music.random = main.core.ui.music.randomList.indexOf(
-			main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-				main.core.ui.music.selection[1]
-			]
-		);
-		page = 0;
-		music.style.display = "block";
-		let time = 0;
-		core.registerAnimationFrame("music", null, (temptime) => {
-			if (temptime > time + 1000 / 60) {
-				time = temptime;
-				main.core.ui.music.update();
-				const duration =
-					core.plugin.audioSystem.bgmController.player.getRoute(
-						"bgms." +
-						main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-							main.core.ui.music.selection[1]
-						]
-					).duration;
-
-				const currentTime =
-					core.plugin.audioSystem.bgmController.player.getRoute(
-						"bgms." +
-						main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
-							main.core.ui.music.selection[1]
-						]
-					).currentTime;
-				if (currentTime && duration && duration - currentTime < 0.05) {
-					if (core.domStyle.isVertical) {
-						core.ui.music.mousedown(830, 1770);
-					} else {
-						core.ui.music.mousedown(475, 765);
-					}
-				}
-			}
-		});
-	};
-},
-    "横屏切换": function () {
+  musicMode: function () {
+    // 在此增加新插件
+    const music = document.createElement("canvas");
+    music.style.position = "absolute";
+    music.style.zIndex = 300;
+    music.style.display = "none";
+    music.id = "music";
+    main.dom.gameGroup.insertAdjacentElement("afterend", music);
+    music.style.top = "50%";
+    music.style.left = "50%";
+    music.style.transform = "translate(-50%,-50%)";
+    const ctx = music.getContext("2d");
+    main.dom.music = music;
+
+    const audio = core.plugin.audioSystem.bgmController;
+
+    let page = 0; //初始页面
+
+    let isvolume = false;
+
+    function shuffle(arr) {
+      let n = arr.length,
+        random;
+      while (n) {
+        random = (Math.random() * n--) >>> 0;
+        [arr[n], arr[random]] = [arr[random], arr[n]];
+      }
+      return arr;
+    }
+    music.addEventListener("mousedown", function (e) {
+      e.stopPropagation();
+      const left = core.dom.gameGroup.offsetLeft;
+      const top = core.dom.gameGroup.offsetTop;
+      const px = Math.floor((e.clientX - left) / core.domStyle.scale),
+        py = Math.floor((e.clientY - top) / core.domStyle.scale);
+      core.ui.music.mousedown(px * 3, py * 3);
+    });
+    music.addEventListener("mousemove", function (e) {
+      e.stopPropagation();
+      const left = core.dom.gameGroup.offsetLeft;
+      const top = core.dom.gameGroup.offsetTop;
+      const px = Math.floor((e.clientX - left) / core.domStyle.scale),
+        py = Math.floor((e.clientY - top) / core.domStyle.scale);
+      core.ui.music.mousemove(px * 3, py * 3);
+    });
+    music.addEventListener("mouseup", function (e) {
+      e.stopPropagation();
+
+      isvolume = false;
+    });
+    music.addEventListener("mouseleave", function (e) {
+      e.stopPropagation();
+
+      isvolume = false;
+    });
+    music.addEventListener("touchstart", function (e) {
+      e.preventDefault();
+      const left = core.dom.gameGroup.offsetLeft;
+      const top = core.dom.gameGroup.offsetTop;
+      const px = Math.floor(
+          (e.touches[0].clientX - left) / core.domStyle.scale
+        ),
+        py = Math.floor((e.touches[0].clientY - top) / core.domStyle.scale);
+      core.ui.music.mousedown(px * 3, py * 3);
+    });
+    music.addEventListener("touchmove", function (e) {
+      e.stopPropagation();
+      const left = core.dom.gameGroup.offsetLeft;
+      const top = core.dom.gameGroup.offsetTop;
+      const px = Math.floor(
+          (e.touches[0].clientX - left) / core.domStyle.scale
+        ),
+        py = Math.floor((e.touches[0].clientY - top) / core.domStyle.scale);
+      core.ui.music.mousemove(px * 3, py * 3);
+    });
+    music.addEventListener("touchend", function (e) {
+      e.stopPropagation();
+
+      isvolume = false;
+    });
+    music.addEventListener("touchcancel", function (e) {
+      e.stopPropagation();
+
+      isvolume = false;
+    });
+
+    class musicclass {
+      constructor() {
+        //music列表
+        //需全塔属性注册并保存在bgms文件夹,每个数组为显示的一页内容
+        this.musicMx = [
+          ["Asphodelus_Ceui.opus", "Blind_Alley.opus"],
+          ["Crawler.opus", "op.opus", "theme.opus"],
+        ];
+        //音乐别名（将在播放器内显示的音乐名，music列表内的都要有对应歌名）
+        this.musicname = {
+          "Asphodelus_Ceui.opus": "Asphodelus",
+          "Blind_Alley.opus": "Blind",
+          "Crawler.opus": "Crawler",
+          "op.opus": "op",
+          "theme.opus": "theme",
+        };
+        this.selection = [0, 0];
+        this.stop = false;
+        this.type = "xunhuan";
+        this.randomList = [];
+        this.random = 0;
+      }
+
+      //更新
+      update() {
+        this.background();
+        this.drawUI();
+      }
+      background() {
+        //画布大小设置
+        if (core.domStyle.isVertical) {
+          music.width = 1248;
+          music.height = 2028;
+        } else {
+          music.width = 2028;
+          music.height = 1248;
+        }
+      }
+      mousedown(px, py) {
+        //鼠标按下时
+
+        const makeBox = ([x, y], [w, h]) => {
+          return [
+            [x, y],
+            [x + w, y + h],
+          ];
+        };
+        const inRect = ([x, y], [[sx, sy], [dx, dy]]) => {
+          return sx <= x && x <= dx && sy <= y && y <= dy;
+        };
+        const pos = [px, py];
+        const backbox = makeBox([15, 35], [210, 90]);
+        if (inRect(pos, backbox)) {
+          //离开按钮是一致的，其余的记区分横竖屏
+          music.style.display = "none";
+          core.clearMap(ctx);
+
+          core.unregisterAnimationFrame("music");
+          core.restart();
+
+          return;
+        }
+        if (core.domStyle.isVertical) {
+          //竖屏
+
+          const pageupbox = makeBox([100, 1230], [200, 100]);
+          const pagedownbox = makeBox([950, 1230], [200, 100]);
+          const musicbox = makeBox(
+            [100, 200],
+            [1048, this.musicMx[page].length * 100]
+          );
+          const beforebox = makeBox([120, 1620], [100, 100]);
+          const afterbox = makeBox([780, 1620], [100, 100]);
+          const playbox = makeBox([420, 1580], [200, 200]);
+          const typebox = makeBox([1040, 1600], [120, 120]);
+
+          const volumebox = makeBox([250, 1940], [1050, 20]);
+          if (inRect(pos, pageupbox)) {
+            if (page !== 0) page -= 1;
+            return;
+          }
+          if (inRect(pos, pagedownbox)) {
+            if (page !== this.musicMx.length - 1) page += 1;
+            return;
+          }
+          if (inRect(pos, playbox)) {
+            if (this.stop) {
+              this.stop = !this.stop;
+
+              core.resumeBgm();
+            } else {
+              this.stop = !this.stop;
+              core.pauseBgm();
+            }
+            return;
+          }
+          if (inRect(pos, beforebox)) {
+            this.stop = false;
+            switch (this.type) {
+              case "danqu":
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                page = this.selection[0];
+
+                break;
+              case "xunhuan":
+                if (this.selection[1] === 0) {
+                  if (this.selection[0] === 0) {
+                    this.selection[0] = this.musicMx.length - 1;
+                    this.selection[1] =
+                      this.musicMx[this.selection[0]].length - 1;
+                  } else {
+                    this.selection[0] -= 1;
+                    this.selection[1] =
+                      this.musicMx[this.selection[0]].length - 1;
+                  }
+                } else {
+                  this.selection[1] -= 1;
+                }
+                this.randomList.indexOf(
+                  this.musicMx[this.selection[0]][this.selection[1]]
+                );
+                page = this.selection[0];
+
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                break;
+              case "suiji":
+                if (this.random > 0) {
+                  this.random -= 1;
+                } else {
+                  this.random = this.randomList.length - 1;
+                }
+                this.selection[0] = this.musicMx.findIndex((v) =>
+                  v.includes(this.randomList[this.random])
+                );
+                this.selection[1] = this.musicMx[this.selection[0]].indexOf(
+                  this.randomList[this.random]
+                );
+
+                page = this.selection[0];
+
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, afterbox)) {
+            this.stop = false;
+            switch (this.type) {
+              case "danqu":
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                page = this.selection[0];
+                break;
+              case "xunhuan":
+                if (
+                  this.selection[1] ===
+                  this.musicMx[this.selection[0]].length - 1
+                ) {
+                  if (this.selection[0] === this.musicMx.length - 1) {
+                    this.selection[0] = 0;
+                    this.selection[1] = 0;
+                  } else {
+                    this.selection[0] += 1;
+                    this.selection[1] = 0;
+                  }
+                } else {
+                  this.selection[1] += 1;
+                }
+                this.random = this.randomList.indexOf(
+                  this.musicMx[this.selection[0]][this.selection[1]]
+                );
+                page = this.selection[0];
+
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                break;
+              case "suiji":
+                if (this.random < this.randomList.length - 1) {
+                  this.random += 1;
+                } else {
+                  this.random = 0;
+                }
+                this.selection[0] = this.musicMx.findIndex((v) =>
+                  v.includes(this.randomList[this.random])
+                );
+                this.selection[1] = this.musicMx[this.selection[0]].indexOf(
+                  this.randomList[this.random]
+                );
+
+                page = this.selection[0];
+                core.playBgm(
+                  main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                    main.core.ui.music.selection[1]
+                  ]
+                );
+
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, typebox)) {
+            switch (this.type) {
+              case "danqu":
+                this.type = "xunhuan";
+                break;
+              case "xunhuan":
+                this.type = "suiji";
+                break;
+              case "suiji":
+                this.type = "danqu";
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, musicbox)) {
+            const index = Math.floor((py - 200) / 100);
+            if (page !== this.selection[0] || index !== this.selection[1]) {
+              this.selection[0] = page;
+              this.selection[1] = index;
+              this.randomList.indexOf(
+                this.musicMx[this.selection[0]][this.selection[1]]
+              );
+
+              core.playBgm(
+                main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                  main.core.ui.music.selection[1]
+                ]
+              );
+
+              this.stop = false;
+            } else {
+              if (this.stop) {
+                this.stop = !this.stop;
+                core.resumeBgm();
+              } else {
+                this.stop = !this.stop;
+                core.pauseBgm();
+              }
+            }
+            return;
+          }
+
+          if (inRect(pos, volumebox)) {
+            const time = Math.min(Math.max((px - 250) / 800, 0), 1);
+            audio.setVolume(time);
+            core.plugin.audioSystem.soundPlayer.setVolume(time);
+            isvolume = true;
+          }
+        } else {
+          //横屏
+          const pageupbox = makeBox([1050, 1100], [200, 100]);
+          const pagedownbox = makeBox([1550, 1100], [200, 100]);
+          const musicbox = makeBox(
+            [900, 100],
+            [1000, this.musicMx[page].length * 100]
+          );
+          const beforebox = makeBox([60, 620], [100, 100]);
+          const afterbox = makeBox([450, 620], [100, 100]);
+          const playbox = makeBox([200, 570], [200, 200]);
+          const typebox = makeBox([620, 600], [120, 120]);
+
+          const volumebox = makeBox([100, 990], [600, 20]);
+          if (inRect(pos, pageupbox)) {
+            if (page !== 0) page -= 1;
+            return;
+          }
+          if (inRect(pos, pagedownbox)) {
+            if (page !== this.musicMx.length - 1) page += 1;
+            return;
+          }
+          if (inRect(pos, playbox)) {
+            if (this.stop) {
+              this.stop = !this.stop;
+              core.resumeBgm();
+            } else {
+              this.stop = !this.stop;
+              core.pauseBgm();
+            }
+            return;
+          }
+          if (inRect(pos, beforebox)) {
+            this.stop = false;
+            switch (this.type) {
+              case "danqu":
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                page = this.selection[0];
+
+                break;
+              case "xunhuan":
+                if (this.selection[1] === 0) {
+                  if (this.selection[0] === 0) {
+                    this.selection[0] = this.musicMx.length - 1;
+                    this.selection[1] =
+                      this.musicMx[this.selection[0]].length - 1;
+                  } else {
+                    this.selection[0] -= 1;
+                    this.selection[1] =
+                      this.musicMx[this.selection[0]].length - 1;
+                  }
+                } else {
+                  this.selection[1] -= 1;
+                }
+                this.random = this.randomList.indexOf(
+                  this.musicMx[this.selection[0]][this.selection[1]]
+                );
+                page = this.selection[0];
+
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                break;
+              case "suiji":
+                if (this.random > 0) {
+                  this.random -= 1;
+                } else {
+                  this.random = this.randomList.length - 1;
+                }
+                this.selection[0] = this.musicMx.findIndex((v) =>
+                  v.includes(this.randomList[this.random])
+                );
+                this.selection[1] = this.musicMx[this.selection[0]].indexOf(
+                  this.randomList[this.random]
+                );
+
+                page = this.selection[0];
+
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, afterbox)) {
+            this.stop = false;
+            switch (this.type) {
+              case "danqu":
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                page = this.selection[0];
+                break;
+              case "xunhuan":
+                if (
+                  this.selection[1] ===
+                  this.musicMx[this.selection[0]].length - 1
+                ) {
+                  if (this.selection[0] === this.musicMx.length - 1) {
+                    this.selection[0] = 0;
+                    this.selection[1] = 0;
+                  } else {
+                    this.selection[0] += 1;
+                    this.selection[1] = 0;
+                  }
+                } else {
+                  this.selection[1] += 1;
+                }
+                this.randomList.findIndex(
+                  (v) =>
+                    v === this.musicMx[this.selection[0]][this.selection[1]]
+                );
+                page = this.selection[0];
+
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                break;
+              case "suiji":
+                if (this.random < this.randomList.length - 1) {
+                  this.random += 1;
+                } else {
+                  this.random = 0;
+                }
+                this.selection[0] = this.musicMx.findIndex((v) =>
+                  v.includes(this.randomList[this.random])
+                );
+                this.selection[1] = this.musicMx[this.selection[0]].indexOf(
+                  main.core.ui.music.randomList[main.core.ui.music.random]
+                );
+
+                page = this.selection[0];
+                if (!this.stop)
+                  core.playBgm(
+                    main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                      main.core.ui.music.selection[1]
+                    ]
+                  );
+
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, typebox)) {
+            switch (this.type) {
+              case "danqu":
+                this.type = "xunhuan";
+                break;
+              case "xunhuan":
+                this.type = "suiji";
+                break;
+              case "suiji":
+                this.type = "danqu";
+                break;
+            }
+            return;
+          }
+          if (inRect(pos, musicbox)) {
+            const index = Math.floor((py - 100) / 100);
+            if (page !== this.selection[0] || index !== this.selection[1]) {
+              this.selection[0] = page;
+              this.selection[1] = index;
+              this.randomList.indexOf(
+                (v) => v === this.musicMx[this.selection[0]][this.selection[1]]
+              );
+
+              core.playBgm(
+                main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                  main.core.ui.music.selection[1]
+                ]
+              );
+              this.stop = false;
+            } else {
+              if (this.stop) {
+                this.stop = !this.stop;
+                core.resumeBgm();
+              } else {
+                this.stop = !this.stop;
+                core.pauseBgm();
+              }
+            }
+            return;
+          }
+
+          if (inRect(pos, volumebox)) {
+            const time = Math.min(Math.max((px - 100) / 600, 0), 1);
+            audio.setVolume(time);
+            core.plugin.audioSystem.soundPlayer.setVolume(time);
+            isvolume = true;
+          }
+        }
+      }
+      mousemove(px, py) {
+        if (isvolume) {
+          if (core.domStyle.isVertical) {
+            const time = Math.min(Math.max((px - 250) / 800, 0), 1);
+            audio.setVolume(time);
+            core.plugin.audioSystem.soundPlayer.setVolume(time);
+          } else {
+            const time = Math.min(Math.max((px - 100) / 600, 0), 1);
+            audio.setVolume(time);
+            core.plugin.audioSystem.soundPlayer.setVolume(time);
+          }
+        }
+      }
+
+      drawUI() {
+        //绘制页面
+        core.clearMap(music);
+        const bgVertical = core.material.images.images["bg_2010.webp"]; //竖屏背景
+        const bg = core.material.images.images["bg_5043.webp"]; //竖屏背景
+        if (core.domStyle.isVertical) {
+          //竖屏
+
+          core.fillRect(ctx, 0, 0, 1248, 2028, "#000000"); //黑色背景
+          ctx.globalAlpha = 0.3; //透明度
+          if (bgVertical)
+            ctx.drawImage(bgVertical, 0, 0, 1280, 1500, 0, 0, 1248, 2028); //绘制半透明背景图片
+          ctx.globalAlpha = 1; //恢复为不透明
+
+          core.setTextAlign(ctx, "center");
+          core.fillBoldText1(
+            ctx,
+            "◀离开",
+            110,
+            100,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+
+          ctx.strokeStyle = "#FFFFFF";
+          ctx.lineWidth = 3;
+          ctx.beginPath();
+          ctx.moveTo(100, 200);
+          ctx.lineTo(1148, 200);
+
+          ctx.stroke();
+          let posy = 300;
+          const indexList = this.musicMx[page];
+          core.setTextAlign(ctx, "left");
+          for (let i = 0; i < indexList.length; i++) {
+            const text = this.musicname[indexList[i]];
+            core.fillBoldText1(
+              ctx,
+              text,
+              150,
+              posy - 30,
+              page === this.selection[0] && i === this.selection[1]
+                ? "#FFFFFF"
+                : "#444444",
+              "#000000",
+              6,
+              core.ui._buildFont(66, true)
+            );
+            ctx.strokeStyle = "#FFFFFF";
+            ctx.lineWidth = 3;
+            ctx.beginPath();
+            ctx.moveTo(100, posy);
+            ctx.lineTo(1148, posy);
+            ctx.stroke();
+            posy += 100;
+          }
+          ctx.beginPath();
+          ctx.moveTo(100, 1210);
+          ctx.lineTo(1148, 1210);
+          ctx.moveTo(100, 1200);
+          ctx.lineTo(1148, 1200);
+          ctx.stroke();
+
+          core.fillBoldText1(
+            ctx,
+            "上一页",
+            100,
+            1300,
+            page === 0 ? "#444444" : "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+
+          core.fillBoldText1(
+            ctx,
+            page + 1 + "/" + this.musicMx.length,
+            580,
+            1300,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+          core.fillBoldText1(
+            ctx,
+            "下一页",
+            950,
+            1300,
+            page === this.musicMx.length - 1 ? "#444444" : "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+
+          ctx.strokeStyle = "#ffffff";
+          ctx.lineWidth = 3;
+
+          ctx.fillStyle = "#ffffff";
+          ctx.font = "bold 96px Verdana";
+          ctx.fillText("|", 100, 1697);
+          ctx.fillText("◀", 115, 1700);
+          ctx.beginPath();
+          ctx.arc(505, 1670, 80, 0, 3 * Math.PI);
+          ctx.stroke();
+          ctx.fillText("|", 835, 1697);
+          ctx.fillText("▶", 785, 1700);
+          if (this.stop) {
+            ctx.fillText("▶", 473, 1697);
+          } else {
+            ctx.fillText("||", 453, 1694);
+          }
+
+          const img = core.material.images.images[this.type + ".webp"];
+          if (img) ctx.drawImage(img, 1000, 1555, 200, 200);
+          core.setTextAlign(ctx, "center");
+          ctx.font = "bold 52px Verdana";
+          ctx.fillText("当前歌曲", 625, 1397);
+          ctx.fillText(
+            this.musicname[this.musicMx[this.selection[0]][this.selection[1]]],
+            625,
+            1507
+          );
+
+          ctx.fillStyle = "#ffffff";
+          ctx.font = "bold 48px Verdana";
+          ctx.fillText("音量", 150, 1970);
+          ctx.lineWidth = 3;
+          ctx.beginPath();
+          ctx.moveTo(250, 1950);
+          ctx.lineTo(1050, 1950);
+          ctx.stroke();
+          ctx.strokeStyle = "#ffffff";
+          ctx.lineWidth = 9;
+          ctx.fillStyle = "rgba(255,255,255,0.5)";
+
+          ctx.beginPath();
+          ctx.moveTo(250, 1950);
+          ctx.lineTo(800 * audio.getVolume() + 250, 1950);
+          ctx.stroke();
+          ctx.beginPath();
+          ctx.arc(800 * audio.getVolume() + 250, 1950, 10, 0, 2 * Math.PI);
+          ctx.fill();
+          core.fillBoldText1(
+            ctx,
+            Math.floor(100 * audio.getVolume()),
+            1120,
+            1970,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(56, true)
+          );
+        } else {
+          //横屏
+
+          core.fillRect(ctx, 0, 0, 2028, 1248, "#000000"); //黑色背景
+          ctx.globalAlpha = 0.5; //透明度
+          if (bg) ctx.drawImage(bg, 0, 0, 1280, 720, 0, 0, 2028, 1248); //绘制半透明背景图片
+          ctx.globalAlpha = 1; //恢复为不透明
+          core.setTextAlign(ctx, "center");
+
+          core.fillBoldText1(
+            ctx,
+            "◀离开",
+            110,
+            100,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+
+          ctx.strokeStyle = "#FFFFFF";
+          ctx.lineWidth = 3;
+          ctx.beginPath();
+          ctx.moveTo(800, 100);
+          ctx.lineTo(800, 1148);
+          ctx.moveTo(900, 100);
+          ctx.lineTo(1900, 100);
+          ctx.stroke();
+          let posy = 200;
+          const indexList = this.musicMx[page];
+          core.setTextAlign(ctx, "left");
+          for (let i = 0; i < indexList.length; i++) {
+            const text = this.musicname[indexList[i]];
+            core.fillBoldText1(
+              ctx,
+              text,
+              950,
+              posy - 30,
+              page === this.selection[0] && i === this.selection[1]
+                ? "#FFFFFF"
+                : "#444444",
+              "#000000",
+              6,
+              core.ui._buildFont(66, true)
+            );
+            ctx.strokeStyle = "#FFFFFF";
+            ctx.lineWidth = 3;
+            ctx.beginPath();
+            ctx.moveTo(900, posy);
+            ctx.lineTo(1900, posy);
+            ctx.stroke();
+            posy += 100;
+          }
+          core.fillBoldText1(
+            ctx,
+            "上一页",
+            1050,
+            1200 - 30,
+            page === 0 ? "#444444" : "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+
+          core.fillBoldText1(
+            ctx,
+            page + 1 + "/" + this.musicMx.length,
+            1350,
+            1200 - 30,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+          core.fillBoldText1(
+            ctx,
+            "下一页",
+            1550,
+            1200 - 30,
+            page === this.musicMx.length - 1 ? "#444444" : "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(66, true)
+          );
+          ctx.strokeStyle = "#ffffff";
+          ctx.lineWidth = 3;
+
+          ctx.fillStyle = "#ffffff";
+          ctx.font = "bold 96px Verdana";
+          ctx.fillText("|", 60, 697);
+          ctx.fillText("◀", 70, 700);
+          ctx.beginPath();
+          ctx.arc(295, 670, 80, 0, 2 * Math.PI);
+          ctx.stroke();
+          if (this.stop) {
+            ctx.fillText("▶", 245, 697);
+          } else {
+            ctx.fillText("||", 245, 694);
+          }
+
+          ctx.fillText("|", 490, 697);
+          ctx.fillText("▶", 450, 700);
+          ctx.font = "bold 48px Verdana";
+          ctx.fillText("音量", 350, 900);
+          ctx.beginPath();
+          ctx.moveTo(100, 1000);
+          ctx.lineTo(700, 1000);
+          ctx.stroke();
+          ctx.strokeStyle = "#ffffff";
+          ctx.lineWidth = 9;
+          ctx.fillStyle = "rgba(255,255,255,0.5)";
+
+          ctx.beginPath();
+          ctx.moveTo(100, 1000);
+          ctx.lineTo(600 * audio.getVolume() + 100, 1000);
+          ctx.stroke();
+          ctx.beginPath();
+          ctx.arc(600 * audio.getVolume() + 100, 1000, 10, 0, 2 * Math.PI);
+          ctx.fill();
+          core.fillBoldText1(
+            ctx,
+            Math.floor(100 * audio.getVolume()),
+            720,
+            1010,
+            "#FFFFFF",
+            "#000000",
+            6,
+            core.ui._buildFont(56, true)
+          );
+          const img = core.material.images.images[this.type + ".webp"];
+          if (img) ctx.drawImage(img, 580, 560, 200, 200);
+          core.setTextAlign(ctx, "center");
+          ctx.font = "bold 48px Verdana";
+          ctx.fillText("当前歌曲", 400, 297);
+          ctx.fillText(
+            this.musicname[this.musicMx[this.selection[0]][this.selection[1]]],
+            400,
+            397
+          );
+        }
+      }
+    }
+    core.ui.music = new musicclass();
+    main.dom.musicMode.onclick = function () {
+      //点击开始页面的CG MODE进入cg回廊
+
+      core.playBgm(
+        main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+          main.core.ui.music.selection[1]
+        ]
+      );
+
+      const arr = main.core.ui.music.musicMx.flat(Infinity);
+      main.core.ui.music.randomList = shuffle(arr);
+      main.core.ui.music.random = main.core.ui.music.randomList.indexOf(
+        main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+          main.core.ui.music.selection[1]
+        ]
+      );
+      page = 0;
+      music.style.display = "block";
+      let time = 0;
+      core.registerAnimationFrame("music", null, (temptime) => {
+        if (temptime > time + 1000 / 60) {
+          time = temptime;
+          main.core.ui.music.update();
+          const duration =
+            core.plugin.audioSystem.bgmController.player.getRoute(
+              "bgms." +
+                main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                  main.core.ui.music.selection[1]
+                ]
+            ).duration;
+
+          const currentTime =
+            core.plugin.audioSystem.bgmController.player.getRoute(
+              "bgms." +
+                main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+                  main.core.ui.music.selection[1]
+                ]
+            ).currentTime;
+          if (currentTime && duration && duration - currentTime < 0.05) {
+            if (core.domStyle.isVertical) {
+              core.ui.music.mousedown(830, 1770);
+            } else {
+              core.ui.music.mousedown(475, 765);
+            }
+          }
+        }
+      });
+    };
+  },
+  横屏切换: function () {
     // 在此增加新插件
     this.triggerFullscreen = async function (full) {
       if (!!document.fullscreenElement && !full) {
@@ -17338,7 +17336,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       }
     };
   },
-    "图片压缩webp导出": function () {
+  图片压缩webp导出: function () {
     // 在此增加新插件
     //使用方法：进入游戏后开始游戏，F12打开控制台，输入core.towebp(image),image为已在全塔属性中注册过的图片名字，需要""括起来
     this.towebp = function (image) {
@@ -17369,7 +17367,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
       });
     };
   },
-    "帧动画特效（游戏界面）": function () {
+  "帧动画特效（游戏界面）": function () {
     // 在此增加新插件
     const animate2 = document.createElement("canvas"); //画布设置
     animate2.style.zIndex = 71;
@@ -17564,5 +17562,5 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
         });
       }
     });
-  }
-}
\ No newline at end of file
+  },
+};