Merge pull request '修改方法查询效果实现' (#63) from check into main

Reviewed-on: RDCNWebs/rd.rdlevel.cn#63

README.md

@@ -30,9 +30,9 @@
 如果成功安装，那么以下内容的 markdown 预览应当是一个事件栏。  
 
 ```rdview 7 5 1
-es.PlaySong 0 0[];
-es.SetCrotchetsPerBar_4 0 1[];
-eb.AddClassicBeat 0 2[tick=6];
+PlaySong 0 0[];
+SetCrotchetsPerBar 0 1[crotchetsPerBar=4];
+AddClassicBeat 0 2[tick=6];
 ```
 
 ### RhythmBase.View

_sidebar.md

@@ -38,10 +38,9 @@
 - 进阶：视觉特效
   - [<img src="/indexicon/camera.png"/><p>镜头移动</p>](/pages/camera.md)
   - [<img src="/indexicon/roomfx.png"/><p>房间视效</p>](/pages/roomfx.md)
-  - [<img src="/indexicon/vfxpro.png"/><p>视觉干扰</p>](/pages/vfxpro.md)
-  - [<img src="/indexicon/camerafx.png"/><p>摄像机视效</p>](/pages/camerafx.md)
+  - [<img src=""/><p>视觉干扰</p>](/pages/vfxpro.md)
   - [<img src="/indexicon/hallofmirror.png"/><p>镜厅</p>](/pages/hallofmirror.md)
-  - [<img src="/indexicon/windowmove.png"/><p>窗口移动</p>](/pages/windowmove.md)
+  - [<img src="/indexicon/windowmove.png"/><p>窗口相关的动画</p>](/pages/WindowDance.md)
   - [<img src="/indexicon/hand.png"/><p>手</p>](/pages/hand.md)
   - [<img src="/indexicon/character.png"/><p>自制角色与精灵资源</p>](/pages/spritesheet.md)
   - [<img src="/indexicon/decoration.png"/><p>使用精灵</p>](/pages/decoration.md)
@@ -50,11 +49,12 @@
   - [<img src="/indexicon/tag.png"/><p>标签</p>](/pages/tag.md)
   - [<img src="/indexicon/custommethod.png"/><p>自定义方法</p>](/pages/custommethod.md)
   - [<img src="/indexicon/condition.png"/><p>条件</p>](/pages/condition.md)
-  - [<img src="/indexicon/variable.png"/><p>变量</p>](/pages/variable.md)
+  - [<img src="/indexicon/variable.png"/><p>表达式</p>](/pages/expression.md)
+  - [<img src="/indexicon/setplaystyleandgotolevel.png"/><p>关卡播放与跳转<p>](/pages/setplaystyleandgotolevel.md)
 - 高级：第三方工具
   - [<img src="/indexicon/3rdparty_coderd.png"/><p>[Python]CodeRD</p>](/pages/3rdparty_coderd.md)
   - [<img src="/indexicon/3rdparty_rdtk.png"/><p>[C#]RhythmBase</p>](/pages/3rdparty_rdtk.md)
-  - [<img src="/indexicon/3rdparty_aserdeco.png" width="64px"/><p>[lua]AserDeco插件</p>](/pages/3rdparty_aserdeco.md)
+  - [<img src="" width="64px"/><p>[lua]AserDeco插件</p>](/pages/3rdparty_aserdeco.md)
 - 附录
   - [<img src="/indexicon/events.png"/><p>事件列表</p>](/pages/appendix_events.md)
   - [<img src="/indexicon/vfxs.png"/><p>预设特效列表</p>](/pages/appendix_vfxs.md)

index.html

@@ -15,93 +15,15 @@
         <link rel="stylesheet" href="/style/dark.css">
         <link rel="stylesheet" href="/style/color.css">
         <link rel="stylesheet" href="/style/rdview.css">
+        <link rel="stylesheet" href="/style/rdview-rdtk.css">
         <link rel="stylesheet" href="/style/otto.css">
         <link rel="stylesheet" href="/style/special.css">
+        <script src="/script/config.js"></script>
     </head>
 
     <body>
         <div id="app">加载中...</div>
-        <script>
-            $docsify = {
-                name: "节奏医生编辑器教程",
-                notFoundPage: "/404.md",
-                homepage: "/pages/intro.md",
-                loadSidebar: true,
-                loadNavbar: true,
-                coverpage: false,
-                maxLevel: 5,
-                subMaxLevel: 4,
-                mergeNavbar: true,
-            };
-        </script>
-        <script type="module">
-            import "./script/rdview.js";
-            import {render} from "./script/rdtkview_render.js";
-
-            function escapeHtml(unsafe) {
-                return unsafe
-                    .replace(/&/g, "&amp;")
-                    .replace(/</g, "&lt;")
-                    .replace(/>/g, "&gt;")
-                    .replace(/"/g, "&quot;")
-                    .replace(/'/g, "&#039;");
-            }
-            loadRDView();
-            const originalCodeRenderer = $docsify.markdown
-                ?.renderer?.code;
-            function codeblockRender(code, lang) {
-                if (lang.trim().startsWith("rdview")) {
-                    return RDViewRender(lang, code);
-                }
-                // else if (lang.trim().startsWith("rdtkview")) {
-                //     const args = lang.slice(8).trim().split(" ");
-                //     const width = parseInt(args[0]) || 8;
-                //     const height = parseInt(args[1]) || 4;
-                //     const scale = parseFloat(args[2]) || 2.0;
-                //     const result = render(code, width, height, scale);
-                //     result.toString = () => result;
-                //     return result;
-                // }
-                return originalCodeRenderer
-                    ? originalCodeRenderer(code, lang)
-                    : `<pre data-lang="${lang}"><code>${
-                        escapeHtml(code)
-                    }</code></pre>`;
-            }
-            $docsify = {
-                ...$docsify,
-                ...{
-                    markdown: {
-                        renderer: {
-                            code: (code, lang) => {
-                                return codeblockRender(code, lang);
-                            },
-                            image: function (src, title, alt) {
-                                return `<div class="image-tip"><img class="medium-zoom-image" src="${src}" alt="${alt}">${
-                                    alt ? `<p>${alt}</p>` : ""
-                                }</div>`;
-                            },
-                        },
-                    },
-                    switchLightDarkMode: {
-                        useSwitchMode: true,
-                        top: 130,
-                        right: 26,
-                        svgColor: "#7d7b75",
-                    },
-                    search: {
-                        noData: {
-                            "/": "没有找到结果!",
-                        },
-                        paths: "auto",
-                        placeholder: {
-                            "/": "搜索",
-                        },
-                        hideOtherSidebarContent: true,
-                    },
-                },
-            };
-        </script>
+        <script type="module" src="./script/rdview-init.js"></script>
         <script type="module" src="./script/special.js"></script>
         <!-- <script src="/script/docsify.min.js"></script> -->
         <script src="/script/zoom-image.min.js"></script>
@@ -110,6 +32,7 @@
         <!-- <script src="/script/docsify-copy-code.min.js"></script> -->
         <script src="/script/switchLightDarkMode.js"></script>
         <script src="/script/otto.js"></script>
+        <script src="/script/custommethod-data.js"></script>
         <script src="/script/custommethod-search.js"></script>
         <!-- <script
             src="https://cdn.jsdelivr.net/npm/prismjs@1/components/prism-yaml.js"

pages/3rdparty_coderd.md

@@ -101,7 +101,7 @@ metadata:
 
   - 对于 落雨/JPEG失真/马赛克/海底波浪/电影噪点/暴风雪/素描/色像差/模糊/径向模糊/色调偏移：强度,缓速时长,缓速
 
-  - 对于 自定义屏幕块/自定义滚屏：x/y
+  - 对于 自定义屏幕分隔/屏幕滚动：x/y
 
   - 对于 高光：阈值,强度,颜色,缓速时长,缓速
 

pages/WindowDance.md

@@ -0,0 +1,241 @@
+# 窗口相关的动画
+
+在1.0正式版更新后，窗口被单独提取成了一个独立的板块：**窗口板块**。为了避免剧透，这个板块默认是隐藏的，要让这个板块显示出来，我们需要在动作板块先放一个窗口动效事件，或者在编辑器设置中的显示窗口标签栏设置为**总是报告**，这个板块才会显示出来。
+
+![“总是报告”设置](../images/Window_Dance_Always_Active.png)
+
+我们可以看到，窗口事件比以前多了很多。而且4个窗口都像房间板块一样每个窗口都占了一行。所有事件都只会对其所在行对应的窗口生效。接下来将会介绍这些事件的作用和使用方法。
+
+## 隐藏窗口
+
+窗口的显示和隐藏都在这个事件中，窗口默认只有窗口1是显示，其他窗口默认都是隐藏的，所以如果你需要操作其他窗口，需要把窗口显示出来再进行操作。
+
+如果需要使用透明窗口，记得把背景颜色设置为透明（顶部的背景也要）
+
+窗口板块中隐藏状态的窗口会显示灰色，可以通过这个判断你的窗口有没有忘记显示出来。
+
+![默认状态下只有窗口1是显示的，其他窗口都是隐藏的，所以呈现灰色](../images/Window_Dance_Window_Hidden.png)
+
+## 窗口动效
+
+### 移动
+
+移动跟**移动房间**事件一样，坐标填多少就移动到哪。
+
+![](../images/windowsmove.png)
+
+需要注意的是参照，影响的是窗口移动的范围，这两个选项的具体情况如下：
+
+`居中`的范围是整个屏幕，如果将位置设置为（0,0），那么窗口只会露出一个角；
+
+`边缘`的范围是整个屏幕减去窗口大小，如果将位置设置为（0,0），那么窗口的左下角将对齐屏幕左下角。
+
+![居中和边缘](../images/edge.png)
+
+### 摇摆
+
+使窗口按特定速度和方向来回移动。
+
+**位置：** 初始位置；
+
+**增幅：** 移动的幅度；
+
+**角度：** 来回移动的方向，0度为向右；
+
+**频率：** 每拍移动多少次；
+
+**运动缓速：** 每次移动时用的缓速；
+
+**缓速类型：** 偶数次移动可以设置成相同的缓速或者镜像（如从快到慢镜像后就是从慢到快）。
+
+![](../images/windowssway.png)
+
+### 缠绕
+
+像缠胶带一样将窗口绕着屏幕旋转。
+
+**位置：** 初始位置；
+
+**速度：** 每拍移动多少距离（一圈的百分之n）；
+
+**增幅：** 往另一个方向`摇摆`的距离（与移动方向垂直）；
+
+**角度：** 移动的方向，0度为向右；
+
+**频率：** `摇摆`的频率（每拍移动多少次）。
+
+![](../images/windowswrap.png)
+
+### 椭圆
+
+将窗口绕着一点旋转。
+
+**位置：** 旋转中心；
+
+**速度：** 每拍转多少度`（360° * n%）`；
+
+**使用循环：** 文本
+
+**增幅：** X轴和Y轴方向分别远离这个点多远；
+
+**角度：** 从哪个角度开始旋转。
+
+![](../images/windowsellipse.png)
+
+### 震动
+
+震动窗口，跟震动摄像机一样。
+
+**位置：** 初始位置；
+
+**增幅：** 震动时X轴和Y轴方向最远能到哪；
+
+**频率：** 每拍震动多少次；
+
+**周期：** 每多少拍震动的移动会重复；
+
+**运动缓速：** 每次震动时移动的缓速。
+
+![](../images/windowsshake.png)
+
+
+时长和缓速前面都说过了，就不再提了。
+
+> 如果你想直观地看看各种移动方式的速度区别，可以[看看这里](https://easings.net/zh-cn)。
+
+
+## 窗口大小重置
+
+想要让窗口大小发生变化，或调整窗口的轴点，都需要借助**窗口大小重置**事件。这个事件的设置项目是这样的：
+
+![](../images/Window_Dance_Window_Resize.gif)
+
+**大小：** 窗口的目标大小，最大可以设置为`200%， 200%`，如果`x`和`y`同时被设置为了0，则窗口会立刻被重置为初始的大小（即`100%， 100%`）。
+
+**缩放模式：** 窗口大小发生变化时内容的缩放模式，具体如下：
+<ul>
+<li><strong>填充：</strong>将画面中的内容尽可能的填满窗口</li>
+<li><strong>适应：</strong>将画面中的内容尽可能放进窗口</li>
+<li><strong>无：</strong>保持窗口中原来内容的大小不变</li>
+</ul>
+
+![填充模式](../images/Window_Dance_fill.gif)
+![适应模式](../images/Window_Dance_fit.gif)
+![无模式](../images/Window_Dance_none.gif)
+
+> 如果你的窗口在大小发生变化前后长宽比不变，那么**填充**和**适应**在效果上没有区别。
+
+**轴点模式：** 有**默认**和**锚点边缘**两种模式，选择**默认**即和房间移动的轴点没有区别，选择**锚点边缘**则表示选择一条边缘固定不动的情况下进行大小的缩放。
+
+> 实际上选择锚点边缘的情况下就是由系统计算轴点的位置，因此在锚点边缘选择左或右时不要把`x`设置为`0%`，在锚点边缘选择上或下时不要把`y`设置为`0%`，否则会出现bug，表现为对应窗口会消失且**无法被任何方式**移动回来，即使通过事件恢复了窗口的大小和轴点。
+
+**轴点：** 设置位置和缩放的基准点，类似于精灵图和房间的轴点，此处不再赘述。
+
+**动画时长和缓速：** 见过多次了，不再赘述。
+
+> 如果你想直观地看看各种移动方式的速度区别，可以[看看这里](https://easings.net/zh-cn)。
+
+### 轴点的使用技巧
+
+我们知道，在窗口大小发生变化时，调整轴点可以改变其缩放的中心。但是实际上，即使窗口不需要缩放，我们也可以通过调整轴点来改变窗口的位置，那么这种操作从效果上看和直接使用窗口移动看似没有什么区别，实际上在一些特殊的需求中，这个方法可以被很巧妙地使用。
+
+窗口在移动时，使用的坐标是相对整个屏幕的，而由于不同设备的屏幕分辨率不同，导致有些效果如果用窗口移动来做会在不同分辨率下有不同效果，尤其是当多个窗口之间的位置有配合的时候（如两个窗口紧贴的效果）。
+
+如在16:9的分辨率下制作的两个窗口紧挨着的效果：
+
+![16:9分辨率下两个窗口紧贴](../images/Window_Dance_169ratio.png)
+
+在其他分辨率下，即使不改变窗口的位置，也可能会有不同的效果（如在22:9分辨率下）：
+
+![在更宽的屏幕下，两个窗口无法紧贴](../images/Window_Dance_229ratio.png)
+
+如果想要做出在类似`2-XN`中两个窗口相撞的效果，窗口中间有距离会导致表演效果大打折扣。这时我们可能会想，能不能不以屏幕为基准定位，而是以窗口的大小为基准定位，是不是就可以做到了呢？
+
+事实上，**轴点**就解决了这样的问题。
+
+试想，如果两个窗口在同一个位置，而一个窗口的轴点在左边缘，另一个窗口在右边缘，就可以保证无论在什么样的分辨率下，这两个窗口都一定是紧挨着的。
+
+![](../images/Window_Dance_169ratio_pivot.png)
+
+![使用轴点后，无论在哪个分辨率下两个窗口都是紧挨的](../images/Window_Dance_229ratio_pivot.png)
+
+所以当你的动画需要多个窗口之间的位置配合时，不妨试试用轴点的移动来代替直接移动窗口。
+
+## 设置窗口内容
+
+~~这个事件以前翻译错误，译成了**设置窗口数量**，害人不浅。~~
+
+这个事件的设置项目是这样的：
+
+![](../images/Window_Content.png)
+
+**内容模式：** 可以选择**一个房间**或**全部房间**，在选择**一个房间**时，下面会出现**房间目录**选项，可以从4个房间里面选择一个，随后这个窗口中只会显示这个房间的内容。在选择全部房间时，这个窗口将会像平常一样显示全部4个房间的内容。
+
+> 注意，在选择**一个房间**时，这个房间中的所有房间事件都不会在这个窗口中生效，包括房间移动，淡入淡出房间，房间遮罩等。
+
+![左侧窗口是全部房间，右侧房间是一个房间(房间1)，可以发现房间移动和房间遮罩在右侧房间都没有生效](../images/Window_Dance_All_or_One.png)
+
+**位置，缩放和角度：** 类似于摄像头移动的对应参数。
+
+在内容模式为**一个房间**时，等同于调用房间的摄像头，`位置`是对应房间区域的对应坐标(左下角是`(0%, 0%)`，右上角是`(100%, 100%)`)；
+
+在选择**全部房间**时，等同于调用顶部摄像头，而所有房间可显示的范围为`(200%, 200%)`大小，所以当`位置`设置为`(100%, 100%)`时，实际会在（相对于一个房间默认大小的）`(200%, 200%)`的位置，默认位置的房间的`(100%, 100%)`则在`(75%, 75%)`的位置。
+
+根据这个结论，可以将4个房间分别放在显示区域的四个角上，并显示`全部房间`，这样就能用`全部房间`分别显示4个房间了
+
+![上图中黄色区域是一个处于默认位置和默认大小的房间，蓝色区域是全部房间的坐标区域](../images/Window_Dance_Coordinate_of_All_Room.png)
+
+无论选择哪种内容模式，超出区域范围的内容都会被裁剪。
+
+**时长和缓速：** 略
+
+## 重新排列窗口
+
+类似于房间板块的**重新排列房间**，可以设置窗口的上下关系。
+
+## 设置主窗口
+
+将对应的窗口设置为主窗口，对话，顶部护士灯光，状态牌等内容将在主窗口显示。
+
+## 设置窗口名称
+
+修改窗口的标题。在动作选择**设置**的时候，会直接设置窗口的标题；在动作选择**增补**的时候，会在原来标题的后面增加内容；在动作选择**重置**的时候，会将标题重置为`Rhythm Doctor`。
+
+## 设置桌面颜色
+
+修改模拟移动时桌面的颜色，如果不打开起始颜色，则表示从当前颜色渐变为结束颜色，如果打开起始颜色，效果将类似于**自定义闪烁**。
+
+## 进阶内容（可能需要手术）
+
+> 如果你不知道手术是什么，可以[看看这里](https://docs.qq.com/sheet/DQUJxb0puSFFOVWpz?tab=000004)。
+
+### 全屏窗口
+
+因为窗口的最大大小写死了只能为200%，所以需要用到`OutElastic`缓速。
+
+> 如果你忘了这个缓速长什么样，可以[看看这里](https://easings.net/zh-cn)。
+
+注意到这个缓速的一部分会超出所设置的值，所以可以先将窗口缩小到`（1%,1%）`大小，然后使用`OutElastic`缓速将窗口缩放到`（200%,200%）`大小，当窗口变大的过程中会有几帧是占满整个屏幕的，此时放一个大小为`（200%,200%）`、时长为999、缓速为`Linear`的**窗口大小重置事件**，窗口大小就会固定成全屏的了。
+
+> 使用注释指令`()=>windowSize(float SizeX%, float SizeY%, float duration)`可以直接将窗口缩放到200%以上，但这个方法只能控制窗口1的大小，还没有缓速。
+
+### 更多窗口（暂时不确定官方会不会修这个）
+
+在谱面中放置一个窗口相关的事件（这个例子用`隐藏窗口`事件），记住这个事件的小节、节拍和在第几行，然后打开这个谱面的文件（xxx.rdlevel），找到{ "bar": <小节>, "beat": <节拍>, "y": <行数减一>, "type": "HideWindow", "show": true }，这一行，<>里面应该是你记住的数据，将"y": 后面的数替换成一个大于3的数，保存并返回编辑器，重新打开这个谱面，就会发现这个事件到第4行下面了，接着当正常窗口使用就行。
+
+如果想要`重新排列窗口`，同上，找到"ReorderWindows", "order": [0, 1, 2, 3]，在[]中加上 窗口的编号减一 的数，还有逗号。
+
+窗口事件名称表：
+
+| 事件 | 名称 |
+| :--- | :--- |
+| 窗口动效 | NewWindowDance |
+| 重置窗口大小 | WindowResize |
+| 设置窗口内容 | SetWindowContent |
+| 重新排列窗口 | ReorderWindows |
+| 隐藏窗口 | HideWindow |
+| 设置主窗口 | SetMainWindow |
+| 设置窗口名称 | RenameWindow |
+| 设置桌面颜色 | DesktopColor |
+
+当然，如果你不想手术，可以安装[这个模组](https://github.com/9thCore/RDEditorPlus/releases)（b站有安装教程）

pages/accessibledesign.md

@@ -62,7 +62,7 @@
 
 #### 朗读轨道信息
 
-![](../images/narraterowinfo.png)
+![](../images/readrowinformation.png)
 
 **轨道**：选择要朗读哪条轨道的信息。
 
@@ -77,6 +77,8 @@
 
 **玩家**：选择在双人模式下，该轨道由哪位玩家接管。
 
+**自定义长度**：启用后将朗读所填的轨道长度。
+
 一般情况下，游戏会按以下的顺序来朗读：
 
 `[玩家][类型][轨道角色][X字拍子]`

pages/appendix_audios.md

@@ -169,8 +169,8 @@
 | sndSleighLo | 圣诞树节拍器 - 低 |
 | sndCalibrationBeep | 校准界面哔声 |
 | sndMelonMorse | Melon 摩尔斯电码 |
-| sndVividStasisResultsRiser | <code>X-FTS</code>恋恋群星S+评价结算音乐前摇 |
-| sndVividStasisScratch | <code>X-FTS</code>恋恋群星S+评价结算音乐前摇（刮擦声） |
+| sndVividStasisResultsRiser | <code>X-FTS</code>恋恋群星S+评价前摇 |
+| sndVividStasisScratch | <code>X-FTS</code>恋恋群星V评价出现 |
 | sndWingFlap | 鸟儿扇动翅膀 |
 
 ### 未在正式版本中使用的音效
@@ -365,10 +365,19 @@
 | sndWornOutTapes | <code>X-WOT</code>Worn Out Tapes | 149 |
 | sndSparkLine | <code>X-KOB</code>气球王国 | 124 |
 | sndVividStasis | <code>X-FTS</code>恋恋群星 | 150 |
-| sndVividStasisResults | <code>X-FTS</code>恋恋群星S+评价结算音乐 | 150 |
+| sndVividStasisResults | <code>X-FTS</code>恋恋群星V评价结算音乐 | 150 |
 | sndOsmBluesRadio | 夜间的病房内过剧情 | 98? |
-| sndInsomniacCutscene | 1-X后过剧情 | 88 |
+| sndOsmBluesNormal | 袖管涂鸦背景音乐 | 98? |
+| sndInsomniacCutscene | 1-X后过剧情 | 140 |
 | SoftPianoIntimate | 第一章末尾的过剧情 | 88 |
+| sndDistantDuetCutsceneLoop | 3-3后过剧情 | 165 |
+| sndDDSPianoCutsceneLoop | 5-X后过剧情第一部分 | 130 |
+| sndDDSEdegaCutscene | 5-X后过剧情第一部分（埃德加来） | 140 |
+| sndDDSVirusTalkCutsceneLoop | 5-X后过剧情（伊恩来） | 105 |
+| sndMarksTheme | 病历间音乐 | 110 |
+| sndBlurredCutscene | 7-1后过剧情 | 63? |
+| sndPaigeReturnsCutscene | 佩奇回来 | 157? |
+| sndEdegaBedsidePaigeCutscene | 7-X2后埃德加住院 | 58? |
 
 ### 未在正式版本中出现的音乐
 

pages/appendix_events.md

@@ -34,6 +34,7 @@
 | 切换玩家轨道 | `Y` | [采音和节奏设计](../pages/beatpatterndesign.md) | 切换轨道的游玩者：1P，2P或是CPU |
 | 结束关卡 | `L` | [导入与导出](../pages/importandexport.md#导出关卡) | 制作关卡必需的特效，放置三个来结束关卡 |
 | 显示手 | `U` | [手](../pages/hand.md#显示手) | 显示或者隐藏手 |
+| 手涂色 | `Shift+U` | [手](../pages/hand.md#手涂色) | 设置轨道的边框、涂色、透明度 |
 | 手分配 | `Shift+Y` | [手](../pages/hand.md#手分配) | 为手设置所属角色 |
 | 设置播放方式 | `Shift+Z` |  | 设置播放头的运动方式 |
 | **环境类** |   |   |   |
@@ -46,9 +47,11 @@
 | **轨道特效类** |   |   |   |
 | 隐藏轨道 | `X` | [轨道移动](../pages/moverow.md#轨道的显示与隐藏) | 改变轨道的显示和隐藏状态 |
 | 移动轨道 | `O` | [轨道移动](../pages/moverow.md#轨道的移动) | 让轨道在画面中移动，缩放，旋转等 |
-| 重排序：行 | `Shift+O` |   | 将轨道移动到不同房间，或是重新对轨道进行排序 |
+| 轨道重排序~~重排序：行~~ | `Shift+O` |   | 将轨道移动到不同房间，或是重新对轨道进行排序 |
 | 播放表情 | `J` | [自制角色与精灵资源](../pages/spritesheet.md#播放表情) | 改变轨道中角色的表情 |
+| 改变角色 | `Shift+J` | [轨道视效](../pages/rowfx.md#轨道涂色) | 改变轨道的角色 |
 | 轨道涂色 | `R` | [轨道视效](../pages/rowfx.md#轨道涂色) | 设置轨道的边框、涂色、透明度 |
+| 旋转轨道 | `Shift+S` |  | （仅高级模式下可用）将另一个轨道连接到角色上，实现`7-1`中的一人多轨 |
 | **摄像头特效类** |   |   |   |
 | 移动摄像头 | `C` | [镜头移动](../pages/camera.md) | 设置摄像头动画 |
 | 脉冲摄像机 | `Shift+C` | [轨道视效](../pages/rowfx.md#和轨道相关的特效) | 添加一个按一定时间和频次缩放画面的效果 |
@@ -60,18 +63,18 @@
 | 设置速度 | `S` | [轨道视效](../pages/vfx.md#设置速度) |  改变整个画面中物件及特效的运行速度 |
 | 自定义闪烁 | `F` | [轨道视效](../pages/rowfx.md#适合配合轨道或节拍一起使用的特效) | 自定义屏幕闪烁的图层位置，颜色，透明度 |
 | 闪烁 | `Shift+F` | [轨道视效](../pages/rowfx.md#适合配合轨道或节拍一起使用的特效) | 简单地屏幕闪烁 |
-| 重低音震动 | `K` | [轨道视效](../pages/rowfx.md#适合配合轨道或节拍一起使用的特效) | 添加一次大幅度的色像差加大幅度屏幕缩放 |
+| 重低音震动 | `K` | [轨道视效](../pages/rowfx.md#适合配合轨道或节拍一起使用的特效) | 添加一次大幅度的色像差+大幅度屏幕缩放 |
 | 颜色反转 | `I` | [镜厅](../pages/hallofmirror.md) | 给画面添加反色效果 |
 | 卡带效果 | `E` | [视觉干扰](../pages/vfx.md#卡带效果) | 反复重现某个画面造成卡顿错觉 |
 | 手涂色 | `Shift+U` | [手](../pages/hand.md#手涂色) | 改变手的颜色 |
-| 窗口动效 | `W` | [窗口移动](../pages/windowmove.md) | 把关卡变成窗口模式，并设置窗口的移动 |
+| 窗口动效 | `W` | [窗口移动](../pages/WindowDance.md#窗口相关的动画) | 把关卡变成窗口模式，并设置窗口的移动 |
 | **文本类** |   |   |   |
 | 显示对话 | `D` | [其他文字事件](../pages/captions.md#显示对话) | 添加一个悬浮在屏幕上方或下方的对话窗口 |
 | 显示状态标识 | `Shift+D` | [其他文字事件](../pages/captions.md#显示状态牌) | 在画面左上角显示一个状态标识 |
 | 浮动文字 | `A` | [浮动文字](../pages/floatingtext.md) | 在画面中显示一段文字 |
-| 弹幕效果 | `Shift+A` | [其他文字事件](../pages/captions.md#弹幕效果) | 添加一个从右至左的弹幕飘过效果 |
+| 弹幕效果 | `Shift+A` | [其他文字事件](../pages/captions.md#弹幕效果) | 添加弹幕飘过效果 |
 | **组件类** |   |   |   |
-| 标签动作 | `O` | [标签](../pages/tag.md#设置标签事件) | 运行/禁用指定标签带有的事件 |
+| 标签动作 | `O` | [标签](../pages/tag.md#设置标签事件) | 运行/禁用带有指定标签的事件 |
 | 调用自定义方法 | `Z` | [自定义方法](../pages/custommethod.md) | 运行指令，执行无法用常规手段达成的效果 |
 | 注释 | `M` | [标签](../pages/tag.md#让事件摆放更有条理) | 添加注释内容或插入注释型自定义方法 |
 
@@ -79,9 +82,9 @@
 
 | 功能 | 快捷键 | 章节 | 内容 |
 | :--- | :--- | :--- | :--- |
-| 排列显示房间 | `S` | [房间](../pages/room.md#排列显示房间) | 改变四个房间的前后顺序 |
+| 排列显示房间 | `S` | [房间](../pages/room.md#排列显示房间) | 从上到下显示房间 |
 | 移动房间 | `M` | [镜头移动](../pages/camera.md) | 让房间在画面中移动，缩放，旋转等 |
-| 重新排序房间 | `O` | [房间](../pages/room.md#房间的前后关系) | 改变四个房间的前后顺序 |
+| 重新排序房间 | `O` | [房间](../pages/room.md#房间的前后关系) | 改变四个房间叠放时的上下关系 |
 | 设置房间内容模式 | `C` | [镜头移动](../pages/camera.md) | 设置房间在缩小时是缩放房间还是剪裁房间 |
 | 房间遮罩 | `K` | [房间视效](../pages/roomfx.md#房间遮罩) | 为房间设置遮罩 |
 | 淡入淡出房间 | `F` | [镜头移动](../pages/camera.md) | 设置房间的透明度 |
@@ -96,7 +99,21 @@
 | 绘制精灵图 | `R` | [使用精灵](../pages/decoration.md#绘制精灵图) | 设置精灵的边框、涂色、透明度 |
 | 播放表情 | `J` | [使用精灵](../pages/decoration.md#播放表情) | 播放精灵的表情 |
 | 显示/隐藏 | `X` | [使用精灵](../pages/decoration.md#显示/隐藏) | 显示或隐藏精灵 |
-| 重排序：精灵图 | `Shift+O` |   | 将精灵移动到不同房间，或是重新对精灵进行排序 |
+| 精灵重排序~~重排序：行~~ | `Shift+O` |   | 将精灵移动到不同房间，或是重新对精灵进行排序 |
 | 平铺精灵图 | `I` | [使用精灵](../pages/decoration.md#平铺精灵图) | 显示或隐藏精灵 |
 | 混合精灵图 | `B` |  | 设置精灵的颜色混合模式 |
 | 注释 | `M` | [标签](../pages/tag.md#让事件摆放更有条理) | 添加注释内容或插入注释型自定义方法 |
+
+## 淡蓝色版块（窗口）
+
+| 功能 | 快捷键 | 章节 | 内容 |
+| :--- | :--- | :--- | :--- |
+| 窗口动效 | `W` | [窗口相关的动画](../pages/WindowDance.md#窗口动效) | 设置窗口的移动模式，移动窗口 |
+| 窗口大小重置 | `R` | [窗口相关的动画](../pages/WindowDance.md#窗口大小重置) | 改变窗口的大小、缩放模式、轴点 |
+| 设置窗口内容 | `C` | [窗口相关的动画](../pages/WindowDance.md#设置窗口内容) | 设置窗口显示的内容是哪个房间或全部房间 |
+| 重新排列窗口 | `O` | [窗口相关的动画](../pages/WindowDance.md#重新排列窗口) | 改变四个窗口叠放时的上下关系 |
+| 隐藏窗口 | `H` | [窗口相关的动画](../pages/WindowDance.md#隐藏窗口) | 隐藏或显示窗口 |
+| 设置主窗口 | `U` | [窗口相关的动画](../pages/WindowDance.md#设置主窗口) | 设置对话，顶部护士灯光，状态牌等内容在哪个窗口显示 |
+| 设置窗口名称 | `N` | [窗口相关的动画](../pages/WindowDance.md#设置窗口名称) | 修改窗口的标题 |
+| 设置桌面颜色 | `D` | [窗口相关的动画](../pages/WindowDance.md#设置桌面颜色) | 修改模拟移动时桌面的颜色 |
+| 注释 | `M` | [标签](../pages/tag.md#让事件摆放更有条理) | 添加注释内容或插入注释型自定义方法 |

pages/appendix_tools.md

@@ -1,11 +1,11 @@
 # RDView Playground
 <div class="rdview"><div class="canvas"></div><div class="editor"><div class="number"></div><textarea class="area" spellcheck="false" placeholder="Enter code here">
 rdview 8 5
-es.Comment 2[if=true];
+Comment 2[tab=Sounds,if=true];
 g 1 1 5 4 #0ff{
-  eb.SetRowXs[rowxs=--x-xx];
-  eb.AddClassicBeat 2[tick=3,swing=0.333,grayscale=100];
-  eb.AddOneshotBeat 2 1[
+  SetRowXs[rowxs=--x-xx];
+  AddClassicBeat 2[tick=0.5,swing=0.333,grayscale=100];
+  AddOneshotBeat 2 1[
     type=freezeshot subdivision,
     interval=2,
     delay=0.25,
@@ -13,10 +13,10 @@ g 1 1 5 4 #0ff{
     loop=2,
     offset_grayscale=100
   ];
-  es.SayReadyGetSetGo_Get 0 2;
-  es.SayReadyGetSetGo_Set 1 2;
-  es.SayReadyGetSetGo_Go 2 2;
-  es.SayReadyGetSetGo_GetSetGo 0 3;
+  SayReadyGetSetGo 0 2[phraseToSay=JustSayGet];
+  SayReadyGetSetGo 1 2[phraseToSay=JustSaySet];
+  SayReadyGetSetGo 2 2[phraseToSay=JustSayGo];
+  SayReadyGetSetGo 0 3[phraseToSay=SayGetSetGo];
 };
 </textarea></div></div>
 

pages/appendix_vfxs.md

@@ -5,32 +5,39 @@
 | 特效名称 | 具体效果 |
 | :--- | :--- |
 | **摄像头类** |   |
-| <font color='red'>屏幕块2x2</font> | 把屏幕块变成2x2个相同的部分 |
-| <font color='red'>屏幕块3x3</font> | 把屏幕块变成3x3个相同的部分 |
-| <font color='red'>屏幕块4x4</font> | 把屏幕块变成4x4个相同的部分 |
-| 自定义屏幕块 | 把屏幕块变成任意个相同的部分，注意这里是可以填写小数的 |
+| <font color='red'>屏幕分隔2x2</font> | 把屏幕分隔变成2x2个相同的部分 |
+| <font color='red'>屏幕分隔3x3</font> | 把屏幕分隔变成3x3个相同的部分 |
+| <font color='red'>屏幕分隔4x4</font> | 把屏幕分隔变成4x4个相同的部分 |
+| 屏幕分割 | 把屏幕分隔变成任意个相同的部分，注意这里是可以填写小数的 |
 | <font color='red'>水平滚屏</font> | 画面向左移动，并且从右方重复出现 |
 | <font color='red'>垂直滚屏</font> | 画面向上移动，并且从下方重复出现；需要注意：水平垂直滚屏只能存在一个 |
 | ＶＨＳ | 画面带有横条和轻微抖动，有老式录像机的感觉 |
 | <font color='red'>水平滚屏＋ＶＨＳ</font>　 | 上面两个的叠加，实际上分开放两个物块效果也是一样的 |
 | <font color='red'>垂直滚屏＋ＶＨＳ</font> | 上面两个的叠加，实际上分开放两个物块效果也是一样的 |
-| 自定义滚屏 | 允许同时设置水平和垂直的滚屏，并且自由设置滚屏速度 |
+| 屏幕滚动 | 允许同时设置水平和垂直的滚屏，并且自由设置滚屏速度 |
 | 过场模式 | 屏幕上下方出现黑条，类似于很多游戏出过场动画时的效果 |
 | 按键低重音 | 每次按拍后画面产生震动和色像差 |
+| 鱼眼 | 用鱼眼镜头拍出来的效果，中间比其他部分更大（显得更靠近屏幕），强度可以是负数 |
 |   |   |
 | **画风突变类** |   |
 | <font color='red'>黑屏</font> | <font color='red'>别多想，真的就是屏幕全黑了</font> |
+| 倒带 | 屏幕内容左右抽搐 |
+| 扫描线 | 屏幕被分割为许多极小横条，透明大横条从上往下循环移动 |
 | 噪点 | 就是那种老电视收不到信号的马赛克 |
 | 电影噪点 | 在保持画面的基础上加一些噪点 |
 | 色调偏移 | 改变画面的色调，每隔100%是一个色调循环 |
 | 亮度 | 改变画面的亮度，小于等于0的情况下等效于黑屏 |
 | 对比度 | 改变画面的色彩对比度，负数的情况下等效于反色 |
 | 饱和度 | 改变画面的色彩饱和度，负数的情况下等效于反色 |
-| <font color='red'>灰度</font> | <font color='red'>画面变成黑白灰的</font> |
+| 灰度 | 画面变成黑白灰的 |
 | 怀旧 | 画面发黄 |
 | JPEG失真 | 出现类似信号不稳定时的画面割裂效果 |
+| 像素化 | 画面变成一个个像素格，“数量”其实是格子的大小 |
 | 马赛克 | 与普通的打码不太一样，能感觉到画面依然清晰但是割裂成了一个个小格子 |
+| 点阵 | 画面变成一个个小点，类似于`5-1N`中的背景 |
 | 海底波浪 | 屏幕左右扭曲 |
+| 热变 | 受高温影响屏幕逐渐扭曲和失真 |
+| 玻璃碎裂 | 和`6-1`中一样的碎裂效果，一次性 |
 | 放克 | 精神污染，屏幕上滚动着高饱和度的纯色 |
 | 素描 | 添加一张揉皱的白纸背景，将原始画面自动抽取关键部分变成黑色画在纸上 |
 | 色像差 | 有点像红蓝眼镜3D视频不戴眼镜时看到的效果 |
@@ -50,11 +57,15 @@
 | 矩阵 | 添加一个绿色音符上升的效果，和`1-XN`这关是一样的，可以和前景背景叠加起来显示 |
 | 落花 | 屏幕上方开始落下花瓣，可以和前景背景叠加起来显示 |
 | 落花即刻 | 屏幕上方落下花瓣，同时屏幕上已生成一些花瓣，可以和前景背景叠加起来显示 |
+| 落叶 | 屏幕上方开始落下落叶，可以和前景背景叠加起来显示 |
 | 飘雪 | 屏幕上方开始落下雪花，可以和前景背景叠加起来显示 |
 | 雪花 | 屏幕上方开始落下快速的雪花，短时间内充满屏幕，可以和前景背景叠加起来显示 |
 | 暴风雪 | 屏幕上方开始落下暴风雪，可以和前景背景叠加起来显示 |
 | 钻石 | 屏幕上出现很多方块 |
 | 气球 | 屏幕下方飘出很多气球 |
+| 余烬 | 屏幕上出现飘动的火星 |
+| 纸屑 | 屏幕上方落下各种颜色的纸屑 |
+| 彩纸爆破 | 屏幕左下角和右下角爆出彩纸，和`5-3N`中一样 |
 | 教程音符 | 屏幕铺满剧情模式教程中的音符背景，可以自定义颜色等 |
 |   |   |
 | **轨道类** |   |
@@ -65,7 +76,7 @@
 | <font color='red'>轨道全白</font> | 把轨道变成纯白色，需要事先布置一个轨道涂色物件 |
 | <font color='red'>轨道轮廓光</font> | 把轨道变成纯黑色白边，需要事先布置一个轨道涂色物件 |
 | <font color='red'>轨道普通</font> | 把轨道变成普通样子，需要事先布置一个轨道涂色物件 |
-| 波状轨道 | 轨道自己上下来回移动，类似于`2-3N`这关 |
+| 轨道浮动 | 轨道自己上下来回移动，类似于`2-2`这关 |
 | 脉冲计数 | 对普通拍子轨道有效，轨道上方随节奏出现1~7的数字，每个房间只能有一条轨道显示 |
 | 心跳震屏 | 每个心跳拍子都会让轨道抖动一下 |
 | 按键震屏 | 每个按键拍子都会让轨道抖动一下 |

pages/audiodesign.md

@@ -24,7 +24,7 @@
 
 除了节奏音效和按拍音效之外，游戏里还有一些地方会出现音效，主要是失误的时候（分为微小失误和严重失误），没有节拍却按了空格的时候（默认是“啵”一声，所以在编辑器里面叫“手掌-啵音”），第七拍按下之后第八拍“咚”地一声回音（叫做心爆，这时候心脏图标也会小抖一下），以及跳过拍（嘎↘的声音），长按拍，冻结拍，灼热拍的音效。
 
-这些音效在设置的时候是无法下拉列表选择更改的，只能通过键入游戏内置的音效文件名，或者导入自定义的音效来改变。目前已公开的内置音效文件名因为数量太多，集中收录在了[附录3](../appendix/3.html)中。
+这些音效在设置的时候是无法下拉列表选择更改的，只能通过键入游戏内置的音效文件名，或者导入自定义的音效来改变。目前已公开的内置音效文件名因为数量太多，集中收录在了[附录3](../pages/appendix_audios.md)中。
 
 ## 心爆
 
@@ -39,12 +39,12 @@
 **心爆 3** ：三次及以上累计的按拍 / 三个及以上重叠的按拍产生的心爆。
 
 ```rdview 3 5
-eb.AddFreeTimeBeat 1 1[pulse=7];
-eb.AddFreeTimeBeat 1 2[pulse=7];
-eb.AddFreeTimeBeat 1 2[pulse=7];
-eb.AddFreeTimeBeat 1 3[pulse=7];
-eb.AddFreeTimeBeat 1 3[pulse=7];
-eb.AddFreeTimeBeat 1 3[pulse=7];
+AddFreeTimeBeat 1 1[pulse=6];
+AddFreeTimeBeat 1 2[pulse=6];
+AddFreeTimeBeat 1 2[pulse=6];
+AddFreeTimeBeat 1 3[pulse=6];
+AddFreeTimeBeat 1 3[pulse=6];
+AddFreeTimeBeat 1 3[pulse=6];
 ```
 
 ### 设置心跳音量
@@ -73,19 +73,19 @@ eb.AddFreeTimeBeat 1 3[pulse=7];
 ```rdview 4 9
 g 1 1{
     g 1 0 0 1 #08f{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1.25 3 1.75 1 #08f{
     g{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1.5 5 1.5 1 #08f{
     g{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1.75 7 1.25 1 #08f{
     g{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 ```
 
@@ -97,39 +97,39 @@ g 1.75 7 1.25 1 #08f{
 ```rdview 7 9
 g 1 1 0.75 1 #08f{
     g 0 0 0.25{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1 3 1.25 1 #08f{
     g 0 0 0.75{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1 5 1.25{
     g 1.25 0 0 1 #08f{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 1 7 1.75 {
     g 1.75 0 0 1 #08f{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 4 1 1 1 #08f{
     g 0 0 0.5{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 4 3 1.5 1 #08f{
     g{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 4 5 1.5{
     g 1.5 0 0 1 #08f{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 g 4 7 2 {
     g 2 0 0 1 #08f{};
-    eb.AddFreeTimeBeat [pulse=7];
+    AddFreeTimeBeat [pulse=6];
 };
 ```
 
 ## 播放音效
 **播放音效**是所有音效设置里面自由度最高的一个，可以在任意的时间开始播放一个音效文件，和游戏的轨道与按键没有任何关联。如果处理得当，你甚至可以用这个功能写一个打击乐段在游戏里面。
 
-另外，剧情模式里面的内置音效也可以在这里通过写文件名的形式添加进自己的谱面。但是官方目前并没有公开所有的音效文件，我们收集了其中的一部分放在了[附录3](../appendix/3.html)中整理成了表格，需要的话可以自取。
+另外，剧情模式里面的内置音效也可以在这里通过写文件名的形式添加进自己的谱面。但是官方目前并没有公开所有的音效文件，我们收集了其中的一部分放在了[附录3](../pages/appendix_audios.md)中整理成了表格，需要的话可以自取。

pages/beatpatterndesign.md

@@ -47,15 +47,15 @@
 首先，剧情模式出现两次五拍子机制，它们出现的位置在节奏上都是连续附点的，即两个心跳之间的间隔都是1.5拍，这样五拍子的有声拍长也是6，和普通的普通拍子是完全一致的。在这种连续附点的压迫感之下设置五拍，与音乐非常契合。
 
 ```rdview 14 4
-eb.AddClassicBeat 6 1[tick=6];
-eb.SetRowXs 1 2[rowxs=xx----];
-eb.AddFreeTimeBeat 3 2[pulse=1];
-eb.PulseFreeTimeBeat 4.5 2[pulse=9];
-eb.PulseFreeTimeBeat 6 2[pulse=9];
-eb.PulseFreeTimeBeat 7.5 2[pulse=9];
-eb.PulseFreeTimeBeat 9 2[pulse=9];
-eb.PulseFreeTimeBeat 10.5 2[pulse=9];
-eb.PulseFreeTimeBeat 12 2[pulse=9];
+AddClassicBeat 6 1[tick=6];
+SetRowXs 1 2[rowxs=xx----];
+AddFreeTimeBeat 3 2[pulse=1];
+PulseFreeTimeBeat 4.5 2[pulse=9];
+PulseFreeTimeBeat 6 2[pulse=9];
+PulseFreeTimeBeat 7.5 2[pulse=9];
+PulseFreeTimeBeat 9 2[pulse=9];
+PulseFreeTimeBeat 10.5 2[pulse=9];
+PulseFreeTimeBeat 12 2[pulse=9];
 ```
 
 而我们自选音乐时很多时候遇到的情况都是连续五个采音点，但间隔都是1拍，这种情况与其精准采音`xx----`反而不如额外增加一个不存在的采音变成`-x----`或者`-----x`，这样既不损失与音乐的契合，又能把节奏归化简单。
@@ -89,22 +89,22 @@ eb.PulseFreeTimeBeat 12 2[pulse=9];
 **三、**每一条轨道的**节奏功能做出严格的区分**，如果场上本身就有多轨，不要给一条轨道设计过多差距太大的节奏类型。同时，非必要尽量不要增添太多轨道。让很多轨道展现出花里胡哨的节奏但却在同一拍按键也会让人感觉很牵强。
 
 ```rdview 14 4
-eb.AddClassicBeat 0 0[tick=1.5,swing=0.25];
-eb.AddClassicBeat 2 0[tick=3,swing=0.5];
-eb.AddClassicBeat 6 0[tick=3,hold=0.5,swing=0.5];
-eb.AddFreeTimeBeat 10 0[pulse=1];
-eb.PulseFreeTimeBeat 10.25[pulse=9];
-eb.PulseFreeTimeBeat 11[pulse=9];
-eb.PulseFreeTimeBeat 11.25[pulse=9];
-eb.PulseFreeTimeBeat 12[pulse=9];
-eb.PulseFreeTimeBeat 12.25[pulse=9];
-eb.PulseFreeTimeBeat 13[pulse=9];
-eb.AddClassicBeat 0 1[tick=6];
-eb.AddClassicBeat 7 1[tick=1.5,swing=0.25];
-eb.AddClassicBeat 9 1[tick=1.5,swing=0.25];
-eb.AddClassicBeat 0 2[tick=3,hold=0.5,swing=0.5];
-eb.AddClassicBeat 4 2[tick=3,swing=0.5];
-eb.AddClassicBeat 7 2[tick=6];
+AddClassicBeat 0 0[tick=1.5,swing=0.25];
+AddClassicBeat 2 0[tick=3,swing=0.5];
+AddClassicBeat 6 0[tick=3,hold=0.5,swing=0.5];
+AddFreeTimeBeat 10 0[pulse=1];
+PulseFreeTimeBeat 10.25[pulse=9];
+PulseFreeTimeBeat 11[pulse=9];
+PulseFreeTimeBeat 11.25[pulse=9];
+PulseFreeTimeBeat 12[pulse=9];
+PulseFreeTimeBeat 12.25[pulse=9];
+PulseFreeTimeBeat 13[pulse=9];
+AddClassicBeat 0 1[tick=6];
+AddClassicBeat 7 1[tick=1.5,swing=0.25];
+AddClassicBeat 9 1[tick=1.5,swing=0.25];
+AddClassicBeat 0 2[tick=3,hold=0.5,swing=0.5];
+AddClassicBeat 4 2[tick=3,swing=0.5];
+AddClassicBeat 7 2[tick=6];
 ```
 
 **四、**不要过度采音。更不要为了精准采音做出种类繁多，重复次数又少的自由拍子。节奏医生的游戏机制是和一般的音乐游戏不同的。音乐游戏是可以给每一个节奏点都设计按键（Note）的，但节奏医生却不能这样。节奏医生的本质是“提示拍 + 按键拍”的组合，**所有的提示拍全都应该按照没有按键的节奏点来设计**。如果像其他音乐游戏一样来设计节奏医生的谱面，得到的一定是塞爆谱。

pages/camera.md

@@ -101,6 +101,8 @@
 
 **1、**所谓的移动摄像头，画一个三维空间出来也许可以让你更好地理解。它就像是我们举着一台摄像机拍摄自己的家一样，你的手或者身子移动，那么摄像头跟着移动，拍摄下来的整体画面位置就会不同。
 
+如果“真实运动”选择的是开启，那么摄像头就是记录房间内的画面，怎么移动都在房间内；选择关闭则是像看录像一样，移动时会露出边缘。
+
 ![拍摄房间里的爱心和海莉](../images/camera-haleyandheart.gif)
 
 **2、**移动摄像头最基本的用法就是把摄像头跟着节奏晃来晃去，与全程静止不动的背景相比，这样会给谱面增加一些动感。这个轨道移动的弹跳设计原理是一样的，仅仅是呈现的画面效果稍显不同。

pages/camerafx.md

@@ -31,9 +31,9 @@
 ![字幕在轨道浮动的中间出现并消失](../images/camerafx-cameracroprow.gif)
 ![列车的门外冒出字了](../images/camerafx-cameracroptrain.gif)
 
-## 配合自定义滚屏
+## 配合屏幕滚动
 
-自定义滚屏这个**预设特效**和普通的移动房间不一样，他的屏幕是上下左右接续的。但是只要是移动的屏幕，自然就可以配合浮动文字。为了方便操控文字的出现，一般也可以考虑剪裁房间的大小，并且配合遮罩。接下来就只需要安排好文字出现和消失的时机，文字就会像弹幕一样播放起来了。
+屏幕滚动这个**预设特效**和普通的移动房间不一样，他的屏幕是上下左右接续的。但是只要是移动的屏幕，自然就可以配合浮动文字。为了方便操控文字的出现，一般也可以考虑剪裁房间的大小，并且配合遮罩。接下来就只需要安排好文字出现和消失的时机，文字就会像弹幕一样播放起来了。
 
 ![飞屋环街记？](../images/camerafx-cameracropwithscreenscrolling.gif)
 
@@ -43,8 +43,8 @@
 
 | 预设特效 | 配合效果 |
 | :--- | :--- |
-| 自定义屏幕块 | 当然是把字也分成多块，没什么特别的 |
-| 自定义滚屏 | 见上面那段 |
+| 自定义屏幕分隔 | 当然是把字也分成多块，没什么特别的 |
+| 屏幕滚动 | 见上面那段 |
 | 黑屏 | 不出意外地全黑了 |
 | 噪点、干扰 | 对浮动文字无效 |
 | 电影噪点、高光、JPEG失真、马赛克、海底波浪 | 正常地产生效果 |

pages/captions.md

@@ -20,6 +20,10 @@
 
 ![](../images/floatingtext-position.png)
 
+**字体**：可以强制文本是哪种字体，有像素字体（不支持中文）、矢量字体（中文默认显示的字体）和粗体字体（`2-X`判定文字同款）。点击旁边的文件夹图标可以自行导入ttf或otf格式字体文件。
+
+![](../images/captions_FONT.png)
+
 **位置**：指的是基准的位置。可以按一下准星符号再在预览画面窗口中点选位置。有条件精准找到位置的话还是建议在`X`和`Y`栏中输入具体数值。**点击右边的`%`按键可以切换屏幕像素点和屏幕百分比两种输入方式**。
 
 ![不同基准在同一位置下的不同效果](../images/floatingtext-align.png)
@@ -35,25 +39,25 @@
 **创建文本递进**：如果想要把一整句歌词按歌词节奏一个一个地显示出来，就需要在文本中使用“`/`”将它们隔开。如果想要一个一个地覆盖掉之前显示的内容，就需要在文本中使用`回车键`将他们隔开。之后点击下面的“创建文本递进”，在工作区里面可以拖动右箭头事件来调整时机。如果你做好了又不想要了，那么再把下面的开启改成关闭即可，无需手动删除。如果你又反悔了，还是想要，再改成开启，又会恢复记录。
 
 ```rdview 8 3
-ea.FloatingText 1 1;
-ea.AdvanceText 2 1;
-ea.AdvanceText 3 1;
-ea.AdvanceText 4 1;
-ea.AdvanceText 5 1;
-ea.AdvanceText 6 1;
-ea.AdvanceText 7 1;
+FloatingText 1 1;
+AdvanceText 2 1;
+AdvanceText 3 1;
+AdvanceText 4 1;
+AdvanceText 5 1;
+AdvanceText 6 1;
+AdvanceText 7 1;
 ```
 
 音节的消失方式选择**淡出**就是慢慢消失，**立即**就是瞬间消失，音节显示的时长是按创建文本递进的最后一个事件往后数拍子的。
 
 ```rdview 13 3
-ea.FloatingText 1 1;
+FloatingText 1 1;
 g 3 1 4 1;
 g 7 1 0 1 #f80;
-ea.AdvanceText 3 1;
+AdvanceText 3 1;
 g 8 1 4 1;
 g 12 1 0 1 #f80;
-ea.AdvanceText 8 1;
+AdvanceText 8 1;
 ```
 
 ## 更丰富的效果和技巧
@@ -117,7 +121,7 @@ ea.AdvanceText 8 1;
 
 你以为这里会有一个我们制作的关卡？其实并不。在这里我想介绍的是官方联动关卡`MD-2`，不知道你们在游玩这关感受爆炸难度的同时有没有注意到字幕的表现？如果你没有什么印象的话可以先看看下面这个视频：
 
-<div class="bv"><iframe src="https://player.bilibili.com/player.html?aid=374450491&page=55&autoplay=0" title="BPM 与偏移的校对教程" width="100%" height="100%" scrolling="no" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div>
+<div class="bv"><iframe src="https://player.bilibili.com/player.html?aid=374450491&page=56&autoplay=0" title="BPM 与偏移的校对教程" width="100%" height="100%" scrolling="no" frameborder="no" framespacing="0" allowfullscreen="true"></iframe></div>
 
 看完之后我们再来回忆一下其中一段歌词的表现：
 
@@ -147,6 +151,16 @@ ea.AdvanceText 8 1;
 
 有没有发现不管是颜色效果还是显示效果，在设计上都和歌词本身有着些许联系，也就让平淡无奇的歌词字幕一下子变得生动起来。
 
+## 文本装饰
+
+你可能已经注意到，**浮动文字**事件并没有移动文字的功能。如果想要移动文字，请移步绿色板块，点击加号创建装饰，选择“文本”。
+
+![创建文本装饰](../images/captions-textdecoration.png)
+
+创建一个**设置文本**事件，你会发现这个事件和浮动文字基本一样，相信你已经知道怎么用了。
+
+这里的文本比起用浮动文字事件创建的文本功能更加齐全，不仅可以**移动装饰**，还可以**显示/隐藏**、**重排序：装饰**，等等。总之和精灵图差不多（如果想了解精灵图请看[这里](../pages/decoration.md#制作一个精灵)），这里就不过多赘述了。
+
 ## 显示对话
 
 在不少剧情关卡里面角色都会有聊天的过程，这在编辑器内也是可以轻松实现的，需要的是紫色版块中的**显示对话**功能。

pages/changelog.md

@@ -1,5 +1,31 @@
 # 更新信息
 
+#### 2026-06-06
+- 更新 [VFX](../pages/vfx.md) 章节
+- 更新[镜厅](../pages/hallofmirror.md) 章节
+
+#### 2026-03-25
+- 更新事件列表
+- 更新预设特效列表
+- 修正格式错误
+- 更改“设置窗口数量”译名为“设置窗口内容”
+- 补充 WindowDance 页内容
+- 更新轨道涂色属性页图片
+- 更新轨道重排序事件
+- 更新旋转轨道事件的详细内容
+- 更新默认轨道的各部分位置分布数值
+- 为改变轨道事件描述添加图片
+- 更新制作人员表
+
+#### 2026-03-01
+- **变量**一节被替换为[表达式](../pages/expression.md)。  
+- 为各种标题添加了容易辨识和定位的背景渐变条。  
+- ~~我也要加入文档编撰列表吗（~~
+
+#### 2026-02-26
+- 临时修复了若干资源查找问题
+- 同步音频列表
+
 #### 2026-01-24
 - 制作人员表增加了
 

pages/classicbeat.md

@@ -28,6 +28,8 @@
 
 如何加入类似于`1-2亲密`的`X`记号呢？在生成一个节奏之后，点击“**切换为X字拍子设置**”就可以调节。需要注意的是：你需要在一串普通拍子开始的**同时**或是**之前**就放置好修饰拍子设置。如果在普通拍子已经响起之后再添加`X`，虽然画面上能即时生效，但是节拍音效是没法立刻改变的。
 
+如果你在单发类型的轨道上放置`切换为X字拍子设置`，那么时间轴会卡住无法播放。
+
 > 在没有节奏的地方放置一连串的“切换为X字拍子设置”来改变`X`的排布也可以视为一种画面演出。
 
 当然，这个功能也不仅仅是为轨道加`X`，按下鼠标左键是加入`X`记号，按下鼠标右键一次是`↑`箭头记号，两次是`↓`箭头记号。按下鼠标中键一次是摇摆心跳记号，两次是抖动心跳记号。

pages/createbuiltincharacter.md

@@ -20,7 +20,7 @@
 
 ![轨道的设置界面](../images/createbuiltincharacter-rowinfo.png)
 
-**类型：**“**普通**”表示像武士一样的普通拍子节奏，“**单发**”表示像咖啡师一样的单发拍子节奏。需要注意的是，切换轨道类型的同时也会清空轨道上的所有节拍，因此建议在一开始就确定好轨道的类型。
+**类型：**“**普通**”表示像武士一样的普通拍子节奏，“**单发**”表示像咖啡师一样的单发拍子节奏。虽然现在单发和普通拍子可以共存，但需要注意的是，切换轨道类型的同时也会清空轨道上的所有节拍，因此建议在一开始就确定好轨道的类型。
 
 **玩家：**P1，P2表示玩家1和玩家2，CPU表示电脑演示。
 

pages/credits.md

@@ -14,6 +14,8 @@
     - [0x4D2](https://space.bilibili.com/478595264)  
     - [正宗的小绿君](https://space.bilibili.com/1782518253)
     - [kuanpan](https://space.bilibili.com/1928620300)
+	- [obugs](https://space.bilibili.com/498017546)
+    - [zyx](https://space.bilibili.com/2045355693)
 - 视频制作：
     - [吾夜犹明](https://space.bilibili.com/29219948)
     - [山不转水到渠成](https://space.bilibili.com/4870582)

pages/custommethod.md

@@ -93,6 +93,20 @@
 ## 快捷查询
 
 <div class="custommethods-search">
+  <div class="cm-search">
+    <input class="cm-query" type="text" placeholder="输入自定义方法名，如 ChangeCharacter" autocomplete="off">
+    <ul class="cm-suggest"></ul>
+  </div>
+  <div class="cm-options"></div>
+  <div class="cm-selected" hidden>
+    <div class="cm-head">
+      <span class="cm-name"></span>
+      <span class="cm-short"></span>
+    </div>
+    <div class="cm-call"></div>
+    <code class="cm-preview"></code>
+    <div class="cm-desc"></div>
+  </div>
 </div>
 
 ## 我知道你还想问什么

pages/decoration.md

@@ -110,6 +110,21 @@
 
 **时长与缓速：**同其他事件。
 
+## 混合精灵图
+可以将精灵图的颜色与场景混合。
+
+混合模式将进行以下计算（超过255的按255算，小于0按0算，小数四舍五入）：
+
+假设背景色为RGB(r1,g1,b1)
+
+精灵图颜色为RGB(r2.g2.b2）
+
+**附加（add 线性减淡）**模式显示的颜色为RGB(r1+r2,g1+g2,b1+b2)
+
+**叠加（mul 正片叠底）**模式显示的颜色为RGB(r1*r2/255.g1*g2/255.b1*b2/255)
+
+**反转（inv 反色）**模式显示的颜色为RGB(rl-r2,b1-b2,g1-g2)
+
 ## 精灵的使用技巧
 
 **1、作为场景物体**

pages/editorinterface.md

@@ -86,6 +86,8 @@
 
 **另存为**：保存为额外的一个文件。
 
+**测试**：直接开始游玩关卡。
+
 **导出以发布**：导出以发布：将谱面导出为 .rdzip 文件，或将谱面上传至创意工坊。
 
 **退出**：退出编辑器，记得先保存。

pages/expression.md

@@ -0,0 +1,108 @@
+# 表达式
+
+在节奏医生编辑器中，为了增加灵活性与可玩性，很多地方都支持使用表达式在游戏运行时动态决定实际的效果。这种表达式被称作 **RDCode**。  
+
+## 数据类型
+
+类似于其他编程语言，RDCode 中有且仅有一些预定义的数据类型。
+
+### 常量
+表示一个确定的值，其值在关卡制作时就已经确立。  
+
+### 变量
+表示一个不定的值，其值可能会在关卡运行过程中被赋值语句更改。  
+
+- **访问权限**  
+  为了保证关卡运行的稳定，一些变量会设置访问权限：
+  - **只读**  
+    此变量可以参与表达式求值（读），但不能被赋值（写）。  
+  - **只写**  
+    此变量仅允许被赋值（写）而不能参与表达式求值（读）。  
+  - **可读写**  
+    此变量既能够参与表达式求值（读）也能够被赋值（写）。  
+
+- #### 整形（Integer/int）  
+  即整数。  
+  整形可以自动参与浮点型数据的数学运算。  
+  你可以直接使用整形常量并参加运算，例如 `2026`, `-308`, `999`, `0`。  
+- #### 浮点型（Single/Float/float）  
+  可以带有小数部分的数字。  
+  例如 `3.1415`, `200.1`, `-9.99`。  
+  > 在将浮点型转换为整型的操作（如赋值操作）时，将遵循**向最近偶数舍入**的原则（与大多数编程语言中的**向下取整**原则不同），即若计算结果为 `0.5`，那么它对应的整数值为 `0`；而 `1.5` 将对应 `2`。  
+- #### 布尔型（Boolean/bool）  
+  仅 `true` 或 `false` 以表示启用或禁用等。  
+  > 在**自定义方法**中，
+
+- #### 字符串型（String/string）  
+  一串字符。  
+  不参与运算，仅在调用自定义方法时作为参数存在。  
+  值得注意的是，不同于其他语言的双引号 `"STRING"` 等表示方式，RDCode 的字符串表示是 `str:STRING`，即在字符串的前面加上一个 `str:` 前缀。  
+  一般而言，在 RDCode 内用到字符串型的地方都只能在一系列候选词中选择一个填入，例如在选择角色或缓速类型时。  
+  例如 `str:Samurai`, `str:Linear`
+
+- #### 预定义变量  
+  节奏医生为整数、浮点数、布尔类型各预定义了 10 个可读写变量，分别以 `i`, `f`, `b` 开头，即 `i0`-`i9`, `f0`-`f9`, `b0`-`b9`。  
+  一些只读或只写的变量可在[自定义方法表](../pages/appendix_custommethods.md)查到。  
+
+## 运算类型
+
+- **数学运算符**    
+  `+` `-` `*` `/` `%`
+- **逻辑运算符**  
+  `And` `Or` `Not`
+  > 在 `And` `Or` 的两侧、`Not` 的右侧只支持布尔型数据。
+- **比较运算符**  
+  `>` `<` `>=` `<=` `==` `<>`
+- **函数调用**  
+  如 `Rand`, `IIf`, `atLeastRank`  
+  > 所有的可用的自定义方法请查阅[自定义方法表](../pages/appendix_custommethods.md)。  
+  > 表内标注的方法按照每个参数的含义及其类型表示，  
+  > 例如 `SetMistakeWeight(int RowID, float Weight)` 中，注明了此方法需要一个 int 类型（即整形）的值表示 RowID 和一个 float 类型（即浮点型）的值表示 Weight，  
+  > 你可以这样使用：`SetMistakeWeight(0, 2)`，表示将轨道 1 的错误权重设为 2。
+
+## 语句类型  
+只能在自定义方法中使用。  
+
+- **自增/自减**  
+  在变量后面添加 `++` 或 `--` 使变量本身加 1 或减 1。  
+  > 布尔变量不支持自增/自减。  
+  例如 `i2++`。  
+
+- **赋值**  
+  在变量和表达式之间使用 `=` 将变量的值设为表达式的值。  
+  例如 `f3 = 20 * f5`。  
+
+- **调用**  
+    调用[自定义方法](../pages/appendix_custommethods.md)。  
+
+## 表达式的用途
+
+### 条件
+- 在使用[条件](../pages/condition.md)的自定义条件模式时，可以定义一个自定义条件，用于决定赋予此条件的事件能否在播放关卡时启用。  
+- 在条件的表达式限制下我们难以直接写出用 `And` 或 `Or` 组合的形式；但是我们可以通过设立多个自定义条件并分别添加对应的表达式，应用于事件上，或是执行多次自定义表达式并赋值给预定变量，再在条件内组合。  
+- 在**条件**内无法使用 `>=` `<=`。~~怀疑是史山代码发力了~~  
+- 在**条件**内若有 `>` `<` 存在时不允许有括号嵌套。~~史山代码还在发力~~  
+- 逻辑运算符的优先级比比较运算符更高。  
+
+### 自定义方法
+- 自定义方法中的表达式仅在赋值和调用行为时才能使用，其中赋值时以 `[变量]=[表达式]` 形式将对应的变量设为计算后的值，调用时将表达式填入对应的参数的位置。  
+例如 `b0 = b1 Or Not b2 And 3 > f2`。
+- 自增或自减运算的左值仅能使用变量名，不能使用表达式。  
+- 在将布尔型数据转换为整形或浮点型的操作（如参与数学运算）时，其值将退化为整形，其中 `true` 对应 `1`，`false` 对应 `0`。  
+- 在将整形或浮点型数据转换为布尔型的操作（如赋值操作）时，其值将遵循**非 `0` 即 `true`** 的原则，即若计算结果为 `0`，那么它对应的布尔值为 `false`，否则为 `true`。  
+- 实际上在**自定义方法**内进行数学运算时，所有数据都将转换为浮点型再参与运算。  
+- 比较运算符的优先级比逻辑运算符更高。  
+- `Rand` 方法既不能包含表达式形式的参数，也不能参与计算。  
+
+### 自定义方法（注释）
+- 注释型自定义方法的参数不支持表达式，仅支持单独的值或变量。  
+
+### 事件参数
+- 部分事件的属性支持填入表达式，如移动轨道、移动精灵图的位置、轴点、尺寸、角度等。  
+- 需要用花括号 `{}` 将表达式括起来以表示这是一个表达式。  
+- 其他同**自定义方法**。  
+
+### 内插字符串
+- 部分事件的字符串类型属性支持将表达式插入字符串，如浮动文字、显示状态牌等。  
+- 需要用花括号 `{}` 将表达式括起来以表示游戏需要将表达式的值替换表达式插入原字符串中。  
+- 其他同**自定义方法**。  

pages/hallofmirror.md

@@ -1,22 +1,25 @@
 # 镜厅
 
-游戏的画面是一帧一帧地播放的。为了确保游戏的画面一直在更新，在绘制一帧画面之前，游戏会将已经绘制过的画面重置为全黑。  
+## 镜厅的本质
+正常情况下，游戏每一帧绘制前都会清空屏幕（填充黑色），然后重新绘制所有物件。这保证了上一帧的画面不会残留。  
 **但是如果不重置呢？**  
+镜厅（Hall of Mirror） 就是关闭这个清空操作。上一帧的画面保留在屏幕上，新画面直接叠加在上面。
 
-## 基础效果  
+你可以尝试：  
+- 添加一个会移动的轨道或精灵（如一个向右匀速移动的豆子盒）
+- 在预设特效中添加"镜厅"
+- 播放关卡
+你会发现，方块不再是一个清晰的个体，而是一条向右延伸的 "尾巴"。
+这是每一帧的方块叠加在一起形成的拖影。
+> 镜厅在 "主题设置" 和 "预设特效" 中都有，但请使用预设特效版本。主题设置是全局开关且难以与其他特效组合，预设特效可以灵活控制。
 
-相信你已经有了初步的感觉。镜厅就是这样，原来一帧的画面仍然保留在屏幕上，只是游戏重新绘制的画面直接覆盖在了原画面之上，从而造成一种“拖影”的效果。  
-这本是一种“bug”，但如果稍加利用，或许会有出其不意的效果。  
+如果不加控制，每一帧都叠加新画面，屏幕很快会被完全填满。我们需要一种机制让旧的画面逐渐淡出。
 
 ## 抑制方法
 
-### 画面的覆盖  
+### 亮度衰减  
 
-既然画面是一层一层叠在上面，如果要“修复这个 bug”，那就得咱们手动去将整个屏幕更新。  
-但是如果直接覆盖一个特定的颜色或者背景，那好像和直接设置背景没什么区别，镜厅就没有存在的意义了。  
-那半透明呢？  
-画面会被覆盖，但是覆盖程度取决于透明度。  
-我们来做个小实验：假设现在有一个像素的亮度为 100，每一帧向右移动 1 像素，在镜厅的效果下会导致它在每一帧一直留存，但是现在有一个手段，能够在每一帧画完之前整个画面的亮度降为原来的一半，那这个像素的实际亮度是怎样的呢？  
+假设一个亮度为 100 的像素每帧向右移动 1 像素，且每帧绘制前整个画面亮度衰减为原来的 50%：
 
 | 帧 | 亮度 ||||
 |-|-:|-:|-:|-:|
@@ -25,88 +28,111 @@
 |3|25|50|100|
 |4|12.5|25|50|100|
 
-理解了这个之后，你就可以着手做出这样的效果：
+衰减率决定拖尾长度。  
+节奏医生没有直接的 "衰减率" 参数，但可以通过以下方式模拟：  
 
-![](../images/hallofmirror-trail.gif)
+#### 半透明黑色背景覆盖
+添加一个黑色背景板  
+设置透明度为 20%（即每帧覆盖 20% 不透明黑色，相当于 80% 亮度保留）  
+在元素移动时，原来留下的影子会逐渐被黑色覆盖，形成拖影的效果。  
+![](../images/hallofmirror-trail.gif)  
+![在医院走廊奔跑的科尔](../images/hallofmirror-runningcole.gif)  
 
-### 画面的扭曲
-
-同样的，也可以
-   
----
-
-
-镜厅一共能在两个地方找到，一是设置主题中的 “镜厅”，二是预设特效中的“镜厅”。**但最好使用预设特效中的**。  
-
-如果只是直接使用镜厅加上预设特效，效果一般只会越来越阴间，所以我们一般会使用预设特效里的“晕影”和“闪烁晕影”或者半透明的背景或半透明的后背景板闪光（由于设备性能差别，镜厅的效果显示可能每个人会有所不同，我一般使用20的透明度）来起到抑制的效果，同时这样也能直接做出最简单的拖尾效果。
-
-
-拖尾效果（可以注意到镜厅留下了痕迹 ，如果想去除就需要再加上其他的效果，比如-1强度的高光）。这里再附上一些特效在遮罩后的组合（默认都已经打开了镜厅）。
-
-![x=1,y=1 的自定义滚屏 + 20 透明度的黑色背景](../images/hallofmirror-trailrepeat.gif)
-![2x2 屏幕块 + 晕影](../images/hallofmirror-screenblock.gif)
-![0% 强度海底波浪 + 20 透明度的黑色背景](../images/hallofmirror-wavetrail.gif)
+#### 晕影特效
+添加预设特效"晕影"或"闪烁晕影"  
+晕影会从边缘向中心逐渐覆盖，产生柔和的拖影抑制  
 ![蓝色高光 + 晕影](../images/hallofmirror-bluehighlight.gif)
 
-一般来说直接用这些效果是不会太好的，用的时候会使用更多其他的特效进行组合。
+### 位移扭曲
+除了亮度衰减，还可以让历史画面发生位移，产生流动感。
 
-### 反色（HOMVERT）
+---
 
-镜厅+反色的结果往往是会让眼睛难以承受的高频闪烁，因此直接使用是禁止的，但是加上一点遮罩就可以避免这种结果。
+#### 基础位移效果
+在镜厅基础上添加屏幕滚动：x = 1, y = 1  
+配合 20% 透明度黑色背景  
+元素朝左上方向流动的同时会一直复制画面本身叠印起来。  
+![x=1,y=1 的屏幕滚动 + 20 透明度的黑色背景](../images/hallofmirror-trailrepeat.gif)  
+![0% 强度海底波浪 + 20 透明度的黑色背景](../images/hallofmirror-wavetrail.gif)
 
-![镜厅 + 反色 + 20 透明度背景的效果](../images/hallofmirror-homvert.gif)
+#### 屏幕分隔扭曲
+添加屏幕分隔特效：x = 2, y = 2  
+画面被划分为 2×2 的块，同时会叠上原来的画面。  
+![2x2 屏幕分隔 + 晕影](../images/hallofmirror-screenblock.gif)
 
-另外，值得一提的是护士语音自带的灯光实际上是一片反色的区域，因此如果使用了镜厅，就要注意是否产生了镜厅反色（实在没办法也可以用音效代替直接使用语音来避免出现灯光）。
+### 区域控制
+镜厅是全屏效果，但有时你只想部分区域有拖影，或者需要保护某些区域不被拖影污染。  
 
-### 背景
+---
 
-如果直接使用背景加上镜厅使用是不会有效果的，但如果我们把背景的颜色设成半透明在加上镜厅就能在保留背景的情况下加上镜厅的效果。
+#### 反色遮罩
+镜厅 + 反色（HOMVERT）会产生高频闪烁，极其伤眼，**禁止直接使用**。  
+通常使用镜厅 + 反色 + 20% 透明度黑色背景的组合。  
+黑色背景作为遮罩层，可以降低反色区域的对比度，消除闪烁  
+> 护士语音自带的灯光是反色区域，使用镜厅时需注意，或用音效代替语音避免灯光。 
 
-![在医院走廊奔跑的科尔](../images/hallofmirror-runningcole.gif)
+![镜厅 + 反色 + 20 透明度背景的效果](../images/hallofmirror-homvert.gif) 
 
-如果图片本身有透明部分，则镜厅的效果会只在透明的部分显示。
+#### 背景遮罩
+直接使用背景 + 镜厅无效果（背景完全覆盖，没有透明区域供镜厅显示）。  
+设置背景为半透明（如 50% 透明度），镜厅效果只在背景的透明部分显示  
+> 如果图片本身有透明通道（如 PNG），镜厅会自动只在透明区域产生拖影。
 
 ![镜厅的效果附在了每个方块后面](../images/hallofmirror-trailblock.gif)
 
-### 顶部镜厅
-
-预设特效里的镜厅除了四个房间外，还可以选择在“顶部”生效，这样就能做出只用房间做不出的效果，或者通过缩放和移动房间让整个房间受到镜厅影响。我们可以利用这个干很多事。
+### 房间控制
+预设特效中的镜厅有两个作用域：  
+- 四个房间：仅影响关卡内的游戏区域  
+- 顶部：影响整个屏幕，包括 UI 和边框  
 
+#### 顶部镜厅
+##### 边框绘制
+使用顶部镜厅 + 特定物件移动  
+拖影会在屏幕边缘形成 "画框" 效果  
 ![用顶部镜厅来画边框](../images/hallofmirror-danmaku.gif)
+
+##### 万花筒
+顶部镜厅 + 旋转 / 缩放房间  
+整个画面产生对称的镜像拖影  
 ![](../images/hallofmirror-kaleidoscope.gif)
 
-直接在使用主题的房间使用镜厅是不会有效果的，但如果设置透明背景再使用顶部镜厅就能起到作用（需要注意的是，有些主题设置的时候会自动设置一些效果，可以在设置主题后0.0001拍再设置其他效果来避免与主题冲突）。
+#### 房间透明化
+直接使用主题 + 镜厅无效果（主题背景不透明）。  
+设置主题后，在 0.0001 拍时添加其他特效（避免与主题自动设置冲突）  
+设置透明背景 + 顶部镜厅
+或者将主题放在单独房间，将该房间设为半透明，轨道物件叠加在上方
 
 ![](../images/hallofmirror-trailinroom.gif)
 
-对于本身没有透明部分的主题，我们可以把主题单独放在一个房间然后把那个房间半透明化，之后把轨道单独叠在那个房间上面来达成效果。
+## 组合
+镜厅不是单独使用的特效，而是基础层。真正丰富的效果来自组合。
 
-### 透明化
+### 控制维度
 
-虽然在大部分情况下使用了镜厅就意味着房间的背景不再能透明，但在少数特效影响下的情况是可以的。
+维度 | 特效示例             | 作用
+---- | -------------------- | -----------------
+衰减 | 黑色背景透明度、晕影 | 控制拖尾长度
+位移 | 滚屏、海底波浪       | 让拖影流动 / 扭曲
+颜色 | 高光、反色、VHS      | 改变拖影色彩
+遮罩 | 背景透明度、屏幕分隔 | 限制镜厅作用区域
 
-![镜厅 + 负数强度的落雨](../images/hallofmirror-homandrain.gif)
-![镜厅 + 负数强度的高光](../images/hallofmirrorhomandhighlight.gif)
+### 经典组合参考
+- 拖尾基础：镜厅 + 20% 黑色背景 + 晕影
+- 流动拖尾：镜厅 + 海底波浪 (0% 强度) + 20% 黑色背景
+- 方块拖影：镜厅 + 屏幕分隔 (2×2) + 晕影
+- 蓝色光晕：镜厅 + 蓝色高光 + 晕影
+- 复古故障：镜厅 + VHS + 电影噪点
+- 雨夜效果：镜厅 + 落雨 (负数强度) + 高光 (负数强度)
+### 透明化特例
+某些特效会让背景在镜厅下保持透明：
+![镜厅 + 负数强度的落雨](../images/hallofmirror-homandrain.gif)  
+![镜厅 + 负数强度的高光](../images/hallofmirrorhomandhighlight.gif)  
+![镜厅 + VHS](../images/hallofmirror-hmandvhs.gif)  
+![镜厅 + 电影噪点](../images/hallofmirror-homandnoise.gif)  
 
-也有一些特效会让背景半透明。
-
-![镜厅 + VHS](../images/hallofmirror-hmandvhs.gif)
-![镜厅 + 电影噪点](../images/hallofmirror-homandnoise.gif)
-
-与之相对的，也有部分特效会让镜厅无法透明，加上其他的特效也一样。
-
-![镜厅 + 暴风雪（同时有 VHS 效果但并没有透明）](../images/hallofmirror-homandsnowstorm.gif)
-![镜厅 + 素描（同时有 VHS 效果但并没有透明）](../images/hallofmirror-homandpaint.gif)
-
-### 特殊效果
-
-镜厅其实不只能用来做特效，也可以用来做一些特殊的效果。比如用来画画或者猜单词，当然这些都是一般用不到且比较难实现的，放在这里只是让你们知道一下。
-
-### 组合
-
-上面提到的都是镜厅的一些基本的用法。但做谱的时候不可能只用这些效果，这样是做不出花样来的。要做出更多变数，就要尝试更多的组合，甚至把组合再组合，这样就能做出很多不同的效果。在想不到怎么做特效的时候这是个很好用的方法试的时候也要注意效果不能太伤眼，也不是叠的特效越多越好。丰富谱面的内容才是第一目的。
-
-与此同时，我们也要知道，镜厅只是做谱时的一种手段，做特效如果只是一味的试各种特效还不去了解其他方面，是没法提高的。希望你们做谱的时候能够合理使用镜厅，让内容更丰富。
+某些特效会强制背景不透明：  
+![镜厅 + 暴风雪（同时有 VHS 效果但并没有透明）](../images/hallofmirror-homandsnowstorm.gif)  
+![镜厅 + 素描（同时有 VHS 效果但并没有透明）](../images/hallofmirror-homandpaint.gif)  
 
 ## 一些陈旧的示例
 
@@ -147,13 +173,13 @@
 
 ![巨　硬　报　错](../images/hallofmirror-repeattttttttttt.gif)
 
-### 镜厅 + 屏幕块
+### 镜厅 + 屏幕分隔
 
 这个需要配合晕影使用，不然也会直接崩坏。
 
 ![千　人　一　面](../images/hallofmirror-screenblock2.gif)
 
-要注意屏幕块是可以填写小数的，例如填写`x = 1.05, y = 1`，自定义闪烁透明度`15%~0%`。
+要注意屏幕分隔是可以填写小数的，例如填写`x = 1.05, y = 1`，自定义闪烁透明度`15%~0%`。
 
 ![](../images/hallofmirror-rush.png)
 

pages/holdbeat.md

@@ -6,11 +6,11 @@
 
 ![](../images/holdbeat-lenght.png)
 
-如果不对其添加任何其他设置，那么轨道就会自动变成 `—x—x—x————♥` 的模式，像`4-1`这关的矿工一样，也就是在1，3，5，7拍有按压的动画效果。当然你可以在“设置X标记”这个项目里面选择跳过节拍的形式，默认有三种情况，如果想使用“切换为修饰拍子设置”来自由决定跳过也是可以的，先在“设置X标记”里面选择NO，然后设置好自己决定的修饰拍子就行了。
+如果不对其添加任何其他设置，那么轨道会延续上一个“切换为修饰拍子设置”的模式，当然你可以在“设置X标记”这个项目里面选择跳过节拍的形式，默认有三种情况，比如选`—x—x—x`轨道就会自动变成 `—x—x—x————♥` 的模式，像`4-1`这关的矿工一样，也就是在1，3，5，7拍有按压的动画效果。
 
 ```rdview 7 3
-eb.AddClassicBeat 3 1[tick=3,hold=0.3,swing=0.5];
-eb.SetRowXs 1 1[rowxs=---x--];
+AddClassicBeat 3 1[tick=0.5,hold=0.3,swing=0.5];
+SetRowXs 1 1[rowxs=---x--];
 ```
 
 另外长按拍子在编辑器里面也可以分解为自由节拍，使用自由节拍时，需将脉冲出现与脉冲消失分别构成两个合法的普通拍，也即所有脉冲出现的相隔时长相同，且所有脉冲消失的相隔时长相同。
@@ -24,12 +24,12 @@ g 5 2 0 5 #f00{};
 g 5.5 3 0 4 #d20{};
 g 6 4 0 3 #b40{};
 g 6.5 5 0 2 #960{};
-eb.AddFreeTimeBeat 1 1[offset=0 1,hold=4];
-eb.PulseFreeTimeBeat 2 1[offset=0 2,hold=3.5,pulse=3];
-eb.PulseFreeTimeBeat 3 1[offset=0 3,hold=3,pulse=5];
-eb.PulseFreeTimeBeat 4 1[offset=0 4,hold=2.5,pulse=7];
-eb.AddClassicBeat 1 6[tick=3,swing=0.5];
-eb.AddClassicBeat 5 6[tick=1.5,swing=0.25];
+AddFreeTimeBeat 1 1[pulse=0,offset=0 1,hold=4];
+PulseFreeTimeBeat 2 1[offset=0 2,hold=3.5,action=Custom,customPulse=2];
+PulseFreeTimeBeat 3 1[offset=0 3,hold=3,action=Custom,customPulse=4];
+PulseFreeTimeBeat 4 1[offset=0 4,hold=2.5,action=Custom,customPulse=6];
+AddClassicBeat 1 6[tick=0.5,swing=2];
+AddClassicBeat 5 6[tick=0.25,swing=2];
 ```
 
 ## 演示关卡
@@ -41,23 +41,23 @@ eb.AddClassicBeat 5 6[tick=1.5,swing=0.25];
 **1、**在长按拍松手的时刻可以有其他的按拍。这在曾经的编辑器版本里是不允许的，目前官方修正了这一机制。
 
 ```rdview 9 4
-eb.AddClassicBeat 1 1[tick=6,hold=1];
-eb.AddClassicBeat 2 2[tick=6];
+AddClassicBeat 1 1[tick=1,hold=1];
+AddClassicBeat 2 2[tick=1];
 ```
 
 **2、**当同时存在多个长按拍子时，这些长按拍的长按时间段必须完全一致。也就是说，长按时间段之间不能是包含、交叉或首尾相连的关系。
 
 ```rdview 16 7
-eb.AddClassicBeat 1 1[tick=3,hold=1,swing=0.5];
-eb.AddClassicBeat 1 2[tick=3,hold=0.5,swing=0.5];
-eb.AddClassicBeat 6 1[tick=3,hold=1,swing=0.5];
-eb.AddClassicBeat 6.25 2[tick=3,hold=0.5,swing=0.5];
-eb.AddClassicBeat 11 1[tick=3,hold=1,swing=0.5];
-eb.AddClassicBeat 11.5 2[tick=3,hold=1,swing=0.5];
-eb.AddClassicBeat 1.5 4[tick=1.5,hold=1,swing=0.25];
-eb.AddClassicBeat 1 5[tick=3,hold=0.5,swing=0.5];
-eb.AddClassicBeat 6 4[tick=3,hold=1,swing=0.5];
-eb.AddClassicBeat 6.5 5[tick=3,hold=0.5,swing=0.5];
+AddClassicBeat 1 1[tick=0.5,hold=1,swing=0.5];
+AddClassicBeat 1 2[tick=0.5,hold=0.5,swing=0.5];
+AddClassicBeat 6 1[tick=0.5,hold=1,swing=0.5];
+AddClassicBeat 6.25 2[tick=0.5,hold=0.5,swing=0.5];
+AddClassicBeat 11 1[tick=0.5,hold=1,swing=0.5];
+AddClassicBeat 11.5 2[tick=0.5,hold=1,swing=0.5];
+AddClassicBeat 1.5 4[tick=0.5,hold=1,swing=0.25];
+AddClassicBeat 1 5[tick=0.5,hold=0.5,swing=0.5];
+AddClassicBeat 6 4[tick=0.5,hold=1,swing=0.5];
+AddClassicBeat 6.5 5[tick=0.5,hold=0.5,swing=0.5];
 ```
 
 **3、**凹兔的自动演示对于长按拍的处理十分诡异，可能会提前松掉长按拍子，但不必惊慌，这不是你的问题。

pages/importandexport.md

@@ -4,7 +4,7 @@
 
 制作一个自制谱的第一步就是导入一首音乐。虽然编辑器本身对音频文件格式无严格要求，但还是**请使用.ogg格式的音频文件**，以减少出BUG的可能性，对后续的调整偏移和选关界面试听也有帮助。如果你需要.ogg格式但是手头只有.mp3可以使用[aconvert](https://www.aconvert.com/cn/audio/mp3-to-ogg)等软件转换。**音乐的文件名尽量只包含字母、数字和半角符号**。
 
-点击左上角的**菜单→新关卡**来创建新关卡，编辑器会帮我们选择到默认位置（C:\用户\你自己的用户名\文档\Rhythm Doctor）。如果你有长期做谱的需求，建议另取一个独立文件夹，会方便管理。在这个文件夹里创建的文件夹，就代表着你制作的不同的谱面。创建文件夹后进入，输入好谱面文件名，点击确定，就成功创建了一个谱面。
+点击左上角的**菜单→新关卡**来创建新关卡，编辑器会帮我们选择到默认位置（`C:\用户\你自己的用户名\文档\Rhythm Doctor`）。如果你有长期做谱的需求，建议另取一个独立文件夹，会方便管理。在这个文件夹里创建的文件夹，就代表着你制作的不同的谱面。创建文件夹后进入，输入好谱面文件名，点击确定，就成功创建了一个谱面。
 
 > 在编辑已保存的关卡时，编辑器会每隔 5 分钟在此关卡相同目录生成一个 `backup.rdlevel` 备份文件并覆盖原有 `backup.rdlevel` 文件，如果做到一半编辑器崩了没保存就可以打开这个文件来恢复数据。
 
@@ -20,7 +20,7 @@
 
 ## 调整曲速和偏移
 
-接下来一点十分重要，那就是调节BPM，也就是一分钟有多少拍的意思，只有设置对了BPM才能让游戏节奏和音乐速度保持一致。排除掉一些变速曲我们可以用[ArrowVortex](https://arrowvortex.ddrnl.com/)。或者你不想额外下载软件的话，也有一些在线网站可以测试，比如[all8](https://www.all8.com/tools/bpm.htm)。
+接下来一点十分重要，那就是调节BPM（Beats Per Minute，每分钟节拍数），只有设置对了BPM才能让游戏节奏和音乐速度保持一致。如果你在制作的曲目是匀速的，可以使用一些软件如 [ArrowVortex](https://arrowvortex.ddrnl.com/)，或是一些在线网站，比如[all8](https://www.all8.com/tools/bpm.htm)。
 
 调整好BPM之后还需要调整偏移。我们看一下下面波形图案，点击`‐`和`+`两个按钮进行缩小和放大。
 
@@ -45,9 +45,9 @@
 接下来在左下角点击紫色星星图标进入紫色的版块，在能看到波形结束的地方点一下，然后往下翻到**结束关卡**按钮，这样的按钮一共必须放三个。
 
 ```rdview 5 5
-ea.FinishLevel 1 1;
-ea.FinishLevel 2 2;
-ea.FinishLevel 3 3;
+FinishLevel 1 1;
+FinishLevel 2 2;
+FinishLevel 3 3;
 ```
 
 最后我们回到红色的版块，点击**关卡设置**，选择上方的导出，有几个空栏是必须要填写的：

pages/moreclassicbeats.md

@@ -7,13 +7,13 @@
 我们把一个普通的普通拍子分解为自由时长节拍后，可以看到它变成了一个大的`1`和六个小的`>` 。
 
 ```rdview 8 2
-eb.AddFreeTimeBeat 1 0[pulse=1];
-eb.PulseFreeTimeBeat 2 0[pulse=9];
-eb.PulseFreeTimeBeat 3 0[pulse=9];
-eb.PulseFreeTimeBeat 4 0[pulse=9];
-eb.PulseFreeTimeBeat 5 0[pulse=9];
-eb.PulseFreeTimeBeat 6 0[pulse=9];
-eb.PulseFreeTimeBeat 7 0[pulse=9];
+AddFreeTimeBeat 1 0[pulse=0];
+PulseFreeTimeBeat 2 0[action=Increment];
+PulseFreeTimeBeat 3 0[action=Increment];
+PulseFreeTimeBeat 4 0[action=Increment];
+PulseFreeTimeBeat 5 0[action=Increment];
+PulseFreeTimeBeat 6 0[action=Increment];
+PulseFreeTimeBeat 7 0[action=Increment];
 ```
 
 我们选中数字1对应的节拍，发现这个是设置起始脉冲位置的。你甚至可以将它改为第七拍，然后把六个小的`>`删掉，这样就没有任何节拍提示。如果你设计的关卡是一个和节奏医生没什么关联的创意谱（梦幻联动？），且按键密度很大，则可以考虑这样使用。相比于工作区里面重叠摆放一大堆普通普通拍子，这样会看上去更清爽。但如果你设计的就是节奏医生，**请不要在完全无节奏提示的情况下直接响起第七拍**。
@@ -23,20 +23,20 @@ eb.PulseFreeTimeBeat 7 0[pulse=9];
 剩下的大于号`>`即意味着心跳向右移动一格，数到7的时候则需要按拍。点选之后，把它改成 `<`，心跳还能向左移动一格；点击自定义，还可以任意指定到第几个节拍。每一组自由拍**必须使用较大的节拍作为开头**，较小的则数量不限，直到数到第七拍为止。
 
 ```rdview 10 2
-eb.AddFreeTimeBeat 1 0[pulse=1];
-eb.PulseFreeTimeBeat 2 0[pulse=9];
-eb.PulseFreeTimeBeat 2.75 0[pulse=9];
-eb.PulseFreeTimeBeat 3.5 0[pulse=9];
-eb.PulseFreeTimeBeat 4 0[pulse=9];
-eb.PulseFreeTimeBeat 4.5 0[pulse=9];
-eb.PulseFreeTimeBeat 5 0[pulse=9];
-eb.AddFreeTimeBeat 5 0[pulse=1];
-eb.PulseFreeTimeBeat 6 0[pulse=9];
-eb.PulseFreeTimeBeat 6.75 0[pulse=9];
-eb.PulseFreeTimeBeat 7.5 0[pulse=9];
-eb.PulseFreeTimeBeat 8 0[pulse=9];
-eb.PulseFreeTimeBeat 8.5 0[pulse=9];
-eb.PulseFreeTimeBeat 9 0[pulse=9];
+AddFreeTimeBeat 1 0[pulse=0];
+PulseFreeTimeBeat 2 0[action=Increment];
+PulseFreeTimeBeat 2.75 0[action=Increment];
+PulseFreeTimeBeat 3.5 0[action=Increment];
+PulseFreeTimeBeat 4 0[action=Increment];
+PulseFreeTimeBeat 4.5 0[action=Increment];
+PulseFreeTimeBeat 5 0[action=Increment];
+AddFreeTimeBeat 5 0[pulse=0];
+PulseFreeTimeBeat 6 0[action=Increment];
+PulseFreeTimeBeat 6.75 0[action=Increment];
+PulseFreeTimeBeat 7.5 0[action=Increment];
+PulseFreeTimeBeat 8 0[action=Increment];
+PulseFreeTimeBeat 8.5 0[action=Increment];
+PulseFreeTimeBeat 9 0[action=Increment];
 ```
 
 如果你想让一串自由节拍最后不需要按拍，而是节奏直接消失，就把这一组自由节拍的最后一个点选**垃圾桶**符号。
@@ -49,33 +49,36 @@ eb.PulseFreeTimeBeat 9 0[pulse=9];
 
 ## 切分音（Syncopation）
 
-切分音的概念不难理解，拍子的数量仍然为七个，但是最后一个拍子响起的时间是在6.5拍的时候，即提早了半拍。这少的半拍时间是可以发生在任意相邻两拍之间的。早期版本的编辑器需要使用自由拍来制作切分音，现在在**切换为X字拍子设置**里，点亮激活拍子下方的`->>>>>-`符号，就会将这一拍的时间缩短一半。每个轨道最多只能设置一个切分音位置。
+切分音的概念不难理解，拍子的数量仍然为七个，但是最后一个拍子响起的时间是在6.5拍的时候，即提早了半拍。这少的半拍时间是可以发生在任意相邻两拍之间的。早期版本的编辑器需要使用自由拍来制作切分音，现在在**切换为X字拍子设置**里，点亮激活拍子下方的`> > >`符号，就会将这一拍的时间缩短一半并自动添加提示音。每个轨道最多只能设置一个切分音位置。
 
 ![](../images/moreclassicbeats-syn.png)
 
-**如何提示**
+添加完后会发现多了几个选项，各个选项效果如下：
 
-> 1. 将轨道边缘染成黄色（参考颜色： `#FFFF00FF` ）
-> 2. 在切分发生前的奇数拍使用“切分音嘟声-低”音效
-> 3. 在切分发生后的第一拍使用“切分音嘟声-中”音效
-> 4. 在第7拍使用“切分音嘟声-高”音效
+**摇摆**：设置切分后的按拍点距离原来的提前了（拍长*摇摆）拍。
 
-需要额外注意的是，无论拍子之中是否有`X`，切分的第一个提示音、最后一个提示音以及可能存在的切分中音效都要保留，只有剩下的切分低音效是可以自行选择放置与否的。
+**音量&音高**：设置提示音的音量和音高。
+
+**样式**：设置提示音的样式，鸣声是剧情模式里用到的，嘟声则是社区创造的，用哪种都可以。
+
+**修饰拍子出现/消失音效**：只在使用鸣声样式才会有，用来提示切分音的出现和消失，嘟声则不需要。
+
+需要额外注意的是，无论拍子之中是否有`X`，切分出现/消失和切分后第一拍的音效必须保留，只有剩下的音效是可以自行选择放置与否的。
 
 ## 八拍子（8 Beats）
 
 八拍子就更好理解了，我们直接额外增加一个节拍，让按拍的时机在第八拍响起的时候。但是轨道上是只能显示七个拍子的，所以我们依然要依赖**分解成自由拍**，以`2 1 2 3 4 5 6 7`的形式响起节拍。设置的方法如下图所示：
 
 ```rdview 10 3
-eb.AddClassicBeat 1 0[tick=6];
-eb.AddFreeTimeBeat 1 1[pulse=2];
-eb.PulseFreeTimeBeat 2 1[pulse=8];
-eb.PulseFreeTimeBeat 3 1[pulse=9];
-eb.PulseFreeTimeBeat 4 1[pulse=9];
-eb.PulseFreeTimeBeat 5 1[pulse=9];
-eb.PulseFreeTimeBeat 6 1[pulse=9];
-eb.PulseFreeTimeBeat 7 1[pulse=9];
-eb.PulseFreeTimeBeat 8 1[pulse=9];
+AddClassicBeat 1 0[tick=1];
+AddFreeTimeBeat 1 1[pulse=1];
+PulseFreeTimeBeat 2 1[action=Decrement];
+PulseFreeTimeBeat 3 1[action=Increment];
+PulseFreeTimeBeat 4 1[action=Increment];
+PulseFreeTimeBeat 5 1[action=Increment];
+PulseFreeTimeBeat 6 1[action=Increment];
+PulseFreeTimeBeat 7 1[action=Increment];
+PulseFreeTimeBeat 8 1[action=Increment];
 ```
 
 **如何提示**
@@ -83,20 +86,20 @@ eb.PulseFreeTimeBeat 8 1[pulse=9];
 > 1. 将轨道边缘染成红色（参考颜色： `#FF0000FF` ）
 > 2. 在第1拍使用 `beep_mid.ogg` 自定义音效
 
-不要使用内置的 `sndBeepMid` 音效！
+也可以使用内置的 `sndBeepMid` 音效。
 
 八拍子也可以是摇摆拍，只需要将所有偶数拍选择并拖动即可变成摇摆拍：
 
 ```rdview 10 3
-eb.AddClassicBeat 1 0[tick=6,swing=0.5];
-eb.AddFreeTimeBeat 1 1[pulse=2];
-eb.PulseFreeTimeBeat 2.5 1[pulse=8];
-eb.PulseFreeTimeBeat 3 1[pulse=9];
-eb.PulseFreeTimeBeat 4.5 1[pulse=9];
-eb.PulseFreeTimeBeat 5 1[pulse=9];
-eb.PulseFreeTimeBeat 6.5 1[pulse=9];
-eb.PulseFreeTimeBeat 7 1[pulse=9];
-eb.PulseFreeTimeBeat 8.5 1[pulse=9];
+AddClassicBeat 1 0[tick=1,swing=0.5];
+AddFreeTimeBeat 1 1[pulse=1];
+PulseFreeTimeBeat 2.5 1[action=Decrement];
+PulseFreeTimeBeat 3 1[action=Increment];
+PulseFreeTimeBeat 4.5 1[action=Increment];
+PulseFreeTimeBeat 5 1[action=Increment];
+PulseFreeTimeBeat 6.5 1[action=Increment];
+PulseFreeTimeBeat 7 1[action=Increment];
+PulseFreeTimeBeat 8.5 1[action=Increment];
 ```
 
 在八拍子中，**激活拍子**与八拍子的对应关系如下图所示。不要给第1拍和第3拍设置X拍子，这样做它就相当于变回普通拍了。
@@ -115,33 +118,33 @@ eb.PulseFreeTimeBeat 8.5 1[pulse=9];
 整数拍和附点拍是交错排列的，即`0.25<->0.375<->0.5<->0.75<->1<->1.5<->2<->3<->4`。附点变速拍可以将整拍长变成附点拍长，也可以反过来，但只能变化到排列里它**相邻**的拍长上。
 
 ```rdview 9 3
-eb.AddFreeTimeBeat 1 0;
-eb.PulseFreeTimeBeat 2 0[pulse=9];
-eb.PulseFreeTimeBeat 3 0[pulse=9];
-eb.PulseFreeTimeBeat 4 0[pulse=9];
+AddFreeTimeBeat 1 0;
+PulseFreeTimeBeat 2 0[action=Increment];
+PulseFreeTimeBeat 3 0[action=Increment];
+PulseFreeTimeBeat 4 0[action=Increment];
 g 4 0 0.5 1 #08f[offset=0 0 #08f0]{
-    eb.PulseFreeTimeBeat 1 0[pulse=9];
+    PulseFreeTimeBeat 1 0[action=Increment];
     g 1 0 0.5 1 #000[offset=0 0 #0000]{
         g 0 0 0 0 #0000[offset=0.25]{
-            eb.PulseFreeTimeBeat 0.75 0[pulse=9,offset=0.25];
+            PulseFreeTimeBeat 0.75 0[action=Increment,offset=0.25];
             g 0.75 0 0.5 1 #0000[offset=0.25]{
-                eb.PulseFreeTimeBeat 0.75 0[pulse=9];
+                PulseFreeTimeBeat 0.75 0[action=Increment];
                 g -1.75 0 3 1 #0000{};
             };
         };
     };
 };
-eb.AddFreeTimeBeat 1 1;
-eb.PulseFreeTimeBeat 2 1[pulse=9];
-eb.PulseFreeTimeBeat 3 1[pulse=9];
-eb.PulseFreeTimeBeat 4 1[pulse=9];
+AddFreeTimeBeat 1 1;
+PulseFreeTimeBeat 2 1[action=Increment];
+PulseFreeTimeBeat 3 1[action=Increment];
+PulseFreeTimeBeat 4 1[action=Increment];
 g 4 1 0.5 1 #80f[offset=0 0 #08f0]{
-    eb.PulseFreeTimeBeat 1 0[pulse=9];
+    PulseFreeTimeBeat 1 0[action=Increment];
     g 1 0 0.5 1 #000[offset=0 0 #0000]{
         g 0 0 0 0 #0000[offset=-0.5]{
-            eb.PulseFreeTimeBeat 1.5 0[pulse=9];
+            PulseFreeTimeBeat 1.5 0[action=Increment];
             g 1.5 0 0.5 1 #0000[offset=-0.5]{
-                eb.PulseFreeTimeBeat 1.5 0[pulse=9];
+                PulseFreeTimeBeat 1.5 0[action=Increment];
                 g -2.5 0 4.5 1 #0000{};
             };
         };
@@ -168,33 +171,33 @@ g 4 1 0.5 1 #80f[offset=0 0 #08f0]{
 变速普通拍的另一种形式是倍速变速拍，变速是拍长翻倍或减半，注意与附点变速拍区分。
 
 ```rdview 11 3
-eb.AddFreeTimeBeat 1 0;
-eb.PulseFreeTimeBeat 2 0[pulse=9];
-eb.PulseFreeTimeBeat 3 0[pulse=9];
-eb.PulseFreeTimeBeat 4 0[pulse=9];
+AddFreeTimeBeat 1 0;
+PulseFreeTimeBeat 2 0[action=Increment];
+PulseFreeTimeBeat 3 0[action=Increment];
+PulseFreeTimeBeat 4 0[action=Increment];
 g 4 0 0.5 1 #08f[offset=0 0 #08f0]{
-    eb.PulseFreeTimeBeat 1 0[pulse=9];
+    PulseFreeTimeBeat 1 0[action=Increment];
     g 1 0 0.5 1 #000[offset=0 0 #0000]{
         g 0 0 0 0 #0000[offset=0.5]{
-            eb.PulseFreeTimeBeat 0.5 0[pulse=9];
+            PulseFreeTimeBeat 0.5 0[action=Increment];
             g 0.5 0 0.5 1 #0000[offset=0.5]{
-                eb.PulseFreeTimeBeat 0.5 0[pulse=9];
+                PulseFreeTimeBeat 0.5 0[action=Increment];
                 g -1.75 0 3 1 #0000{};
             };
         };
     };
 };
-eb.AddFreeTimeBeat 1 1;
-eb.PulseFreeTimeBeat 2 1[pulse=9];
-eb.PulseFreeTimeBeat 3 1[pulse=9];
-eb.PulseFreeTimeBeat 4 1[pulse=9];
+AddFreeTimeBeat 1 1;
+PulseFreeTimeBeat 2 1[action=Increment];
+PulseFreeTimeBeat 3 1[action=Increment];
+PulseFreeTimeBeat 4 1[action=Increment];
 g 4 1 0.5 1 #08f[offset=0 0 #08f0]{
-    eb.PulseFreeTimeBeat 1 0[pulse=9];
+    PulseFreeTimeBeat 1 0[action=Increment];
     g 1 0 0.5 1 #000[offset=0 0 #0000]{
         g 0 0 0 0 #0000[offset=-1]{
-            eb.PulseFreeTimeBeat 2 0[pulse=9];
+            PulseFreeTimeBeat 2 0[action=Increment];
             g 2 0 0.5 1 #0000[offset=-1]{
-                eb.PulseFreeTimeBeat 2 0[pulse=9];
+                PulseFreeTimeBeat 2 0[action=Increment];
                 g -2.5 0 4.5 1 #0000{};
             };
         };

pages/moreoneshotbeats.md

@@ -7,10 +7,10 @@
 我们前面说过，护士提示的 Rea 和 Get 对应脉冲，Dy 和 Set 对应按拍，Go 代表单发拍开始，这种规则当然不仅仅适用于普通单发拍。先来看一个简单的摇摆单发拍：
 
 ```rdview 11 3
-es.SayReadyGetSetGo_Get 1[];
-es.SayReadyGetSetGo_Set 2.5[];
-es.SayReadyGetSetGo_Go 5[];
-eb.AddOneshotBeat 5 1[loop=1,tick=1.5,interval=4];
+SayReadyGetSetGo 1[phraseToSay=JustSayGet];
+SayReadyGetSetGo 2.5[phraseToSay=JustSaySet];
+SayReadyGetSetGo 5[phraseToSay=JustSayGo];
+AddOneshotBeat 5 1[loop=1,tick=1.5,interval=4];
 ```
 
 可以看到，虽然 Get-Set 与 Set-Go 之间的间隔不同，但依然保持了上述的对应关系。实际上，这就是`4-4`使用的单发拍。
@@ -18,31 +18,31 @@ eb.AddOneshotBeat 5 1[loop=1,tick=1.5,interval=4];
 在`2-3`中也出现了摇摆单发拍，可以试着自己理解一下这关的单发拍提示：
 
 ```rdview 10 2
-eb.AddOneshotBeat 1[];
-eb.AddOneshotBeat 3[];
-eb.AddOneshotBeat 5[tick=0.75];
-eb.AddOneshotBeat 6[tick=0.75];
-eb.AddOneshotBeat 7[tick=0.75];
-eb.AddOneshotBeat 8[tick=0.75];
+AddOneshotBeat 1[];
+AddOneshotBeat 3[];
+AddOneshotBeat 5[tick=0.75];
+AddOneshotBeat 6[tick=0.75];
+AddOneshotBeat 7[tick=0.75];
+AddOneshotBeat 8[tick=0.75];
 ```
 
 如果我们在此基础上更进一步，会发生什么呢？来看看`4-4N`中出现过的这段单发拍：
 
 ```rdview 12 4
 g 1 1 4 2[offset=4]{
-    es.SayReadyGetSetGo_Rea 0 0[];
-    es.SayReadyGetSetGo_Dy 0.75 1[];
-    es.SayReadyGetSetGo_Get 1.5 0[];
-    es.SayReadyGetSetGo_Set 2.25 1[];
-    es.SayReadyGetSetGo_Go 4 0[];
+    SayReadyGetSetGo 0 0[phraseToSay=JustSayRea];
+    SayReadyGetSetGo 0.75 1[phraseToSay=JustSayDy];
+    SayReadyGetSetGo 1.5 0[phraseToSay=JustSayGet];
+    SayReadyGetSetGo 2.25 1[phraseToSay=JustSaySet];
+    SayReadyGetSetGo 4 0[phraseToSay=JustSayGo];
     g 0 -1 0.75 3 #0f8[]{};
     g 1.5 -1 0.75 3 #0f8[]{};
     g 4 -1 0 3 #0f8[]{};
 };
-eb.AddOneshotBeat 5[tick=0.75];
-eb.AddOneshotBeat 6.5[tick=0.75];
-eb.AddOneshotBeat 9[tick=0.75];
-eb.AddOneshotBeat 10.5[tick=0.75];
+AddOneshotBeat 5[tick=0.75];
+AddOneshotBeat 6.5[tick=0.75];
+AddOneshotBeat 9[tick=0.75];
+AddOneshotBeat 10.5[tick=0.75];
 ```
 
 可以看到，图中的单发拍已不再局限于一个单发拍不断重复了，而是变成了若干个单发拍构成的单发拍组的不断重复，但前面讲过的与护士提示之间的对应关系仍保持不变。由此我们可以得到单发拍的核心规则：
@@ -53,24 +53,24 @@ eb.AddOneshotBeat 10.5[tick=0.75];
 
 ```rdview 13 4
 g 1 1 4 2[offset=4]{
-    es.SayReadyGetSetGo_Rea 0 0[];
-    es.SayReadyGetSetGo_Dy 1 0[];
-    es.SayReadyGetSetGo_Rea 2 0[];
-    es.SayReadyGetSetGo_Dy 2.5 1[];
-    es.SayReadyGetSetGo_Get 3 0[];
-    es.SayReadyGetSetGo_Set 3.5 1[];
-    es.SayReadyGetSetGo_Go 4 0[];
+    SayReadyGetSetGo 0 0[phraseToSay=JustSayRea];
+    SayReadyGetSetGo 1 0[phraseToSay=JustSayDy];
+    SayReadyGetSetGo 2 0[phraseToSay=JustSayRea];
+    SayReadyGetSetGo 2.5 1[phraseToSay=JustSayDy];
+    SayReadyGetSetGo 3 0[phraseToSay=JustSayGet];
+    SayReadyGetSetGo 3.5 1[phraseToSay=JustSaySet];
+    SayReadyGetSetGo 4 0[phraseToSay=JustSayGo];
     g 0 -1 1 2 #0f8[]{};
     g 2 -1 0.5 3 #0f8[]{};
     g 3 -1 0.5 3 #0f8[]{};
     g 4 -1 0 3 #0f8[]{};
 };
-eb.AddOneshotBeat 5[];
-eb.AddOneshotBeat 7[tick=0.5];
-eb.AddOneshotBeat 8[tick=0.5];
-eb.AddOneshotBeat 9[];
-eb.AddOneshotBeat 11[tick=0.5];
-eb.AddOneshotBeat 12[tick=0.5];
+AddOneshotBeat 5[];
+AddOneshotBeat 7[tick=0.5];
+AddOneshotBeat 8[tick=0.5];
+AddOneshotBeat 9[];
+AddOneshotBeat 11[tick=0.5];
+AddOneshotBeat 12[tick=0.5];
 ```
 
 当你不确定一段单发拍提示是否正确时，可以把这段单发拍提示向后复制几份，首尾相连，如果发现所有的 Dy 和 Set 均对齐了按拍时机，就说明单发拍提示是正确的。
@@ -84,13 +84,13 @@ eb.AddOneshotBeat 12[tick=0.5];
 以下单发拍均是合法的：
 
 ```rdview 9 2
-eb.AddOneshotBeat 1[];
-eb.AddOneshotBeat 3[];
-eb.AddOneshotBeat 3.5[tick=0.5];
-eb.AddOneshotBeat 4.75[tick=1.25];
-eb.AddOneshotBeat 5[];
-eb.AddOneshotBeat 5.75[tick=0.25];
-eb.AddOneshotBeat 7.5[tick=0.5];
+AddOneshotBeat 1[];
+AddOneshotBeat 3[];
+AddOneshotBeat 3.5[tick=0.5];
+AddOneshotBeat 4.75[tick=1.25];
+AddOneshotBeat 5[];
+AddOneshotBeat 5.75[tick=0.25];
+AddOneshotBeat 7.5[tick=0.5];
 ```
 ![](../images/moreoneshotbeats-farmer.gif)
 
@@ -103,31 +103,31 @@ eb.AddOneshotBeat 7.5[tick=0.5];
 举个例子：Rea-Dy-Get-Set-Go 与 Rea-Dy--GetSet-Go，尽管两者的按拍时机相同，但不同的 Rea、Get 位置会给人带来不同的游玩体验。
 
 ```rdview 12 6
-eb.AddOneshotBeat 5[];
-eb.AddOneshotBeat 7.5[tick=0.5];
-eb.AddOneshotBeat 9[];
-eb.AddOneshotBeat 11.5[tick=0.5];
+AddOneshotBeat 5[];
+AddOneshotBeat 7.5[tick=0.5];
+AddOneshotBeat 9[];
+AddOneshotBeat 11.5[tick=0.5];
 g 1 1 4 1 [offset=4]{
-    es.SayReadyGetSetGo_Rea 0[];
-    es.SayReadyGetSetGo_Dy 1[];
-    es.SayReadyGetSetGo_Get 2.5[];
-    es.SayReadyGetSetGo_Set 3[];
-    es.SayReadyGetSetGo_Go 4[];
+    SayReadyGetSetGo 0[phraseToSay=JustSayRea];
+    SayReadyGetSetGo 1[phraseToSay=JustSayDy];
+    SayReadyGetSetGo 2.5[phraseToSay=JustSayGet];
+    SayReadyGetSetGo 3[phraseToSay=JustSaySet];
+    SayReadyGetSetGo 4[phraseToSay=JustSayGo];
     g 0 -1 1 2 #0f8[]{};
     g 2.5 -1 0.5 2 #0f8[]{};
     g 4 -1 0 2 #0f8[]{};
 };
 
-eb.AddOneshotBeat 5 3[];
-eb.AddOneshotBeat 7 3[];
-eb.AddOneshotBeat 9 3[];
-eb.AddOneshotBeat 11 3[];
+AddOneshotBeat 5 3[];
+AddOneshotBeat 7 3[];
+AddOneshotBeat 9 3[];
+AddOneshotBeat 11 3[];
 g 1 4 4 1 [offset=4]{
-    es.SayReadyGetSetGo_Rea 0[];
-    es.SayReadyGetSetGo_Dy 1[];
-    es.SayReadyGetSetGo_Get 2[];
-    es.SayReadyGetSetGo_Set 3[];
-    es.SayReadyGetSetGo_Go 4[];
+    SayReadyGetSetGo 0[phraseToSay=JustSayRea];
+    SayReadyGetSetGo 1[phraseToSay=JustSayDy];
+    SayReadyGetSetGo 2[phraseToSay=JustSayGet];
+    SayReadyGetSetGo 3[phraseToSay=JustSaySet];
+    SayReadyGetSetGo 4[phraseToSay=JustSayGo];
     g 0 -1 1 2 #0f8[]{};
     g 2 -1 1 2 #0f8[]{};
     g 4 -1 0 2 #0f8[]{};
@@ -143,13 +143,13 @@ g 1 4 4 1 [offset=4]{
 需要注意的是，跳过单发拍会跳过下一次**击拍**，而不是下一个循环节。
 
 ```rdview 7 4
-eb.AddOneshotBeat 1[type=skipshot];
-eb.AddOneshotBeat 5[];
-eb.AddOneshotBeat 1 2[type=skipshot];
-eb.AddOneshotBeat 3 2[tick=3];
-eb.AddOneshotBeat 3.75 2[tick=2.25];
-eb.AddOneshotBeat 4.5 2[tick=1.5];
-eb.AddOneshotBeat 5.25 2[tick=0.75];
+AddOneshotBeat 1[type=skipshot];
+AddOneshotBeat 5[];
+AddOneshotBeat 1 2[type=skipshot];
+AddOneshotBeat 3 2[tick=3];
+AddOneshotBeat 3.75 2[tick=2.25];
+AddOneshotBeat 4.5 2[tick=1.5];
+AddOneshotBeat 5.25 2[tick=0.75];
 ```
 
 另外，在剧情关卡中，跳过拍的位置如果按下空格会计算成失误，但编辑器中默认是不会失误的。
@@ -167,10 +167,10 @@ eb.AddOneshotBeat 5.25 2[tick=0.75];
 除此之外，方块单发拍也需要护士提示。这种护士提示与普通单发拍的提示类似，唯一的不同点在于最后的 Go 被替换为了 One。
 
 ```rdview 5 3
-eb.AddOneshotBeat 3[];
-es.SayReadyGetSetGo_Get 1 1[];
-es.SayReadyGetSetGo_Set 2 1[];
-es.SayReadyGetSetGo_Go 3 1[];
+AddOneshotBeat 3[];
+SayReadyGetSetGo 1 1[phraseToSay=JustSayGet];
+SayReadyGetSetGo 2 1[phraseToSay=JustSaySet];
+SayReadyGetSetGo 3 1[];
 ```
 
 如果相同拍长的方块单发拍连续出现了多次，无需为每次出现添加完整的护士提示。可以逐步减少护士提示，直到完全没有护士提示，只剩下特殊提示音。
@@ -186,32 +186,32 @@ es.SayReadyGetSetGo_Go 3 1[];
 ![](../images/moreoneshotbeats-amountofsubdivision.png)
 
 ```rdview 4 5
-eb.AddOneshotBeat 1[type=subdivision,subdivision=2];
-eb.AddOneshotBeat 1 1[type=subdivision,subdivision=3];
-eb.AddOneshotBeat 1 2[type=subdivision,subdivision=4];
-eb.AddOneshotBeat 1 3[type=subdivision,subdivision=5];
+AddOneshotBeat 1[type=subdivision,subdivision=2];
+AddOneshotBeat 1 1[type=subdivision,subdivision=3];
+AddOneshotBeat 1 2[type=subdivision,subdivision=4];
+AddOneshotBeat 1 3[type=subdivision,subdivision=5];
 ```
 
 在护士提示方面，不同于方块单发拍，细分拍需要在出拍前的半拍长开始数拍提示。
 
 ```rdview 13
-eb.AddOneshotBeat 1[type=subdivision,subdivision=2];
+AddOneshotBeat 1[type=subdivision,subdivision=2];
 g 1 1 0.5 1 #0f0[]{};
 g 1 1 1 1 #0f0[]{};
 g 0.5 1 0.5 1[offset=0.5]{
-    es.SayReadyGetSetGo_2 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count2];
 };
-eb.AddOneshotBeat 4[tick=2,type=subdivision,subdivision=2,interval=4];
+AddOneshotBeat 4[tick=2,type=subdivision,subdivision=2,interval=4];
 g 4 1 1 1 #0f0[]{};
 g 4 1 2 1 #0f0[]{};
 g 3 1 1 1[offset=1]{
-    es.SayReadyGetSetGo_2 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count2];
 };
-eb.AddOneshotBeat 9[tick=2,type=subdivision,subdivision=3,interval=4];
+AddOneshotBeat 9[tick=2,type=subdivision,subdivision=3,interval=4];
 g 9 1 1 1 #0f0[]{};
 g 9 1 2 1 #0f0[]{};
 g 8 1 1 1[offset=1]{
-    es.SayReadyGetSetGo_3 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count3];
 };
 ```
 
@@ -228,14 +228,14 @@ g 8 1 1 1[offset=1]{
 单独细分的提示**与正常单发拍的提示类似**，Rea Dy 或 Get Set 之间的间隔同样用于提示细分拍的拍长，且数字提示**和 Go! 提示一样不需要提前**。
 
 ```rdview 14 3
-eb.AddOneshotBeat 3[type=subdivision,subdivision=2];
-es.SayReadyGetSetGo_Get 1 1[];
-es.SayReadyGetSetGo_Set 2 1[];
-es.SayReadyGetSetGo_2 3 1[];
-eb.AddOneshotBeat 9[tick=2,type=subdivision,subdivision=4,interval=4];
-es.SayReadyGetSetGo_Get 5 1[];
-es.SayReadyGetSetGo_Set 7 1[];
-es.SayReadyGetSetGo_4 9 1[];
+AddOneshotBeat 3[type=subdivision,subdivision=2];
+SayReadyGetSetGo 1 1[phraseToSay=JustSayGet];
+SayReadyGetSetGo 2 1[phraseToSay=JustSaySet];
+SayReadyGetSetGo 3 1[phraseToSay=Count2];
+AddOneshotBeat 9[tick=2,type=subdivision,subdivision=4,interval=4];
+SayReadyGetSetGo 5 1[phraseToSay=JustSayGet];
+SayReadyGetSetGo 7 1[phraseToSay=JustSaySet];
+SayReadyGetSetGo 9 1[phraseToSay=Count4];
 ```
 
 ## 冻结拍🧊
@@ -249,14 +249,14 @@ es.SayReadyGetSetGo_4 9 1[];
 ![](../images/moreoneshotbeats-freezeshot.png)
 
 ```rdview 8 2
-eb.AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
-eb.AddOneshotBeat 5[type=freezeshot,delay=0.5,interval=2,tick=2];
+AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
+AddOneshotBeat 5[type=freezeshot,delay=0.5,interval=2,tick=2];
 ```
 
 对于一个冻结拍而言，一共有五个关键的时间点：左十字，右十字，出拍点（绿线），原按拍点（蓝线），实际按拍点（黄线）。
 
 ```rdview 4 2
-eb.AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
+AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
 ```
 
 - **左十字**和**右十字**会显示两次冰冻特效并分别播放不同的冰冻音效，用于预示拍延长的时间。
@@ -274,20 +274,20 @@ eb.AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
 - **左十字**必须和上一个普通单发拍的按拍位置重合。
 
 ```rdview 5 3
-eb.AddOneshotBeat 1[];
-eb.AddOneshotBeat 3[type=freezeshot,delay=0.5,interval=2];
-eb.AddOneshotBeat 1 1[grayscale=100,offset_grayscale=80];
-eb.AddOneshotBeat 3 1[grayscale=100,offset_grayscale=80];
+AddOneshotBeat 1[];
+AddOneshotBeat 3[type=freezeshot,delay=0.5,interval=2];
+AddOneshotBeat 1 1[grayscale=100,offset_grayscale=80];
+AddOneshotBeat 3 1[grayscale=100,offset_grayscale=80];
 ```
 
 如果需要在冻结拍上叠加多个拍子来凸显鼓点，可以将他们的按拍点放在同一位置。
 
 ```rdview 5 3
-eb.AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
+AddOneshotBeat 2[type=freezeshot,delay=0.5,interval=2];
 g 2 -1 2 2 #0000[offset=0 1]{
-    eb.AddOneshotBeat 0.5 1[];
+    AddOneshotBeat 0.5 1[];
     g 0 -2 2 3 #0000[offset=0 1]{
-        eb.AddOneshotBeat -1 3[tick=2.5];
+        AddOneshotBeat -1 3[tick=2.5];
     };
 };
 ```
@@ -305,7 +305,7 @@ g 2 -1 2 2 #0000[offset=0 1]{
 类似地，对于一个灼热拍，一共有四个关键的时间点：左十字，右十字，出拍点（绿线），按拍点。为作区分且方便表述，将会把按拍点称为红线。
 
 ```rdview 5 2
-eb.AddOneshotBeat 3[tick=0.5,type=burnshot,interval=2];
+AddOneshotBeat 3[tick=0.5,type=burnshot,interval=2];
 ```
 
 - **左十字**和**右十字**会显示两次热浪特效并分别播放不同的灼热音效，用于预示拍实际的时间。
@@ -320,20 +320,20 @@ eb.AddOneshotBeat 3[tick=0.5,type=burnshot,interval=2];
 - **左十字**必须和上一个普通单发拍的原定出拍位置重合。
 
 ```rdview 5 3
-eb.AddOneshotBeat 1[];
-eb.AddOneshotBeat 3[tick=0.5,type=burnshot,interval=2];
-eb.AddOneshotBeat 1 1[grayscale=100,offset_grayscale=80];
-eb.AddOneshotBeat 3 1[grayscale=100,offset_grayscale=80];
+AddOneshotBeat 1[];
+AddOneshotBeat 3[tick=0.5,type=burnshot,interval=2];
+AddOneshotBeat 1 1[grayscale=100,offset_grayscale=80];
+AddOneshotBeat 3 1[grayscale=100,offset_grayscale=80];
 ```
 
 如果需要在灼热拍上叠加多个拍子来凸显鼓点，可以将他们的按拍点放在同一位置。
 
 ```rdview 5 3
-eb.AddOneshotBeat 2[type=burnshot,delay=0.5,interval=2];
+AddOneshotBeat 2[type=burnshot,delay=0.5,interval=2];
 g 0 -1 3 2 #0000[offset=0 1]{
-    eb.AddOneshotBeat 1.5 1[tick=1.5];
+    AddOneshotBeat 1.5 1[tick=1.5];
     g 0 -1 3 3 #0000[offset=0 1]{
-        eb.AddOneshotBeat 0.5 2[tick=2.5];
+        AddOneshotBeat 0.5 2[tick=2.5];
     };
 };
 ```
@@ -387,32 +387,32 @@ g 0 -1 3 2 #0000[offset=0 1]{
 最后我们针对细分拍、冻结拍、灼热拍做一个技术总结：
 
 ```rdview 19 7
-eb.AddOneshotBeat 1[loop=1];
-eb.AddOneshotBeat 5[type=freezeshot,delay=0.5,interval=2];
-eb.AddOneshotBeat 1 1[loop=1];
-eb.AddOneshotBeat 5 1[];
-eb.AddOneshotBeat 1 2[loop=1];
-eb.AddOneshotBeat 5 2[tick=0.5,type=burnshot,interval=2];
-eb.AddOneshotBeat 1 4[loop=1];
-eb.AddOneshotBeat 5 4[tick=1,type=subdivision,subdivision=2,interval=2];
-eb.AddOneshotBeat 7 4[tick=0.5,loop=1,interval=1];
-eb.AddOneshotBeat 9 4[tick=0.5,type=subdivision,subdivision=2,interval=1];
-eb.AddOneshotBeat 10 4[tick=2];
-eb.AddOneshotBeat 14 4[tick=2,type=subdivision,subdivision=3,interval=4];
+AddOneshotBeat 1[loop=1];
+AddOneshotBeat 5[type=freezeshot,delay=0.5,interval=2];
+AddOneshotBeat 1 1[loop=1];
+AddOneshotBeat 5 1[];
+AddOneshotBeat 1 2[loop=1];
+AddOneshotBeat 5 2[tick=0.5,type=burnshot,interval=2];
+AddOneshotBeat 1 4[loop=1];
+AddOneshotBeat 5 4[tick=1,type=subdivision,subdivision=2,interval=2];
+AddOneshotBeat 7 4[tick=0.5,loop=1,interval=1];
+AddOneshotBeat 9 4[tick=0.5,type=subdivision,subdivision=2,interval=1];
+AddOneshotBeat 10 4[tick=2];
+AddOneshotBeat 14 4[tick=2,type=subdivision,subdivision=3,interval=4];
 g 5 5 0.5 1 #0f0[]{};
 g 5 5 1 1 #0f0[]{};
 g 4.5 5 0.5 1[offset=0.5]{
-    es.SayReadyGetSetGo_2 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count2];
 };
 g 9 5 0.25 1 #0f0[]{};
 g 9 5 0.5 1 #0f0[]{};
 g 8.75 5 0.25 1[offset=0.25]{
-    es.SayReadyGetSetGo_2 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count2];
 };
 g 14 5 1 1 #0f0[]{};
 g 14 5 2 1 #0f0[]{};
 g 13 5 1 1[offset=1]{
-    es.SayReadyGetSetGo_2 0 1[];
+    SayReadyGetSetGo 0 1[phraseToSay=Count2];
 };
 ```
 

pages/moverow.md

@@ -12,6 +12,8 @@
 
 ![](../images/settheme-rowposition.png)
 
+> 此图片已过时，正确的请看下面：
+
 <div class="theme-positions" id="theme-positions">
     <div class="column ccharacter"></div>
     <div class="column c1"></div>
@@ -69,6 +71,8 @@
 
 **缓速：**动画的速度变化，可自行尝试。这东西在很多需要持续一段时间的特效里都会存在，里面会有很多模式，只要把握以下原则就能快速明白了：`In`代表由慢至快，`Out`代表由快至慢，`InOut`代表由慢至快再变慢。后面不同的形式也就是快慢速的细微差距，可以根据自己的需要慢慢尝试。
 
+**加速/减速：**在一段时间内加速/减速，相当于自定义缓速。如果此处填写`0`则是瞬间完成加速/减速。填写负数则视为`0`。
+
 > 如果你想直观地看看各种移动方式的速度区别，可以[看看这里](https://easings.net/zh-cn)。
 
 ## 轴点
@@ -122,12 +126,51 @@
 
 如果想要实现`6-2`马克一人多轨的情况就可以使旋转轨道事件。
 
-先准备两个轨道，使用`连接`将轨道2连接到轨道1上，此时心会自动变成裂纹状态，如果不想要这个效果，可以用下一章轨道涂色里的`心`设置回默认。
+### 连接
 
-在连接后，通过`分割`可以将两个轨道都显示出来，这两个轨道都会对被连接到的轨道对应角色产生影响。
+![](../images/moverow1_SpinningRows_Connect.png)
 
-`断开`后这些轨道都会回复正常状态。
+将`轨道`**连接**`到轨道`。
 
+### 断开
+
+![](../images/moverow2_SpinningRows_Disconnect.png)
+
+将`轨道`**断开**。
+
+### 旋转
+
+![](../images/moverow3_SpinningRows_Rotate.png)
+
+将`轨道`**旋转**`角度`度。
+
+### 均速旋转
+
+![](../images/moverow4_SpinningRows_ContinuousRotation.png)
+
+`轨道`在每拍**均速旋转**`角度`。
+
+### 波动旋转
+
+![](../images/moverow5_SpinningRows_WavyRotation.png)
+
+`轨道`在每拍`频率`次**波动旋转**`增幅`度。
+
+### 合并
+
+![](../images/moverow6_SpinningRows_Merge.png)
+
+将`轨道`转到`角度`度是**合并**。
+
+### 分割
+
+![](../images/moverow7_SpinningRows_Split.png)
+
+将`轨道`从主轨道上**分割**出来，并旋转到`角度`度。
+
+## 轨道重排序~~重排序：行~~
+
+将轨道转移到其他房间，或者改变轨道的层级
 
 ## 演示关卡
 

pages/oneshotbeat.md

@@ -15,14 +15,14 @@
 在“**循环**”的空栏里输入次数，这个单发拍就会被**额外**重复这么多次。当然了，直接输入循环次数的方法并不够方便，因为很多时候不听具体音乐自己也不知道该循环多少次。更方便的方法是，把鼠标移动到工作区的这个单发拍子上，右上角就会出现一个**红色的箭头符号**，按住它并拖动即可。
 
 ```rdview 7 3
-eb.AddOneshotBeat 1 1[tick=1,loop=2];
+AddOneshotBeat 1 1[tick=1,loop=2];
 ```
 
 在循环设置后，左上角又会多出一个“**间隔**”的设置，指的是两个绿线之间的时间长度。大多数时候，我们会将间隔设为拍长的两倍，这也就构成了一个普通单发拍子。但如果你想设计更为复杂的单发拍子节奏型，也可以试着将间隔改为其他数值：例如，把间隔改成`1`，拍长改成`0.75`，就变成了一种摇摆单发拍子。
 
 ```rdview 10 3
-eb.AddOneshotBeat 1 1[loop=1];
-eb.AddOneshotBeat 5 1[tick=0.75,loop=3,interval=1];
+AddOneshotBeat 1 1[loop=1];
+AddOneshotBeat 5 1[tick=0.75,loop=3,interval=1];
 ```
 
 配置好带有循环的单发拍之后，按一下“**分解为单发节拍**”，会发现它被拆散成了若干个没有循环的单发拍事件。分解后的单发拍更加便于修改，你可以为它们单独添加修饰符或额外的脉冲。
@@ -42,80 +42,80 @@ eb.AddOneshotBeat 5 1[tick=0.75,loop=3,interval=1];
 将护士语音的拍长与单发拍的拍长保持一致，并将护士**喊出`Go!`的位置**与 **第一个普通单发拍的脉冲位置** 对齐即可，这样就完成了对一个普通单发拍的提示。
 
 ```rdview 16 12
-eb.AddOneshotBeat 5 1[tick=2];
-eb.AddOneshotBeat 9 1[tick=2];
-eb.AddOneshotBeat 13 1[tick=2];
+AddOneshotBeat 5 1[tick=2];
+AddOneshotBeat 9 1[tick=2];
+AddOneshotBeat 13 1[tick=2];
 g 1 2 4 1[offset=4 0]{
     g 0 -1 0 2 #0f08{
-        es.SayReadyGetSetGo_Get 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayGet];
     };
     g 2 -1 0 2 #ff08{
-        es.SayReadyGetSetGo_Set 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSaySet];
     };
     g 4 -1 0 2 #f008{
-        es.SayReadyGetSetGo_Go 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayGo];
     };
 };
-eb.AddOneshotBeat 5 4;
-eb.AddOneshotBeat 7 4;
-eb.AddOneshotBeat 9 4;
-eb.AddOneshotBeat 11 4;
-eb.AddOneshotBeat 13 4;
+AddOneshotBeat 5 4;
+AddOneshotBeat 7 4;
+AddOneshotBeat 9 4;
+AddOneshotBeat 11 4;
+AddOneshotBeat 13 4;
 g 1 5 4 2[offset=4 0]{
-    es.SayReadyGetSetGo_ReaDyGetSetGo 0 0;
+    SayReadyGetSetGo 0 0[phraseToSay=SayReaDyGetSetGoNew];
     g 0 -1 0 3 #0f08{
-        es.SayReadyGetSetGo_Rea 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayRea];
     };
     g 1 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Dy 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayDy];
     };
     g 2 -1 0 3 #0f08{
-        es.SayReadyGetSetGo_Get 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayGet];
     };
     g 3 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Set 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSaySet];
     };
     g 4 -1 0 3 #F008{
-        es.SayReadyGetSetGo_Go 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayGo];
     };
 };
-eb.AddOneshotBeat 5 8[tick=0.5];
-eb.AddOneshotBeat 6 8[tick=0.5];
-eb.AddOneshotBeat 7 8[tick=0.5];
-eb.AddOneshotBeat 8 8[tick=0.5];
-eb.AddOneshotBeat 9 8[tick=0.5];
-eb.AddOneshotBeat 10 8[tick=0.5];
-eb.AddOneshotBeat 11 8[tick=0.5];
-eb.AddOneshotBeat 12 8[tick=0.5];
-eb.AddOneshotBeat 13 8[tick=0.5];
-eb.AddOneshotBeat 14 8[tick=0.5];
+AddOneshotBeat 5 8[tick=0.5];
+AddOneshotBeat 6 8[tick=0.5];
+AddOneshotBeat 7 8[tick=0.5];
+AddOneshotBeat 8 8[tick=0.5];
+AddOneshotBeat 9 8[tick=0.5];
+AddOneshotBeat 10 8[tick=0.5];
+AddOneshotBeat 11 8[tick=0.5];
+AddOneshotBeat 12 8[tick=0.5];
+AddOneshotBeat 13 8[tick=0.5];
+AddOneshotBeat 14 8[tick=0.5];
 g 1 9 4 2[offset=4 0]{
     g 0 -1 0 2 #0f08{
-        es.SayReadyGetSetGo_Rea 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayRea];
     };
     g 0.5 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Dy 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayDy];
     };
     g 1 -1 0 2 #0f08{
-        es.SayReadyGetSetGo_Rea 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayRea];
     };
     g 1.5 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Dy 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayDy];
     };
     g 2 -1 0 2 #0f08{
-        es.SayReadyGetSetGo_Rea 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayRea];
     };
     g 2.5 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Dy 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSayDy];
     };
     g 3 -1 0 2 #0f08{
-        es.SayReadyGetSetGo_Get 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayGet];
     };
     g 3.5 -1 0 3 #ff08{
-        es.SayReadyGetSetGo_Set 0 2;
+        SayReadyGetSetGo 0 2[phraseToSay=JustSaySet];
     };
     g 4 -1 0 2 #F008{
-        es.SayReadyGetSetGo_Go 0 1;
+        SayReadyGetSetGo 0 1[phraseToSay=JustSayGo];
     };
 };
 ```
@@ -131,30 +131,30 @@ g 1 9 4 2[offset=4 0]{
 也可以让单发拍子在几种拍速之间来回切换，提示方法与前面所讲的相同。只需要注意一点：单发拍子的节奏型应该在**Go!的瞬间**完成切换，Go之前的护士提示不会影响当前正在进行的单发拍子，而 Go 之后也不应再出现前一种单发拍子的节拍。
 
 ```rdview 20 5
-eb.AddOneshotBeat 3 1;
-eb.AddOneshotBeat 5 1;
-eb.AddOneshotBeat 7 1[tick=0.5];
-eb.AddOneshotBeat 8 1[tick=0.5];
-eb.AddOneshotBeat 9 1[tick=0.5];
-eb.AddOneshotBeat 10 1[tick=0.5];
-eb.AddOneshotBeat 11 1;
-eb.AddOneshotBeat 13 1;
-eb.AddOneshotBeat 15 1[tick=0.75];
-eb.AddOneshotBeat 16 1[tick=0.75];
-eb.AddOneshotBeat 17 1[tick=0.75];
-eb.AddOneshotBeat 18 1[tick=0.75];
-es.SayReadyGetSetGo_Get 1 2;
-es.SayReadyGetSetGo_Set 2 2;
-es.SayReadyGetSetGo_Go 3 2;
-es.SayReadyGetSetGo_Get 6 2;
-es.SayReadyGetSetGo_Set 6.5 3;
-es.SayReadyGetSetGo_Go 7 2;
-es.SayReadyGetSetGo_Get 9 2;
-es.SayReadyGetSetGo_Set 10 2;
-es.SayReadyGetSetGo_Go 11 2;
-es.SayReadyGetSetGo_Get 14 2;
-es.SayReadyGetSetGo_Set 14.75 3;
-es.SayReadyGetSetGo_Go 15 2;
+AddOneshotBeat 3 1;
+AddOneshotBeat 5 1;
+AddOneshotBeat 7 1[tick=0.5];
+AddOneshotBeat 8 1[tick=0.5];
+AddOneshotBeat 9 1[tick=0.5];
+AddOneshotBeat 10 1[tick=0.5];
+AddOneshotBeat 11 1;
+AddOneshotBeat 13 1;
+AddOneshotBeat 15 1[tick=0.75];
+AddOneshotBeat 16 1[tick=0.75];
+AddOneshotBeat 17 1[tick=0.75];
+AddOneshotBeat 18 1[tick=0.75];
+SayReadyGetSetGo 1 2[phraseToSay=JustSayGet];
+SayReadyGetSetGo 2 2[phraseToSay=JustSaySet];
+SayReadyGetSetGo 3 2[phraseToSay=JustSayGo];
+SayReadyGetSetGo 6 2[phraseToSay=JustSayGet];
+SayReadyGetSetGo 6.5 3[phraseToSay=JustSaySet];
+SayReadyGetSetGo 7 2[phraseToSay=JustSayGo];
+SayReadyGetSetGo 9 2[phraseToSay=JustSayGet];
+SayReadyGetSetGo 10 2[phraseToSay=JustSaySet];
+SayReadyGetSetGo 11 2[phraseToSay=JustSayGo];
+SayReadyGetSetGo 14 2[phraseToSay=JustSayGet];
+SayReadyGetSetGo 14.75 3[phraseToSay=JustSaySet];
+SayReadyGetSetGo 15 2[phraseToSay=JustSayGo];
 ```
 
 一个单发拍子不可能无限循环下去，总会有停下来的时候，可以使用护士提示中的`Stop`告知玩家单发拍子的结束。通常情况下，应使`Stop`对齐单发拍子的**最后一次击拍位置**。
@@ -164,12 +164,12 @@ es.SayReadyGetSetGo_Go 15 2;
 如果单发拍子的停止时机足够符合直觉，可以省略单发拍子的Stop，但必须保证玩家下意识多打出的拍子不会判Miss。最稳妥的方法永远是为所有单发拍子的停止都添加 Stop 提示。
 
 ```rdview 10 3
-eb.AddClassicBeat 2.5[tick=6];
-eb.AddOneshotBeat 1 1[];
-eb.AddOneshotBeat 3 1[];
-eb.AddOneshotBeat 5 1[];
+AddClassicBeat 2.5[tick=1];
+AddOneshotBeat 1 1[];
+AddOneshotBeat 3 1[];
+AddOneshotBeat 5 1[];
 g 7 1 1 1{
-    eb.AddOneshotBeat[grayscale=100];
+    AddOneshotBeat[grayscale=100];
 };
 ```
 
@@ -182,12 +182,12 @@ g 7 1 1 1{
 ![设置波](../images/oneshotbeat-oneshotwave.png)
 ![设置波效果](../images/oneshotbeat-nicolewave.gif)
 
+`摇晃`就是像`4-4`那关一样的摇晃效果。
+
 选中一个单发拍子，按住`Shift + H`，会发现多出了一个爱心脉冲的修饰符。启用这个修饰符，可以将单发拍的形状变成`2-X`结尾的超大爱心。
 
 ![隐藏的爱心](../images/oneshotbeat-heart.png)
 
-> 此外像`4-4`关的抖动轨道单发拍子，需调用自定义方法来完成，语句为`wobblyLines = true`。如果你还不明白自定义方法是什么，需要先翻到[自定义方法](../pages/custommethod.md)看看。考虑到这玩意问的人比较多，所以就先写在此处了。
-
 ## 演示关卡
 
 最后依然是呈上一个示范谱面。

pages/rowfx.md

@@ -18,6 +18,8 @@
 
 > 当你把透明度调节为`0%`并打开轨道边框时，就会看到轨道线是插入进人物和心脏的像素图的。
 
+**心：**修改心脏的贴图，比如马克的分心、万圣节的南瓜心、被网好卡菌感染的紫心等。
+
 **时长与缓速：**和其他特效中的完全一致，不过多赘述。
 
 > 如果你想直观地看看各种移动方式的速度区别，可以[看看这里](https://easings.net/zh-cn)。
@@ -71,6 +73,18 @@
 
 **过渡方式**：顺滑（有烟雾特效）；即刻（瞬间显示/隐藏）；全动画（仅限“动作”中选择“显示”，有完整的出场及轨道延伸动画）。
 
+## 改变轨道
+
+可以在中途改变轨道上的角色。
+
+![](../images/rowfx_Change_Character.png)
+
+**轨道**：需要改哪个轨道上的角色。
+
+**角色**：改成哪个角色。
+
+**过渡方式**：跟隐藏轨道一样，顺滑有烟雾特效，即刻没有。
+
 ## 适合配合轨道或节拍一起使用的特效
 
 **闪烁：**屏幕白色闪烁，分为短，中，长三种。

pages/setplaystyleandgotolevel.md

@@ -0,0 +1,54 @@
+# 关卡播放与跳转
+
+## 设置播放方式
+
+**设置播放方式**（在紫色板块中），作用是设置关卡的播放方式，比如说，跳转到某个小节，或者循环播放某个小节。
+
+![设置播放方式](../images/setplaystyleandgotolevel-setplaystyle.png)
+
+**下一小节**是将要跳转到的小节，如果勾选了`相对`，那么这个数字就是相对于当前小节的数字。
+
+> 比如说，当前小节是第3小节，**下一小节**填写了4，则若勾选`相对`将跳转到第7小节，不勾选`相对`则跳转到第4小节。
+
+播放方式有以下几种：
+
+- **正常**：正常播放完当前小节，然后跳转。
+- **循环**：循环播放当前小节。（如果选择**循环**，则没有**下一小节**）
+- **延长**：~~据笔者实验，似乎是无限延长当前小节~~笔者不确定它的作用，待补充。
+- **立即**：播放完这一拍之后，立即跳转。
+- **超级立即**: 立即跳转。
+- **延长下一拍**：~~据笔者实验，似乎与**正常**差别不大，但若在小节最后一拍，不会跳转~~笔者不确定它的作用，待补充。
+
+## 前往关卡
+
+**前往关卡**（也在紫色板块中），顾名思义，就是前往某个关卡。（为了方便叙述~~偷懒~~，下文中将**当前关卡**称为**a关卡**，**要前往的关卡**称作**b关卡**）但要注意，a关卡和b关卡需在同一文件夹中。导出a关卡时，b关卡会打包进a关卡的rdzip里。
+
+**前往关卡**事件有两个用法，一个是直接`前往关卡`，另一个是先`设置下一个`关卡再`前往下一个`关卡。后者需要两个**前往关卡**事件。
+
+你可能会问，为什么要用两个事件，先`设置下一个`再`前往下一个`~~，这不是脱裤子放屁吗~~？这是因为，只有先`设置下一个`关卡，才能有`跳过`功能。这里我们先按下不表，详见后文[制作教程关卡](#制作教程关卡)。
+
+![前往关卡](../images/setplaystyleandgotolevel-gotolevel.png)
+
+**淡入**：设置是否淡入。
+
+**立即开始**：设置在b关卡开始前，是否显示`按空格键开始`的画面。
+
+**保留失误**：这条很好理解，设置是否将a关卡的失误数带入b关卡。
+
+**阻止重启按钮**：这条的名称可能有点迷惑。它的作用实际上是：在**已经跳转到b关卡后**，当点击重启按钮时，如果它被勾选，那么将**从a关卡开始**，而不是从b关卡开始；反之，如果它未被勾选，则从b关卡开始。
+
+## 制作教程关卡
+
+为什么把这两个事件一起介绍呢？原因就是，它们最常见的场景都是在**教程关卡**中使用。什么是**教程关卡**？相信只要你玩过主线，对它不会陌生，它是在正式关卡开始前，对**新出现的机制或节奏**的介绍与教学。一般都长这样：
+
+![2-1的教程](../images/setplaystyleandgotolevel-tutorial.png)
+
+想要实现在教程结束之后跳转到正式关卡，就需要用**前往关卡**事件。
+
+你想必知道，官方的**教程关卡**都可以在菜单里`跳过`，要实现这个功能，就得在关卡开头放上`动作`为`设置下一个关卡`的**前往关卡**事件，并且勾选**允许跳过按钮**。再在结尾放上`动作`为`前往下一个关卡`的**前往关卡**事件。
+
+那么，**设置播放方式**在**教程关卡**中有什么用呢？如果你节奏感一般~~像我一样~~，可能就会发现，官方的**教程关卡**中，如果你在一段中失误太多，就会重新开始这一段。这就需要用到**设置播放方式**，以跳转到之前的小节。当然，也要结合上之前学过的[条件](../pages/condition.md)，以判断失误数是否超过某个值。（[atLeastNPerfects](https://docs.qq.com/sheet/DQUJxb0puSFFOVWpz?tab=000003)可能会派上用场）
+
+> 最后，做个关于关卡设计的提醒：制作**教程关卡**时，请添加`晕影`或`闪烁晕影`特效并添加`轨道涂色`，以确保`轨道`清晰可见。
+
+![2-1的教程](../images/setplaystyleandgotolevel-tutorialvfx.png)

pages/settheme.md

@@ -16,7 +16,7 @@
 
 甚至轨道可以大部分位置都不可见。比如制作只显示脉冲心跳部位的单发拍子，并做成纯色等。
 
-> 调用自定义方法`invisibleHeart = true`可以让轨道上的心脏消失。如果不选择角色，那么就只剩下一根线了，在一些极简色块画风的关卡里效果拔群。
+> 使用轨道涂色或调用自定义方法`invisibleHeart = true`可以让轨道上的心脏消失。如果不选择角色，那么就只剩下一根线了，在一些极简色块画风的关卡里效果拔群。
 
 ## 背景和前景图片
 

pages/tag.md

@@ -9,58 +9,58 @@
 ```rdview 18 3
 g 1 0 4 2 #ff0{
     g 0 -1 0 3 #08f[]{};
-    ea.MoveRow [tag=true];
-    ea.MoveRow 1[tag=true];
-    ea.MoveCamera 2[tag=true];
-    ea.Flash 2.5[tag=true];
-    ea.HideRow 0 1[tag=true];
-    ea.SetVFXPreset 1.5 1[tag=true];
-    ea.SetVFXPreset 2 1[tag=true];
-    ea.HideRow 3 1[tag=true];
+    MoveRow [tag=action];
+    MoveRow 1[tag=action];
+    MoveCamera 2[tag=action];
+    Flash 2.5[tag=action];
+    HideRow 0 1[tag=action];
+    SetVFXPreset 1.5 1[tag=action];
+    SetVFXPreset 2 1[tag=action];
+    HideRow 3 1[tag=action];
 
     g 5 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[offset_opacity=0];
+        TagAction[offset_opacity=0,Tag=action];
         g 0 1 4 2 #ff0[opacity=0,offset_opacity=100]{
             g 0 -1 0 3 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
-            ea.MoveCamera 2[];
-            ea.Flash 2.5[];
-            ea.HideRow 0 1[];
-            ea.SetVFXPreset 1.5 1[];
-            ea.SetVFXPreset 2 1[];
-            ea.HideRow 3 1[];
+            MoveRow [];
+            MoveRow 1[];
+            MoveCamera 2[];
+            Flash 2.5[];
+            HideRow 0 1[];
+            SetVFXPreset 1.5 1[];
+            SetVFXPreset 2 1[];
+            HideRow 3 1[];
         };
     };
     g 9 0 0 0 #0000[offset=0 -1]{        
-        ea.TagAction[];
+        TagAction[offset_opacity=0,Tag=action];
         g 0 1 4 2 #ff0[opacity=0,offset_opacity=100]{
             g 0 -1 0 3 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
-            ea.MoveCamera 2[];
-            ea.Flash 2.5[];
-            ea.HideRow 0 1[];
-            ea.SetVFXPreset 1.5 1[];
-            ea.SetVFXPreset 2 1[];
-            ea.HideRow 3 1[];
+            MoveRow [];
+            MoveRow 1[];
+            MoveCamera 2[];
+            Flash 2.5[];
+            HideRow 0 1[];
+            SetVFXPreset 1.5 1[];
+            SetVFXPreset 2 1[];
+            HideRow 3 1[];
         };
     };
     g 13 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[];
+        TagAction[offset_opacity=0,Tag=action];
         g 0 1 4 2 #ff0[opacity=0,offset_opacity=100]{
             g 0 -1 0 3 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
-            ea.MoveCamera 2[];
-            ea.Flash 2.5[];
-            ea.HideRow 0 1[];
-            ea.SetVFXPreset 1.5 1[];
-            ea.SetVFXPreset 2 1[];
-            ea.HideRow 3 1[];
+            MoveRow [];
+            MoveRow 1[];
+            MoveCamera 2[];
+            Flash 2.5[];
+            HideRow 0 1[];
+            SetVFXPreset 1.5 1[];
+            SetVFXPreset 2 1[];
+            HideRow 3 1[];
         };
     };
 };
@@ -111,75 +111,75 @@ g 1 0 4 2 #ff0{
 ```rdview 16 5
 g 1 1 2 1 #df0{
     g 0 -1 0 2 #08f[]{};
-    ea.MoveRow [tag=true];
-    ea.MoveRow 1[tag=true];
+    MoveRow [tag=move];
+    MoveRow 1[tag=move];
 
     g 4 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[];
+        TagAction[Tag=move];
         g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
             g 0 -1 0 2 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
+            MoveRow [];
+            MoveRow 1[];
         };
     };
     g 6 0 0 0 #0000[offset=0 -1]{        
-        ea.TagAction[];
+        TagAction[Tag=move];
         g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
             g 0 -1 0 2 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
+            MoveRow [];
+            MoveRow 1[];
         };
     };
     g 8 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[];
+        TagAction[Tag=move];
         g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
             g 0 -1 0 2 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
+            MoveRow [];
+            MoveRow 1[];
         };
     };
     g 10 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[];
+        TagAction[Tag=move];
         g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
             g 0 -1 0 2 #08f[]{};
             g 0 -1 1 1 #0000[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
+            MoveRow [];
+            MoveRow 1[];
         };
     };
 };
 g 1 3 3 1 #df0{
     g 0 -1 0 2 #08f[]{};
-    ea.MoveRow [tag=true];
-    ea.MoveRow 1[tag=true];
-    ea.TagAction 2[tag=true];
+    MoveRow [tag=move];
+    MoveRow 1[tag=move];
+    TagAction 2[tag=move];
     g 4 0 0 0 #0000[offset=0 -1]{
-        ea.TagAction[offset_opacity=0];
+        TagAction[offset_opacity=0,Tag=move];
         g 0 1 3 1 #ff0[opacity=20,offset_opacity=100]{
             g 0 -1 0 2 #08f[]{};
-            ea.MoveRow [];
-            ea.MoveRow 1[];
+            MoveRow [];
+            MoveRow 1[];
             g 2 0 0 0 #0000[offset=0 -1]{        
-                ea.TagAction[];
+                TagAction[offset_opacity=0,Tag=move];
                 g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
                     g 0 -1 0 2 #08f[]{};
-                    ea.MoveRow [];
-                    ea.MoveRow 1[];
+                    MoveRow [];
+                    MoveRow 1[];
                     g 2 0 0 0 #0000[offset=0 -1]{        
-                        ea.TagAction[];
+                        TagAction[offset_opacity=0,Tag=move];
                         g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
                             g 0 -1 0 2 #08f[]{};
-                            ea.MoveRow [];
-                            ea.MoveRow 1[];
+                            MoveRow [];
+                            MoveRow 1[];
                             g 2 0 0 0 #0000[offset=0 -1]{        
-                                ea.TagAction[];
+                                TagAction[offset_opacity=0,Tag=move];
                                 g 0 1 2 1 #ff0[opacity=20,offset_opacity=100]{
                                     g 0 -1 0 2 #08f[]{};
-                                    ea.MoveRow [];
-                                    ea.MoveRow 1[];
+                                    MoveRow [];
+                                    MoveRow 1[];
                                     g -6 -4 1 5 #0000[]{};
                                 };
                             };
@@ -189,7 +189,7 @@ g 1 3 3 1 #df0{
             };
         };
     };
-    ea.TagAction 12[];
+    TagAction 12[];
 };
 ```
 
@@ -211,143 +211,143 @@ g 1 3 3 1 #df0{
 
 ```rdview 19 4
 g 0 0 19 1 #f00[]{
-    ea.Comment [];
-    ea.FloatingText 0.5[];
-    ea.FloatingText 1[];
-    ea.FloatingText 1.5[];
-    ea.FloatingText 2[];
-    ea.FloatingText 2.5[];
-    ea.FloatingText 3[];
-    ea.FloatingText 3.5[];
-    ea.FloatingText 4[];
-    ea.AdvanceText 4.5[];
-    ea.AdvanceText 5[];
-    ea.AdvanceText 5.5[];
-    ea.AdvanceText 6[];
-    ea.AdvanceText 6.5[];
-    ea.AdvanceText 7[];
-    ea.AdvanceText 7.5[];
-    ea.FloatingText 8[];
-    ea.FloatingText 8.75[];
-    ea.Comment 9.75[];
-    ea.FloatingText 11.75[];
-    ea.FloatingText 12.5[];
-    ea.FloatingText 13.5[];
-    ea.FloatingText 14[];
-    ea.FloatingText 14.5[];
-    ea.FloatingText 15[];
-    ea.FloatingText 15.5[];
-    ea.FloatingText 16[];
-    ea.FloatingText 16.5[];
-    ea.FloatingText 17[];
-    ea.FloatingText 17.5[];
+    Comment [color=ffff00];
+    FloatingText 0.5[outlineColor=000000];
+    FloatingText 1[outlineColor=000000];
+    FloatingText 1.5[outlineColor=000000];
+    FloatingText 2[outlineColor=000000];
+    FloatingText 2.5[outlineColor=000000];
+    FloatingText 3[outlineColor=000000];
+    FloatingText 3.5[outlineColor=000000];
+    FloatingText 4[outlineColor=000000];
+    AdvanceText 4.5[];
+    AdvanceText 5[];
+    AdvanceText 5.5[];
+    AdvanceText 6[];
+    AdvanceText 6.5[];
+    AdvanceText 7[];
+    AdvanceText 7.5[];
+    FloatingText 8[outlineColor=000000];
+    FloatingText 8.75[outlineColor=000000];
+    Comment 9.75[tab=Actions];
+    FloatingText 11.75[outlineColor=000000];
+    FloatingText 12.5[outlineColor=000000];
+    FloatingText 13.5[outlineColor=000000];
+    FloatingText 14[outlineColor=000000];
+    FloatingText 14.5[outlineColor=000000];
+    FloatingText 15[outlineColor=000000];
+    FloatingText 15.5[outlineColor=000000];
+    FloatingText 16[outlineColor=000000];
+    FloatingText 16.5[outlineColor=000000];
+    FloatingText 17[outlineColor=000000];
+    FloatingText 17.5[outlineColor=000000];
 };
 g 0 1 6.25 1 #08f[]{
-    ea.MoveCamera [];
-    ea.MoveCamera 0.5[];
-    ea.MoveCamera 1[];
-    ea.MoveCamera 1.5[];
-    ea.MoveCamera 2[];
-    ea.MoveCamera 2.5[];
-    ea.MoveCamera 3[];
-    ea.MoveCamera 3.5[];
-    ea.MoveCamera 4[];
-    ea.MoveCamera 5[];
-    ea.SetForeground 5.25[];
+    MoveCamera [];
+    MoveCamera 0.5[];
+    MoveCamera 1[];
+    MoveCamera 1.5[];
+    MoveCamera 2[];
+    MoveCamera 2.5[];
+    MoveCamera 3[];
+    MoveCamera 3.5[];
+    MoveCamera 4[];
+    MoveCamera 5[];
+    SetForeground 5.25[];
 };
-ea.Comment 6.25 1[];
-ea.MoveRow 7.75 1[];
-ea.MoveRow 8 1[];
-ea.MoveRow 8.75 1[];
-ea.MoveCamera 12 1[];
-ea.SetForeground 12.25 1[];
-ea.FloatingText 14.5 1[];
-ea.FloatingText 15 1[];
-ea.FloatingText 15.5 1[];
-ea.FloatingText 16 1[];
-ea.FloatingText 16.5 1[];
-ea.SetVFXPreset 18 1[];
+Comment 6.25 1[tab=Actions];
+MoveRow 7.75 1[];
+MoveRow 8 1[];
+MoveRow 8.75 1[];
+MoveCamera 12 1[];
+SetForeground 12.25 1[];
+FloatingText 14.5 1[outlineColor=000000];
+FloatingText 15 1[outlineColor=000000];
+FloatingText 15.5 1[outlineColor=000000];
+FloatingText 16 1[outlineColor=000000];
+FloatingText 16.5 1[outlineColor=000000];
+SetVFXPreset 18 1[];
 g 0 2 13.875 1 #06f[]{
-    ea.MoveRow [];
-    ea.MoveRow [];
-    ea.Comment 1.75[];
-    ea.MoveRow 2.75[];
-    ea.MoveRow 3[];
-    ea.MoveRow 4.5[];
-    ea.MoveRow 4.75[];
-    ea.MoveRow 5[];
-    ea.MoveRow 5.25[];
-    ea.MoveRow 6.75[];
-    ea.MoveRow 7[];
-    ea.MoveRow 7.5[];
-    ea.MoveRow 7.75[];
-    ea.MoveRow 8.5[];
-    ea.MoveRow 10[];
-    ea.MoveRow 10.25[];
-    ea.HideRow 11.5[];
-    ea.HideRow 11.5[];
-    ea.MoveRow 12.5[];
-    ea.MoveRow 12.75[];
+    MoveRow [];
+    MoveRow [];
+    Comment 1.75[tab=Actions];
+    MoveRow 2.75[];
+    MoveRow 3[];
+    MoveRow 4.5[];
+    MoveRow 4.75[];
+    MoveRow 5[];
+    MoveRow 5.25[];
+    MoveRow 6.75[];
+    MoveRow 7[];
+    MoveRow 7.5[];
+    MoveRow 7.75[];
+    MoveRow 8.5[];
+    MoveRow 10[];
+    MoveRow 10.25[];
+    HideRow 11.5[];
+    HideRow 11.5[];
+    MoveRow 12.5[];
+    MoveRow 12.75[];
 };
-ea.Comment 14 2[];
+Comment 14 2[tab=Actions];
 g 0 3 18 1 #f80[]{
-    ea.FloatingText 0.5[];
-    ea.AdvanceText 1[];
-    ea.AdvanceText 1.5[];
-    ea.AdvanceText 2.5[];
-    ea.AdvanceText 3[]; 
-    ea.AdvanceText 4.5[];
-    ea.AdvanceText 5[];
-    ea.AdvanceText 5.5[];
-    ea.AdvanceText 6[];
-    ea.AdvanceText 6.5[];
-    ea.AdvanceText 7[];
-    ea.AdvanceText 8[];
-    ea.AdvanceText 10.5[];
-    ea.AdvanceText 11.5[];
-    ea.AdvanceText 12[];
-    ea.AdvanceText 12.5[];
-    ea.AdvanceText 13[];
-    ea.AdvanceText 13.5[];
-    ea.AdvanceText 14[];
-    ea.AdvanceText 14.5[];
-    ea.AdvanceText 15[];
-    ea.AdvanceText 15.5[];
-    ea.AdvanceText 16[];
-    ea.AdvanceText 16.5[];
-    ea.AdvanceText 17[];
-    ea.AdvanceText 17.5[];
+    FloatingText 0.5[outlineColor=000000];
+    AdvanceText 1[];
+    AdvanceText 1.5[];
+    AdvanceText 2.5[];
+    AdvanceText 3[]; 
+    AdvanceText 4.5[];
+    AdvanceText 5[];
+    AdvanceText 5.5[];
+    AdvanceText 6[];
+    AdvanceText 6.5[];
+    AdvanceText 7[];
+    AdvanceText 8[];
+    AdvanceText 10.5[];
+    AdvanceText 11.5[];
+    AdvanceText 12[];
+    AdvanceText 12.5[];
+    AdvanceText 13[];
+    AdvanceText 13.5[];
+    AdvanceText 14[];
+    AdvanceText 14.5[];
+    AdvanceText 15[];
+    AdvanceText 15.5[];
+    AdvanceText 16[];
+    AdvanceText 16.5[];
+    AdvanceText 17[];
+    AdvanceText 17.5[];
 };
 ```
 
 2. 如果有一串同类型的事件紧密排布，例如每1/4格或者1/2格放一个，那么可以考虑不放在同一行，而是上下交错排开。
 
 ```rdview 16 4
-ea.MoveRow [];
-ea.MoveRow 1[];
-ea.MoveRow 2[];
-ea.MoveRow 4[];
-ea.MoveRow 5[];
-ea.MoveRow 6[];
-ea.MoveRow 8[];
-ea.MoveRow 9[];
-ea.MoveRow 10[];
-ea.MoveRow 12[];
-ea.MoveRow 13[];
-ea.MoveRow 14[];
-ea.MoveRow 0.5 1[];
-ea.MoveRow 1.5 1[];
-ea.MoveRow 3 1[];
-ea.MoveRow 4.5 1[];
-ea.MoveRow 5.5 1[];
-ea.MoveRow 7 1[];
-ea.MoveRow 8.5 1[];
-ea.MoveRow 9.5 1[];
-ea.MoveRow 11 1[];
-ea.MoveRow 12.5 1[];
-ea.MoveRow 13.5 1[];
-ea.MoveRow 15 1[];
-ea.Comment 4 3[];
+MoveRow [];
+MoveRow 1[];
+MoveRow 2[];
+MoveRow 4[];
+MoveRow 5[];
+MoveRow 6[];
+MoveRow 8[];
+MoveRow 9[];
+MoveRow 10[];
+MoveRow 12[];
+MoveRow 13[];
+MoveRow 14[];
+MoveRow 0.5 1[];
+MoveRow 1.5 1[];
+MoveRow 3 1[];
+MoveRow 4.5 1[];
+MoveRow 5.5 1[];
+MoveRow 7 1[];
+MoveRow 8.5 1[];
+MoveRow 9.5 1[];
+MoveRow 11 1[];
+MoveRow 12.5 1[];
+MoveRow 13.5 1[];
+MoveRow 15 1[];
+Comment 4 3[tab=Actions];
 ```
 
 3. 对于事件总体数量不太高的情况，如果有操作房间和轨道类型的特效，可以考虑把他们放在对应数量的行里，找起来会更加方便。

pages/vfx.md

@@ -1,11 +1,103 @@
 # 基础 VFX 效果
 
+本节将介绍几种最常用、最容易上手的视觉特效。这些特效不需要复杂的组合，单独使用就能为你的关卡增色不少。如果你是第一次接触节奏医生的谱面制作，建议先从这里开始。
+
 ## 震动
 
+震动是最直觉的反馈手段——玩家按对了拍子，画面跟着"咚"一下，手感立刻就上来了。
+
+编辑器中提供了几种震动方式，可以在紫色版块中找到：
+
+| 震动类型 | 效果 |
+| :--- | :--- |
+| **屏幕震动** | 整个画面抖动，分为轻微、中等、剧烈三档 |
+| **自定义震动** | 自由度更高，有多种模式 |
+| **按键震屏** | 每次按拍时画面抖动一下，适合强调节拍的"打击感" |
+| **心跳震屏** | 每次脉冲时画面轻微抖动，适合营造心跳般的律动感 |
+| **重低音震动** | 大幅度色像差 + 大幅度屏幕缩放，视觉冲击力最强 |
+
+> 震动虽然好用，但也不要每个拍子都加。在一整段密集节奏里全部堆震动，画面会晃得让人头晕。建议只在重拍或者情绪转折点使用，这样才能"震"到点上。
+
+![](../images/rowfx-shake.gif)
+
 ## 闪光
 
+闪光和震动类似，也是一种即时的视觉反馈。按下拍子的瞬间闪一下白光，能让玩家清晰地感受到节奏的落点。
+
+在紫色版块中可以找到两种闪光：
+
+**闪烁：** 最简单的闪光，屏幕白色一闪，分为短、中、长三种时长。适合用在副歌进入、重拍等需要强调的时刻。
+
+**自定义闪烁：** 可以自由设置闪烁的颜色、透明度变化、持续时间和缓速模式。其中有一个"闪烁版"选项，可以控制闪烁出现在前景图之上还是背景图之上，灵活度很高。最下面的“减弱闪烁强度”则是当玩家开启“减弱闪烁强度”时使用这个设置的闪烁。
+
+> 频繁闪烁的谱面请务必加上癫痫警告！
+
+闪光通常配合节拍或者轨道一起使用效果最好。比如在副歌开始时闪一下，或者在长按拍子结束时闪一下，都能让画面和音乐的配合更加紧密。
+
 ## 预设 VFX
 
+预设特效是编辑器内置的一大类视觉效果，种类非常丰富，从轻微的画面调整到强烈的精神污染应有尽有。你可以在紫色版块的**预设特效**中找到它们。
+
+这里列举一些初学者最常用的预设特效：
+
+### 摄像头类
+
+| 特效 | 效果 |
+| :--- | :--- |
+| **屏幕分隔** | 把画面分成若干个相同的部分，可以填写小数 |
+| **屏幕滚动** | 画面向指定方向循环滚动 |
+| **过场模式** | 屏幕上下出现黑条，像游戏过场动画的感觉 |
+| **按键低重音** | 每次按拍后画面产生震动和色像差 |
+| **鱼眼** | 中间比边缘更大的鱼眼镜头效果，强度可以是负数 |
+
+### 画风突变类
+
+| 特效 | 效果 |
+| :--- | :--- |
+| **亮度** | 改变画面亮度，小于等于0相当于黑屏 |
+| **对比度** | 改变色彩对比度，负数相当于反色 |
+| **饱和度** | 改变色彩饱和度，负数相当于反色 |
+| **灰度** | 画面变成黑白灰的 |
+| **怀旧** | 画面发黄，复古感 |
+| **模糊** | 让画面变得模糊 |
+| **像素化** | 画面变成像素格 |
+| **色调偏移** | 改变画面色调，每隔100%是一个色调循环 |
+| **色像差** | 类似红蓝3D眼镜不戴时看到的效果 |
+| **晕影** | 边缘变暗的效果 |
+
+### 添加物类
+
+| 特效 | 效果 |
+| :--- | :--- |
+| **落雨** | 屏幕上出现下雨效果 |
+| **飘雪** | 屏幕上方落下雪花 |
+| **落花** | 屏幕上方落下花瓣 |
+| **气球** | 屏幕下方飘出气球 |
+| **纸屑** | 屏幕上方落下各种颜色的纸屑 |
+
+> 预设特效可以叠加使用，但也要适度。堆太多特效不仅会让画面变得混乱，还可能造成性能问题。初学者建议每次只叠加2-3个特效，观察效果后再决定是否继续添加。
+
+完整的预设特效列表可以参考[预设特效附录](../pages/appendix_vfxs.md)。
+
 ## 反色
 
-## 镜像
+反色就是把画面上所有颜色变成它的互补色——黑变白、白变黑、红变青、蓝变黄。这是一个简单但效果非常明显的特效。
+
+实现反色有几种方式：
+
+1. **对比度或饱和度设为负数：** 在预设特效中，将对比度或饱和度的值设为负数，就能达到类似反色的效果。
+2. **使用颜色反转事件：** 直接在紫色版块中使用颜色反转事件，一步到位。
+
+反色通常用于表达情绪突变、场景切换或者节奏上的高潮段落。例如在一段平静的音乐之后突然反色，能给玩家带来强烈的视觉冲击。
+
+> 反色不要用得太频繁。快速交替的反色会造成高频率闪烁，非常伤眼，属于视觉干扰的范畴。如果确实需要频繁反色，请参考[视觉干扰](../pages/vfxpro.md)中的注意事项。
+
+## 镜像
+
+镜像效果可以让画面左右对称或者上下对称，产生一种"照镜子"的感觉。这个效果在编辑器中可以通过**屏幕翻转**事件来实现。
+
+镜像最典型的用法是配合场景设计。比如在一个对称的舞台背景中使用镜像，可以让画面看起来更加整齐华丽。又或者在某些特定的节拍点上突然镜像再恢复，能产生一种"时空错乱"的视觉效果。
+
+镜像也可以和移动房间配合使用。把房间缩小并镜像，就可以在屏幕边缘做出类似"画中画"的效果，丰富画面的层次感。
+
+> 镜像本身是一个比较克制的特效，单独使用时不会太伤眼。但如果和其他特效（尤其是镜厅、放克等）叠加，效果可能会变得非常夸张，使用时请注意测试。

pages/vfxpro.md

@@ -1,6 +1,9 @@
 # 视觉干扰
 
-> 在关卡中出现对比度较高画面快速交替，如红蓝、黑白快速闪烁，必须开启癫痫警告。使用“放克”特效，必须开启癫痫警告。使用“干扰”特效较多，建议开启癫痫警告。一秒出现3次以上快速闪烁，建议开启癫痫警告。
+> 在关卡中出现对比度较高画面快速交替，如红蓝、黑白快速闪烁，必须开启癫痫警告。  
+> 使用“放克”特效，必须开启癫痫警告。  
+> 使用“干扰”特效较多，建议开启癫痫警告。  
+> 一秒出现3次以上快速闪烁，建议开启癫痫警告。
 
 > 即使开启了癫痫警告，也不要设计出会伤害视力的干扰效果。
 
@@ -43,30 +46,4 @@
 
 很多预设特效都自带一点画面干扰的倾向，而将这些效果叠加就能加剧干扰效果，如果再叠加上一节所述的镜厅效果则会更加一发不可收拾。堆预设特效可以玩玩，但也要适度。
 
-除镜厅外，放克特效也是要谨慎使用的，过大的饱和度会让眼部急剧不适，往往可以放在整个场景的最底层空区域进行一个小面积适度的铺设。
-
-下面举几个例子：
-
-**竖直滚屏+VHS+电影噪点+高光**
-
-带来信号干扰、丢失的感觉
-
-**顶部镜厅+摄像头/房间动画**
-
-旋转，跳跃，残影，你画面拉出了完美的拖尾
-
-**屏幕翻转+颜色反转+滚屏**
-
-画面你别乱跑
-
-**短暂的噪点/干扰**
-
-默数拍子开启
-
-**放克+落雨+灰度+慢游戏速度**
-
-听话，别把灰度去掉
-
-**25%白色前景闪烁+暴风雪+雪花+VHS+关闭竖直滚屏+电影噪点+JPEG失真+落雨+快游戏速度**
-
-最后的绝望（《冰与火之舞》 “XH-X  最后的希望”类似效果）
+除镜厅外，放克特效也是要谨慎使用的，过大的饱和度会让眼部急剧不适，往往可以放在整个场景的最底层空区域进行一个小面积适度的铺设。

resources/Appendix8.md

@@ -101,7 +101,7 @@ metadata:
 
   - 对于 落雨/JPEG失真/马赛克/海底波浪/电影噪点/暴风雪/素描/色像差/模糊/径向模糊/色调偏移：强度,缓速时长,缓速
 
-  - 对于 自定义屏幕块/自定义滚屏：x/y
+  - 对于 自定义屏幕分隔/屏幕滚动：x/y
 
   - 对于 高光：阈值,强度,颜色,缓速时长,缓速
 

script/config.js

@@ -0,0 +1,36 @@
+window.$docsify = {
+    name: "节奏医生编辑器教程",
+    notFoundPage: "/404.md",
+    homepage: "/pages/intro.md",
+    loadSidebar: true,
+    loadNavbar: true,
+    coverpage: false,
+    maxLevel: 5,
+    subMaxLevel: 4,
+    mergeNavbar: true,
+    markdown: {
+        renderer: {
+            image: function (src, title, alt) {
+                return `<div class="image-tip"><img class="medium-zoom-image" src="${src}" alt="${alt}">${
+                    alt ? `<p>${alt}</p>` : ""
+                }</div>`;
+            },
+        },
+    },
+    switchLightDarkMode: {
+        useSwitchMode: true,
+        top: 130,
+        right: 26,
+        svgColor: "#7d7b75",
+    },
+    search: {
+        noData: {
+            "/": "没有找到结果!",
+        },
+        paths: "auto",
+        placeholder: {
+            "/": "搜索",
+        },
+        hideOtherSidebarContent: true,
+    },
+};

script/custommethod-search.js

@@ -1,31 +1,711 @@
-
-
-
-const customMethods = [
-  { type: 'mod',}
-]
-
-const editDistance = (a, b) => {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  const matrix = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1),
-        );
-      }
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function () {
+    "use strict";
+    let ParameterType;
+    (function (ParameterType) {
+        ParameterType["String"] = "string";
+        ParameterType["Number"] = "number";
+        ParameterType["Boolean"] = "boolean";
+        ParameterType["Enum"] = "enum";
+    })(ParameterType || (ParameterType = {}));
+    let MethodType;
+    (function (MethodType) {
+        MethodType["Mod"] = "mod";
+        MethodType["Surgery"] = "surgery";
+        MethodType["Comment"] = "comment";
+        MethodType["CustomMethod"] = "custom_method";
+        MethodType["Ink"] = "ink";
+        MethodType["Variable"] = "variable";
+        MethodType["Condition"] = "condition";
+        MethodType["CustomClass"] = "custom_class";
+    })(MethodType || (MethodType = {}));
+    const enumTypeMap = {
+        Characters: ["Logan", "Green", "Blue", "Yellow", "Purple", "Orange"],
+        Size: ["Small", "Medium", "Large"],
+        Shape: ["Circle", "Square", "Triangle"],
+    };
+    class NumericRange {
+        constructor(min, max, isInteger = false) {
+            this.min = min;
+            this.max = max;
+            this.isInteger = isInteger;
+        }
     }
-  }
-  return matrix[b.length][a.length];
-}
+    class Parameter {
+        constructor(name, type, description, enumType, numericRange) {
+            this.name = name;
+            this.type = type;
+            this.description = description;
+            this.enumType = enumType;
+            this.numericRange = numericRange;
+        }
+    }
+    class Method {
+        constructor(name, type, shortDescription, description) {
+            this.name = name;
+            this.type = type;
+            this.shortDescription = shortDescription;
+            this.description = description;
+        }
+    }
+    class Mod extends Method {
+        constructor(name, shortDescription, description) {
+            super(name, MethodType.Mod, shortDescription, description);
+        }
+    }
+    class Surgery extends Method {
+        constructor(name, shortDescription, description) {
+            super(name, MethodType.Surgery, shortDescription, description);
+        }
+    }
+    class CommentMethod extends Method {
+        constructor(name, shortDescription, description, parameters) {
+            super(name, MethodType.Comment, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class InkMethod extends Method {
+        constructor(name, shortDescription, description, parameters) {
+            super(name, MethodType.Ink, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class CustomMethods extends Method {
+        constructor(name, shortDescription, description, parameters) {
+            super(name, MethodType.CustomMethod, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class VariableMethod extends Method {
+        constructor(name, shortDescription, description, parameters) {
+            super(name, MethodType.Variable, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class ConditionMethod extends Method {
+        constructor(name, shortDescription, description, parameters) {
+            super(name, MethodType.Condition, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class CustomClassMethod extends Method {
+        constructor(name, shortDescription, description) {
+            super(name, MethodType.CustomClass, shortDescription, description);
+        }
+    }
+    function editDistance(a, b, caseSensitive = true) {
+        if (a.length === 0)
+            return b.length;
+        if (b.length === 0)
+            return a.length;
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                const ac = a.charAt(j - 1);
+                const bc = b.charAt(i - 1);
+                if (caseSensitive ? bc === ac : bc.toLowerCase() === ac.toLowerCase()) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    function parametersOf(method) {
+        var _a;
+        return (_a = method.parameters) !== null && _a !== void 0 ? _a : [];
+    }
+    // 全局策略：字符串写法、数字/布尔默认的常量/表达式状态
+    const strategies = {
+        string: "prefix",
+        number: "constant",
+        boolean: "constant",
+    };
+    // ---------------------------------------------------------------------
+    // 外置数据 hydrate（script/custommethod-data.js）
+    // ---------------------------------------------------------------------
+    function hydrateMethod(raw) {
+        var _a, _b, _c, _d;
+        const shortDescription = (_b = (_a = raw.shortDescription) !== null && _a !== void 0 ? _a : raw.description) !== null && _b !== void 0 ? _b : "";
+        const description = (_d = (_c = raw.description) !== null && _c !== void 0 ? _c : raw.shortDescription) !== null && _d !== void 0 ? _d : "";
+        const parameters = Array.isArray(raw.parameters)
+            ? raw.parameters.map((item) => {
+                var _a, _b;
+                return new Parameter(item.name, (_a = item.type) !== null && _a !== void 0 ? _a : ParameterType.String, (_b = item.description) !== null && _b !== void 0 ? _b : "", item.enumType, item.numericRange
+                    ? new NumericRange(item.numericRange.min, item.numericRange.max, item.numericRange.isInteger)
+                    : undefined);
+            })
+            : [];
+        switch (raw.type) {
+            case MethodType.Mod: return new Mod(raw.name, shortDescription, description);
+            case MethodType.Surgery: return new Surgery(raw.name, shortDescription, description);
+            case MethodType.Comment: return new CommentMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Ink: return new InkMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Variable: return new VariableMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Condition: return new ConditionMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.CustomClass: return new CustomClassMethod(raw.name, shortDescription, description);
+            default: return new CustomMethods(raw.name, shortDescription, description, parameters);
+        }
+    }
+    let methods = [];
+    function loadExternalData() {
+        const data = window.CustomMethodSearchData;
+        if (!data)
+            return;
+        if (data.enumTypes) {
+            for (const key of Object.keys(data.enumTypes)) {
+                enumTypeMap[key] = data.enumTypes[key];
+            }
+        }
+        if (Array.isArray(data.methods)) {
+            const index = new Map();
+            methods.forEach((method, i) => index.set(method.name.toLowerCase(), i));
+            for (const raw of data.methods) {
+                if (!raw || !raw.name)
+                    continue;
+                const name = String(raw.name).toLowerCase();
+                const hydrated = hydrateMethod(raw);
+                if (index.has(name)) {
+                    methods[index.get(name)] = hydrated;
+                }
+                else {
+                    index.set(name, methods.length);
+                    methods.push(hydrated);
+                }
+            }
+        }
+    }
+    loadExternalData();
+    // ---------------------------------------------------------------------
+    // 匹配
+    // ---------------------------------------------------------------------
+    function searchMethods(query) {
+        const q = query.trim();
+        if (!q)
+            return [];
+        const ql = q.toLowerCase();
+        const maxDistance = Math.max(2, Math.floor(q.length / 2));
+        return methods
+            .map((method) => {
+            const name = method.name;
+            const lower = name.toLowerCase();
+            let score;
+            if (name === q) {
+                score = 0;
+            }
+            else if (lower.startsWith(ql)) {
+                score = 1;
+            }
+            else if (lower.indexOf(ql) >= 0) {
+                score = 2;
+            }
+            else {
+                score = 3 + editDistance(name, q, false);
+            }
+            return { method, score };
+        })
+            .filter((item) => item.score <= 2 || item.score <= 3 + maxDistance)
+            .sort((a, b) => a.score - b.score || a.method.name.localeCompare(b.method.name))
+            .slice(0, 8)
+            .map((item) => item.method);
+    }
+    // ---------------------------------------------------------------------
+    // DOM 工具
+    // ---------------------------------------------------------------------
+    function el(tag, className) {
+        const node = document.createElement(tag);
+        if (className)
+            node.className = className;
+        return node;
+    }
+    function resolveEnumOptions(parameter) {
+        if (parameter.enumType && enumTypeMap[parameter.enumType])
+            return enumTypeMap[parameter.enumType];
+        if (enumTypeMap[parameter.description])
+            return enumTypeMap[parameter.description];
+        if (enumTypeMap[parameter.name])
+            return enumTypeMap[parameter.name];
+        return [];
+    }
+    // 布尔可用 true/false，或布尔变量 b0~b9
+    const BOOLEAN_OPTIONS = ["true", "false"];
+    for (let i = 0; i < 10; i++) {
+        BOOLEAN_OPTIONS.push("b" + i);
+    }
+    function makeCombo(parameter, options, onChange) {
+        const combo = el("span", "cm-combo");
+        const input = el("input", "cm-input cm-combo-input");
+        input.type = "text";
+        input.placeholder = parameter.name;
+        input.autocomplete = "off";
+        const list = el("ul", "cm-combo-list");
+        list.hidden = true;
+        function populate() {
+            list.textContent = "";
+            if (options.length === 0) {
+                list.hidden = true;
+                return;
+            }
+            const query = input.value.trim();
+            const ql = query.toLowerCase();
+            const maxDistance = Math.max(1, Math.floor(query.length / 2));
+            const shown = (query
+                ? options.filter((option) => option.toLowerCase().indexOf(ql) >= 0 ||
+                    editDistance(option, query, false) <= maxDistance)
+                : options).slice(0, 10);
+            if (shown.length === 0) {
+                list.hidden = true;
+                return;
+            }
+            for (const option of shown) {
+                const item = el("li", "cm-combo-item");
+                item.textContent = option;
+                item.title = option;
+                item.addEventListener("mousedown", (event) => {
+                    event.preventDefault();
+                    input.value = option;
+                    list.hidden = true;
+                    onChange();
+                });
+                list.appendChild(item);
+            }
+            list.hidden = false;
+        }
+        input.addEventListener("input", () => { populate(); onChange(); });
+        input.addEventListener("focus", populate);
+        input.addEventListener("blur", () => { window.setTimeout(() => { list.hidden = true; }, 120); });
+        combo.appendChild(input);
+        combo.appendChild(list);
+        return combo;
+    }
+    function makeModeToggle(initial, onChange) {
+        const button = el("button", "cm-mode");
+        button.type = "button";
+        let mode = initial;
+        const render = () => {
+            button.textContent = mode === "expression" ? "表达式" : "常量";
+            button.title = "切换 常量 / 表达式";
+            button.classList.toggle("is-expression", mode === "expression");
+        };
+        render();
+        button.addEventListener("click", (event) => {
+            event.preventDefault();
+            mode = mode === "expression" ? "constant" : "expression";
+            render();
+            onChange();
+        });
+        return { el: button, get: () => mode };
+    }
+    function stringValue(value) {
+        if (value.length === 0)
+            return "<文本>";
+        return strategies.string === "quote" ? `"${value}"` : `str:${value}`;
+    }
+    function makeField(parameter, onChange) {
+        switch (parameter.type) {
+            case ParameterType.Boolean: {
+                const wrap = el("span", "cm-field");
+                const checkbox = el("input", "cm-input cm-check");
+                checkbox.type = "checkbox";
+                checkbox.addEventListener("change", onChange);
+                const combo = makeCombo(parameter, BOOLEAN_OPTIONS, onChange);
+                const comboInput = combo.querySelector("input");
+                let mode = strategies.boolean;
+                const toggle = makeModeToggle(strategies.boolean, () => {
+                    mode = toggle.get();
+                    applyMode();
+                    onChange();
+                });
+                function applyMode() {
+                    const expression = mode === "expression";
+                    checkbox.hidden = expression;
+                    combo.hidden = !expression;
+                }
+                applyMode();
+                wrap.appendChild(toggle.el);
+                wrap.appendChild(checkbox);
+                wrap.appendChild(combo);
+                return {
+                    el: wrap,
+                    read: () => {
+                        if (mode === "constant") {
+                            return { text: checkbox.checked ? "true" : "false", valid: true, invalid: false };
+                        }
+                        const value = comboInput.value.trim();
+                        return value.length > 0
+                            ? { text: value, valid: true, invalid: false }
+                            : { text: "<布尔>", valid: false, invalid: true };
+                    },
+                };
+            }
+            case ParameterType.Number: {
+                const wrap = el("span", "cm-field");
+                const input = el("input", "cm-input");
+                input.type = "text";
+                input.inputMode = "decimal";
+                input.placeholder = parameter.name;
+                input.addEventListener("input", onChange);
+                const mode = makeModeToggle(strategies.number, onChange);
+                wrap.appendChild(mode.el);
+                wrap.appendChild(input);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        if (value.length === 0)
+                            return { text: "<数字>", valid: false, invalid: true };
+                        if (mode.get() === "expression")
+                            return { text: value, valid: true, invalid: false };
+                        const number = Number(value);
+                        let valid = isFinite(number);
+                        const range = parameter.numericRange;
+                        if (valid && range) {
+                            if (range.isInteger && !Number.isInteger(number))
+                                valid = false;
+                            if (range.min !== undefined && number < range.min)
+                                valid = false;
+                            if (range.max !== undefined && number > range.max)
+                                valid = false;
+                        }
+                        return { text: value, valid, invalid: !valid };
+                    },
+                };
+            }
+            case ParameterType.Enum: {
+                const wrap = el("span", "cm-field cm-field-string");
+                const open = el("span", "cm-lit");
+                const close = el("span", "cm-lit");
+                open.textContent = strategies.string === "quote" ? "\"" : "str:";
+                close.textContent = strategies.string === "quote" ? "\"" : "";
+                const combo = makeCombo(parameter, resolveEnumOptions(parameter), onChange);
+                const input = combo.querySelector("input");
+                wrap.appendChild(open);
+                wrap.appendChild(combo);
+                wrap.appendChild(close);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        const options = resolveEnumOptions(parameter);
+                        const valid = options.length > 0
+                            ? options.some((option) => option.toLowerCase() === value.toLowerCase())
+                            : value.length > 0;
+                        return { text: stringValue(value), valid, invalid: !valid };
+                    },
+                };
+            }
+            default: {
+                const wrap = el("span", "cm-field cm-field-string");
+                const open = el("span", "cm-lit");
+                const close = el("span", "cm-lit");
+                open.textContent = strategies.string === "quote" ? "\"" : "str:";
+                close.textContent = strategies.string === "quote" ? "\"" : "";
+                const input = el("input", "cm-input");
+                input.type = "text";
+                input.placeholder = parameter.name;
+                input.addEventListener("input", onChange);
+                wrap.appendChild(open);
+                wrap.appendChild(input);
+                wrap.appendChild(close);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        return { text: stringValue(value), valid: value.length > 0, invalid: value.length === 0 };
+                    },
+                };
+            }
+        }
+    }
+    function methodSkeleton(method, hasParams) {
+        switch (method.type) {
+            case MethodType.Comment: return { prefix: `()=>${method.name}(`, suffix: ")" };
+            case MethodType.Ink: return { prefix: `DOTHIS{${method.name}(`, suffix: ")}" };
+            case MethodType.Variable: return { prefix: `${method.name} = `, suffix: "" };
+            case MethodType.Mod: return { prefix: `"mods": [..., "`, suffix: `"]` };
+            case MethodType.CustomClass: return { prefix: `"customClass": "`, suffix: `"` };
+            case MethodType.Condition:
+                return hasParams ? { prefix: `${method.name}(`, suffix: ")" } : { prefix: method.name, suffix: "" };
+            case MethodType.Surgery: return { prefix: method.name, suffix: "" };
+            default:
+                return hasParams ? { prefix: `${method.name}(`, suffix: ")" } : { prefix: method.name, suffix: "" };
+        }
+    }
+    function formatMethod(method, states) {
+        const args = states.map((state) => state.text).join(", ");
+        switch (method.type) {
+            case MethodType.Comment: return `()=>${method.name}(${args})`;
+            case MethodType.Ink: return `DOTHIS{${method.name}(${args})}`;
+            case MethodType.Variable: return `${method.name} = ${states.length ? states[0].text : ""}`;
+            case MethodType.Mod: return `"mods": [..., "${method.name}"]`;
+            case MethodType.CustomClass: return `"customClass": "${method.name}"`;
+            case MethodType.Condition: return states.length ? `${method.name}(${args})` : method.name;
+            case MethodType.Surgery: return method.name;
+            default: return states.length ? `${method.name}(${args})` : method.name;
+        }
+    }
+    function copyText(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (navigator.clipboard && navigator.clipboard.writeText) {
+                    yield navigator.clipboard.writeText(text);
+                    return true;
+                }
+            }
+            catch (error) {
+                // fall through
+            }
+            try {
+                const area = document.createElement("textarea");
+                area.value = text;
+                area.style.position = "fixed";
+                area.style.opacity = "0";
+                document.body.appendChild(area);
+                area.select();
+                const ok = document.execCommand("copy");
+                document.body.removeChild(area);
+                return ok;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+    }
+    // ---------------------------------------------------------------------
+    // 渲染
+    // ---------------------------------------------------------------------
+    function renderContainer(container) {
+        if (container.dataset.cmReady === "1")
+            return;
+        container.dataset.cmReady = "1";
+        let currentMethod = null;
+        let query = container.querySelector(".cm-query");
+        let suggest = container.querySelector(".cm-suggest");
+        let selected = container.querySelector(".cm-selected");
+        let nameEl = container.querySelector(".cm-name");
+        let shortEl = container.querySelector(".cm-short");
+        let call = container.querySelector(".cm-call");
+        let preview = container.querySelector(".cm-preview");
+        let desc = container.querySelector(".cm-desc");
+        let options = container.querySelector(".cm-options");
+        if (!query || !suggest || !selected || !nameEl || !shortEl || !call || !preview || !desc) {
+            container.textContent = "";
+            const searchBar = el("div", "cm-search");
+            query = el("input", "cm-query");
+            query.type = "text";
+            query.placeholder = "输入自定义方法名，如 ChangeCharacter";
+            query.autocomplete = "off";
+            suggest = el("ul", "cm-suggest");
+            searchBar.appendChild(query);
+            searchBar.appendChild(suggest);
+            selected = el("div", "cm-selected");
+            selected.hidden = true;
+            const head = el("div", "cm-head");
+            nameEl = el("span", "cm-name");
+            shortEl = el("span", "cm-short");
+            head.appendChild(nameEl);
+            head.appendChild(shortEl);
+            call = el("div", "cm-call");
+            preview = el("code", "cm-preview");
+            desc = el("div", "cm-desc");
+            selected.appendChild(head);
+            selected.appendChild(call);
+            selected.appendChild(preview);
+            selected.appendChild(desc);
+            container.appendChild(searchBar);
+            container.appendChild(selected);
+        }
+        // 搜索框下的策略选项
+        options = container.querySelector(".cm-options");
+        if (!options) {
+            options = el("div", "cm-options");
+            query.parentElement.insertAdjacentElement("afterend", options);
+        }
+        if (!options.querySelector(".cm-option-select")) {
+            const optionsBox = options;
+            function addOption(label, key, values, current) {
+                const wrap = el("label", "cm-option");
+                const text = el("span", "cm-option-label");
+                text.textContent = label;
+                const select = el("select", "cm-option-select");
+                for (const [value, caption] of values) {
+                    const opt = el("option");
+                    opt.value = value;
+                    opt.textContent = caption;
+                    select.appendChild(opt);
+                }
+                select.value = current;
+                select.addEventListener("change", () => {
+                    strategies[key] = select.value;
+                    if (currentMethod) {
+                        selectMethod(currentMethod);
+                    }
+                });
+                wrap.appendChild(text);
+                wrap.appendChild(select);
+                optionsBox.appendChild(wrap);
+            }
+            addOption("字符串", "string", [["prefix", "str: 前缀"], ["quote", "引号 \"…\""]], strategies.string);
+        }
+        const queryEl = query;
+        const suggestEl = suggest;
+        const selectedEl = selected;
+        const nameNode = nameEl;
+        const shortNode = shortEl;
+        const callEl = call;
+        const previewEl = preview;
+        const descNode = desc;
+        const copyBtn = el("button", "cm-copy");
+        copyBtn.type = "button";
+        copyBtn.textContent = "复制";
+        copyBtn.hidden = true;
+        copyBtn.title = "复制生成的代码";
+        selectedEl.appendChild(copyBtn);
+        copyBtn.addEventListener("click", () => {
+            var _a;
+            copyText((_a = previewEl.textContent) !== null && _a !== void 0 ? _a : "").then((ok) => {
+                copyBtn.textContent = ok ? "已复制" : "复制失败";
+                window.setTimeout(() => { copyBtn.textContent = "复制"; }, 1200);
+            });
+        });
+        function clearSuggest() {
+            suggestEl.textContent = "";
+        }
+        function selectMethod(method) {
+            currentMethod = method;
+            clearSuggest();
+            queryEl.value = method.name;
+            selectedEl.hidden = false;
+            nameNode.textContent = method.name;
+            shortNode.textContent = method.shortDescription || "";
+            descNode.textContent = method.description || "";
+            callEl.textContent = "";
+            previewEl.textContent = "";
+            copyBtn.hidden = true;
+            const parameters = parametersOf(method);
+            const fields = [];
+            function updatePreview() {
+                const states = fields.map((field) => field.read());
+                fields.forEach((field, i) => field.el.classList.toggle("cm-invalid", states[i].invalid));
+                previewEl.textContent = formatMethod(method, states);
+                copyBtn.hidden = !states.every((state) => state.valid);
+            }
+            const skeleton = methodSkeleton(method, parameters.length > 0);
+            const code = el("code", "cm-code");
+            const prefix = el("span", "cm-lit");
+            prefix.textContent = skeleton.prefix;
+            code.appendChild(prefix);
+            parameters.forEach((parameter, index) => {
+                if (index > 0) {
+                    const sep = el("span", "cm-lit");
+                    sep.textContent = ", ";
+                    code.appendChild(sep);
+                }
+                const field = makeField(parameter, updatePreview);
+                field.el.title = parameter.description;
+                code.appendChild(field.el);
+                fields.push(field);
+            });
+            if (skeleton.suffix) {
+                const suffix = el("span", "cm-lit");
+                suffix.textContent = skeleton.suffix;
+                code.appendChild(suffix);
+            }
+            callEl.appendChild(code);
+            if (parameters.length === 0) {
+                const empty = el("span", "cm-empty");
+                empty.textContent = "（无参数）";
+                callEl.appendChild(empty);
+            }
+            updatePreview();
+        }
+        function updateSuggestions() {
+            clearSuggest();
+            for (const method of searchMethods(queryEl.value)) {
+                const item = el("li", "cm-suggest-item");
+                const nameSpan = el("span", "cm-suggest-name");
+                nameSpan.textContent = method.name;
+                const descSpan = el("span", "cm-suggest-desc");
+                descSpan.textContent = method.shortDescription || method.description;
+                item.appendChild(nameSpan);
+                item.appendChild(descSpan);
+                item.addEventListener("mousedown", (event) => {
+                    event.preventDefault();
+                    selectMethod(method);
+                });
+                suggestEl.appendChild(item);
+            }
+        }
+        queryEl.addEventListener("input", () => {
+            updateSuggestions();
+            selectedEl.hidden = true;
+        });
+        queryEl.addEventListener("focus", updateSuggestions);
+        queryEl.addEventListener("blur", () => {
+            window.setTimeout(clearSuggest, 120);
+        });
+        if (queryEl.value) {
+            updateSuggestions();
+        }
+    }
+    function initAll() {
+        document.querySelectorAll(".custommethods-search").forEach((container) => renderContainer(container));
+    }
+    function register() {
+        const docsify = window.$docsify;
+        if (docsify) {
+            docsify.plugins = [].concat(docsify.plugins, (hook) => {
+                hook.doneEach(() => initAll());
+            });
+        }
+        else if (document.readyState === "loading") {
+            document.addEventListener("DOMContentLoaded", () => initAll());
+        }
+        else {
+            initAll();
+        }
+    }
+    window.CustomMethodSearch = {
+        search: searchMethods,
+        editDistance,
+        renderAll: initAll,
+        strategies,
+        getMethods: () => methods,
+        setMethods: (list) => { methods = list; initAll(); },
+        Parameter,
+        ParameterType,
+        Method,
+        MethodType,
+        Mod,
+        Surgery,
+        CommentMethod,
+        InkMethod,
+        CustomMethods,
+        VariableMethod,
+        ConditionMethod,
+        CustomClassMethod,
+    };
+    if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", register);
+    }
+    else {
+        register();
+    }
+})();

script/custommethod-search.ts

@@ -1,32 +1,747 @@
-class CustomMethods{
-  type: "mod"|"surgery"|"comment"|"custom_method";
-}
+(function () {
+    "use strict";
 
-function editDistance(a: String, b: String): number {
-  if (a.length === 0) return b.length;
-  if (b.length === 0) return a.length;
-  const matrix: number[][] = [];
-  for (let i = 0; i <= b.length; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= a.length; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      if (b.charAt(i - 1) === a.charAt(j - 1)) {
-        matrix[i][j] = matrix[i - 1][j - 1];
-      } else {
-        matrix[i][j] = Math.min(
-          matrix[i - 1][j - 1] + 1,
-          Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1),
-        );
-      }
+    enum ParameterType {
+        String = "string",
+        Number = "number",
+        Boolean = "boolean",
+        Enum = "enum",
     }
-  }
-  return matrix[b.length][a.length];
-}
+    enum MethodType {
+        Mod = "mod",
+        Surgery = "surgery",
+        Comment = "comment",
+        CustomMethod = "custom_method",
+        Ink = "ink",
+        Variable = "variable",
+        Condition = "condition",
+        CustomClass = "custom_class",
+    }
+    type ValueMode = "constant" | "expression";
+    type StringStrategy = "prefix" | "quote";
 
+    const enumTypeMap: Record<string, string[]> = {
+        Characters: ["Logan", "Green", "Blue", "Yellow", "Purple", "Orange"],
+        Size: ["Small", "Medium", "Large"],
+        Shape: ["Circle", "Square", "Triangle"],
+    };
 
+    class NumericRange {
+        min?: number;
+        max?: number;
+        isInteger: boolean;
+        public constructor(min?: number, max?: number, isInteger: boolean = false) {
+            this.min = min;
+            this.max = max;
+            this.isInteger = isInteger;
+        }
+    }
+    class Parameter {
+        name: string;
+        type: ParameterType;
+        enumType?: string;
+        numericRange?: NumericRange;
+        description: string;
+        public constructor(name: string, type: ParameterType, description: string, enumType?: string, numericRange?: NumericRange) {
+            this.name = name;
+            this.type = type;
+            this.description = description;
+            this.enumType = enumType;
+            this.numericRange = numericRange;
+        }
+    }
+    class Method {
+        name: string;
+        type: MethodType;
+        shortDescription: string;
+        description: string;
+        public constructor(name: string, type: MethodType, shortDescription: string, description: string) {
+            this.name = name;
+            this.type = type;
+            this.shortDescription = shortDescription;
+            this.description = description;
+        }
+    }
+    class Mod extends Method {
+        public constructor(name: string, shortDescription: string, description: string) {
+            super(name, MethodType.Mod, shortDescription, description);
+        }
+    }
+    class Surgery extends Method {
+        public constructor(name: string, shortDescription: string, description: string) {
+            super(name, MethodType.Surgery, shortDescription, description);
+        }
+    }
+    class CommentMethod extends Method {
+        parameters: Parameter[];
+        public constructor(name: string, shortDescription: string, description: string, parameters: Parameter[]) {
+            super(name, MethodType.Comment, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class InkMethod extends Method {
+        parameters: Parameter[];
+        public constructor(name: string, shortDescription: string, description: string, parameters: Parameter[]) {
+            super(name, MethodType.Ink, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class CustomMethods extends Method {
+        parameters: Parameter[];
+        public constructor(name: string, shortDescription: string, description: string, parameters: Parameter[]) {
+            super(name, MethodType.CustomMethod, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class VariableMethod extends Method {
+        parameters: Parameter[];
+        public constructor(name: string, shortDescription: string, description: string, parameters: Parameter[]) {
+            super(name, MethodType.Variable, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class ConditionMethod extends Method {
+        parameters: Parameter[];
+        public constructor(name: string, shortDescription: string, description: string, parameters: Parameter[]) {
+            super(name, MethodType.Condition, shortDescription, description);
+            this.parameters = parameters;
+        }
+    }
+    class CustomClassMethod extends Method {
+        public constructor(name: string, shortDescription: string, description: string) {
+            super(name, MethodType.CustomClass, shortDescription, description);
+        }
+    }
 
-export { editDistance };
+    function editDistance(a: string, b: string, caseSensitive: boolean = true): number {
+        if (a.length === 0) return b.length;
+        if (b.length === 0) return a.length;
+        const matrix: number[][] = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                const ac = a.charAt(j - 1);
+                const bc = b.charAt(i - 1);
+                if (caseSensitive ? bc === ac : bc.toLowerCase() === ac.toLowerCase()) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                } else {
+                    matrix[i][j] = Math.min(
+                        matrix[i - 1][j - 1] + 1,
+                        Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1),
+                    );
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+
+    function parametersOf(method: Method): Parameter[] {
+        return (method as CommentMethod | InkMethod | CustomMethods | VariableMethod | ConditionMethod).parameters ?? [];
+    }
+
+    // 全局策略：字符串写法、数字/布尔默认的常量/表达式状态
+    const strategies: { string: StringStrategy; number: ValueMode; boolean: ValueMode } = {
+        string: "prefix",
+        number: "constant",
+        boolean: "constant",
+    };
+
+    // ---------------------------------------------------------------------
+    // 外置数据 hydrate（script/custommethod-data.js）
+    // ---------------------------------------------------------------------
+    function hydrateMethod(raw: any): Method {
+        const shortDescription = raw.shortDescription ?? raw.description ?? "";
+        const description = raw.description ?? raw.shortDescription ?? "";
+        const parameters: Parameter[] = Array.isArray(raw.parameters)
+            ? raw.parameters.map((item: any) => new Parameter(
+                item.name,
+                item.type ?? ParameterType.String,
+                item.description ?? "",
+                item.enumType,
+                item.numericRange
+                    ? new NumericRange(item.numericRange.min, item.numericRange.max, item.numericRange.isInteger)
+                    : undefined,
+            ))
+            : [];
+        switch (raw.type) {
+            case MethodType.Mod: return new Mod(raw.name, shortDescription, description);
+            case MethodType.Surgery: return new Surgery(raw.name, shortDescription, description);
+            case MethodType.Comment: return new CommentMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Ink: return new InkMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Variable: return new VariableMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.Condition: return new ConditionMethod(raw.name, shortDescription, description, parameters);
+            case MethodType.CustomClass: return new CustomClassMethod(raw.name, shortDescription, description);
+            default: return new CustomMethods(raw.name, shortDescription, description, parameters);
+        }
+    }
+
+    let methods: Method[] = [];
+
+    function loadExternalData(): void {
+        const data = (window as any).CustomMethodSearchData;
+        if (!data) return;
+        if (data.enumTypes) {
+            for (const key of Object.keys(data.enumTypes)) {
+                enumTypeMap[key] = data.enumTypes[key];
+            }
+        }
+        if (Array.isArray(data.methods)) {
+            const index = new Map<string, number>();
+            methods.forEach((method, i) => index.set(method.name.toLowerCase(), i));
+            for (const raw of data.methods) {
+                if (!raw || !raw.name) continue;
+                const name = String(raw.name).toLowerCase();
+                const hydrated = hydrateMethod(raw);
+                if (index.has(name)) {
+                    methods[index.get(name)!] = hydrated;
+                } else {
+                    index.set(name, methods.length);
+                    methods.push(hydrated);
+                }
+            }
+        }
+    }
+    loadExternalData();
+
+    // ---------------------------------------------------------------------
+    // 匹配
+    // ---------------------------------------------------------------------
+    function searchMethods(query: string): Method[] {
+        const q = query.trim();
+        if (!q) return [];
+        const ql = q.toLowerCase();
+        const maxDistance = Math.max(2, Math.floor(q.length / 2));
+        return methods
+            .map((method) => {
+                const name = method.name;
+                const lower = name.toLowerCase();
+                let score: number;
+                if (name === q) {
+                    score = 0;
+                } else if (lower.startsWith(ql)) {
+                    score = 1;
+                } else if (lower.indexOf(ql) >= 0) {
+                    score = 2;
+                } else {
+                    score = 3 + editDistance(name, q, false);
+                }
+                return { method, score };
+            })
+            .filter((item) => item.score <= 2 || item.score <= 3 + maxDistance)
+            .sort((a, b) => a.score - b.score || a.method.name.localeCompare(b.method.name))
+            .slice(0, 8)
+            .map((item) => item.method);
+    }
+
+    // ---------------------------------------------------------------------
+    // DOM 工具
+    // ---------------------------------------------------------------------
+    function el<K extends keyof HTMLElementTagNameMap>(tag: K, className?: string): HTMLElementTagNameMap[K] {
+        const node = document.createElement(tag);
+        if (className) node.className = className;
+        return node;
+    }
+
+    function resolveEnumOptions(parameter: Parameter): string[] {
+        if (parameter.enumType && enumTypeMap[parameter.enumType]) return enumTypeMap[parameter.enumType];
+        if (enumTypeMap[parameter.description]) return enumTypeMap[parameter.description];
+        if (enumTypeMap[parameter.name]) return enumTypeMap[parameter.name];
+        return [];
+    }
+
+    // 布尔可用 true/false，或布尔变量 b0~b9
+    const BOOLEAN_OPTIONS: string[] = ["true", "false"];
+    for (let i = 0; i < 10; i++) {
+        BOOLEAN_OPTIONS.push("b" + i);
+    }
+
+    function makeCombo(parameter: Parameter, options: string[], onChange: () => void): HTMLElement {
+        const combo = el("span", "cm-combo");
+        const input = el("input", "cm-input cm-combo-input") as HTMLInputElement;
+        input.type = "text";
+        input.placeholder = parameter.name;
+        input.autocomplete = "off";
+        const list = el("ul", "cm-combo-list");
+        list.hidden = true;
+
+        function populate(): void {
+            list.textContent = "";
+            if (options.length === 0) { list.hidden = true; return; }
+            const query = input.value.trim();
+            const ql = query.toLowerCase();
+            const maxDistance = Math.max(1, Math.floor(query.length / 2));
+            const shown = (query
+                ? options.filter((option) =>
+                    option.toLowerCase().indexOf(ql) >= 0 ||
+                    editDistance(option, query, false) <= maxDistance)
+                : options
+            ).slice(0, 10);
+            if (shown.length === 0) { list.hidden = true; return; }
+            for (const option of shown) {
+                const item = el("li", "cm-combo-item");
+                item.textContent = option;
+                item.title = option;
+                item.addEventListener("mousedown", (event) => {
+                    event.preventDefault();
+                    input.value = option;
+                    list.hidden = true;
+                    onChange();
+                });
+                list.appendChild(item);
+            }
+            list.hidden = false;
+        }
+
+        input.addEventListener("input", () => { populate(); onChange(); });
+        input.addEventListener("focus", populate);
+        input.addEventListener("blur", () => { window.setTimeout(() => { list.hidden = true; }, 120); });
+        combo.appendChild(input);
+        combo.appendChild(list);
+        return combo;
+    }
+
+    function makeModeToggle(initial: ValueMode, onChange: () => void): { el: HTMLButtonElement; get: () => ValueMode } {
+        const button = el("button", "cm-mode") as HTMLButtonElement;
+        button.type = "button";
+        let mode = initial;
+        const render = (): void => {
+            button.textContent = mode === "expression" ? "表达式" : "常量";
+            button.title = "切换 常量 / 表达式";
+            button.classList.toggle("is-expression", mode === "expression");
+        };
+        render();
+        button.addEventListener("click", (event) => {
+            event.preventDefault();
+            mode = mode === "expression" ? "constant" : "expression";
+            render();
+            onChange();
+        });
+        return { el: button, get: () => mode };
+    }
+
+    interface ParamState {
+        text: string;
+        valid: boolean;
+        invalid: boolean;
+    }
+    interface Field {
+        el: HTMLElement;
+        read: () => ParamState;
+    }
+
+    function stringValue(value: string): string {
+        if (value.length === 0) return "<文本>";
+        return strategies.string === "quote" ? `"${value}"` : `str:${value}`;
+    }
+
+    function makeField(parameter: Parameter, onChange: () => void): Field {
+        switch (parameter.type) {
+            case ParameterType.Boolean: {
+                const wrap = el("span", "cm-field");
+                const checkbox = el("input", "cm-input cm-check") as HTMLInputElement;
+                checkbox.type = "checkbox";
+                checkbox.addEventListener("change", onChange);
+                const combo = makeCombo(parameter, BOOLEAN_OPTIONS, onChange);
+                const comboInput = combo.querySelector("input") as HTMLInputElement;
+                let mode: ValueMode = strategies.boolean;
+                const toggle = makeModeToggle(strategies.boolean, () => {
+                    mode = toggle.get();
+                    applyMode();
+                    onChange();
+                });
+                function applyMode(): void {
+                    const expression = mode === "expression";
+                    checkbox.hidden = expression;
+                    combo.hidden = !expression;
+                }
+                applyMode();
+                wrap.appendChild(toggle.el);
+                wrap.appendChild(checkbox);
+                wrap.appendChild(combo);
+                return {
+                    el: wrap,
+                    read: () => {
+                        if (mode === "constant") {
+                            return { text: checkbox.checked ? "true" : "false", valid: true, invalid: false };
+                        }
+                        const value = comboInput.value.trim();
+                        return value.length > 0
+                            ? { text: value, valid: true, invalid: false }
+                            : { text: "<布尔>", valid: false, invalid: true };
+                    },
+                };
+            }
+            case ParameterType.Number: {
+                const wrap = el("span", "cm-field");
+                const input = el("input", "cm-input") as HTMLInputElement;
+                input.type = "text";
+                input.inputMode = "decimal";
+                input.placeholder = parameter.name;
+                input.addEventListener("input", onChange);
+                const mode = makeModeToggle(strategies.number, onChange);
+                wrap.appendChild(mode.el);
+                wrap.appendChild(input);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        if (value.length === 0) return { text: "<数字>", valid: false, invalid: true };
+                        if (mode.get() === "expression") return { text: value, valid: true, invalid: false };
+                        const number = Number(value);
+                        let valid = isFinite(number);
+                        const range = parameter.numericRange;
+                        if (valid && range) {
+                            if (range.isInteger && !Number.isInteger(number)) valid = false;
+                            if (range.min !== undefined && number < range.min) valid = false;
+                            if (range.max !== undefined && number > range.max) valid = false;
+                        }
+                        return { text: value, valid, invalid: !valid };
+                    },
+                };
+            }
+            case ParameterType.Enum: {
+                const wrap = el("span", "cm-field cm-field-string");
+                const open = el("span", "cm-lit");
+                const close = el("span", "cm-lit");
+                open.textContent = strategies.string === "quote" ? "\"" : "str:";
+                close.textContent = strategies.string === "quote" ? "\"" : "";
+                const combo = makeCombo(parameter, resolveEnumOptions(parameter), onChange);
+                const input = combo.querySelector("input") as HTMLInputElement;
+                wrap.appendChild(open);
+                wrap.appendChild(combo);
+                wrap.appendChild(close);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        const options = resolveEnumOptions(parameter);
+                        const valid = options.length > 0
+                            ? options.some((option) => option.toLowerCase() === value.toLowerCase())
+                            : value.length > 0;
+                        return { text: stringValue(value), valid, invalid: !valid };
+                    },
+                };
+            }
+            default: {
+                const wrap = el("span", "cm-field cm-field-string");
+                const open = el("span", "cm-lit");
+                const close = el("span", "cm-lit");
+                open.textContent = strategies.string === "quote" ? "\"" : "str:";
+                close.textContent = strategies.string === "quote" ? "\"" : "";
+                const input = el("input", "cm-input") as HTMLInputElement;
+                input.type = "text";
+                input.placeholder = parameter.name;
+                input.addEventListener("input", onChange);
+                wrap.appendChild(open);
+                wrap.appendChild(input);
+                wrap.appendChild(close);
+                return {
+                    el: wrap,
+                    read: () => {
+                        const value = input.value.trim();
+                        return { text: stringValue(value), valid: value.length > 0, invalid: value.length === 0 };
+                    },
+                };
+            }
+        }
+    }
+
+    interface Skeleton {
+        prefix: string;
+        suffix: string;
+    }
+
+    function methodSkeleton(method: Method, hasParams: boolean): Skeleton {
+        switch (method.type) {
+            case MethodType.Comment: return { prefix: `()=>${method.name}(`, suffix: ")" };
+            case MethodType.Ink: return { prefix: `DOTHIS{${method.name}(`, suffix: ")}" };
+            case MethodType.Variable: return { prefix: `${method.name} = `, suffix: "" };
+            case MethodType.Mod: return { prefix: `"mods": [..., "`, suffix: `"]` };
+            case MethodType.CustomClass: return { prefix: `"customClass": "`, suffix: `"` };
+            case MethodType.Condition:
+                return hasParams ? { prefix: `${method.name}(`, suffix: ")" } : { prefix: method.name, suffix: "" };
+            case MethodType.Surgery: return { prefix: method.name, suffix: "" };
+            default:
+                return hasParams ? { prefix: `${method.name}(`, suffix: ")" } : { prefix: method.name, suffix: "" };
+        }
+    }
+
+    function formatMethod(method: Method, states: ParamState[]): string {
+        const args = states.map((state) => state.text).join(", ");
+        switch (method.type) {
+            case MethodType.Comment: return `()=>${method.name}(${args})`;
+            case MethodType.Ink: return `DOTHIS{${method.name}(${args})}`;
+            case MethodType.Variable: return `${method.name} = ${states.length ? states[0].text : ""}`;
+            case MethodType.Mod: return `"mods": [..., "${method.name}"]`;
+            case MethodType.CustomClass: return `"customClass": "${method.name}"`;
+            case MethodType.Condition: return states.length ? `${method.name}(${args})` : method.name;
+            case MethodType.Surgery: return method.name;
+            default: return states.length ? `${method.name}(${args})` : method.name;
+        }
+    }
+
+    async function copyText(text: string): Promise<boolean> {
+        try {
+            if (navigator.clipboard && navigator.clipboard.writeText) {
+                await navigator.clipboard.writeText(text);
+                return true;
+            }
+        } catch (error) {
+            // fall through
+        }
+        try {
+            const area = document.createElement("textarea");
+            area.value = text;
+            area.style.position = "fixed";
+            area.style.opacity = "0";
+            document.body.appendChild(area);
+            area.select();
+            const ok = document.execCommand("copy");
+            document.body.removeChild(area);
+            return ok;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    // 渲染
+    // ---------------------------------------------------------------------
+    function renderContainer(container: HTMLElement): void {
+        if (container.dataset.cmReady === "1") return;
+        container.dataset.cmReady = "1";
+
+        let currentMethod: Method | null = null;
+
+        let query = container.querySelector<HTMLInputElement>(".cm-query");
+        let suggest = container.querySelector<HTMLUListElement>(".cm-suggest");
+        let selected = container.querySelector<HTMLElement>(".cm-selected");
+        let nameEl = container.querySelector<HTMLElement>(".cm-name");
+        let shortEl = container.querySelector<HTMLElement>(".cm-short");
+        let call = container.querySelector<HTMLElement>(".cm-call");
+        let preview = container.querySelector<HTMLElement>(".cm-preview");
+        let desc = container.querySelector<HTMLElement>(".cm-desc");
+        let options = container.querySelector<HTMLElement>(".cm-options");
+
+        if (!query || !suggest || !selected || !nameEl || !shortEl || !call || !preview || !desc) {
+            container.textContent = "";
+            const searchBar = el("div", "cm-search");
+            query = el("input", "cm-query") as HTMLInputElement;
+            query.type = "text";
+            query.placeholder = "输入自定义方法名，如 ChangeCharacter";
+            query.autocomplete = "off";
+            suggest = el("ul", "cm-suggest");
+            searchBar.appendChild(query);
+            searchBar.appendChild(suggest);
+            selected = el("div", "cm-selected");
+            selected.hidden = true;
+            const head = el("div", "cm-head");
+            nameEl = el("span", "cm-name");
+            shortEl = el("span", "cm-short");
+            head.appendChild(nameEl);
+            head.appendChild(shortEl);
+            call = el("div", "cm-call");
+            preview = el("code", "cm-preview");
+            desc = el("div", "cm-desc");
+            selected.appendChild(head);
+            selected.appendChild(call);
+            selected.appendChild(preview);
+            selected.appendChild(desc);
+            container.appendChild(searchBar);
+            container.appendChild(selected);
+        }
+
+        // 搜索框下的策略选项
+        options = container.querySelector<HTMLElement>(".cm-options");
+        if (!options) {
+            options = el("div", "cm-options");
+            (query.parentElement as HTMLElement).insertAdjacentElement("afterend", options);
+        }
+        if (!options.querySelector(".cm-option-select")) {
+            const optionsBox = options;
+            function addOption(label: string, key: "string" | "number" | "boolean", values: [string, string][], current: string): void {
+                const wrap = el("label", "cm-option");
+                const text = el("span", "cm-option-label");
+                text.textContent = label;
+                const select = el("select", "cm-option-select") as HTMLSelectElement;
+                for (const [value, caption] of values) {
+                    const opt = el("option");
+                    opt.value = value;
+                    opt.textContent = caption;
+                    select.appendChild(opt);
+                }
+                select.value = current;
+                select.addEventListener("change", () => {
+                    (strategies as any)[key] = select.value;
+                    if (currentMethod) { selectMethod(currentMethod); }
+                });
+                wrap.appendChild(text);
+                wrap.appendChild(select);
+                optionsBox.appendChild(wrap);
+            }
+            addOption("字符串", "string", [["prefix", "str: 前缀"], ["quote", "引号 \"…\""]], strategies.string);
+        }
+
+        const queryEl = query;
+        const suggestEl = suggest;
+        const selectedEl = selected;
+        const nameNode = nameEl;
+        const shortNode = shortEl;
+        const callEl = call;
+        const previewEl = preview;
+        const descNode = desc;
+
+        const copyBtn = el("button", "cm-copy") as HTMLButtonElement;
+        copyBtn.type = "button";
+        copyBtn.textContent = "复制";
+        copyBtn.hidden = true;
+        copyBtn.title = "复制生成的代码";
+        selectedEl.appendChild(copyBtn);
+        copyBtn.addEventListener("click", () => {
+            copyText(previewEl.textContent ?? "").then((ok) => {
+                copyBtn.textContent = ok ? "已复制" : "复制失败";
+                window.setTimeout(() => { copyBtn.textContent = "复制"; }, 1200);
+            });
+        });
+
+        function clearSuggest(): void {
+            suggestEl.textContent = "";
+        }
+
+        function selectMethod(method: Method): void {
+            currentMethod = method;
+            clearSuggest();
+            queryEl.value = method.name;
+            selectedEl.hidden = false;
+            nameNode.textContent = method.name;
+            shortNode.textContent = method.shortDescription || "";
+            descNode.textContent = method.description || "";
+            callEl.textContent = "";
+            previewEl.textContent = "";
+            copyBtn.hidden = true;
+
+            const parameters = parametersOf(method);
+            const fields: Field[] = [];
+
+            function updatePreview(): void {
+                const states = fields.map((field) => field.read());
+                fields.forEach((field, i) => field.el.classList.toggle("cm-invalid", states[i].invalid));
+                previewEl.textContent = formatMethod(method, states);
+                copyBtn.hidden = !states.every((state) => state.valid);
+            }
+
+            const skeleton = methodSkeleton(method, parameters.length > 0);
+            const code = el("code", "cm-code");
+            const prefix = el("span", "cm-lit");
+            prefix.textContent = skeleton.prefix;
+            code.appendChild(prefix);
+
+            parameters.forEach((parameter, index) => {
+                if (index > 0) {
+                    const sep = el("span", "cm-lit");
+                    sep.textContent = ", ";
+                    code.appendChild(sep);
+                }
+                const field = makeField(parameter, updatePreview);
+                field.el.title = parameter.description;
+                code.appendChild(field.el);
+                fields.push(field);
+            });
+
+            if (skeleton.suffix) {
+                const suffix = el("span", "cm-lit");
+                suffix.textContent = skeleton.suffix;
+                code.appendChild(suffix);
+            }
+            callEl.appendChild(code);
+
+            if (parameters.length === 0) {
+                const empty = el("span", "cm-empty");
+                empty.textContent = "（无参数）";
+                callEl.appendChild(empty);
+            }
+
+            updatePreview();
+        }
+
+        function updateSuggestions(): void {
+            clearSuggest();
+            for (const method of searchMethods(queryEl.value)) {
+                const item = el("li", "cm-suggest-item");
+                const nameSpan = el("span", "cm-suggest-name");
+                nameSpan.textContent = method.name;
+                const descSpan = el("span", "cm-suggest-desc");
+                descSpan.textContent = method.shortDescription || method.description;
+                item.appendChild(nameSpan);
+                item.appendChild(descSpan);
+                item.addEventListener("mousedown", (event) => {
+                    event.preventDefault();
+                    selectMethod(method);
+                });
+                suggestEl.appendChild(item);
+            }
+        }
+
+        queryEl.addEventListener("input", () => {
+            updateSuggestions();
+            selectedEl.hidden = true;
+        });
+        queryEl.addEventListener("focus", updateSuggestions);
+        queryEl.addEventListener("blur", () => {
+            window.setTimeout(clearSuggest, 120);
+        });
+
+        if (queryEl.value) {
+            updateSuggestions();
+        }
+    }
+
+    function initAll(): void {
+        document.querySelectorAll<HTMLElement>(".custommethods-search").forEach((container) => renderContainer(container));
+    }
+
+    function register(): void {
+        const docsify = (window as any).$docsify;
+        if (docsify) {
+            docsify.plugins = ([] as any[]).concat(docsify.plugins, (hook: any) => {
+                hook.doneEach(() => initAll());
+            });
+        } else if (document.readyState === "loading") {
+            document.addEventListener("DOMContentLoaded", () => initAll());
+        } else {
+            initAll();
+        }
+    }
+
+    (window as any).CustomMethodSearch = {
+        search: searchMethods,
+        editDistance,
+        renderAll: initAll,
+        strategies,
+        getMethods: () => methods,
+        setMethods: (list: Method[]) => { methods = list; initAll(); },
+        Parameter,
+        ParameterType,
+        Method,
+        MethodType,
+        Mod,
+        Surgery,
+        CommentMethod,
+        InkMethod,
+        CustomMethods,
+        VariableMethod,
+        ConditionMethod,
+        CustomClassMethod,
+    };
+
+    if (document.readyState === "loading") {
+        document.addEventListener("DOMContentLoaded", register);
+    } else {
+        register();
+    }
+})();

script/rdtkview.d.ts

@@ -0,0 +1,27 @@
+export declare class IconStyle {
+    enabled: boolean;
+    active: boolean;
+    hover: boolean;
+    scale: number;
+    showDuration: boolean;
+}
+
+export interface HTMLLayerElement extends HTMLDivElement {
+    onStateChange?: (style: IconStyle) => void;
+    filterData: unknown;
+    updateFilter: () => void;
+}
+
+export interface HTMLEventElement extends HTMLDivElement {
+    onStateChange: (style: IconStyle) => void;
+    eventStyle: IconStyle;
+    eventData: object;
+    moveTo: (x: number, y: number) => void;
+}
+
+export declare function createElementEvent(
+    obj: any,
+    style: IconStyle,
+): HTMLEventElement | null;
+
+export declare function colorOf(tab: string): any;

script/rdview-init.js

@@ -0,0 +1,5 @@
+import "./rdview.js";
+import "./rdtkview_render.js";
+import "./rdview_render.js";
+
+window.loadRDView();

script/rdview_render.js

@@ -0,0 +1,30 @@
+window.$docsify.plugins = [].concat(window.$docsify.plugins, (hook) => {
+    hook.doneEach(() => {
+        if (typeof window.RDViewRender !== "function") {
+            return;
+        }
+        const codeBlocks = document.querySelectorAll("pre[data-lang]");
+        codeBlocks.forEach((codeBlock) => {
+            const lang = codeBlock.getAttribute("data-lang") || "";
+            if (!lang.trim().startsWith("rdview")) {
+                return;
+            }
+            const codeEl = codeBlock.querySelector("code");
+            const code = codeEl ? codeEl.innerText : codeBlock.innerText;
+            let node;
+            try {
+                node = window.RDViewRender(lang, code);
+            } catch (e) {
+                console.error("rdview render failed:", lang, e);
+                return;
+            }
+            if (!node) {
+                return;
+            }
+            const parent = document.createElement("div");
+            parent.className = "rdtk-rdview-wrap";
+            parent.appendChild(node);
+            codeBlock.replaceWith(parent);
+        });
+    });
+});

script/special.js

@@ -6,16 +6,16 @@ let rowx;
 let columny;
 
 let positions = {
-    "c1": { "x": 64, "name": "第一拍" },
-    "c2": { "x": 88, "name": "第二拍" },
-    "c3": { "x": 112, "name": "第三拍" },
-    "c4": { "x": 136, "name": "第四拍" },
-    "c5": { "x": 160, "name": "第五拍" },
-    "c6": { "x": 184, "name": "第六拍" },
-    "c7": { "x": 249, "name": "第七拍" },
+    "c1": { "x": 66, "name": "第一拍" },
+    "c2": { "x": 90, "name": "第二拍" },
+    "c3": { "x": 114, "name": "第三拍" },
+    "c4": { "x": 138, "name": "第四拍" },
+    "c5": { "x": 162, "name": "第五拍" },
+    "c6": { "x": 186, "name": "第六拍" },
+    "c7": { "x": 251, "name": "第七拍" },
     "ccharacter": { "x": 35, "name": "角色" },
     "ccenter": { "x": 176, "name": "中心" },
-    "cheart": { "x": 317, "name": "心" },
+    "cheart": { "x": 315, "name": "心" },
     "r1": { "y": 162, "name": "四轨时的第四轨" },
     "r2": { "y": 141, "name": "三轨时的第三轨" },
     "r3": { "y": 120, "name": "二轨时的第一轨/四轨时的第三轨" },
@@ -228,7 +228,7 @@ function rdview() {
     function initCanvas() {
         const lang = textarea.value.split("\n")[0];
         const code = textarea.value.split("\n").slice(1).join("\n");
-        rdcanvas.innerHTML = RDViewRender(lang, code);
+        rdcanvas.replaceChildren(RDViewRender(lang, code));
     }
     initCanvas();
     initLineNumbers();
@@ -322,55 +322,52 @@ function rdview2() {
         }
         const eventStyle = { "scale": 2.0, "showDuration": false };
         let maxy = 0;
-        const elemPromises = [];
+        const elems = [];
         for (let obj of objs) {
             const style = { ...eventStyle, enabled: obj.active ?? true };
-            const elem = createElementEvent(obj, style).then((elem) => {
-                elem.eventStyle = style;
-                elem.style.position = "absolute";
-                elem.style.left = `${
-                    ((((obj.bar ?? 1) - 1) * 8) + (obj.beat ?? 1) - 1) * 14 *
-                    eventStyle.scale
-                }px`;
-                elem.style.top = `${
-                    (obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale
-                }px`;
-                if (
-                    ((obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale) +
-                            elem.offsetHeight > maxy
-                ) {
-                    maxy = ((obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale) +
-                        elem.offsetHeight;
-                }
-                elem.addEventListener("mousedown", (event) => {
-                    const eStyle = elem.eventStyle;
-                    eStyle.active = true;
-                    elem.onStateChange(eStyle);
-                });
-                elem.addEventListener("mouseover", (event) => {
-                    const eStyle = elem.eventStyle;
-                    eStyle.hover = true;
-                    elem.onStateChange(eStyle);
-                });
-                elem.addEventListener("mouseout", (event) => {
-                    const eStyle = elem.eventStyle;
-                    eStyle.hover = false;
-                    eStyle.active = false;
-                    elem.onStateChange(eStyle);
-                });
-                elem.addEventListener("mouseup", (event) => {
-                    const eStyle = elem.eventStyle;
-                    eStyle.active = false;
-                    elem.onStateChange(eStyle);
-                });
-                return elem;
+            const elem = createElementEvent(obj, style);
+            if (!elem) continue;
+            elem.eventStyle = style;
+            elem.style.position = "absolute";
+            elem.style.left = `${
+                ((((obj.bar ?? 1) - 1) * 8) + (obj.beat ?? 1) - 1) * 14 *
+                eventStyle.scale
+            }px`;
+            elem.style.top = `${
+                (obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale
+            }px`;
+            if (
+                ((obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale) +
+                        elem.offsetHeight > maxy
+            ) {
+                maxy = ((obj.y ?? obj.row ?? 0) * 14 * eventStyle.scale) +
+                    elem.offsetHeight;
+            }
+            elem.addEventListener("mousedown", (event) => {
+                const eStyle = elem.eventStyle;
+                eStyle.active = true;
+                elem.onStateChange(eStyle);
             });
-            elemPromises.push(elem);
+            elem.addEventListener("mouseover", (event) => {
+                const eStyle = elem.eventStyle;
+                eStyle.hover = true;
+                elem.onStateChange(eStyle);
+            });
+            elem.addEventListener("mouseout", (event) => {
+                const eStyle = elem.eventStyle;
+                eStyle.hover = false;
+                eStyle.active = false;
+                elem.onStateChange(eStyle);
+            });
+            elem.addEventListener("mouseup", (event) => {
+                const eStyle = elem.eventStyle;
+                eStyle.active = false;
+                elem.onStateChange(eStyle);
+            });
+            elems.push(elem);
         }
-        Promise.all(elemPromises).then((elems) => {
-            elems.forEach((elem) => {
-                rdcanvas.appendChild(elem);
-            });
+        elems.forEach((elem) => {
+            rdcanvas.appendChild(elem);
         });
         rdcanvas.style.position = "relative";
         rdcanvas.style.height = `${maxy + 4 * 14 * eventStyle.scale}px`;

script/tsconfig.json

@@ -3,10 +3,11 @@
         "target": "es2015",
         "lib": [
             "es2017",
-            "dom"
+            "dom",
+            "dom.iterable"
         ],
-        "module": "es6",
-        "moduleResolution": "node",
+        "module": "esnext",
+        "moduleResolution": "bundler",
         "strict": true,
         "esModuleInterop": true,
         "skipLibCheck": true,
@@ -14,6 +15,7 @@
         "resolveJsonModule": true
     },
     "files": [
-        "rdview.ts"
+        "rdview.ts",
+        "custommethod-search.ts"
     ],
 }

style/rdview-rdtk.css

@@ -0,0 +1,66 @@
+.rdtk-rdview-wrap {
+    margin: 0;
+}
+
+.rdtk-rdview {
+    position: relative;
+    overflow: visible;
+}
+
+.rdtk-event {
+    position: absolute;
+    cursor: pointer;
+    z-index: 0;
+    transition: transform 0.3s, filter 0.3s;
+}
+
+.rdtk-event.hover {
+    z-index: 2;
+}
+
+.rdtk-group {
+    position: absolute;
+    outline-style: solid;
+    outline-width: 2px;
+    transition: transform 0.3s, filter 0.3s, outline-color 0.3s;
+}
+
+.rdtk-group.hover {
+    z-index: 1;
+}
+
+.rdtk-condition {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 12px;
+    height: 12px;
+    background-size: contain;
+    background-repeat: no-repeat;
+    pointer-events: none;
+    z-index: 5;
+}
+
+.rdtk-condition.condition-true {
+    background-image: url(./assets/condition-true.png);
+}
+
+.rdtk-condition.condition-false {
+    background-image: url(./assets/condition-false.png);
+}
+
+.rdtk-condition.condition-both {
+    background-image: url(./assets/condition-both.png);
+}
+
+.rdtk-unknown {
+    color: red;
+    font-weight: bold;
+    font-size: 12px;
+}
+
+.rdtk-error {
+    color: red;
+    font-weight: bold;
+    white-space: pre-wrap;
+}

style/special.css

@@ -266,4 +266,315 @@ div.decoration-depth {
             }
         }
     }
+}
+
+div.custommethods-search {
+    position: relative;
+    margin: 16px 0;
+
+    & .cm-search {
+        position: relative;
+    }
+
+    & .cm-query {
+        box-sizing: border-box;
+        width: 100%;
+        padding: 8px 12px;
+        font-family: d9c, d9, monospace;
+        font-size: 15px;
+        color: inherit;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 6px;
+
+        &:focus {
+            outline: none;
+            border-color: #3b8e59;
+        }
+    }
+
+    & .cm-suggest {
+        position: absolute;
+        left: 0;
+        right: 0;
+        top: calc(100% + 4px);
+        z-index: 30;
+        margin: 0;
+        padding: 4px;
+        list-style: none;
+        max-height: 260px;
+        overflow-y: auto;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 6px;
+        box-shadow: 0 8px 20px rgba(0, 0, 0, 0.18);
+
+        &:empty {
+            display: none;
+        }
+    }
+
+    & .cm-suggest-item {
+        display: flex;
+        justify-content: space-between;
+        align-items: baseline;
+        gap: 12px;
+        padding: 6px 8px;
+        border-radius: 4px;
+        cursor: pointer;
+
+        &:hover {
+            background-color: rgba(127, 127, 127, 0.16);
+        }
+    }
+
+    & .cm-suggest-name {
+        font-family: d9c, d9, monospace;
+    }
+
+    & .cm-suggest-desc {
+        font-size: 12px;
+        opacity: 0.6;
+        text-align: right;
+    }
+
+    & .cm-selected {
+        position: relative;
+        margin-top: 10px;
+        padding: 12px;
+        border: 1px solid var(--background-border-color);
+        border-radius: 6px;
+        background-color: rgba(127, 127, 127, 0.06);
+    }
+
+    & .cm-head {
+        display: flex;
+        align-items: baseline;
+        gap: 10px;
+        margin-bottom: 10px;
+        padding-right: 56px;
+    }
+
+    & .cm-name {
+        font-family: d9c, d9, monospace;
+        font-weight: bold;
+    }
+
+    & .cm-desc {
+        font-size: 12px;
+        opacity: 0.6;
+    }
+
+    & .cm-row {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 12px;
+    }
+
+    & .cm-param {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+    }
+
+    & .cm-param-name {
+        font-family: d9c, d9, monospace;
+        font-size: 13px;
+        opacity: 0.8;
+    }
+
+    & .cm-input {
+        padding: 4px 6px;
+        font-size: 14px;
+        color: inherit;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 4px;
+
+        &:focus {
+            outline: none;
+            border-color: #3b8e59;
+        }
+    }
+
+    & select.cm-input {
+        min-width: 90px;
+    }
+
+    & input.cm-input[type="number"] {
+        width: 96px;
+    }
+
+    & input.cm-input[type="text"] {
+        width: 150px;
+    }
+
+    & .cm-preview {
+        display: block;
+        margin-top: 12px;
+        padding: 8px 10px;
+        font-family: d9c, d9, monospace;
+        white-space: pre-wrap;
+        word-break: break-all;
+        background-color: rgba(127, 127, 127, 0.12);
+        border-radius: 6px;
+    }
+
+    & .cm-empty {
+        font-size: 13px;
+        opacity: 0.6;
+    }
+
+    & .cm-input.cm-invalid,
+    & .cm-combo.cm-invalid .cm-input {
+        border-color: #e5484d;
+        box-shadow: 0 0 0 1px #e5484d;
+    }
+
+    & .cm-combo {
+        position: relative;
+        display: inline-block;
+    }
+
+    & .cm-combo-input {
+        width: 150px;
+    }
+
+    & .cm-combo-list {
+        position: absolute;
+        top: calc(100% + 2px);
+        left: 0;
+        min-width: 100%;
+        z-index: 40;
+        margin: 0;
+        padding: 4px;
+        list-style: none;
+        max-height: 200px;
+        overflow-y: auto;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 4px;
+        box-shadow: 0 6px 16px rgba(0, 0, 0, 0.18);
+    }
+
+    & .cm-combo-item {
+        padding: 4px 8px;
+        border-radius: 3px;
+        cursor: pointer;
+
+        &:hover {
+            background-color: rgba(127, 127, 127, 0.16);
+        }
+    }
+
+    & .cm-copy {
+        position: absolute;
+        top: 8px;
+        right: 8px;
+        padding: 2px 10px;
+        font-size: 12px;
+        color: inherit;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 10px;
+        cursor: pointer;
+
+        &:hover {
+            color: #3b8e59;
+            border-color: #3b8e59;
+        }
+    }
+
+    & .cm-options {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 12px;
+        margin-top: 6px;
+        font-size: 12px;
+    }
+
+    & .cm-option {
+        display: inline-flex;
+        align-items: center;
+        gap: 4px;
+        opacity: 0.85;
+    }
+
+    & .cm-option-select {
+        padding: 2px 4px;
+        font-size: 12px;
+        color: inherit;
+        background-color: var(--background-color);
+        border: 1px solid var(--background-border-color);
+        border-radius: 4px;
+    }
+
+    & .cm-short {
+        font-size: 12px;
+        opacity: 0.7;
+    }
+
+    & .cm-call {
+        margin-top: 8px;
+    }
+
+    & .cm-code {
+        display: inline-flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 4px;
+        padding: 8px 10px;
+        font-family: d9c, d9, monospace;
+        background-color: rgba(127, 127, 127, 0.12);
+        border-radius: 6px;
+    }
+
+    & .cm-lit {
+        font-family: d9c, d9, monospace;
+        opacity: 0.85;
+        white-space: pre;
+    }
+
+    & .cm-field {
+        display: inline-flex;
+        align-items: center;
+        gap: 3px;
+
+        & [hidden] {
+            display: none !important;
+        }
+    }
+
+    & .cm-field.cm-invalid .cm-input {
+        border-color: #e5484d;
+        box-shadow: 0 0 0 1px #e5484d;
+    }
+
+    & .cm-check {
+        width: auto;
+    }
+
+    & .cm-desc {
+        margin-top: 8px;
+        font-size: 12px;
+        line-height: 1.5;
+        opacity: 0.75;
+        white-space: pre-wrap;
+    }
+
+    & .cm-mode {
+        padding: 1px 6px;
+        font-size: 11px;
+        color: inherit;
+        background-color: transparent;
+        border: 1px solid var(--background-border-color);
+        border-radius: 8px;
+        cursor: pointer;
+
+        &.is-expression {
+            color: #3b8e59;
+            border-color: #3b8e59;
+        }
+    }
 }

tips.json

@@ -18,7 +18,6 @@
     "如果你的窗口太抖点不到暂停键的话，就按 P 键来暂停吧！",
     
     "单发拍子界面按住Shift + H就能看到巨大爱心拍子~❤",
-    "4-4关的~抖动轨道~用的是自定义方法：wobblyLines = true",
     "关卡内的屏幕像素大小是352*198px",
     "352*198px记住了吗",
     "针管图标的像素大小是19*15或者其整倍数",