diff --git a/project/plugins.js b/project/plugins.js
index 317ee03..71dde29 100644
--- a/project/plugins.js
+++ b/project/plugins.js
@@ -4196,278 +4196,279 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
}
},
"编辑器显伤": function () {
- // 在此增加新插件
- /////// 用户设置 ///////
- // 将__enable置为false将关闭插件
- var __enable = true;
- // 魔防攻速之类的属性可以在这里加 ['atk', 'def', 'mdef']
- var heroStatus = ["atk", "def", "mdef", "hp"];
- // saveHero为true 将会把每次造塔测试时的角色数据存下来 否则会读取初始属性
- // 用不着可以关了 节约缓存空间 (虽然根本没多少 还没一个存档大
- // 也可以手动清理 控制台输入core.removeLocalStorage('editorHero')即可
- var saveHero = true;
+ // 在此增加新插件
+ /////// 用户设置 ///////
+ // 将__enable置为false将关闭插件
+ var __enable = true;
+ // 魔防攻速之类的属性可以在这里加 ['atk', 'def', 'mdef']
+ var heroStatus = ["atk", "def", "mdef", "hp"];
+ // saveHero为true 将会把每次造塔测试时的角色数据存下来 否则会读取初始属性
+ // 用不着可以关了 节约缓存空间 (虽然根本没多少 还没一个存档大
+ // 也可以手动清理 控制台输入core.removeLocalStorage('editorHero')即可
+ var saveHero = true;
- // 下为具体实现 懒得写注释了 大概就是写HTML然后注册交互
- if (!__enable || main.mode != "editor") return;
- core.plugin.initEditorDamage = false;
- if (heroStatus.length >= 4 && !editor.isMobile)
- editor.dom.mid2.style.top = 650 + 30 * (heroStatus.length - 3) + "px";
- editor.statusRatio = core.getLocalStorage("statusRatio", 1);
- editor.saveHero = saveHero;
- editor._heroStatus = heroStatus;
- editor.dom.mapEdit.appendChild(core.canvas.damage.canvas);
- var HTML =
- "";
+ // 下为具体实现 懒得写注释了 大概就是写HTML然后注册交互
+ if (!__enable || main.mode != "editor") return;
+ core.plugin.initEditorDamage = false;
+ if (heroStatus.length >= 4 && !editor.isMobile)
+ editor.dom.mid2.style.top = 650 + 30 * (heroStatus.length - 3) + "px";
+ editor.statusRatio = core.getLocalStorage("statusRatio", 1);
+ editor.saveHero = saveHero;
+ editor._heroStatus = heroStatus;
+ editor.dom.mapEdit.appendChild(core.canvas.damage.canvas);
+ var HTML =
+ "";
- //if (heroStatus.length >= 4 && !editor.isMobile) editor.dom.mid2.style.top = 650 + 30 * (heroStatus.length - 3) + 'px';
- heroStatus.forEach(function (status) {
- var id = status + "set",
- id2 = status + "add",
- id3 = status + "rec",
- id4 = status + "help";
- HTML +=
- "
";
- });
- document.getElementById("viewportButtons").innerHTML = HTML;
- ["set", "add", "rec", "help"].forEach(function (e) {
- heroStatus.forEach(function (status) {
- editor.dom[status + e] = document.getElementById(status + e);
- });
- });
- var _hasItem = core.items.hasItem;
- core.items.hasItem = function (itemId) {
- if (itemId == "book" && main.mode == "editor") return true;
- return _hasItem.call(core.items, itemId);
- };
- if (main.mode == "editor") {
- var applyList = [
- "getDamageString",
- "nextCriticals",
- "getEnemyInfo",
- "getEnemyValue",
- ];
- applyList.forEach(function (name) {
- var func = core.enemys[name];
- core.enemys[name] = function () {
- var args =
- arguments.length === 1 ? [arguments[0]] :
- Array.apply(null, arguments);
- if (typeof args[0] == "string") args[0] = core.enemys.enemys[args[0]];
- return func.apply(core.enemys, args);
- };
- });
- }
+ //if (heroStatus.length >= 4 && !editor.isMobile) editor.dom.mid2.style.top = 650 + 30 * (heroStatus.length - 3) + 'px';
+ heroStatus.forEach(function (status) {
+ var id = status + "set",
+ id2 = status + "add",
+ id3 = status + "rec",
+ id4 = status + "help";
+ HTML +=
+ "
";
+ });
+ document.getElementById("viewportButtons").innerHTML = HTML;
+ ["set", "add", "rec", "help"].forEach(function (e) {
+ heroStatus.forEach(function (status) {
+ editor.dom[status + e] = document.getElementById(status + e);
+ });
+ });
+ var _hasItem = core.items.hasItem;
+ core.items.hasItem = function (itemId) {
+ if (itemId == "book" && main.mode == "editor") return true;
+ return _hasItem.call(core.items, itemId);
+ };
+ if (main.mode == "editor") {
+ var applyList = [
+ "getDamageString",
+ "nextCriticals",
+ "getEnemyInfo",
+ "getEnemyValue",
+ ];
+ applyList.forEach(function (name) {
+ var func = core.enemys[name];
+ core.enemys[name] = function () {
+ var args =
+ arguments.length === 1
+ ? [arguments[0]]
+ : Array.apply(null, arguments);
+ if (typeof args[0] == "string") args[0] = core.enemys.enemys[args[0]];
+ return func.apply(core.enemys, args);
+ };
+ });
+ }
- ////// 获得勇士属性 //////
- core.control.getStatus = function (name) {
- if (!core.status.hero) return null;
- if (name == "x" || name == "y" || name == "direction")
- return this.getHeroLoc(name);
- /*if ( main.mode == 'editor' && !core.hasFlag('__statistics__')) {
+ ////// 获得勇士属性 //////
+ core.control.getStatus = function (name) {
+ if (!core.status.hero) return null;
+ if (name == "x" || name == "y" || name == "direction")
+ return this.getHeroLoc(name);
+ /*if ( main.mode == 'editor' && !core.hasFlag('__statistics__')) {
return data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.hero[name];
}*/
- return core.status.hero[name];
- };
+ return core.status.hero[name];
+ };
- core.control.updateDamage = function (floorId, ctx) {
- floorId = floorId || core.status.floorId;
- if (!floorId || core.status.gameOver) return;
- var onMap = ctx == null;
- if (main.mode == "editor") {
- ctx = core.canvas.damage;
- core.updateCheckBlock();
- core.clearMap(ctx);
- if (editor.uivalues.bigmap) return;
- }
+ core.control.updateDamage = function (floorId, ctx) {
+ floorId = floorId || core.status.floorId;
+ if (!floorId || core.status.gameOver) return;
+ var onMap = ctx == null;
+ if (main.mode == "editor") {
+ ctx = core.canvas.damage;
+ core.updateCheckBlock();
+ core.clearMap(ctx);
+ if (editor.uivalues.bigmap) return;
+ }
- // 没有怪物手册
- if (!core.hasItem("book")) return;
- core.status.damage.posX = core.bigmap.posX;
- core.status.damage.posY = core.bigmap.posY;
- if (!onMap) {
- var width = core.floors[floorId].width,
- height = core.floors[floorId].height;
- // 地图过大的缩略图不绘制显伤
- if (width * height > core.bigmap.threshold) return;
- }
- this._updateDamage_damage(floorId, onMap);
- this._updateDamage_extraDamage(floorId, onMap);
- this.drawDamage(ctx);
- };
+ // 没有怪物手册
+ if (!core.hasItem("book")) return;
+ core.status.damage.posX = core.bigmap.posX;
+ core.status.damage.posY = core.bigmap.posY;
+ if (!onMap) {
+ var width = core.floors[floorId].width,
+ height = core.floors[floorId].height;
+ // 地图过大的缩略图不绘制显伤
+ if (width * height > core.bigmap.threshold) return;
+ }
+ this._updateDamage_damage(floorId, onMap);
+ this._updateDamage_extraDamage(floorId, onMap);
+ this.drawDamage(ctx);
+ };
- core.control.drawDamage = function (ctx) {
- if (
- core.status.gameOver ||
- !core.status.damage /* || main.mode != 'play'*/
- )
- return;
- var onMap = false;
- if (ctx == null) {
- ctx = core.canvas.damage;
- core.clearMap("damage");
- onMap = true;
- }
+ core.control.drawDamage = function (ctx) {
+ if (
+ core.status.gameOver ||
+ !core.status.damage /* || main.mode != 'play'*/
+ )
+ return;
+ var onMap = false;
+ if (ctx == null) {
+ ctx = core.canvas.damage;
+ core.clearMap("damage");
+ onMap = true;
+ }
- if (onMap && core.bigmap.v2) {
- // 检查是否需要重算...
- if (
- Math.abs(core.bigmap.posX - core.status.damage.posX) >=
- core.bigmap.extend - 1 ||
- Math.abs(core.bigmap.posY - core.status.damage.posY) >=
- core.bigmap.extend - 1
- ) {
- return this.updateDamage();
- }
- }
- return this._drawDamage_draw(ctx, onMap);
- };
+ if (onMap && core.bigmap.v2) {
+ // 检查是否需要重算...
+ if (
+ Math.abs(core.bigmap.posX - core.status.damage.posX) >=
+ core.bigmap.extend - 1 ||
+ Math.abs(core.bigmap.posY - core.status.damage.posY) >=
+ core.bigmap.extend - 1
+ ) {
+ return this.updateDamage();
+ }
+ }
+ return this._drawDamage_draw(ctx, onMap);
+ };
- ////// 以x,y的形式返回每个点的事件 //////
- core.maps.getMapBlocksObj = function (floorId, noCache) {
- floorId = floorId || core.status.floorId;
- if (
- core.status.mapBlockObjs[floorId] &&
- !noCache &&
- main.mode != "editor"
- )
- return core.status.mapBlockObjs[floorId];
+ ////// 以x,y的形式返回每个点的事件 //////
+ core.maps.getMapBlocksObj = function (floorId, noCache) {
+ floorId = floorId || core.status.floorId;
+ if (
+ core.status.mapBlockObjs[floorId] &&
+ !noCache &&
+ main.mode != "editor"
+ )
+ return core.status.mapBlockObjs[floorId];
- var obj = {};
- core.extractBlocks(floorId);
- core.status.maps[floorId].blocks.forEach(function (block) {
- obj[block.x + "," + block.y] = block;
- });
- core.status.mapBlockObjs[floorId] = obj;
- return obj;
- };
+ var obj = {};
+ core.extractBlocks(floorId);
+ core.status.maps[floorId].blocks.forEach(function (block) {
+ obj[block.x + "," + block.y] = block;
+ });
+ core.status.mapBlockObjs[floorId] = obj;
+ return obj;
+ };
- this.bignum = function (num, defaultValue) {
- if (num == null || num == "") return defaultValue;
- num = num + "";
- var list = {
- w: 1e4,
- e: 1e8,
- z: 1e12,
- j: 1e16,
- g: 1e20,
- };
- // 浮点数问题
- function checkFloat(num) {
- if (!core.isset(num)) return 0;
- num = num + "";
- var index = num.indexOf(".");
- if (index < 0) return 0;
- else return num.slice(index + 1).length;
- }
- var index = num.search(/w|e|z|j|g/);
- if (index <= 0) {
- num = parseInt(num);
- if (core.isset(num)) return num;
- else {
- alert("不正确的输入");
- return defaultValue;
- }
- }
- for (; index > 0; index = num.search(/w|e|z|j|g/)) {
- var p = num[index],
- q = list[p],
- n = num.slice(0, index),
- m = Math.pow(10, checkFloat(n));
- num = (n * m * q) / m + num.slice(index + 1);
- }
- return parseInt(num);
- };
+ this.bignum = function (num, defaultValue) {
+ if (num == null || num == "") return defaultValue;
+ num = num + "";
+ var list = {
+ w: 1e4,
+ e: 1e8,
+ z: 1e12,
+ j: 1e16,
+ g: 1e20,
+ };
+ // 浮点数问题
+ function checkFloat(num) {
+ if (!core.isset(num)) return 0;
+ num = num + "";
+ var index = num.indexOf(".");
+ if (index < 0) return 0;
+ else return num.slice(index + 1).length;
+ }
+ var index = num.search(/w|e|z|j|g/);
+ if (index <= 0) {
+ num = parseInt(num);
+ if (core.isset(num)) return num;
+ else {
+ alert("不正确的输入");
+ return defaultValue;
+ }
+ }
+ for (; index > 0; index = num.search(/w|e|z|j|g/)) {
+ var p = num[index],
+ q = list[p],
+ n = num.slice(0, index),
+ m = Math.pow(10, checkFloat(n));
+ num = (n * m * q) / m + num.slice(index + 1);
+ }
+ return parseInt(num);
+ };
- this.updateEditorDamage = function (noSave) {
- core.updateDamage();
- heroStatus.forEach(function (status) {
- editor.dom[status + "set"].value = core.status.hero[status];
- });
- if (!noSave && editor.saveHero)
- core.setLocalStorage("editorHero", core.status.hero);
- };
+ this.updateEditorDamage = function (noSave) {
+ core.updateDamage();
+ heroStatus.forEach(function (status) {
+ editor.dom[status + "set"].value = core.status.hero[status];
+ });
+ if (!noSave && editor.saveHero)
+ core.setLocalStorage("editorHero", core.status.hero);
+ };
- var _resizeMap = core.maps.resizeMap;
- core.maps.resizeMap = function (floorId) {
- _resizeMap.call(core.maps, floorId);
- if (!core.plugin.initEditorDamage && main.mode == "editor") {
- core.plugin.initEditorDamage = true;
- var editorHero = core.getLocalStorage("editorHero");
- if (editorHero && saveHero) core.status.hero = editorHero;
- else core.removeLocalStorage("editorHero");
- editor._heroStatus.forEach(function (e) {
- editor.dom[e + "set"].onchange = function () {
- var status = this.id.slice(0, -3);
- core.status.hero[status] = core.bignum(
- this.value,
- core.status.hero[status]
- );
- core.updateEditorDamage();
- };
- editor.dom[e + "add"].onclick = function () {
- var status = this.id.slice(0, -3);
- core.status.hero[status] += editor.statusRatio;
- core.updateEditorDamage();
- };
- editor.dom[e + "rec"].onclick = function () {
- var status = this.id.slice(0, -3);
- core.status.hero[status] -= editor.statusRatio;
- core.updateEditorDamage();
- };
- editor.dom[e + "help"].onclick = function () {
- var status = this.id.slice(0, -4),
- name = core.getStatusLabel(status);
- var ratio = parseInt(
- prompt(
- "当前属性:" +
- name +
- "\n现在的点击按钮变化值:" +
- editor.statusRatio +
- ",请输入按下一次+/-按钮的属性变化量,可以写4w 10.2e这种字母缩写"
- )
- );
- if (!core.isset(ratio)) {
- printe("不合法的输入");
- return;
- }
- editor.statusRatio = ratio;
- core.setLocalStorage("statusRatio", ratio);
- };
- });
- var _updateMap = editor.updateMap;
- editor.updateMap = function () {
- _updateMap.call(editor);
- core.updateEditorDamage(true);
- };
- editor.mode.onmode = function (mode, callback) {
- if (editor_mode.mode != mode) {
- if (mode === "save") {
- editor_mode.doActionList(
- editor_mode.mode,
- editor_mode.actionList,
- function () {
- if (callback) callback();
- core.updateEditorDamage();
- }
- );
- }
- if (editor_mode.mode === "nextChange" && mode)
- editor_mode.showMode(mode);
- if (mode !== "save") editor_mode.mode = mode;
- editor_mode.actionList = [];
- }
- };
- }
- };
-},
+ var _resizeMap = core.maps.resizeMap;
+ core.maps.resizeMap = function (floorId) {
+ _resizeMap.call(core.maps, floorId);
+ if (!core.plugin.initEditorDamage && main.mode == "editor") {
+ core.plugin.initEditorDamage = true;
+ var editorHero = core.getLocalStorage("editorHero");
+ if (editorHero && saveHero) core.status.hero = editorHero;
+ else core.removeLocalStorage("editorHero");
+ editor._heroStatus.forEach(function (e) {
+ editor.dom[e + "set"].onchange = function () {
+ var status = this.id.slice(0, -3);
+ core.status.hero[status] = core.bignum(
+ this.value,
+ core.status.hero[status]
+ );
+ core.updateEditorDamage();
+ };
+ editor.dom[e + "add"].onclick = function () {
+ var status = this.id.slice(0, -3);
+ core.status.hero[status] += editor.statusRatio;
+ core.updateEditorDamage();
+ };
+ editor.dom[e + "rec"].onclick = function () {
+ var status = this.id.slice(0, -3);
+ core.status.hero[status] -= editor.statusRatio;
+ core.updateEditorDamage();
+ };
+ editor.dom[e + "help"].onclick = function () {
+ var status = this.id.slice(0, -4),
+ name = core.getStatusLabel(status);
+ var ratio = parseInt(
+ prompt(
+ "当前属性:" +
+ name +
+ "\n现在的点击按钮变化值:" +
+ editor.statusRatio +
+ ",请输入按下一次+/-按钮的属性变化量,可以写4w 10.2e这种字母缩写"
+ )
+ );
+ if (!core.isset(ratio)) {
+ printe("不合法的输入");
+ return;
+ }
+ editor.statusRatio = ratio;
+ core.setLocalStorage("statusRatio", ratio);
+ };
+ });
+ var _updateMap = editor.updateMap;
+ editor.updateMap = function () {
+ _updateMap.call(editor);
+ core.updateEditorDamage(true);
+ };
+ editor.mode.onmode = function (mode, callback) {
+ if (editor_mode.mode != mode) {
+ if (mode === "save") {
+ editor_mode.doActionList(
+ editor_mode.mode,
+ editor_mode.actionList,
+ function () {
+ if (callback) callback();
+ core.updateEditorDamage();
+ }
+ );
+ }
+ if (editor_mode.mode === "nextChange" && mode)
+ editor_mode.showMode(mode);
+ if (mode !== "save") editor_mode.mode = mode;
+ editor_mode.actionList = [];
+ }
+ };
+ }
+ };
+ },
"手册区分特殊属性": function () {
// 在此增加新插件
this.arrsame = function (Arraya, Arrayb) {
@@ -8447,14 +8448,2080 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
}
};
},
+ "音频系统": function () {
+ // 在此增加新插件
+ /*首先，在造塔群下载所需的库文件，然后放置在塔目录下的 libs/thirdparty 或其他目录下，之后在 index.html 的最后加上下面这几行：
+
+
+
+
+
+
+ */
+ // 将__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 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);
+ 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.gain = 0.5;
+ /** 是否正在播放 */
+ this.playing = false;
+ 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*/
+ 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, [52, 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;
+ }
+
+ 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.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;
+ }
+
+ 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().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();
+
+ this.createSourceNode(this.buffer);
+ this.output.start(0, when);
+ this.playing = true;
+
+ this.output.addEventListener("ended", () => {
+ this.playing = false;
+
+ 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;
+ audio.addEventListener("play", () => {
+ this.playing = true;
+
+ });
+ audio.addEventListener("ended", () => {
+ this.playing = false;
+ this.ac = context;
+ });
+ }
+ 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;
+
+ 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;
+
+ this.createSourceNode(this.buffer);
+ this.output.start(0, when);
+ this.output.addEventListener("ended", () => {
+ this.playing = false;
+ 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;
+ }
+ }
+ const AudioStatus = {
+ Playing: 0,
+ Pausing: 1,
+ Paused: 2,
+ Stoping: 3,
+ Stoped: 4,
+ };
+ const AudioRouteEvent = {
+ updateEffect: [],
+ play: [],
+ stop: [],
+ pause: [],
+ resume: [],
+ };
+ class AudioRoute {
+ constructor(source, player) {
+ this.output = source.output;
+ /** 效果器路由图 */
+ this.effectRoute = [];
+
+ /** 结束时长，当音频暂停或停止时，会经过这么长时间之后才真正终止播放，期间可以做音频淡入淡出等效果 */
+ this.endTime = 0;
+ /** 暂停时播放了多长时间 */
+ this.pauseCurrentTime = 0;
+ /** 当前播放状态 */
+ this.status = AudioStatus.Stoped;
+ this.shouldStop = false;
+ /**
+ * 每次暂停或停止时自增，用于判断当前正在处理的情况。
+ * 假如暂停后很快播放，然后很快暂停，那么需要根据这个来判断实际是否应该执行暂停后操作
+ */
+ this.stopIdentifier = 0;
+ /** 暂停时刻 */
+ this.pauseTime = 0;
+ this.source = source;
+ this.player = player;
+ }
+ /** 音频时长，单位秒 */
+ get duration() {
+ return this.source.duration;
+ }
+ /** 当前播放了多长时间，单位秒 */
+ get currentTime() {
+ if (this.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.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.status = AudioStatus.Playing;
+ this.pauseTime = 0;
+ this.audioStartHook?.(this);
+ this.startAllEffect();
+ }
+
+ /**
+ * 暂停音频播放
+ */
+ async pause() {
+ if (this.status !== AudioStatus.Playing) return;
+ this.status = AudioStatus.Pausing;
+ this.stopIdentifier++;
+ const identifier = this.stopIdentifier;
+ if (this.audioEndHook) {
+ this.audioEndHook(this.endTime, this);
+ await sleep(this.endTime);
+ }
+ if (
+ this.status !== AudioStatus.Pausing ||
+ this.stopIdentifier !== identifier
+ ) {
+ return;
+ }
+ this.pauseCurrentTime = this.source.currentTime;
+ const time = this.source.stop();
+ this.pauseTime = time;
+ if (this.shouldStop) {
+ this.status = AudioStatus.Stoped;
+ this.endAllEffect();
+
+ this.shouldStop = false;
+ } else {
+ this.status = AudioStatus.Paused;
+ this.endAllEffect();
+ }
+ this.endAllEffect();
+ }
+
+ /**
+ * 继续音频播放
+ */
+ resume() {
+ if (this.status === AudioStatus.Playing) return;
+ if (
+ this.status === AudioStatus.Pausing ||
+ this.status === AudioStatus.Stoping
+ ) {
+ this.audioStartHook?.(this);
+
+ return;
+ }
+ if (this.status === AudioStatus.Paused) {
+ this.play(this.pauseTime);
+ } else {
+ this.play(0);
+ }
+ this.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 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);
+ });
+ 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);
+ }
+ 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);
+ }
+
+ async decodeAll(data) {
+ return this.decoder?.decodeFile(data);
+ }
+ /**
+ * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
+ */
+ async flush() {
+ return await this.decoder?.flush();
+ }
+ }
+ 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;
+ this._volume = 1
+ }
+
+ /**
+ * 设置音频渐变时长
+ * @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(volume) {
+ return this._volume;
+ }
+
+ /**
+ * 设置是否启用
+ * @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;
+ }
+
+ /**
+ * 继续当前的 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);
+ }
+ /**
+ * 添加一个音效
+ * @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 () {
- // 在此增加新插件
- // -------------------- 安装说明 -------------------- //
- // 先安装两个在插件简介中说明的前置插件
- // 然后再将本插件复制到插件编写中即可
- // 插件自带一个打怪后显示碎裂特效的功能
- // -------------------- 使用说明 -------------------- //
- /*
+ // 在此增加新插件
+ // -------------------- 安装说明 -------------------- //
+ // 先安装两个在插件简介中说明的前置插件
+ // 然后再将本插件复制到插件编写中即可
+ // 插件自带一个打怪后显示碎裂特效的功能
+ // -------------------- 使用说明 -------------------- //
+ /*
本插件的核心是一个名为 applyFragWith 的函数，打怪后的碎裂特效也是由它执行的。
我们来说明一下这个函数的使用方式。
@@ -8480,217 +10547,218 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
*/
- if (main.replayChecking) return (core.plugin.frag = {});
+ if (main.replayChecking) return (core.plugin.frag = {});
- const { Animation, linear, sleep } = core.plugin.animate;
- const { has } = core.plugin.utils;
+ const { Animation, linear, sleep } = core.plugin.animate;
+ const { has } = core.plugin.utils;
- /** 最大移动距离，最终位置距离中心的距离变成原来的几倍 */
- const MAX_MOVE_LENGTH = 1.15;
- /** 移动距离波动，在最大移动距离的基础上加上多少倍距离的波动距离 */
- const MOVE_FLUSH = 0.7;
- /** 最大旋转角，单位是弧度，每个碎片都会有自己的旋转程度，是随机的 */
- const MAX_ROTATE = 0.5;
- /** 碎裂动画的速率曲线函数 */
- const FRAG_TIMING = linear();
+ /** 最大移动距离，最终位置距离中心的距离变成原来的几倍 */
+ const MAX_MOVE_LENGTH = 1.15;
+ /** 移动距离波动，在最大移动距离的基础上加上多少倍距离的波动距离 */
+ const MOVE_FLUSH = 0.7;
+ /** 最大旋转角，单位是弧度，每个碎片都会有自己的旋转程度，是随机的 */
+ const MAX_ROTATE = 0.5;
+ /** 碎裂动画的速率曲线函数 */
+ const FRAG_TIMING = linear();
- /**
- * @param {HTMLCanvasElement} canvas 要执行特效的画布
- * @param {number} length 切分成的碎片的边长，碎片为正方形
- * @param {number} time 特效持续时长
- * @returns 返回一个碎裂特效控制器，是一个对象，详见开头的使用注释
- */
- function applyFragWith(canvas, length = 4, time = 2000, config = {}) {
- // 先切分图片
- const imgs = splitCanvas(canvas, length);
- const cx = canvas.width / 2;
- const cy = canvas.height / 2;
+ /**
+ * @param {HTMLCanvasElement} canvas 要执行特效的画布
+ * @param {number} length 切分成的碎片的边长，碎片为正方形
+ * @param {number} time 特效持续时长
+ * @returns 返回一个碎裂特效控制器，是一个对象，详见开头的使用注释
+ */
+ function applyFragWith(canvas, length = 4, time = 2000, config = {}) {
+ // 先切分图片
+ const imgs = splitCanvas(canvas, length);
+ const cx = canvas.width / 2;
+ const cy = canvas.height / 2;
- let maxX = 0;
- let maxY = 0;
- const toMove = imgs.map((v) => {
- const centerX = v.x + v.canvas.width / 2;
- const centerY = v.y + v.canvas.height / 2;
- const onX = centerX === cx;
- const onY = centerY === cy;
- const mml = config.maxMoveLength ?? MAX_MOVE_LENGTH;
- const mf = config.moveFlush ?? MOVE_FLUSH;
- const rate = mml - 1 + Math.random() ** 3 * mf;
- let endX = onY ? 0 : (centerX - cx) * rate;
- let endY = onX ? 0 : (centerY - cy) * rate;
- const mx = Math.abs(endX + centerX) + Math.abs(v.canvas.width);
- const my = Math.abs(endY + centerY) + Math.abs(v.canvas.height);
- if (mx > maxX) maxX = mx;
- if (my > maxY) maxY = my;
- const r = config.maxRotate ?? MAX_ROTATE;
- const endRad = Math.random() * r * 2 - r;
+ let maxX = 0;
+ let maxY = 0;
+ const toMove = imgs.map((v) => {
+ const centerX = v.x + v.canvas.width / 2;
+ const centerY = v.y + v.canvas.height / 2;
+ const onX = centerX === cx;
+ const onY = centerY === cy;
+ const mml = config.maxMoveLength ?? MAX_MOVE_LENGTH;
+ const mf = config.moveFlush ?? MOVE_FLUSH;
+ const rate = mml - 1 + Math.random() ** 3 * mf;
+ let endX = onY ? 0 : (centerX - cx) * rate;
+ let endY = onX ? 0 : (centerY - cy) * rate;
+ const mx = Math.abs(endX + centerX) + Math.abs(v.canvas.width);
+ const my = Math.abs(endY + centerY) + Math.abs(v.canvas.height);
+ if (mx > maxX) maxX = mx;
+ if (my > maxY) maxY = my;
+ const r = config.maxRotate ?? MAX_ROTATE;
+ const endRad = Math.random() * r * 2 - r;
- return {
- deltaX: endX,
- deltaY: endY,
- endRad,
- x: centerX,
- y: centerY,
- canvas: v.canvas,
- };
- });
+ return {
+ deltaX: endX,
+ deltaY: endY,
+ endRad,
+ x: centerX,
+ y: centerY,
+ canvas: v.canvas,
+ };
+ });
- // 再执行动画
- const frag = document.createElement("canvas");
- const ctx = frag.getContext("2d");
- const ani = new Animation();
- ani.register("rate", 0);
- const ft = config.fragTiming ?? FRAG_TIMING;
- ani.absolute().time(time).mode(ft).apply("rate", 1);
- frag.width = maxX * 2;
- frag.height = maxY * 2;
- ctx.save();
- const dw = maxX - canvas.width / 2;
- const dh = maxY - canvas.height / 2;
+ // 再执行动画
+ const frag = document.createElement("canvas");
+ const ctx = frag.getContext("2d");
+ const ani = new Animation();
+ ani.register("rate", 0);
+ const ft = config.fragTiming ?? FRAG_TIMING;
+ ani.absolute().time(time).mode(ft).apply("rate", 1);
+ frag.width = maxX * 2;
+ frag.height = maxY * 2;
+ ctx.save();
+ const dw = maxX - canvas.width / 2;
+ const dh = maxY - canvas.height / 2;
- const fragFn = () => {
- const rate = ani.value.rate;
- const opacity = 1 - rate;
- ctx.globalAlpha = opacity;
- ctx.clearRect(0, 0, frag.width, frag.height);
- toMove.forEach((v) => {
- ctx.save();
- const nx = v.deltaX * rate;
- const ny = v.deltaY * rate;
- const rotate = v.endRad * rate;
+ const fragFn = () => {
+ const rate = ani.value.rate;
+ const opacity = 1 - rate;
+ ctx.globalAlpha = opacity;
+ ctx.clearRect(0, 0, frag.width, frag.height);
+ toMove.forEach((v) => {
+ ctx.save();
+ const nx = v.deltaX * rate;
+ const ny = v.deltaY * rate;
+ const rotate = v.endRad * rate;
- ctx.translate(nx + v.x + dw, ny + v.y + dh);
- ctx.rotate(rotate);
- ctx.drawImage(
- v.canvas,
- nx - v.canvas.width / 2,
- ny - v.canvas.height / 2
- );
- ctx.restore();
- });
- };
- const onEnd = () => {};
- ani.ticker.add(fragFn);
+ ctx.translate(nx + v.x + dw, ny + v.y + dh);
+ ctx.rotate(rotate);
+ ctx.drawImage(
+ v.canvas,
+ nx - v.canvas.width / 2,
+ ny - v.canvas.height / 2
+ );
+ ctx.restore();
+ });
+ };
+ const onEnd = () => {};
+ ani.ticker.add(fragFn);
- return makeFragManager(frag, ani, time, onEnd);
- }
+ return makeFragManager(frag, ani, time, onEnd);
+ }
- function makeFragManager(canvas, ani, time, onEnd) {
- const promise = sleep(time + 50);
+ function makeFragManager(canvas, ani, time, onEnd) {
+ const promise = sleep(time + 50);
- return {
- animation: ani,
- onEnd: promise.then(() => {
- ani.ticker.destroy();
- onEnd();
- }),
- canvas,
- };
- }
+ return {
+ animation: ani,
- function withImage(image, sx, sy, sw, sh) {
- const canvas = document.createElement("canvas");
- const ctx = canvas.getContext("2d");
- canvas.width = sw;
- canvas.height = sh;
- ctx.drawImage(image, sx, sy, sw, sh, 0, 0, sw, sh);
- return { canvas, x: sx, y: sy };
- }
+ onEnd: promise.then(() => {
+ ani.ticker.destroy();
+ onEnd();
+ }),
+ canvas,
+ };
+ }
- /**
- * 切分画布
- * @param canvas 要被切分的画布
- * @param l 切分小块的边长
- */
- function splitCanvas(canvas, l) {
- if (canvas.width / l < 2 || canvas.height / l < 2) {
- console.warn("切分画布要求切分边长大于等于画布长宽的一半！");
- return [];
- }
- const w = canvas.width;
- const h = canvas.height;
- const numX = Math.floor(w / l);
- const numY = Math.floor(h / l);
- const rw = (w - numX * l) / 2;
- const rh = (h - numY * l) / 2;
+ function withImage(image, sx, sy, sw, sh) {
+ const canvas = document.createElement("canvas");
+ const ctx = canvas.getContext("2d");
+ canvas.width = sw;
+ canvas.height = sh;
+ ctx.drawImage(image, sx, sy, sw, sh, 0, 0, sw, sh);
+ return { canvas, x: sx, y: sy };
+ }
- const res = [];
+ /**
+ * 切分画布
+ * @param canvas 要被切分的画布
+ * @param l 切分小块的边长
+ */
+ function splitCanvas(canvas, l) {
+ if (canvas.width / l < 2 || canvas.height / l < 2) {
+ console.warn("切分画布要求切分边长大于等于画布长宽的一半！");
+ return [];
+ }
+ const w = canvas.width;
+ const h = canvas.height;
+ const numX = Math.floor(w / l);
+ const numY = Math.floor(h / l);
+ const rw = (w - numX * l) / 2;
+ const rh = (h - numY * l) / 2;
- if (rw > 0) {
- if (rh > 0) {
- res.push(
- withImage(canvas, 0, 0, rw, rh),
- withImage(canvas, 0, canvas.height - rh, rw, rh),
- withImage(canvas, canvas.width - rw, 0, rw, rh),
- withImage(canvas, canvas.width - rw, canvas.height - rh, rw, rh)
- );
- }
- for (const x of [0, canvas.width - rw]) {
- for (let ny = 0; ny < numY; ny++) {
- res.push(withImage(canvas, x, rh + l * ny, rw, l));
- }
- }
- }
- if (rh > 0) {
- for (const y of [0, canvas.height - rh]) {
- for (let nx = 0; nx < numX; nx++) {
- res.push(withImage(canvas, rw + l * nx, y, l, rh));
- }
- }
- }
- for (let nx = 0; nx < numX; nx++) {
- for (let ny = 0; ny < numY; ny++) {
- res.push(withImage(canvas, rw + l * nx, rh + l * ny, l, l));
- }
- }
+ const res = [];
- return res;
- }
+ if (rw > 0) {
+ if (rh > 0) {
+ res.push(
+ withImage(canvas, 0, 0, rw, rh),
+ withImage(canvas, 0, canvas.height - rh, rw, rh),
+ withImage(canvas, canvas.width - rw, 0, rw, rh),
+ withImage(canvas, canvas.width - rw, canvas.height - rh, rw, rh)
+ );
+ }
+ for (const x of [0, canvas.width - rw]) {
+ for (let ny = 0; ny < numY; ny++) {
+ res.push(withImage(canvas, x, rh + l * ny, rw, l));
+ }
+ }
+ }
+ if (rh > 0) {
+ for (const y of [0, canvas.height - rh]) {
+ for (let nx = 0; nx < numX; nx++) {
+ res.push(withImage(canvas, rw + l * nx, y, l, rh));
+ }
+ }
+ }
+ for (let nx = 0; nx < numX; nx++) {
+ for (let ny = 0; ny < numY; ny++) {
+ res.push(withImage(canvas, rw + l * nx, rh + l * ny, l, l));
+ }
+ }
- const origin = core.events.afterBattle;
- core.events.afterBattle = function (enemyId, x, y) {
- // 打怪特效
- if (has(x) && has(y)) {
- const frame = core.status.globalAnimateStatus % 2;
- // 生成怪物图像
- const canvas = document.createElement("canvas");
- canvas.width = 32;
- canvas.height = 32;
- core.drawIcon(canvas, enemyId, 0, 0, 32, 32, frame);
- // 执行动画
- const manager = applyFragWith(canvas);
- const frag = manager.canvas;
- // 设置特效画布的css属性
- frag.style.imageRendering = "pixelated";
- frag.style.width = `${frag.width * core.domStyle.scale}px`;
- frag.style.height = `${frag.height * core.domStyle.scale}px`;
- const left =
- (x * 32 + 16 - frag.width / 2 - core.bigmap.offsetX) *
- core.domStyle.scale;
- const top =
- (y * 32 + 16 - frag.height / 2 - core.bigmap.offsetY) *
- core.domStyle.scale;
- frag.style.left = `${left}px`;
- frag.style.top = `${top}px`;
- frag.style.zIndex = "45";
- frag.style.position = "absolute";
- // 将特效画布部署到样板上
- core.dom.gameDraw.appendChild(frag);
- // 当特效执行完毕后移除这个特效画布
- manager.onEnd.then(() => {
- frag.remove();
- });
- }
- return origin.apply(this, arguments);
- };
+ return res;
+ }
- if ("frag" in core.plugin) {
- throw new ReferenceError(`core.plugin上已存在名为frag的属性！`);
- }
- core.plugin.frag = {
- applyFragWith,
- };
- },
+ const origin = core.events.afterBattle;
+ core.events.afterBattle = function (enemyId, x, y) {
+ // 打怪特效
+ if (has(x) && has(y)) {
+ const frame = core.status.globalAnimateStatus % 2;
+ // 生成怪物图像
+ const canvas = document.createElement("canvas");
+ canvas.width = 32;
+ canvas.height = 32;
+ core.drawIcon(canvas, enemyId, 0, 0, 32, 32, frame);
+ // 执行动画
+ const manager = applyFragWith(canvas);
+ const frag = manager.canvas;
+ // 设置特效画布的css属性
+ frag.style.imageRendering = "pixelated";
+ frag.style.width = `${frag.width * core.domStyle.scale}px`;
+ frag.style.height = `${frag.height * core.domStyle.scale}px`;
+ const left =
+ (x * 32 + 16 - frag.width / 2 - core.bigmap.offsetX) *
+ core.domStyle.scale;
+ const top =
+ (y * 32 + 16 - frag.height / 2 - core.bigmap.offsetY) *
+ core.domStyle.scale;
+ frag.style.left = `${left}px`;
+ frag.style.top = `${top}px`;
+ frag.style.zIndex = "45";
+ frag.style.position = "absolute";
+ // 将特效画布部署到样板上
+ core.dom.gameDraw.appendChild(frag);
+ // 当特效执行完毕后移除这个特效画布
+ manager.onEnd.then(() => {
+ frag.remove();
+ });
+ }
+ return origin.apply(this, arguments);
+ };
+
+ if ("frag" in core.plugin) {
+ throw new ReferenceError(`core.plugin上已存在名为frag的属性！`);
+ }
+ core.plugin.frag = {
+ applyFragWith,
+ };
+},
"自定义常用事件": function () {
// editorBlocklyconfigPlus.js
// 自訂常見事件模板插件
@@ -9308,8 +11376,8 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
MotaActionFunctions.actionParser.parse(
{
time: 160,
- openSound: "door.mp3",
- closeSound: "door.mp3",
+ openSound: "door.opus",
+ closeSound: "door.opus",
keys: { yellowKey: 1, orangeKey: 1 },
},
"doorInfo"
@@ -9318,9 +11386,9 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
MotaActionBlocks["mainStyle_m"].xmlText(),
MotaActionFunctions.actionParser.parse(
{
- 背景音乐: "bgm.mp3",
- 确定: "confirm.mp3",
- 攻击: "attack.mp3",
+ 背景音乐: "bgm.opus",
+ 确定: "confirm.opus",
+ 攻击: "attack.opus",
背景图: "bg.webp",
领域: "zone",
文件名: "file.jpg",
@@ -12528,7 +14596,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
"warning": function () {
// 在此增加新插件
// 默认音效名
- var defaultSound = "jingbao.mp3";
+ var defaultSound = "jingbao.opus";
// 默认字体名
var defaultFont = "Verdana";
@@ -14123,7 +16191,7 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
}
});
bgm = core.musicStatus.playingBgm;
- core.playBgm("op.mp3");
+ core.playBgm("op.opus");
a = setTimeout(() => {
video.remove();
video1.remove();
@@ -14256,1097 +16324,1112 @@ 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 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 = document.createElement("audio");
- audio.autoplay = true;
- audio.preload = "auto";
+ const audio = core.plugin.audioSystem.bgmController;
+ let playtime = 0;
- function getRandomInt(min, max) {
- const minCeiled = Math.ceil(min);
- const maxFloored = Math.floor(max);
- return Math.floor(Math.random() * (maxFloored - minCeiled) + minCeiled);
- }
- let page = 0; //初始页面
- let ischange = false;
- let isvolume = false;
+ let page = 0; //初始页面
+ let ischange = false;
+ 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();
- ischange = false;
- isvolume = false;
- if (!main.core.ui.music.stop) audio.play();
- });
- music.addEventListener("mouseleave", function (e) {
- e.stopPropagation();
- ischange = false;
- isvolume = false;
- if (!main.core.ui.music.stop) audio.play();
- });
- 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();
- ischange = false;
- isvolume = false;
- if (!main.core.ui.music.stop) audio.play();
- });
- music.addEventListener("touchcancel", function (e) {
- e.stopPropagation();
- ischange = false;
- 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();
+ ischange = false;
+ isvolume = false;
+ if (!main.core.ui.music.stop) {
+ core.resumeBgm()
+ core.playBgm(
+ main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ],
+ playtime
+ );
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ }
+ });
+ music.addEventListener("mouseleave", function (e) {
+ e.stopPropagation();
+ ischange = false;
+ isvolume = false;
+ if (!main.core.ui.music.stop) {
+ core.resumeBgm()
+ core.playBgm(
+ main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ],
+ playtime
+ );
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ }
+ });
+ 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();
+ ischange = false;
+ isvolume = false;
+ if (!main.core.ui.music.stop) {
+ core.resumeBgm()
+ core.playBgm(
+ main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ],
+ playtime
+ );
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ }
+ });
+ music.addEventListener("touchcancel", function (e) {
+ e.stopPropagation();
+ ischange = false;
+ isvolume = false;
+ if (!main.core.ui.music.stop) {
+ core.resumeBgm()
+ core.playBgm(
+ main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ],
+ playtime
+ );
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ }
+ });
- audio.addEventListener("ended", function () {
- switch (main.core.ui.music.type) {
- case "danqu":
- audio.currentTime = 0;
- if (!main.core.ui.music.stop) audio.play();
- main.core.ui.music.stop = false;
- page = main.core.ui.music.selection[0];
+ 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;
+ }
- break;
- case "xunhuan":
- if (
- main.core.ui.music.selection[1] ===
- main.core.ui.music.musicMx[main.core.ui.music.selection[0]].length -
- 1
- ) {
- if (
- main.core.ui.music.selection[0] ===
- main.core.ui.music.musicMx.length - 1
- ) {
- main.core.ui.music.selection[0] = 0;
- main.core.ui.music.selection[1] = 0;
- } else {
- main.core.ui.music.selection[0] += 1;
- main.core.ui.music.selection[1] = 0;
- }
- } else {
- main.core.ui.music.selection[1] += 1;
- }
- main.core.ui.music.randomList.indexOf(
- (v) =>
- v ===
- main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
- main.core.ui.music.selection[1]
- ]
- );
- page = main.core.ui.music.selection[0];
- audio.src =
- "project/bgms/" +
- main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
- main.core.ui.music.selection[1]
- ];
+ //更新
+ 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) {
+ //鼠标按下时
- if (!main.core.ui.music.stop) audio.play();
- main.core.ui.music.stop = false;
- break;
- case "suiji":
- if (
- main.core.ui.music.random <
- main.core.ui.music.randomList.length - 1
- ) {
- main.core.ui.music.random += 1;
- } else {
- main.core.ui.music.random = 0;
- }
- main.core.ui.music.selection[0] =
- main.core.ui.music.musicMx.findIndex((v) =>
- v.includes(
- main.core.ui.music.randomList[main.core.ui.music.random]
- )
- );
- main.core.ui.music.selection[1] = main.core.ui.music.musicMx[
- main.core.ui.music.selection[0]
- ].indexOf(main.core.ui.music.randomList[main.core.ui.music.random]);
- audio.src =
- "project/bgms/" +
- main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
- main.core.ui.music.selection[1]
- ];
- page = main.core.ui.music.selection[0];
+ 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);
+ playtime = 0
+ core.unregisterAnimationFrame("music");
+ core.restart();
- if (!main.core.ui.music.stop) audio.play();
- main.core.ui.music.stop = false;
- break;
- }
- });
+ return;
+ }
+ if (core.domStyle.isVertical) {
+ //竖屏
- class musicclass {
- constructor() {
- //music列表
- //需全塔属性注册并保存在bgms文件夹,每个数组为显示的一页内容
- this.musicMx = [
- ["Asphodelus_Ceui.mp3", "Blind_Alley.mp3"],
- ["Crawler.mp3", "op.mp3", "theme.mp3"],
- ];
- //音乐别名（将在播放器内显示的音乐名，music列表内的都要有对应歌名）
- this.musicname = {
- "Asphodelus_Ceui.mp3": "Asphodelus",
- "Blind_Alley.mp3": "Blind",
- "Crawler.mp3": "Crawler",
- "op.mp3": "op",
- "theme.mp3": "theme",
- };
- this.selection = [0, 0];
- this.stop = false;
- this.type = "xunhuan";
- this.randomList = [];
- this.random = 0;
- }
+ 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, 1720], [100, 100]);
+ const afterbox = makeBox([780, 1720], [100, 100]);
+ const playbox = makeBox([420, 1680], [200, 200]);
+ const typebox = makeBox([1040, 1700], [120, 120]);
+ const changebox = makeBox([100, 1590], [1048, 20]);
+ 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()
+ core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ } else {
+ this.stop = !this.stop;
+ core.pauseBgm();
+ }
+ return;
+ }
+ if (inRect(pos, beforebox)) {
+ switch (this.type) {
+ case "danqu":
+ playtime = 0;
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
- //更新
- 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) {
- //鼠标按下时
- //console.log(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");
- audio.src = "";
- core.restart();
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ page = this.selection[0];
- return;
- }
- if (core.domStyle.isVertical) {
- //竖屏
+ 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];
+ playtime = 0
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]
+ );
+ playtime = 0
+ page = this.selection[0];
- 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, 1720], [100, 100]);
- const afterbox = makeBox([780, 1720], [100, 100]);
- const playbox = makeBox([420, 1680], [200, 200]);
- const typebox = makeBox([1040, 1700], [120, 120]);
- const changebox = makeBox([100, 1590], [1048, 20]);
- 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;
- audio.play();
- } else {
- this.stop = !this.stop;
- audio.pause();
- }
- return;
- }
- if (inRect(pos, beforebox)) {
- switch (this.type) {
- case "danqu":
- audio.currentTime = 0;
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ break;
+ }
+ return;
+ }
+ if (inRect(pos, afterbox)) {
+ switch (this.type) {
+ case "danqu":
+ playtime = 0
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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];
+ playtime = 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];
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]
+ );
+ playtime = 0
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
- );
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
- page = this.selection[0];
+ 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]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]]
+ );
+ playtime = 0
- if (!this.stop) audio.play();
- this.stop = false;
- break;
- }
- return;
- }
- if (inRect(pos, afterbox)) {
- switch (this.type) {
- case "danqu":
- audio.currentTime = 0;
- if (!this.stop) audio.play();
- this.stop = false;
- 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];
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime);
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ } else {
+ if (this.stop) {
+ this.stop = !this.stop;
+ core.resumeBgm()
+ core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ } else {
+ this.stop = !this.stop;
+ core.pauseBgm();
+ }
+ }
+ return;
+ }
+ 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 (inRect(pos, changebox)) {
+ const time = Math.floor(((px - 100) / 1000) * duration);
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
- );
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
+ core.pauseBgm();
+ playtime = time;
- page = this.selection[0];
- if (!this.stop) audio.play();
- this.stop = false;
- 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]]
- );
- audio.src = "project/bgms/" + this.musicMx[page][index];
+ ischange = true;
+ }
+ if (inRect(pos, volumebox)) {
+ const time = Math.min(Math.max((px - 250) / 800, 0), 1);
+ audio.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([135, 740], [50, 50]);
+ const afterbox = makeBox([450, 740], [50, 50]);
+ const playbox = makeBox([250, 700], [200, 200]);
+ const typebox = makeBox([600, 700], [100, 100]);
+ const changebox = makeBox([100, 590], [600, 20]);
+ 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()
+ core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ } else {
+ this.stop = !this.stop;
+ core.pauseBgm();
+ }
+ return;
+ }
+ if (inRect(pos, beforebox)) {
+ switch (this.type) {
+ case "danqu":
+ playtime = 0;
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ page = this.selection[0];
- if (!this.stop) audio.play();
- this.stop = false;
- } else {
- if (this.stop) {
- this.stop = !this.stop;
- audio.play();
- } else {
- this.stop = !this.stop;
- audio.pause();
- }
- }
- return;
- }
- if (inRect(pos, changebox)) {
- const time = Math.floor(((px - 100) / 1000) * audio.duration);
+ 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];
+ playtime = 0
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]
+ );
+ playtime = 0
+ page = this.selection[0];
- audio.pause();
- audio.currentTime = time;
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ break;
+ }
+ return;
+ }
+ if (inRect(pos, afterbox)) {
+ switch (this.type) {
+ case "danqu":
+ playtime = 0;
+ if (!this.stop) core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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];
+ playtime = 0
- ischange = true;
- }
- if (inRect(pos, volumebox)) {
- const time = Math.min(Math.max((px - 250) / 800, 0), 1);
- audio.volume = 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([135, 740], [50, 50]);
- const afterbox = makeBox([450, 740], [50, 50]);
- const playbox = makeBox([250, 700], [200, 200]);
- const typebox = makeBox([600, 700], [100, 100]);
- const changebox = makeBox([100, 590], [600, 20]);
- 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;
- audio.play();
- } else {
- this.stop = !this.stop;
- audio.pause();
- }
- return;
- }
- if (inRect(pos, beforebox)) {
- switch (this.type) {
- case "danqu":
- audio.currentTime = 0;
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]
+ );
+ playtime = 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];
- audio.src =
- "project/bgms/" +
- 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]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ this.stop = false;
+ 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]]
+ );
+ playtime = 0
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
- );
- audio.src =
- "project/bgms/" +
- 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]
+ ], playtime)
+ this.stop = false;
+ } else {
+ if (this.stop) {
+ this.stop = !this.stop;
+ core.resumeBgm()
+ core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ], playtime)
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ } else {
+ this.stop = !this.stop;
+ core.pauseBgm();
+ }
+ }
+ return;
+ }
+ 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 (inRect(pos, changebox)) {
+ const time = Math.floor(((px - 100) / 600) * duration);
- if (!this.stop) audio.play();
- this.stop = false;
- break;
- }
- return;
- }
- if (inRect(pos, afterbox)) {
- switch (this.type) {
- case "danqu":
- audio.currentTime = 0;
- if (!this.stop) audio.play();
- this.stop = false;
- 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];
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
+ core.pauseBgm();
+ playtime = time;
- if (!this.stop) audio.play();
- this.stop = false;
- 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]
- );
- audio.src =
- "project/bgms/" +
- this.musicMx[this.selection[0]][this.selection[1]];
+ ischange = true;
+ }
+ if (inRect(pos, volumebox)) {
+ const time = Math.min(Math.max((px - 100) / 600, 0), 1);
+ audio.setVolume(time);
+ isvolume = true;
+ }
+ }
+ }
+ mousemove(px, py) {
+ 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 (ischange) {
+ if (core.domStyle.isVertical) {
+ const time = Math.min(
+ Math.max(Math.floor(((px - 100) / 600) * duration), 0),
+ duration
+ );
- page = this.selection[0];
- if (!this.stop) audio.play();
- this.stop = false;
- 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]]
- );
- audio.src = "project/bgms/" + this.musicMx[page][index];
+ playtime = time;
+ } else {
+ const time = Math.min(
+ Math.max(Math.floor(((px - 100) / 600) * duration), 0),
+ duration
+ );
- if (!this.stop) audio.play();
- this.stop = false;
- } else {
- if (this.stop) {
- this.stop = !this.stop;
- audio.play();
- } else {
- this.stop = !this.stop;
- audio.pause();
- }
- }
- return;
- }
- if (inRect(pos, changebox)) {
- const time = Math.floor(((px - 100) / 600) * audio.duration);
+ playtime = time;
+ }
+ }
+ if (isvolume) {
+ if (core.domStyle.isVertical) {
+ const time = Math.min(Math.max((px - 250) / 800, 0), 1);
+ audio.setVolume(time);
+ } else {
+ const time = Math.min(Math.max((px - 100) / 600, 0), 1);
+ audio.setVolume(time);
+ }
+ }
+ }
- audio.pause();
- audio.currentTime = 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) {
+ //竖屏
- ischange = true;
- }
- if (inRect(pos, volumebox)) {
- const time = Math.min(Math.max((px - 100) / 600, 0), 1);
- audio.volume = time;
- isvolume = true;
- }
- }
- }
- mousemove(px, py) {
- if (ischange) {
- if (core.domStyle.isVertical) {
- const time = Math.min(
- Math.max(Math.floor(((px - 100) / 600) * audio.duration), 0),
- audio.duration
- );
+ 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; //恢复为不透明
- audio.currentTime = time;
- } else {
- const time = Math.min(
- Math.max(Math.floor(((px - 100) / 600) * audio.duration), 0),
- audio.duration
- );
+ core.setTextAlign(ctx, "center");
+ core.fillBoldText1(
+ ctx,
+ "◀离开",
+ 110,
+ 100,
+ "#FFFFFF",
+ "#000000",
+ 6,
+ core.ui._buildFont(66, true)
+ );
- audio.currentTime = time;
- }
- }
- if (isvolume) {
- if (core.domStyle.isVertical) {
- const time = Math.min(Math.max((px - 250) / 800, 0), 1);
- audio.volume = time;
- } else {
- const time = Math.min(Math.max((px - 100) / 600, 0), 1);
- audio.volume = time;
- }
- }
- }
+ ctx.strokeStyle = "#FFFFFF";
+ ctx.lineWidth = 3;
+ ctx.beginPath();
+ ctx.moveTo(100, 200);
+ ctx.lineTo(1148, 200);
- 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) {
- //竖屏
+ 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.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.fillBoldText1(
+ ctx,
+ "上一页",
+ 100,
+ 1300,
+ page === 0 ? "#444444" : "#FFFFFF",
+ "#000000",
+ 6,
+ core.ui._buildFont(66, true)
+ );
- core.setTextAlign(ctx, "center");
- core.fillBoldText1(
- ctx,
- "◀离开",
- 110,
- 100,
- "#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.beginPath();
- ctx.moveTo(100, 200);
- ctx.lineTo(1148, 200);
+ ctx.strokeStyle = "#ffffff";
+ ctx.lineWidth = 3;
+ ctx.beginPath();
+ ctx.moveTo(100, 1600);
+ ctx.lineTo(1148, 1600);
+ ctx.stroke();
+ ctx.fillStyle = "#ffffff";
+ ctx.font = "bold 96px Verdana";
+ ctx.fillText("|", 100, 1797);
+ ctx.fillText("◀", 115, 1800);
+ ctx.beginPath();
+ ctx.arc(505, 1770, 80, 0, 3 * Math.PI);
+ ctx.stroke();
+ ctx.fillText("|", 835, 1797);
+ ctx.fillText("▶", 785, 1800);
+ if (this.stop) {
+ ctx.fillText("▶", 473, 1797);
+ } else {
+ ctx.fillText("||", 453, 1794);
+ }
- 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();
+ const img = core.material.images.images[this.type + ".webp"];
+ if (img) ctx.drawImage(img, 1000, 1655, 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
+ );
- core.fillBoldText1(
- ctx,
- "上一页",
- 100,
- 1300,
- page === 0 ? "#444444" : "#FFFFFF",
- "#000000",
- 6,
- core.ui._buildFont(66, true)
- );
+ ctx.font = "bold 36px Verdana";
+ 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
+ const thistime = currentTime;
- 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)
- );
+ if (thistime) {
+ const timetext =
+ Math.floor(thistime / 60)
+ .toString()
+ .padStart(2, "0") +
+ ":" +
+ Math.floor(thistime % 60)
+ .toString()
+ .padStart(2, "0");
+ ctx.fillText(timetext, 960, 1650);
+ } else {
+ const timetext = "00:00";
+ ctx.fillText(timetext, 960, 1650);
+ }
+ ctx.fillText("/", 1030, 1650);
+ const fulltime = duration;
- ctx.strokeStyle = "#ffffff";
- ctx.lineWidth = 3;
- ctx.beginPath();
- ctx.moveTo(100, 1600);
- ctx.lineTo(1148, 1600);
- ctx.stroke();
- ctx.fillStyle = "#ffffff";
- ctx.font = "bold 96px Verdana";
- ctx.fillText("|", 100, 1797);
- ctx.fillText("◀", 115, 1800);
- ctx.beginPath();
- ctx.arc(505, 1770, 80, 0, 3 * Math.PI);
- ctx.stroke();
- ctx.fillText("|", 835, 1797);
- ctx.fillText("▶", 785, 1800);
- if (this.stop) {
- ctx.fillText("▶", 473, 1797);
- } else {
- ctx.fillText("||", 453, 1794);
- }
+ if (fulltime) {
+ const timetext =
+ Math.floor(fulltime / 60)
+ .toString()
+ .padStart(2, "0") +
+ ":" +
+ Math.floor(fulltime % 60)
+ .toString()
+ .padStart(2, "0");
+ ctx.fillText(timetext, 1100, 1650);
+ } else {
+ const timetext = "00:00";
+ ctx.fillText(timetext, 1100, 1650);
+ }
+ ctx.strokeStyle = "#ffffff";
+ ctx.lineWidth = 9;
+ ctx.fillStyle = "rgba(255,255,255,0.5)";
+ const pointx = (1048 * thistime) / fulltime + 100;
+ if (fulltime && thistime) {
+ ctx.beginPath();
+ ctx.moveTo(100, 1600);
+ ctx.lineTo(pointx, 1600);
+ ctx.stroke();
+ ctx.beginPath();
+ ctx.arc(pointx, 1600, 10, 0, 2 * Math.PI);
+ ctx.fill();
+ } else {
+ ctx.beginPath();
+ ctx.arc(100, 1600, 10, 0, 2 * Math.PI);
+ ctx.fill();
+ }
- const img = core.material.images.images[this.type + ".webp"];
- if (img) ctx.drawImage(img, 1000, 1655, 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.font = "bold 36px Verdana";
- const thistime = audio.currentTime;
+ 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(48, 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");
- if (thistime) {
- const timetext =
- Math.floor(thistime / 60)
- .toString()
- .padStart(2, "0") +
- ":" +
- Math.floor(thistime % 60)
- .toString()
- .padStart(2, "0");
- ctx.fillText(timetext, 960, 1650);
- } else {
- const timetext = "00:00";
- ctx.fillText(timetext, 960, 1650);
- }
- ctx.fillText("/", 1030, 1650);
- const fulltime = audio.duration;
+ core.fillBoldText1(
+ ctx,
+ "◀离开",
+ 110,
+ 100,
+ "#FFFFFF",
+ "#000000",
+ 6,
+ core.ui._buildFont(66, true)
+ );
+ //core.fillRect(ctx, 440, 760, 50, 50)
+ 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)
+ );
- if (fulltime) {
- const timetext =
- Math.floor(fulltime / 60)
- .toString()
- .padStart(2, "0") +
- ":" +
- Math.floor(fulltime % 60)
- .toString()
- .padStart(2, "0");
- ctx.fillText(timetext, 1100, 1650);
- } else {
- const timetext = "00:00";
- ctx.fillText(timetext, 1100, 1650);
- }
- ctx.strokeStyle = "#ffffff";
- ctx.lineWidth = 9;
- ctx.fillStyle = "rgba(255,255,255,0.5)";
- const pointx = (1048 * thistime) / fulltime + 100;
- if (fulltime && thistime) {
- ctx.beginPath();
- ctx.moveTo(100, 1600);
- ctx.lineTo(pointx, 1600);
- ctx.stroke();
- ctx.beginPath();
- ctx.arc(pointx, 1600, 10, 0, 2 * Math.PI);
- ctx.fill();
- } else {
- ctx.beginPath();
- ctx.arc(100, 1600, 10, 0, 2 * Math.PI);
- ctx.fill();
- }
+ 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.beginPath();
+ ctx.moveTo(100, 600);
+ ctx.lineTo(700, 600);
+ ctx.stroke();
+ ctx.fillStyle = "#ffffff";
+ ctx.font = "bold 48px Verdana";
+ ctx.fillText("|", 130, 797);
+ ctx.fillText("◀", 140, 800);
+ ctx.beginPath();
+ ctx.arc(310, 780, 50, 0, 2 * Math.PI);
+ ctx.stroke();
+ if (this.stop) {
+ ctx.fillText("▶", 295, 797);
+ } else {
+ ctx.fillText("||", 285, 794);
+ }
- 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.fillText("|", 470, 797);
+ ctx.fillText("▶", 450, 800);
+ 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(250, 1950);
- ctx.lineTo(800 * audio.volume + 250, 1950);
- ctx.stroke();
- ctx.beginPath();
- ctx.arc(800 * audio.volume + 250, 1950, 10, 0, 2 * Math.PI);
- ctx.fill();
- core.fillBoldText1(
- ctx,
- Math.floor(100 * audio.volume),
- 1120,
- 1970,
- "#FFFFFF",
- "#000000",
- 6,
- core.ui._buildFont(48, 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");
+ 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(32, true)
+ );
+ const img = core.material.images.images[this.type + ".webp"];
+ if (img) ctx.drawImage(img, 580, 730, 100, 100);
+ 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.fillBoldText1(
- ctx,
- "◀离开",
- 110,
- 100,
- "#FFFFFF",
- "#000000",
- 6,
- core.ui._buildFont(66, true)
- );
- //core.fillRect(ctx, 440, 760, 50, 50)
- 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)
- );
+ ctx.font = "bold 36px Verdana";
+ 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
+ const thistime = currentTime;
- 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.beginPath();
- ctx.moveTo(100, 600);
- ctx.lineTo(700, 600);
- ctx.stroke();
- ctx.fillStyle = "#ffffff";
- ctx.font = "bold 48px Verdana";
- ctx.fillText("|", 130, 797);
- ctx.fillText("◀", 140, 800);
- ctx.beginPath();
- ctx.arc(310, 780, 50, 0, 2 * Math.PI);
- ctx.stroke();
- if (this.stop) {
- ctx.fillText("▶", 295, 797);
- } else {
- ctx.fillText("||", 285, 794);
- }
- ctx.fillText("|", 470, 797);
- ctx.fillText("▶", 450, 800);
- 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)";
+ if (thistime) {
+ const timetext =
+ Math.floor(thistime / 60)
+ .toString()
+ .padStart(2, "0") +
+ ":" +
+ Math.floor(thistime % 60)
+ .toString()
+ .padStart(2, "0");
+ ctx.fillText(timetext, 510, 650);
+ } else {
+ const timetext = "00:00";
+ ctx.fillText(timetext, 510, 650);
+ }
+ ctx.fillText("/", 580, 650);
+ const fulltime = duration;
- ctx.beginPath();
- ctx.moveTo(100, 1000);
- ctx.lineTo(600 * audio.volume + 100, 1000);
- ctx.stroke();
- ctx.beginPath();
- ctx.arc(600 * audio.volume + 100, 1000, 10, 0, 2 * Math.PI);
- ctx.fill();
- core.fillBoldText1(
- ctx,
- Math.floor(100 * audio.volume),
- 720,
- 1010,
- "#FFFFFF",
- "#000000",
- 6,
- core.ui._buildFont(32, true)
- );
- const img = core.material.images.images[this.type + ".webp"];
- if (img) ctx.drawImage(img, 580, 730, 100, 100);
- 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
- );
+ if (fulltime) {
+ const timetext =
+ Math.floor(fulltime / 60)
+ .toString()
+ .padStart(2, "0") +
+ ":" +
+ Math.floor(fulltime % 60)
+ .toString()
+ .padStart(2, "0");
+ ctx.fillText(timetext, 650, 650);
+ } else {
+ const timetext = "00:00";
+ ctx.fillText(timetext, 650, 650);
+ }
+ ctx.strokeStyle = "#ffffff";
+ ctx.lineWidth = 9;
+ ctx.fillStyle = "rgba(255,255,255,0.5)";
+ const pointx = (600 * thistime) / fulltime + 100;
+ if (fulltime && thistime) {
+ ctx.beginPath();
+ ctx.moveTo(100, 600);
+ ctx.lineTo(pointx, 600);
+ ctx.stroke();
+ ctx.beginPath();
+ ctx.arc(pointx, 600, 10, 0, 2 * Math.PI);
+ ctx.fill();
+ } else {
+ ctx.beginPath();
+ ctx.arc(100, 600, 10, 0, 2 * Math.PI);
+ ctx.fill();
+ }
+ }
+ }
+ }
+ core.ui.music = new musicclass();
+ main.dom.musicMode.onclick = function () {
+ //点击开始页面的CG MODE进入cg回廊
+ playtime = 0
+ core.playBgm(main.core.ui.music.musicMx[main.core.ui.music.selection[0]][
+ main.core.ui.music.selection[1]
+ ])
+ audio.player.getRoute("bgms." + main.core.ui.music.musicMx[main.core.ui.music.selection[0]][main.core.ui.music.selection[1]]).source?.audio?.load()
+ 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
- ctx.font = "bold 36px Verdana";
- const thistime = audio.currentTime;
-
- if (thistime) {
- const timetext =
- Math.floor(thistime / 60)
- .toString()
- .padStart(2, "0") +
- ":" +
- Math.floor(thistime % 60)
- .toString()
- .padStart(2, "0");
- ctx.fillText(timetext, 510, 650);
- } else {
- const timetext = "00:00";
- ctx.fillText(timetext, 510, 650);
- }
- ctx.fillText("/", 580, 650);
- const fulltime = audio.duration;
-
- if (fulltime) {
- const timetext =
- Math.floor(fulltime / 60)
- .toString()
- .padStart(2, "0") +
- ":" +
- Math.floor(fulltime % 60)
- .toString()
- .padStart(2, "0");
- ctx.fillText(timetext, 650, 650);
- } else {
- const timetext = "00:00";
- ctx.fillText(timetext, 650, 650);
- }
- ctx.strokeStyle = "#ffffff";
- ctx.lineWidth = 9;
- ctx.fillStyle = "rgba(255,255,255,0.5)";
- const pointx = (600 * thistime) / fulltime + 100;
- if (fulltime && thistime) {
- ctx.beginPath();
- ctx.moveTo(100, 600);
- ctx.lineTo(pointx, 600);
- ctx.stroke();
- ctx.beginPath();
- ctx.arc(pointx, 600, 10, 0, 2 * Math.PI);
- ctx.fill();
- } else {
- ctx.beginPath();
- ctx.arc(100, 600, 10, 0, 2 * Math.PI);
- ctx.fill();
- }
- }
- }
- }
- core.ui.music = new musicclass();
- main.dom.musicMode.onclick = function () {
- //点击开始页面的CG MODE进入cg回廊
- main.core.control.checkBgm();
- main.core.control.pauseBgm();
- audio.src =
- "project/bgms/" +
- 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 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) playtime = currentTime
+ if (currentTime && duration && duration - currentTime < 0.05) {
+ playtime = 0
+ if (core.domStyle.isVertical) { core.ui.music.mousedown(830, 1770) } else { core.ui.music.mousedown(475, 765) }
+ }
+ }
+ });
+ };
+},
"横屏切换": function () {
// 在此增加新插件
this.triggerFullscreen = async function (full) {
@@ -15609,2062 +17692,5 @@ var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 =
});
}
});
- },
- "音频系统": function () {
- // 在此增加新插件
- /*首先，在造塔群下载所需的库文件，然后放置在塔目录下的 libs/thirdparty 或其他目录下，之后在 index.html 的最后加上下面这几行：
-
-
-
-
-
-
- */
- // 将__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 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);
- 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.gain = 0.5;
- /** 是否正在播放 */
- this.playing = false;
- 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*/
- 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, [52, 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;
- }
-
- 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.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;
- }
-
- 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().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();
-
- this.createSourceNode(this.buffer);
- this.output.start(0, when);
- this.playing = true;
-
-
- this.output.addEventListener("ended", () => {
- this.playing = false;
-
- 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;
- audio.addEventListener("play", () => {
- this.playing = true;
- });
- audio.addEventListener("ended", () => {
- this.playing = false;
- this.ac = context;
- });
- }
- 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;
-
- 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;
-
- this.createSourceNode(this.buffer);
- this.output.start(0, when);
- this.output.addEventListener("ended", () => {
- this.playing = false;
- 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;
- }
- }
- const AudioStatus = {
- Playing: 0,
- Pausing: 1,
- Paused: 2,
- Stoping: 3,
- Stoped: 4,
- };
- const AudioRouteEvent = {
- updateEffect: [],
- play: [],
- stop: [],
- pause: [],
- resume: [],
- };
- class AudioRoute {
- constructor(source, player) {
- this.output = source.output;
- /** 效果器路由图 */
- this.effectRoute = [];
-
- /** 结束时长，当音频暂停或停止时，会经过这么长时间之后才真正终止播放，期间可以做音频淡入淡出等效果 */
- this.endTime = 0;
- /** 暂停时播放了多长时间 */
- this.pauseCurrentTime = 0;
- /** 当前播放状态 */
- this.status = AudioStatus.Stoped;
- this.shouldStop = false;
- /**
- * 每次暂停或停止时自增，用于判断当前正在处理的情况。
- * 假如暂停后很快播放，然后很快暂停，那么需要根据这个来判断实际是否应该执行暂停后操作
- */
- this.stopIdentifier = 0;
- /** 暂停时刻 */
- this.pauseTime = 0;
- this.source = source;
- this.player = player;
- }
- /** 音频时长，单位秒 */
- get duration() {
- return this.source.duration;
- }
- /** 当前播放了多长时间，单位秒 */
- get currentTime() {
- if (this.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.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.status = AudioStatus.Playing;
- this.pauseTime = 0;
- this.audioStartHook?.(this);
- this.startAllEffect();
- }
-
- /**
- * 暂停音频播放
- */
- async pause() {
- if (this.status !== AudioStatus.Playing) return;
- this.status = AudioStatus.Pausing;
- this.stopIdentifier++;
- const identifier = this.stopIdentifier;
- if (this.audioEndHook) {
- this.audioEndHook(this.endTime, this);
- await sleep(this.endTime);
- }
- if (
- this.status !== AudioStatus.Pausing ||
- this.stopIdentifier !== identifier
- ) {
- return;
- }
- this.pauseCurrentTime = this.source.currentTime;
- const time = this.source.stop();
- this.pauseTime = time;
- if (this.shouldStop) {
- this.status = AudioStatus.Stoped;
- this.endAllEffect();
-
- this.shouldStop = false;
- } else {
- this.status = AudioStatus.Paused;
- this.endAllEffect();
- }
- this.endAllEffect();
- }
-
- /**
- * 继续音频播放
- */
- resume() {
- if (this.status === AudioStatus.Playing) return;
- if (
- this.status === AudioStatus.Pausing ||
- this.status === AudioStatus.Stoping
- ) {
-
- this.audioStartHook?.(this);
-
- return;
- }
- if (this.status === AudioStatus.Paused) {
- this.play(this.pauseTime);
- } else {
- this.play(0);
- }
- this.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 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);
- });
- 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);
- }
- 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);
- }
-
- async decodeAll(data) {
- return this.decoder?.decodeFile(data);
- }
- /**
- * 当音频解码完成后，会调用此函数，需要返回之前还未解析或未返回的音频数据。调用后，该解码器将不会被再次使用
- */
- async flush() {
- return await this.decoder?.flush();
- }
- }
- 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);
- }
-
- /**
- * 设置是否启用
- * @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;
- }
-
- /**
- * 继续当前的 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);
- }
- /**
- * 添加一个音效
- * @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();
- }
-}
+ }
}
\ No newline at end of file