From e1b9aa9b0e9b916d9e31fb1933680c9a4bbdf804 Mon Sep 17 00:00:00 2001
From: unamed <1319491857@qq.com>
Date: Wed, 2 Feb 2022 01:55:41 +0800
Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=90=AF=E5=8A=A8=E6=9C=8D?=
=?UTF-8?q?=E5=8A=A1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
_codelab/index.html | 2 +-
_docs/index.html | 2 +-
_server/CodeMirror/defs.js | 1586 ++++++++++++++++++------------------
libs/core.js | 3 -
project/functions.js | 2 +-
runtime.d.ts | 2 +-
启动服务.exe | Bin 57344 -> 59904 bytes
7 files changed, 797 insertions(+), 800 deletions(-)
diff --git a/_codelab/index.html b/_codelab/index.html
index 9a1b71be..88d16c89 100644
--- a/_codelab/index.html
+++ b/_codelab/index.html
@@ -1,5 +1,5 @@
-
+
HTML5魔塔样板JS进阶
diff --git a/_docs/index.html b/_docs/index.html
index 25223a72..3ef02834 100644
--- a/_docs/index.html
+++ b/_docs/index.html
@@ -1,5 +1,5 @@
-
+
HTML5魔塔样板
diff --git a/_server/CodeMirror/defs.js b/_server/CodeMirror/defs.js
index 9eb4de71..3174be5f 100644
--- a/_server/CodeMirror/defs.js
+++ b/_server/CodeMirror/defs.js
@@ -294,7 +294,7 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
},
"title": {
"!type": "string",
- "!doc":" \"\u5efa\u7acb\u5f53\u9f20\u6807\u60ac\u505c\u5728\u663e\u793a\u7684\u8282\u70b9\u4e0a\u65f6\u5728\"\u5de5\u5177\u63d0\u793a\"\u5f39\u51fa\u7a97\u53e3\u4e2d\u663e\u793a\u7684\u6587\u672c.\","
+ "!doc": " \"\u5efa\u7acb\u5f53\u9f20\u6807\u60ac\u505c\u5728\u663e\u793a\u7684\u8282\u70b9\u4e0a\u65f6\u5728\"\u5de5\u5177\u63d0\u793a\"\u5f39\u51fa\u7a97\u53e3\u4e2d\u663e\u793a\u7684\u6587\u672c.\","
},
"width": {
"!type": "number",
@@ -966,7 +966,7 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
},
"isSafeInteger": {
"!type": "fn(testValue: ?) -> bool",
- "!doc": " Number.isSafeInteger()方法确定所提供的值是否是一个安全整数的数字.安全整数是该数字的整数." ,
+ "!doc": " Number.isSafeInteger()方法确定所提供的值是否是一个安全整数的数字.安全整数是该数字的整数.",
},
"parseFloat": {
"!type": "fn(string: string) -> number",
@@ -1197,11 +1197,11 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
},
"log10": {
"!type": "fn(x: number) -> number",
- "!doc": " Math.log10()函数返回数字的以10为底的对数." ,
+ "!doc": " Math.log10()函数返回数字的以10为底的对数.",
},
"log2": {
"!type": "fn(x: number) -> number",
- "!doc": " Math.log2()函数返回数字的以2为底的对数." ,
+ "!doc": " Math.log2()函数返回数字的以2为底的对数.",
},
"sign": {
"!type": "fn(x: number) -> number",
@@ -1249,19 +1249,19 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "number",
"!doc": "当前难度编号"
},
- "hatred":{
+ "hatred": {
"!type": "number",
"!doc": "当前仇恨值"
},
- "poison":{
+ "poison": {
"!type": "bool",
"!doc": "是否处于中毒状态"
},
- "weak":{
+ "weak": {
"!type": "number",
"!doc": "是否处于衰弱状态"
},
- "curse":{
+ "curse": {
"!type": "number",
"!doc": "是否处于诅咒状态"
},
@@ -1609,7 +1609,7 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!doc": "固伤值"
},
},
- "item":{
+ "item": {
"!doc": "道具信息",
"id": {
"!type": "string",
@@ -2132,59 +2132,59 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"control": {
"!doc": "负责整个游戏的核心控制系统，分为如下几个部分：
- requestAnimationFrame相关
- 标题界面，开始和重新开始游戏
- 自动寻路和人物行走相关
- 画布、位置、阻激夹域、显伤等相关
- 录像的回放相关
- 存读档，自动存档，同步存档等相关
- 人物属性和状态、位置、变量等相关
- 天气、色调、音乐和音效的播放
- 状态栏和工具栏相关
- 界面resize相关",
"showStatusBar": {
- "!doc": "显示状态栏",
+ "!doc": "显示状态栏",
"!type": "fn()"
- },
+ },
"startReplay": {
- "!doc": "开始播放录像",
+ "!doc": "开始播放录像",
"!type": "fn(list: [string])"
- },
+ },
"triggerReplay": {
- "!doc": "播放或暂停录像回放",
+ "!doc": "播放或暂停录像回放",
"!type": "fn()"
- },
+ },
"screenFlash": {
- "!doc": "画面闪烁
例如：core.screenFlash([255, 0, 0, 1], 3); // 红屏一闪而过
color: 一行三列（第四列视为1）或一行四列（第四列若大于1则会被视为1，第四列若填负数则会被视为0）的颜色数组，必填
time: 单次闪烁时长，实际闪烁效果为先花其三分之一的时间渐变到目标色调，再花剩余三分之二的时间渐变回去
times: 闪烁的总次数，不填或填0都视为1
moveMode: 渐变方式
callback: 闪烁全部完毕后的回调函数，可选",
+ "!doc": "画面闪烁
例如：core.screenFlash([255, 0, 0, 1], 3); // 红屏一闪而过
color: 一行三列（第四列视为1）或一行四列（第四列若大于1则会被视为1，第四列若填负数则会被视为0）的颜色数组，必填
time: 单次闪烁时长，实际闪烁效果为先花其三分之一的时间渐变到目标色调，再花剩余三分之二的时间渐变回去
times: 闪烁的总次数，不填或填0都视为1
moveMode: 渐变方式
callback: 闪烁全部完毕后的回调函数，可选",
"!type": "fn(color: [number], time: number, times?: number, moveMode?: string, callback?: fn())"
- },
+ },
"setCurtain": {
- "!doc": "更改画面色调，不计入存档。如需长期生效请使用core.events._action_setCurtain()函数
例如：core.setCurtain(); // 恢复画面色调，用时四分之三秒
color: 一行三列（第四列视为1）或一行四列（第四列若大于1则会被视为1，第四列若为负数则会被视为0）的颜色数组，不填视为[0, 0, 0, 0]
time: 渐变时间，单位为毫秒。不填视为750ms，负数视为0（无渐变，立即更改）
moveMode: 渐变方式
callback: 更改完毕后的回调函数，可选。事件流中常取core.doAction",
+ "!doc": "更改画面色调，不计入存档。如需长期生效请使用core.events._action_setCurtain()函数
例如：core.setCurtain(); // 恢复画面色调，用时四分之三秒
color: 一行三列（第四列视为1）或一行四列（第四列若大于1则会被视为1，第四列若为负数则会被视为0）的颜色数组，不填视为[0, 0, 0, 0]
time: 渐变时间，单位为毫秒。不填视为750ms，负数视为0（无渐变，立即更改）
moveMode: 渐变方式
callback: 更改完毕后的回调函数，可选。事件流中常取core.doAction",
"!type": "fn(color?: [number], time?: number, moveMode?: string, callback?: fn())"
- },
+ },
"updateDamage": {
- "!doc": "重算并绘制地图显伤
例如：core.updateDamage(); // 更新当前地图的显伤，绘制在显伤层（废话）
floorId: 地图id，不填视为当前地图。预览地图时填写
ctx: 绘制到的画布，如果填写了就会画在该画布而不是显伤层",
+ "!doc": "注意！请勿使用该函数！请使用core.updateStatusBar()代替！！重算并绘制地图显伤
例如：core.updateDamage(); // 更新当前地图的显伤，绘制在显伤层（废话）
floorId: 地图id，不填视为当前地图。预览地图时填写
ctx: 绘制到的画布，如果填写了就会画在该画布而不是显伤层",
"!type": "fn(floorId?: string, ctx?: string|CanvasRenderingContext2D)"
- },
+ },
"drawDamage": {
"!doc": "仅绘制地图显伤",
"!type": "fn(string|CanvasRenderingContext2D)"
},
"nextX": {
- "!doc": "获取主角面前第n格的横坐标
例如：core.closeDoor(core.nextX(), core.nextY(), 'yellowDoor', core.turnHero); // 在主角面前关上一扇黄门，然后主角顺时针旋转90°
n: 目标格与主角的距离，面前为正数，背后为负数，脚下为0，不填视为1",
+ "!doc": "获取主角面前第n格的横坐标
例如：core.closeDoor(core.nextX(), core.nextY(), 'yellowDoor', core.turnHero); // 在主角面前关上一扇黄门，然后主角顺时针旋转90°
n: 目标格与主角的距离，面前为正数，背后为负数，脚下为0，不填视为1",
"!type": "fn(n?: number) -> number"
- },
+ },
"nextY": {
- "!doc": "获取主角面前第n格的纵坐标
例如：core.jumpHero(core.nextX(2), core.nextY(2)); // 主角向前跃过一格，即跳跃靴道具的使用效果
n: 目标格与主角的距离，面前为正数，背后为负数，脚下为0，不填视为1",
+ "!doc": "获取主角面前第n格的纵坐标
例如：core.jumpHero(core.nextX(2), core.nextY(2)); // 主角向前跃过一格，即跳跃靴道具的使用效果
n: 目标格与主角的距离，面前为正数，背后为负数，脚下为0，不填视为1",
"!type": "fn(n?: number) -> number"
- },
+ },
"clearContinueAutomaticRoute": {
- "!doc": "清空剩下的自动寻路列表",
+ "!doc": "清空剩下的自动寻路列表",
"!type": "fn(callback?: fn())"
- },
+ },
"updateViewport": {
- "!doc": "更新大地图的可见区域",
+ "!doc": "更新大地图的可见区域",
"!type": "fn()"
- },
+ },
"getMappedName": {
- "!doc": "获得映射文件名",
+ "!doc": "获得映射文件名",
"!type": "fn(name: string) -> string"
- },
+ },
"addFlag": {
- "!doc": "增减一个flag变量，等价于 core.setFlag(name, core.getFlag(name, 0) + value)
例如：core.addFlag('hatred', 1); // 增加1点仇恨值
name: 变量名，支持中文
value: 变量的增量",
+ "!doc": "增减一个flag变量，等价于 core.setFlag(name, core.getFlag(name, 0) + value)
例如：core.addFlag('hatred', 1); // 增加1点仇恨值
name: 变量名，支持中文
value: 变量的增量",
"!type": "fn(name: string, value: number)"
- },
+ },
"setFlag": {
- "!doc": "设置一个flag变量
例如：core.setFlag('poison', true); // 令主角中毒
name: 变量名，支持中文
value: 变量的新值，不填或填null视为删除",
+ "!doc": "设置一个flag变量
例如：core.setFlag('poison', true); // 令主角中毒
name: 变量名，支持中文
value: 变量的新值，不填或填null视为删除",
"!type": "fn(name: string, value: ?)"
},
"playSound": {
@@ -2192,407 +2192,407 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(sound: string, pitch?: number, callback?: fn()) -> number"
},
"stopSound": {
- "!doc": "停止播放音效。如果未指定id则停止所有音效，否则只停止指定的音效。",
+ "!doc": "停止播放音效。如果未指定id则停止所有音效，否则只停止指定的音效。",
"!type": "fn(id?: number)"
- },
+ },
"getPlayingSounds": {
"!doc": "获得当前正在播放的所有（指定）音效的id列表
name: 音效名，可用别名；不填代表返回正在播放的全部音效
返回值: 一个列表，每一项为一个正在播放的音效id；可用core.stopSound立刻停止播放",
"!type": "fn(name?: string) -> [number]"
},
"addGameCanvasTranslate": {
- "!doc": "加减画布偏移",
+ "!doc": "加减画布偏移",
"!type": "fn(x?: number, y?: number)"
- },
+ },
"addBuff": {
- "!doc": "增减主角某个属性的百分比修正倍率，加减法叠加和抵消。等价于 core.setBuff(name, core.getBuff(name) + value)
例如：core.addBuff('atk', -0.1); // 主角获得一层“攻击力减一成”的负面效果
name: 属性的英文名，请注意只能用于数值类属性哦，否则随后的乘法会得到NaN
value: 倍率的增量",
+ "!doc": "增减主角某个属性的百分比修正倍率，加减法叠加和抵消。等价于 core.setBuff(name, core.getBuff(name) + value)
例如：core.addBuff('atk', -0.1); // 主角获得一层“攻击力减一成”的负面效果
name: 属性的英文名，请注意只能用于数值类属性哦，否则随后的乘法会得到NaN
value: 倍率的增量",
"!type": "fn(name: string, value: number)"
- },
+ },
"drawHero": {
- "!doc": "绘制主角和跟随者并重置视野到以主角为中心
例如：core.drawHero(); // 原地绘制主角的静止帧并重置视野野
status: 只能为 stop, leftFoot 和 rightFoot，不填用stop。
offset: 相对主角逻辑位置的偏移量，不填视为无偏移。
frame: 绘制的第几帧",
+ "!doc": "绘制主角和跟随者并重置视野到以主角为中心
例如：core.drawHero(); // 原地绘制主角的静止帧并重置视野野
status: 只能为 stop, leftFoot 和 rightFoot，不填用stop。
offset: 相对主角逻辑位置的偏移量，不填视为无偏移。
frame: 绘制的第几帧",
"!type": "fn(status?: string, offset?: number, frame?: number)"
- },
+ },
"pauseBgm": {
- "!doc": "暂停背景音乐的播放",
+ "!doc": "暂停背景音乐的播放",
"!type": "fn()"
- },
+ },
"setBgmSpeed": {
"!doc": "设置背景音乐的播放速度和音调
speed: 播放速度，必须为30-300中间的值。100为正常速度。
usePitch: 是否同时改变音调（部分设备可能不支持）",
"!type": "fn(speed: number, usePitch?: bool)"
},
"setReplaySpeed": {
- "!doc": "设置播放速度",
+ "!doc": "设置播放速度",
"!type": "fn(speed: number)"
- },
+ },
"pauseReplay": {
- "!doc": "暂停播放",
+ "!doc": "暂停播放",
"!type": "fn()"
- },
+ },
"doSL": {
- "!doc": "实际进行存读档事件",
+ "!doc": "实际进行存读档事件",
"!type": "fn(id?: string, type?: string)"
- },
+ },
"setStatus": {
- "!doc": "设置主角的某个属性
例如：core.setStatus('atk', 100); // 设置攻击力为100
name: 属性的英文名，其中'x'、'y'和'direction'会被特殊处理为 core.setHeroLoc(name, value)，其他的会直接对 core.status.hero[name] 赋值
value: 属性的新值",
+ "!doc": "设置主角的某个属性
例如：core.setStatus('atk', 100); // 设置攻击力为100
name: 属性的英文名，其中'x'、'y'和'direction'会被特殊处理为 core.setHeroLoc(name, value)，其他的会直接对 core.status.hero[name] 赋值
value: 属性的新值",
"!type": "fn(name: string, value: number)"
- },
+ },
"setAutomaticRoute": {
- "!doc": "半自动寻路，用于鼠标或手指拖动
例如：core.setAutomaticRoute(0, 0, [{direction: \"right\", x: 4, y: 9}, {direction: \"right\", x: 5, y: 9}]);
destX: 鼠标或手指的起拖点横坐标
destY: 鼠标或手指的起拖点纵坐标
stepPostfix: 拖动轨迹的数组表示，每项为一步的方向和目标点。",
+ "!doc": "半自动寻路，用于鼠标或手指拖动
例如：core.setAutomaticRoute(0, 0, [{direction: \"right\", x: 4, y: 9}, {direction: \"right\", x: 5, y: 9}]);
destX: 鼠标或手指的起拖点横坐标
destY: 鼠标或手指的起拖点纵坐标
stepPostfix: 拖动轨迹的数组表示，每项为一步的方向和目标点。",
"!type": "fn(destX: number, destY: number, stepPostfix: [{x: number, y: number, direction: string}])"
- },
+ },
"setHeroOpacity": {
- "!doc": "改变勇士的不透明度",
+ "!doc": "改变勇士的不透明度",
"!type": "fn(opacity?: number, moveMode?: string, time?: number, callback?: fn())"
- },
+ },
"gatherFollowers": {
- "!doc": "立刻聚集所有的跟随者",
+ "!doc": "立刻聚集所有的跟随者",
"!type": "fn()"
- },
+ },
"getStatus": {
- "!doc": "读取主角的某个属性，不包括百分比修正
例如：core.getStatus('atk'); // 读取主角的攻击力
name: 属性的英文名，其中'x'、'y'和'direction'会被特殊处理为 core.getHeroLoc(name)，其他的会直接读取 core.status.hero[name]",
+ "!doc": "读取主角的某个属性，不包括百分比修正
例如：core.getStatus('atk'); // 读取主角的攻击力
name: 属性的英文名，其中'x'、'y'和'direction'会被特殊处理为 core.getHeroLoc(name)，其他的会直接读取 core.status.hero[name]",
"!type": "fn(name: string) -> number"
- },
+ },
"setHeroLoc": {
- "!doc": "设置勇士位置
值得注意的是，这句话虽然会使勇士改变位置，但并不会使界面重新绘制；
如需立刻重新绘制地图还需调用：core.clearMap('hero'); core.drawHero(); 来对界面进行更新。
例如：core.setHeroLoc('x', 5) // 将勇士当前位置的横坐标设置为5。
name: 要设置的坐标属性
value: 新值
noGather: 是否聚集跟随者",
+ "!doc": "设置勇士位置
值得注意的是，这句话虽然会使勇士改变位置，但并不会使界面重新绘制；
如需立刻重新绘制地图还需调用：core.clearMap('hero'); core.drawHero(); 来对界面进行更新。
例如：core.setHeroLoc('x', 5) // 将勇士当前位置的横坐标设置为5。
name: 要设置的坐标属性
value: 新值
noGather: 是否聚集跟随者",
"!type": "fn(name: string, value: string|number, noGather?: bool)"
- },
+ },
"getLvName": {
- "!doc": "根据级别的数字获取对应的名称，后者定义在全塔属性
例如：core.getLvName(); // 获取主角当前级别的名称，如“下级佣兵”
lv: 级别的数字，不填则视为主角当前的级别
返回值：级别的名称，如果不存在就还是返回数字",
+ "!doc": "根据级别的数字获取对应的名称，后者定义在全塔属性
例如：core.getLvName(); // 获取主角当前级别的名称，如“下级佣兵”
lv: 级别的数字，不填则视为主角当前的级别
返回值：级别的名称，如果不存在就还是返回数字",
"!type": "fn(lv?: number) -> string|number"
- },
+ },
"getNextLvUpNeed": {
"!doc": "获得下次升级需要的经验值。
升级扣除模式下会返回经验差值；非扣除模式下会返回总共需要的经验值。
如果无法进行下次升级，返回null。",
"!type": "fn() -> number"
},
"addStatus": {
- "!doc": "增减主角的某个属性，等价于core.setStatus(name, core.getStatus(name) + value)
例如：core.addStatus('atk', 100'); // 给主角攻击力加100
name: 属性的英文名
value: 属性的增量",
+ "!doc": "增减主角的某个属性，等价于core.setStatus(name, core.getStatus(name) + value)
例如：core.addStatus('atk', 100'); // 给主角攻击力加100
name: 属性的英文名
value: 属性的增量",
"!type": "fn(name: string, value: number)"
- },
+ },
"speedUpReplay": {
- "!doc": "加速播放",
+ "!doc": "加速播放",
"!type": "fn()"
- },
+ },
"loadData": {
- "!doc": "从本地读档",
+ "!doc": "从本地读档",
"!type": "fn(data?: ?, callback?: fn())"
- },
+ },
"debug": {
- "!doc": "开启调试模式, 此模式下可以按Ctrl键进行穿墙, 并忽略一切事件。
此模式下不可回放录像和上传成绩。",
+ "!doc": "开启调试模式, 此模式下可以按Ctrl键进行穿墙, 并忽略一切事件。
此模式下不可回放录像和上传成绩。",
"!type": "fn()"
- },
+ },
"moveOneStep": {
- "!doc": "每移动一格后执行的事件
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "每移动一格后执行的事件
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(callback?: fn())"
- },
+ },
"clearStatus": {
- "!doc": "清除游戏状态和数据",
+ "!doc": "清除游戏状态和数据",
"!type": "fn()"
- },
+ },
"updateFollowers": {
- "!doc": "更新跟随者坐标",
+ "!doc": "更新跟随者坐标",
"!type": "fn()"
- },
+ },
"waitHeroToStop": {
- "!doc": "等待主角停下
例如：core.waitHeroToStop(core.vibrate); // 等待主角停下，然后视野左右抖动1秒
callback: 主角停止后的回调函数",
+ "!doc": "等待主角停下
例如：core.waitHeroToStop(core.vibrate); // 等待主角停下，然后视野左右抖动1秒
callback: 主角停止后的回调函数",
"!type": "fn(callback?: fn())"
- },
+ },
"hideStatusBar": {
- "!doc": "隐藏状态栏
showToolbox: 是否不隐藏竖屏工具栏",
+ "!doc": "隐藏状态栏
showToolbox: 是否不隐藏竖屏工具栏",
"!type": "fn(showToolbox?: bool)"
- },
+ },
"getBuff": {
- "!doc": "读取主角某个属性的百分比修正倍率，初始值为1
例如：core.getBuff('atk'); // 主角当前能发挥出多大比例的攻击力
name: 属性的英文名",
+ "!doc": "读取主角某个属性的百分比修正倍率，初始值为1
例如：core.getBuff('atk'); // 主角当前能发挥出多大比例的攻击力
name: 属性的英文名",
"!type": "fn(name: string) -> number"
- },
+ },
"triggerDebuff": {
"!doc": "获得或移除毒衰咒效果
action: 要获得还是移除，'get'为获得，'remove'为移除
type: 获得或移除的内容（poison/weak/curse），可以为字符串或数组",
"!type": "fn(action: string, type: string|[string])"
},
"setToolbarButton": {
- "!doc": "改变工具栏为按钮1-8",
+ "!doc": "改变工具栏为按钮1-8",
"!type": "fn(useButton?: bool)"
- },
+ },
"getSaves": {
- "!doc": "获得某些存档内容",
+ "!doc": "获得某些存档内容",
"!type": "fn(ids?: ?, callback?: fn())"
- },
+ },
"replay": {
- "!doc": "回放下一个操作",
+ "!doc": "回放下一个操作",
"!type": "fn()"
- },
+ },
"getStatusOrDefault": {
- "!doc": "从status中获得属性，如果不存在则从勇士属性中获取",
+ "!doc": "从status中获得属性，如果不存在则从勇士属性中获取",
"!type": "fn(status?: ?, name?: string)"
- },
+ },
"unregisterReplayAction": {
- "!doc": "注销一个录像行为",
+ "!doc": "注销一个录像行为",
"!type": "fn(name: string)"
- },
+ },
"unregisterWeather": {
"!doc": "注销一个天气",
"!type": "fn(name: string)"
},
"setBuff": {
- "!doc": "设置主角某个属性的百分比修正倍率，初始值为1，
倍率存放在flag: '__'+name+'_buff__' 中
例如：core.setBuff('atk', 0.5); // 主角能发挥出的攻击力减半
name: 属性的英文名，请注意只能用于数值类属性哦，否则随后的乘法会得到NaN
value: 新的百分比修正倍率，不填（效果上）视为1",
+ "!doc": "设置主角某个属性的百分比修正倍率，初始值为1，
倍率存放在flag: '__'+name+'_buff__' 中
例如：core.setBuff('atk', 0.5); // 主角能发挥出的攻击力减半
name: 属性的英文名，请注意只能用于数值类属性哦，否则随后的乘法会得到NaN
value: 新的百分比修正倍率，不填（效果上）视为1",
"!type": "fn(name: string, value: number)"
- },
+ },
"continueAutomaticRoute": {
- "!doc": "继续剩下的自动寻路操作",
+ "!doc": "继续剩下的自动寻路操作",
"!type": "fn()"
},
"setAutoHeroMove": {
- "!doc": "连续行走
例如：core.setAutoHeroMove([{direction: \"up\", step: 1}, {direction: \"left\", step: 3}]); // 上左左左
steps: 压缩的步伐数组，每项表示朝某方向走多少步",
+ "!doc": "连续行走
例如：core.setAutoHeroMove([{direction: \"up\", step: 1}, {direction: \"left\", step: 3}]); // 上左左左
steps: 压缩的步伐数组，每项表示朝某方向走多少步",
"!type": "fn(steps: [?])"
},
"unregisterResize": {
- "!doc": "注销一个resize函数",
+ "!doc": "注销一个resize函数",
"!type": "fn(name: string)"
- },
+ },
"saveAndStopAutomaticRoute": {
- "!doc": "保存剩下的寻路，并停止",
+ "!doc": "保存剩下的寻路，并停止",
"!type": "fn()"
- },
+ },
"hideStartAnimate": {
- "!doc": "淡出标题画面
例如：core.hideStartAnimate(core.startGame); // 淡出标题画面并开始新游戏，跳过难度选择
callback: 标题画面完全淡出后的回调函数",
+ "!doc": "淡出标题画面
例如：core.hideStartAnimate(core.startGame); // 淡出标题画面并开始新游戏，跳过难度选择
callback: 标题画面完全淡出后的回调函数",
"!type": "fn(callback?: fn())"
- },
+ },
"getAllSaves": {
- "!doc": "获得所有存档内容",
+ "!doc": "获得所有存档内容",
"!type": "fn(callback?: fn())"
- },
+ },
"updateHeroIcon": {
- "!doc": "更新状态栏的勇士图标",
+ "!doc": "更新状态栏的勇士图标",
"!type": "fn(name: string)"
- },
+ },
"setMusicBtn": {
- "!doc": "设置音乐图标的显隐状态",
+ "!doc": "设置音乐图标的显隐状态",
"!type": "fn()"
- },
+ },
"isPlaying": {
- "!doc": "游戏是否已经开始",
+ "!doc": "游戏是否已经开始",
"!type": "fn() -> bool"
- },
+ },
"triggerBgm": {
- "!doc": "开启或关闭背景音乐的播放",
+ "!doc": "开启或关闭背景音乐的播放",
"!type": "fn()"
- },
+ },
"moveHero": {
- "!doc": "连续前进，不撞南墙不回头
例如：core.moveHero(); // 连续前进
direction: 可选，如果设置了就会先转身到该方向
callback: 可选，如果设置了就只走一步
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "连续前进，不撞南墙不回头
例如：core.moveHero(); // 连续前进
direction: 可选，如果设置了就会先转身到该方向
callback: 可选，如果设置了就只走一步
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(direction?: string, callback?: fn())"
- },
+ },
"getRealStatusOrDefault": {
- "!doc": "从status中获得实际属性（增幅后的），如果不存在则从勇士属性中获取",
+ "!doc": "从status中获得实际属性（增幅后的），如果不存在则从勇士属性中获取",
"!type": "fn(status?: ?, name?: string)"
- },
+ },
"getStatusLabel": {
"!doc": "获得某个状态的名字，如atk->攻击，def->防御等",
"!type": "fn(name: string) -> string"
},
"removeSave": {
- "!doc": "删除某个存档",
+ "!doc": "删除某个存档",
"!type": "fn(index?: number, callback?: fn())"
- },
+ },
"registerAnimationFrame": {
- "!doc": "注册一个 animationFrame
name: 名称，可用来作为注销使用
needPlaying: 是否只在游戏运行时才执行（在标题界面不执行）
func: 要执行的函数，或插件中的函数名；可接受timestamp（从页面加载完毕到当前所经过的时间）作为参数",
+ "!doc": "注册一个 animationFrame
name: 名称，可用来作为注销使用
needPlaying: 是否只在游戏运行时才执行（在标题界面不执行）
func: 要执行的函数，或插件中的函数名；可接受timestamp（从页面加载完毕到当前所经过的时间）作为参数",
"!type": "fn(name: string, needPlaying: bool, func?: fn(timestamp: number))"
- },
+ },
"getHeroLoc": {
- "!doc": "读取主角的位置和/或朝向
例如：core.getHeroLoc(); // 读取主角的位置和朝向
name: 要读取横坐标还是纵坐标还是朝向还是都读取
返回值：name ? core.status.hero.loc[name] : core.status.hero.loc",
+ "!doc": "读取主角的位置和/或朝向
例如：core.getHeroLoc(); // 读取主角的位置和朝向
name: 要读取横坐标还是纵坐标还是朝向还是都读取
返回值：name ? core.status.hero.loc[name] : core.status.hero.loc",
"!type": "fn(name: string) -> string|number"
},
"stopAutomaticRoute": {
- "!doc": "停止自动寻路操作",
+ "!doc": "停止自动寻路操作",
"!type": "fn()"
- },
+ },
"setWeather": {
- "!doc": "设置天气，不计入存档。如需长期生效请使用core.events._action_setWeather()函数
例如：core.setWeather('fog', 10); // 设置十级大雾天
type: 新天气的类型，不填视为晴天
level: 新天气（晴天除外）的级别，必须为不大于10的正整数，不填视为5",
+ "!doc": "设置天气，不计入存档。如需长期生效请使用core.events._action_setWeather()函数
例如：core.setWeather('fog', 10); // 设置十级大雾天
type: 新天气的类型，不填视为晴天
level: 新天气（晴天除外）的级别，必须为不大于10的正整数，不填视为5",
"!type": "fn(type?: string, level?: number)"
- },
+ },
"updateStatusBar": {
- "!doc": "立刻刷新状态栏和地图显伤
doNotCheckAutoEvents: 是否不检查自动事件",
+ "!doc": "立刻刷新状态栏和地图显伤
doNotCheckAutoEvents: 是否不检查自动事件",
"!type": "fn(doNotCheckAutoEvents?: bool)"
- },
+ },
"autosave": {
- "!doc": "自动存档",
+ "!doc": "自动存档",
"!type": "fn(removeLast?: bool)"
- },
+ },
"clearStatusBar": {
- "!doc": "清空状态栏",
+ "!doc": "清空状态栏",
"!type": "fn()"
- },
+ },
"moveAction": {
- "!doc": "尝试前进一步，如果面前不可被踏入就会直接触发该点事件
请勿直接使用此函数，如有需要请使用「勇士前进一步或撞击」事件
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "尝试前进一步，如果面前不可被踏入就会直接触发该点事件
请勿直接使用此函数，如有需要请使用「勇士前进一步或撞击」事件
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(callback?: fn())"
- },
+ },
"hasFlag": {
- "!doc": "判定一个flag变量是否存在且不为false、0、''、null、undefined和NaN
例如：core.hasFlag('poison'); // 判断主角当前是否中毒
name: 变量名，支持中文
此函数等价于 !!core.getFlag(name)",
+ "!doc": "判定一个flag变量是否存在且不为false、0、''、null、undefined和NaN
例如：core.hasFlag('poison'); // 判断主角当前是否中毒
name: 变量名，支持中文
此函数等价于 !!core.getFlag(name)",
"!type": "fn(name: string) -> bool"
- },
+ },
"rewindReplay": {
- "!doc": "回退到上一个录像节点",
+ "!doc": "回退到上一个录像节点",
"!type": "fn()"
},
"playBgm": {
- "!doc": "播放背景音乐，中途开播但不计入存档且只会持续到下次场景切换。如需长期生效请将背景音乐的文件名赋值给flags.__bgm__
例如：core.playBgm('bgm.mp3', 30); // 播放bgm.mp3，并跳过前半分钟
bgm: 背景音乐的文件名，支持全塔属性中映射前的中文名
startTime: 跳过前多少秒，不填则不跳过",
+ "!doc": "播放背景音乐，中途开播但不计入存档且只会持续到下次场景切换。如需长期生效请将背景音乐的文件名赋值给flags.__bgm__
例如：core.playBgm('bgm.mp3', 30); // 播放bgm.mp3，并跳过前半分钟
bgm: 背景音乐的文件名，支持全塔属性中映射前的中文名
startTime: 跳过前多少秒，不填则不跳过",
"!type": "fn(bgm: string, startTime?: number)"
- },
+ },
"isReplaying": {
- "!doc": "是否正在播放录像",
+ "!doc": "是否正在播放录像",
"!type": "fn() -> bool"
- },
+ },
"isMoving": {
- "!doc": "当前是否正在移动",
+ "!doc": "当前是否正在移动",
"!type": "fn() -> bool"
- },
+ },
"getSaveIndexes": {
- "!doc": "获得所有存在存档的存档位",
+ "!doc": "获得所有存在存档的存档位",
"!type": "fn(callback?: fn())"
- },
+ },
"unlockControl": {
- "!doc": "解锁用户控制行为",
+ "!doc": "解锁用户控制行为",
"!type": "fn()"
- },
+ },
"syncSave": {
- "!doc": "同步存档到服务器",
+ "!doc": "同步存档到服务器",
"!type": "fn(type?: string)"
- },
+ },
"removeFlag": {
- "!doc": "删除某个flag/变量",
+ "!doc": "删除某个flag/变量",
"!type": "fn(name: string)"
- },
+ },
"registerResize": {
- "!doc": "注册一个resize函数
name: 名称，可供注销使用
func: 可以是一个函数，或者是插件中的函数名；可以接受obj参数，详见resize函数。",
+ "!doc": "注册一个resize函数
name: 名称，可供注销使用
func: 可以是一个函数，或者是插件中的函数名；可以接受obj参数，详见resize函数。",
"!type": "fn(name: string, func: fn(obj: ?))"
- },
+ },
"registerWeather": {
"!doc": "注册一个天气
name: 要注册的天气名
initFunc: 当切换到此天气时的初始化；接受level（天气等级）为参数；可用于创建多个节点（如初始化雪花）
frameFunc: 每帧的天气效果变化；可接受timestamp（从页面加载完毕到当前所经过的时间）和level（天气等级）作为参数
天气应当仅在weather层进行绘制，推荐使用core.animateFrame.weather.nodes用于节点信息。",
"!type": "fn(name: string, initFunc: fn(level: number), frameFunc?: fn(timestamp: number, level: number))"
},
"stopReplay": {
- "!doc": "停止播放",
+ "!doc": "停止播放",
"!type": "fn(force?: bool)"
},
"turnHero": {
- "!doc": "主角转向并计入录像，不会导致跟随者聚集，会导致视野重置到以主角为中心
例如：core.turnHero(); // 主角顺时针旋转90°，即单击主角或按下Z键的效果
direction: 主角的新朝向，可为 up, down, left, right, :left, :right, :back 七种之一",
+ "!doc": "主角转向并计入录像，不会导致跟随者聚集，会导致视野重置到以主角为中心
例如：core.turnHero(); // 主角顺时针旋转90°，即单击主角或按下Z键的效果
direction: 主角的新朝向，可为 up, down, left, right, :left, :right, :back 七种之一",
"!type": "fn(direction?: string)"
- },
+ },
"resumeReplay": {
- "!doc": "恢复播放",
+ "!doc": "恢复播放",
"!type": "fn()"
- },
+ },
"resize": {
- "!doc": "屏幕分辨率改变后重新自适应",
+ "!doc": "屏幕分辨率改变后重新自适应",
"!type": "fn()"
},
"getSave": {
- "!doc": "获得某个存档内容",
+ "!doc": "获得某个存档内容",
"!type": "fn(index?: number, callback?: fn(data: ?))"
- },
+ },
"setViewport": {
- "!doc": "设置视野范围
px,py: 左上角相对大地图的像素坐标，不需要为32倍数",
+ "!doc": "设置视野范围
px,py: 左上角相对大地图的像素坐标，不需要为32倍数",
"!type": "fn(px?: number, py?: number)"
- },
+ },
"chooseReplayFile": {
- "!doc": "选择录像文件",
+ "!doc": "选择录像文件",
"!type": "fn()"
- },
+ },
"lockControl": {
- "!doc": "锁定用户控制，常常用于事件处理",
+ "!doc": "锁定用户控制，常常用于事件处理",
"!type": "fn()"
- },
+ },
"updateCheckBlock": {
- "!doc": "更新领域、夹击、阻击的伤害地图",
+ "!doc": "更新领域、夹击、阻击的伤害地图",
"!type": "fn(floorId?: string)"
- },
+ },
"checkBlock": {
- "!doc": "检查并执行领域、夹击、阻击事件",
+ "!doc": "检查并执行领域、夹击、阻击事件",
"!type": "fn()"
- },
+ },
"clearAutomaticRouteNode": {
- "!doc": "清除自动寻路路线",
+ "!doc": "清除自动寻路路线",
"!type": "fn(x?: number, y?: number)"
- },
+ },
"getFlag": {
- "!doc": "读取一个flag变量
name: 变量名，支持中文
defaultValue: 当变量不存在时的返回值，可选（事件流中默认填0）。",
+ "!doc": "读取一个flag变量
name: 变量名，支持中文
defaultValue: 当变量不存在时的返回值，可选（事件流中默认填0）。",
"!type": "fn(name: string, defaultValue?: ?)"
- },
+ },
"getNakedStatus": {
- "!doc": "获得勇士原始属性（无装备和衰弱影响）",
+ "!doc": "获得勇士原始属性（无装备和衰弱影响）",
"!type": "fn(name: string)"
- },
+ },
"nearHero": {
- "!doc": "判定主角是否身处某个点的锯齿领域(取曼哈顿距离)
例如：core.nearHero(6, 6, 6); // 判定主角是否身处点（6，6）的半径为6的锯齿领域
x: 领域的中心横坐标
y: 领域的中心纵坐标
n: 领域的半径，不填视为1",
+ "!doc": "判定主角是否身处某个点的锯齿领域(取曼哈顿距离)
例如：core.nearHero(6, 6, 6); // 判定主角是否身处点（6，6）的半径为6的锯齿领域
x: 领域的中心横坐标
y: 领域的中心纵坐标
n: 领域的半径，不填视为1",
"!type": "fn(x: number, y: number, n?: number) -> bool"
- },
+ },
"stepReplay": {
- "!doc": "单步播放",
+ "!doc": "单步播放",
"!type": "fn()"
- },
+ },
"hasSave": {
- "!doc": "判断某个存档位是否存在存档",
+ "!doc": "判断某个存档位是否存在存档",
"!type": "fn(index?: number) -> bool"
- },
+ },
"showStartAnimate": {
- "!doc": "进入标题画面
例如：core.showStartAnimate(); // 重启游戏但不重置bgm
noAnimate: 可选，true表示不由黑屏淡入而是立即亮屏
callback: 可选，完全亮屏后的回调函数",
+ "!doc": "进入标题画面
例如：core.showStartAnimate(); // 重启游戏但不重置bgm
noAnimate: 可选，true表示不由黑屏淡入而是立即亮屏
callback: 可选，完全亮屏后的回调函数",
"!type": "fn(noAnimate?: bool, callback?: fn())"
- },
+ },
"moveViewport": {
- "!doc": "移动视野范围",
+ "!doc": "移动视野范围",
"!type": "fn(x: number, y: number, moveMode?: string, time?: number, callback?: fn())"
- },
+ },
"syncLoad": {
- "!doc": "从服务器加载存档",
+ "!doc": "从服务器加载存档",
"!type": "fn()"
- },
+ },
"setHeroMoveInterval": {
- "!doc": "设置行走的效果动画",
+ "!doc": "设置行走的效果动画",
"!type": "fn(callback?: fn())"
- },
+ },
"registerReplayAction": {
- "!doc": "注册一个录像行为
name: 自定义名称，可用于注销使用
func: 具体执行录像的函数，可为一个函数或插件中的函数名；
需要接受一个action参数，代表录像回放时的下一个操作
func返回true代表成功处理了此录像行为，false代表没有处理此录像行为。",
+ "!doc": "注册一个录像行为
name: 自定义名称，可用于注销使用
func: 具体执行录像的函数，可为一个函数或插件中的函数名；
需要接受一个action参数，代表录像回放时的下一个操作
func返回true代表成功处理了此录像行为，false代表没有处理此录像行为。",
"!type": "fn(name: string, func: fn(action?: string) -> bool)"
- },
+ },
"checkAutosave": {
- "!doc": "实际将自动存档写入存储",
+ "!doc": "实际将自动存档写入存储",
"!type": "fn()"
- },
+ },
"resumeBgm": {
- "!doc": "恢复背景音乐的播放
resumeTime: 从哪一秒开始恢复播放",
+ "!doc": "恢复背景音乐的播放
resumeTime: 从哪一秒开始恢复播放",
"!type": "fn(resumeTime?: number)"
- },
+ },
"setGameCanvasTranslate": {
- "!doc": "设置大地图的偏移量",
+ "!doc": "设置大地图的偏移量",
"!type": "fn(ctx: string|CanvasRenderingContext2D, x: number, y: number)"
- },
+ },
"checkBgm": {
- "!doc": "检查bgm状态",
+ "!doc": "检查bgm状态",
"!type": "fn()"
- },
+ },
"setDisplayScale": {
"!doc": "设置屏幕放缩",
"!type": "fn(delta: number)"
},
"speedDownReplay": {
- "!doc": "减速播放",
+ "!doc": "减速播放",
"!type": "fn()"
- },
+ },
"getRealStatus": {
- "!doc": "计算主角的某个属性，包括百分比修正
例如：core.getRealStatus('atk'); // 计算主角的攻击力，包括百分比修正。战斗使用的就是这个值
name: 属性的英文名，请注意只能用于数值类属性哦，否则乘法会得到NaN",
+ "!doc": "计算主角的某个属性，包括百分比修正
例如：core.getRealStatus('atk'); // 计算主角的攻击力，包括百分比修正。战斗使用的就是这个值
name: 属性的英文名，请注意只能用于数值类属性哦，否则乘法会得到NaN",
"!type": "fn(name: string)"
- },
+ },
"saveData": {
- "!doc": "存档到本地",
+ "!doc": "存档到本地",
"!type": "fn()"
- },
+ },
"unregisterAnimationFrame": {
- "!doc": "注销一个animationFrame",
+ "!doc": "注销一个animationFrame",
"!type": "fn(name: string)"
- },
+ },
"tryMoveDirectly": {
- "!doc": "尝试瞬移，如果该点有图块/事件/阻激夹域捕则会瞬移到它旁边再走一步（不可踏入的话当然还是触发该点事件），这一步的方向优先和瞬移前主角的朝向一致
例如：core.tryMoveDirectly(6, 0); // 尝试瞬移到地图顶部的正中央，以样板0层为例，实际效果是瞬移到了上楼梯下面一格然后向上走一步并触发上楼事件
destX: 目标点的横坐标
destY: 目标点的纵坐标",
+ "!doc": "尝试瞬移，如果该点有图块/事件/阻激夹域捕则会瞬移到它旁边再走一步（不可踏入的话当然还是触发该点事件），这一步的方向优先和瞬移前主角的朝向一致
例如：core.tryMoveDirectly(6, 0); // 尝试瞬移到地图顶部的正中央，以样板0层为例，实际效果是瞬移到了上楼梯下面一格然后向上走一步并触发上楼事件
destX: 目标点的横坐标
destY: 目标点的纵坐标",
"!type": "fn(destX: number, destY: number)"
- },
+ },
"moveDirectly": {
- "!doc": "瞬间移动",
+ "!doc": "瞬间移动",
"!type": "fn(destX?: number, destY?: number, ignoreSteps?: number)"
},
"clearRouteFolding": {
@@ -2623,113 +2623,113 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!doc": "判定某个独立开关",
"!type": "fn(x: number, y: number, floorId: string, name: string) -> bool"
}
- },
+ },
"icons": {
"!doc": "图标信息",
"getTilesetOffset": {
- "!doc": "根据图块数字或ID获得所在的tileset和坐标信息",
+ "!doc": "根据图块数字或ID获得所在的tileset和坐标信息",
"!type": "fn(id?: string) -> {image: ?, x: number, y: number}"
- },
+ },
"getClsFromId": {
- "!doc": "根据ID获得其图标类型",
+ "!doc": "根据ID获得其图标类型",
"!type": "fn(id?: string) -> string"
- },
+ },
"getAllIconIds": {
- "!doc": "获得所有图标的ID",
+ "!doc": "获得所有图标的ID",
"!type": "fn() -> [string]"
- },
+ },
"getIcons": {
- "!doc": "获得所有图标类型",
+ "!doc": "获得所有图标类型",
"!type": "fn()"
}
- },
+ },
"items": {
"!doc": "道具相关的函数",
"getEquip": {
- "!doc": "检查主角某种类型的装备目前是什么
例如：core.getEquip(1) // 主角目前装备了什么盾牌
equipType: 装备类型，自然数
返回值：装备id，null表示未穿戴",
+ "!doc": "检查主角某种类型的装备目前是什么
例如：core.getEquip(1) // 主角目前装备了什么盾牌
equipType: 装备类型，自然数
返回值：装备id，null表示未穿戴",
"!type": "fn(equipType: number) -> string"
- },
+ },
"loadEquip": {
- "!doc": "尝试穿上某件背包里面的装备并提示
例如：core.loadEquip('sword5') // 尝试装备上背包里面的神圣剑，无回调
equipId: 装备id
callback: 穿戴成功或失败后的回调函数",
+ "!doc": "尝试穿上某件背包里面的装备并提示
例如：core.loadEquip('sword5') // 尝试装备上背包里面的神圣剑，无回调
equipId: 装备id
callback: 穿戴成功或失败后的回调函数",
"!type": "fn(equipId: string, callback?: fn())"
- },
+ },
"itemCount": {
- "!doc": "统计某种道具的持有量
例如：core.itemCount('yellowKey') // 持有多少把黄钥匙
itemId: 道具id
返回值：该种道具的持有量，不包括已穿戴的装备",
+ "!doc": "统计某种道具的持有量
例如：core.itemCount('yellowKey') // 持有多少把黄钥匙
itemId: 道具id
返回值：该种道具的持有量，不包括已穿戴的装备",
"!type": "fn(itemId: string) -> number"
- },
+ },
"getItems": {
- "!doc": "获得所有道具",
+ "!doc": "获得所有道具",
"!type": "fn()"
- },
+ },
"canUseItem": {
- "!doc": "检查能否使用某种道具
例如：core.canUseItem('pickaxe') // 能否使用破墙镐
itemId: 道具id
返回值：true表示可以使用",
+ "!doc": "检查能否使用某种道具
例如：core.canUseItem('pickaxe') // 能否使用破墙镐
itemId: 道具id
返回值：true表示可以使用",
"!type": "fn(itemId: string) -> bool"
- },
+ },
"hasItem": {
- "!doc": "检查主角是否持有某种道具(不包括已穿戴的装备)
例如：core.hasItem('yellowKey') // 主角是否持有黄钥匙
itemId: 道具id
返回值：true表示持有",
+ "!doc": "检查主角是否持有某种道具(不包括已穿戴的装备)
例如：core.hasItem('yellowKey') // 主角是否持有黄钥匙
itemId: 道具id
返回值：true表示持有",
"!type": "fn(itemId: string) -> bool"
- },
+ },
"addItem": {
- "!doc": "静默增减某种道具的持有量 不会更新游戏画面或是显示提示
例如：core.addItem('yellowKey', -2) // 没收两把黄钥匙
itemId: 道具id
itemNum: 增加量，负数表示没收",
+ "!doc": "静默增减某种道具的持有量 不会更新游戏画面或是显示提示
例如：core.addItem('yellowKey', -2) // 没收两把黄钥匙
itemId: 道具id
itemNum: 增加量，负数表示没收",
"!type": "fn(itemId: string, itemNum?: number)"
},
"unloadEquip": {
- "!doc": "脱下某个类型的装备
例如：core.unloadEquip(1) // 卸下盾牌，无回调
equipType: 装备类型编号，自然数
callback: 卸下装备后的回调函数",
+ "!doc": "脱下某个类型的装备
例如：core.unloadEquip(1) // 卸下盾牌，无回调
equipType: 装备类型编号，自然数
callback: 卸下装备后的回调函数",
"!type": "fn(equipType: number, callback?: fn())"
- },
+ },
"quickLoadEquip": {
- "!doc": "快速换装
例如：core.quickLoadEquip(1) // 快速换上1号套装
index: 套装编号，自然数",
+ "!doc": "快速换装
例如：core.quickLoadEquip(1) // 快速换上1号套装
index: 套装编号，自然数",
"!type": "fn(index: number)"
- },
+ },
"getItemEffect": {
- "!doc": "即捡即用类的道具获得时的效果
例如：core.getItemEffect('redPotion', 10) // 执行获得10瓶红血的效果
itemId: 道具id
itemNum: 道具数量，可选，默认为1",
+ "!doc": "即捡即用类的道具获得时的效果
例如：core.getItemEffect('redPotion', 10) // 执行获得10瓶红血的效果
itemId: 道具id
itemNum: 道具数量，可选，默认为1",
"!type": "fn(itemId: string, itemNum?: number)"
- },
+ },
"quickSaveEquip": {
- "!doc": "保存当前套装
例如：core.quickSaveEquip(1) // 将当前套装保存为1号套装
index: 套装编号，自然数",
+ "!doc": "保存当前套装
例如：core.quickSaveEquip(1) // 将当前套装保存为1号套装
index: 套装编号，自然数",
"!type": "fn(index: number)"
- },
+ },
"setItem": {
- "!doc": "设置某种道具的持有量
例如：core.setItem('yellowKey', 3) // 设置黄钥匙为3把
itemId: 道具id
itemNum: 新的持有量，可选，自然数，默认为0",
+ "!doc": "设置某种道具的持有量
例如：core.setItem('yellowKey', 3) // 设置黄钥匙为3把
itemId: 道具id
itemNum: 新的持有量，可选，自然数，默认为0",
"!type": "fn(itemId: string, itemNum?: number)"
- },
+ },
"compareEquipment": {
- "!doc": "比较两件（类型可不同）装备的优劣
例如：core.compareEquipment('sword5', 'shield5') // 比较神圣剑和神圣盾的优劣
compareEquipId: 装备甲的id
beComparedEquipId: 装备乙的id
返回值：两装备的各属性差，甲减乙，0省略",
+ "!doc": "比较两件（类型可不同）装备的优劣
例如：core.compareEquipment('sword5', 'shield5') // 比较神圣剑和神圣盾的优劣
compareEquipId: 装备甲的id
beComparedEquipId: 装备乙的id
返回值：两装备的各属性差，甲减乙，0省略",
"!type": "fn(compareEquipId: string, beComparedEquipId: string) -> {value: ?, percentage: ?}"
- },
+ },
"removeItem": {
- "!doc": "删除某个物品",
+ "!doc": "删除某个物品",
"!type": "fn(itemId?: string, itemNum?: number)"
- },
+ },
"getEquipTypeById": {
- "!doc": "判定某件装备的类型
例如：core.getEquipTypeById('shield5') // 1（盾牌）
equipId: 装备id
返回值：类型编号，自然数",
+ "!doc": "判定某件装备的类型
例如：core.getEquipTypeById('shield5') // 1（盾牌）
equipId: 装备id
返回值：类型编号，自然数",
"!type": "fn(equipId: string) -> number"
- },
+ },
"getEquipTypeByName": {
- "!doc": "根据类型获得一个可用的装备孔",
+ "!doc": "根据类型获得一个可用的装备孔",
"!type": "fn(name?: string)"
- },
+ },
"useItem": {
- "!doc": "使用一个道具
例如：core.useItem('pickaxe', true) // 使用破墙镐，不计入录像，无回调
itemId: 道具id
noRoute: 是否不计入录像，快捷键使用的请填true，否则可省略
callback: 道具使用完毕或使用失败后的回调函数",
+ "!doc": "使用一个道具
例如：core.useItem('pickaxe', true) // 使用破墙镐，不计入录像，无回调
itemId: 道具id
noRoute: 是否不计入录像，快捷键使用的请填true，否则可省略
callback: 道具使用完毕或使用失败后的回调函数",
"!type": "fn(itemId: string, noRoute?: bool, callback?: fn())"
- },
+ },
"hasEquip": {
- "!doc": "检查主角是否穿戴着某件装备
例如：core.hasEquip('sword5') // 主角是否装备了神圣剑
itemId: 装备id
返回值：true表示已装备",
+ "!doc": "检查主角是否穿戴着某件装备
例如：core.hasEquip('sword5') // 主角是否装备了神圣剑
itemId: 装备id
返回值：true表示已装备",
"!type": "fn(itemId: string) -> bool"
- },
+ },
"getItemEffectTip": {
- "!doc": "即捡即用类的道具获得时的额外提示
例如：core.getItemEffectTip(redPotion) // （获得 红血瓶）'，生命+100'
itemId: 道具id
返回值：图块属性itemEffectTip的内容",
+ "!doc": "即捡即用类的道具获得时的额外提示
例如：core.getItemEffectTip(redPotion) // （获得 红血瓶）'，生命+100'
itemId: 道具id
返回值：图块属性itemEffectTip的内容",
"!type": "fn(itemId: string) -> string"
- },
+ },
"canEquip": {
- "!doc": "检查能否穿上某件装备
例如：core.canEquip('sword5', true) // 主角可以装备神圣剑吗，如果不能会有提示
equipId: 装备id
hint: 无法穿上时是否提示（比如是因为未持有还是别的什么原因）
返回值：true表示可以穿上，false表示无法穿上",
+ "!doc": "检查能否穿上某件装备
例如：core.canEquip('sword5', true) // 主角可以装备神圣剑吗，如果不能会有提示
equipId: 装备id
hint: 无法穿上时是否提示（比如是因为未持有还是别的什么原因）
返回值：true表示可以穿上，false表示无法穿上",
"!type": "fn(equipId: string, hint?: bool) -> bool"
},
"setEquip": {
"!doc": "设置某个装备的属性并计入存档
例如：core.setEquip('sword1', 'value', 'atk', 300, '+='); // 设置铁剑的攻击力数值再加300
equipId: 装备id
valueType: 增幅类型，只能是value（数值）或percentage（百分比）
name: 要修改的属性名称，如atk
value: 要修改到的属性数值
operator: 操作符，可选，如+=表示在原始值上增加
prefix: 独立开关前缀，一般不需要",
"!type": "fn(equipId: string, valueType: string, name: string, value: ?, operator?: string, prefix?: string)"
}
- },
+ },
"utils": {
"!doc": "工具函数库，里面有各个样板中使用到的工具函数。",
"scan": {
@@ -2756,326 +2756,326 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(mode?: string) -> fn(t: number) -> number"
},
"clamp": {
- "!doc": "将x限定在[a,b]区间内，注意a和b可交换
例如：core.clamp(1200, 1, 1000); // 1000
x: 原始值，!x为true时x一律视为0
a: 下限值，大于b将导致与b交换
b: 上限值，小于a将导致与a交换",
+ "!doc": "将x限定在[a,b]区间内，注意a和b可交换
例如：core.clamp(1200, 1, 1000); // 1000
x: 原始值，!x为true时x一律视为0
a: 下限值，大于b将导致与b交换
b: 上限值，小于a将导致与a交换",
"!type": "fn(x: number, a: number, b: number) -> number"
- },
+ },
"rand": {
- "!doc": "不支持SL的随机数
例如：1 + core.rand(6); // 随机生成一个小于7的正整数，模拟骰子的效果
num: 填正数表示生成小于num的随机自然数，否则生成小于1的随机正数
返回值：随机数，即使读档也不会改变结果",
+ "!doc": "不支持SL的随机数
例如：1 + core.rand(6); // 随机生成一个小于7的正整数，模拟骰子的效果
num: 填正数表示生成小于num的随机自然数，否则生成小于1的随机正数
返回值：随机数，即使读档也不会改变结果",
"!type": "fn(num?: number) -> number"
- },
+ },
"clone": {
- "!doc": "深拷贝一个对象(函数将原样返回)
例如：core.clone(core.status.hero, (name, value) => (name == 'items' || typeof value == 'number'), false); // 深拷贝主角的属性和道具
data: 待拷贝对象
filter: 过滤器，可选，表示data为数组或对象时拷贝哪些项或属性，true表示拷贝
recursion: 过滤器是否递归，可选。true表示过滤器也被递归
返回值：拷贝的结果，注意函数将原样返回",
+ "!doc": "深拷贝一个对象(函数将原样返回)
例如：core.clone(core.status.hero, (name, value) => (name == 'items' || typeof value == 'number'), false); // 深拷贝主角的属性和道具
data: 待拷贝对象
filter: 过滤器，可选，表示data为数组或对象时拷贝哪些项或属性，true表示拷贝
recursion: 过滤器是否递归，可选。true表示过滤器也被递归
返回值：拷贝的结果，注意函数将原样返回",
"!type": "fn(data?: ?, filter?: fn(name: string, value: ?) -> bool, recursion?: bool)"
- },
+ },
"cloneArray": {
- "!doc": "深拷贝一个1D或2D数组对象
例如：core.cloneArray(core.status.thisMap.map)",
+ "!doc": "深拷贝一个1D或2D数组对象
例如：core.cloneArray(core.status.thisMap.map)",
"!type": "fn(data?: [number]|[[number]]) -> [number]|[[number]]"
- },
+ },
"setLocalForage": {
- "!doc": "往数据库写入一段数据",
+ "!doc": "往数据库写入一段数据",
"!type": "fn(key: string, value?: ?, successCallback?: fn(), errorCallback?: fn())"
- },
+ },
"getGlobal": {
- "!doc": "读取一个全局存储，适用于global:xxx，支持录像。
例如：if (core.getGlobal('一周目已通关', false) === true) core.getItem('dagger'); // 二周目游戏进行到此处时会获得一把屠龙匕首
key: 全局变量名称，支持中文
defaultValue: 可选，当此全局变量不存在或值为null、undefined时，用此值代替
返回值：全局变量的值",
+ "!doc": "读取一个全局存储，适用于global:xxx，支持录像。
例如：if (core.getGlobal('一周目已通关', false) === true) core.getItem('dagger'); // 二周目游戏进行到此处时会获得一把屠龙匕首
key: 全局变量名称，支持中文
defaultValue: 可选，当此全局变量不存在或值为null、undefined时，用此值代替
返回值：全局变量的值",
"!type": "fn(key: string, defaultValue?: ?)"
- },
+ },
"replaceText": {
- "!doc": "将一段文字中的${}（表达式）进行替换。
例如：core.replaceText('衬衫的价格是${status:hp}镑${item:yellowKey}便士。'); // 把主角的生命值和持有的黄钥匙数量代入这句话
text: 模板字符串，可以使用${}计算js表达式，支持“状态、物品、变量、独立开关、全局存储、图块id、图块类型、敌人数据、装备id”等量参与运算
返回值：替换完毕后的字符串",
+ "!doc": "将一段文字中的${}（表达式）进行替换。
例如：core.replaceText('衬衫的价格是${status:hp}镑${item:yellowKey}便士。'); // 把主角的生命值和持有的黄钥匙数量代入这句话
text: 模板字符串，可以使用${}计算js表达式，支持“状态、物品、变量、独立开关、全局存储、图块id、图块类型、敌人数据、装备id”等量参与运算
返回值：替换完毕后的字符串",
"!type": "fn(text: string, prefix?: string) -> string"
- },
+ },
"removeLocalStorage": {
- "!doc": "移除本地存储",
+ "!doc": "移除本地存储",
"!type": "fn(key: string)"
- },
+ },
"unzip": {
- "!doc": "解压一段内容",
+ "!doc": "解压一段内容",
"!type": "fn(blobOrUrl?: ?, success?: fn(data: ?), error?: fn(error: string), convertToText?: bool, onprogress?: fn(loaded: number, total: number))"
- },
+ },
"formatTime": {
- "!doc": "格式化时间",
+ "!doc": "格式化时间",
"!type": "fn(time: number) -> string"
- },
+ },
"readFile": {
- "!doc": "尝试请求读取一个本地文件内容 [异步]
success: 成功后的回调
error: 失败后的回调
readType: 不设置则以文本读取，否则以DataUrl形式读取",
+ "!doc": "尝试请求读取一个本地文件内容 [异步]
success: 成功后的回调
error: 失败后的回调
readType: 不设置则以文本读取，否则以DataUrl形式读取",
"!type": "fn(success?: fn(data: string), error?: fn(message: string), readType?: bool)"
- },
+ },
"readFileContent": {
- "!doc": "文件读取完毕后的内容处理 [异步]",
+ "!doc": "文件读取完毕后的内容处理 [异步]",
"!type": "fn(content: string)"
- },
+ },
"formatDate": {
- "!doc": "格式化日期为字符串",
+ "!doc": "格式化日期为字符串",
"!type": "fn(date: ?) -> string"
- },
+ },
"download": {
- "!doc": "弹窗请求下载一个文本文件
例如：core.download('route.txt', JSON.stringify(core.status.route)); // 弹窗请求下载录像
filename: 文件名
content: 文件内容",
+ "!doc": "弹窗请求下载一个文本文件
例如：core.download('route.txt', JSON.stringify(core.status.route)); // 弹窗请求下载录像
filename: 文件名
content: 文件内容",
"!type": "fn(filename: string, content: string)"
- },
+ },
"encodeBase64": {
- "!doc": "base64加密
例如：core.encodeBase64('abcd'); // 'YWJjZA=='
str: 明文
返回值：密文",
+ "!doc": "base64加密
例如：core.encodeBase64('abcd'); // 'YWJjZA=='
str: 明文
返回值：密文",
"!type": "fn(str: string) -> string"
- },
+ },
"strlen": {
- "!doc": "求字符串的国标码字节数，也可用于等宽字体下文本的宽度测算。请注意样板的默认字体Verdana不是等宽字体
例如：core.strlen('无敌ad'); // 6
str: 待测字符串
返回值：字符串的国标码字节数，每个汉字为2，每个ASCII字符为1",
+ "!doc": "求字符串的国标码字节数，也可用于等宽字体下文本的宽度测算。请注意样板的默认字体Verdana不是等宽字体
例如：core.strlen('无敌ad'); // 6
str: 待测字符串
返回值：字符串的国标码字节数，每个汉字为2，每个ASCII字符为1",
"!type": "fn(str: string) -> number"
- },
+ },
"myprompt": {
- "!doc": "让用户输入一段文字",
+ "!doc": "让用户输入一段文字",
"!type": "fn(hint: string, value: string, callback?: fn(data?: string))"
- },
+ },
"getCookie": {
- "!doc": "访问浏览器cookie",
+ "!doc": "访问浏览器cookie",
"!type": "fn(name: string) -> string"
- },
+ },
"decodeRoute": {
- "!doc": "录像解压的最后一步，即一压的逆过程
例如：core.decodeRoute(core.encodeRoute(core.status.route)); // 一压当前录像再解压-_-|
route: 录像解压倒数第二步的结果，即一压的结果
返回值：原始录像",
+ "!doc": "录像解压的最后一步，即一压的逆过程
例如：core.decodeRoute(core.encodeRoute(core.status.route)); // 一压当前录像再解压-_-|
route: 录像解压倒数第二步的结果，即一压的结果
返回值：原始录像",
"!type": "fn(route: string) -> [string]"
- },
+ },
"formatDate2": {
- "!doc": "格式化日期为最简字符串",
+ "!doc": "格式化日期为最简字符串",
"!type": "fn(date: ?) -> string"
- },
+ },
"unshift": {
- "!doc": "将b（可以是另一个数组）插入数组a的开头，此函数用于弥补a.unshift(b)中b只能是单项的不足。
例如：core.unshift(todo, {type: 'unfollow'}); // 在事件指令数组todo的开头插入“取消所有跟随者”指令
a: 原数组
b: 待插入的新首项或前缀数组
返回值：插入完毕后的新数组，它是改变原数组a本身得到的",
+ "!doc": "将b（可以是另一个数组）插入数组a的开头，此函数用于弥补a.unshift(b)中b只能是单项的不足。
例如：core.unshift(todo, {type: 'unfollow'}); // 在事件指令数组todo的开头插入“取消所有跟随者”指令
a: 原数组
b: 待插入的新首项或前缀数组
返回值：插入完毕后的新数组，它是改变原数组a本身得到的",
"!type": "fn(a: [?], b: ?) -> [?]"
- },
+ },
"same": {
- "!doc": "判定深层相等, 会逐层比较每个元素
例如：core.same(['1', 2], ['1', 2]); // true",
+ "!doc": "判定深层相等, 会逐层比较每个元素
例如：core.same(['1', 2], ['1', 2]); // true",
"!type": "fn(a?: ?, b?: ?) -> bool"
- },
+ },
"setTwoDigits": {
- "!doc": "两位数显示",
+ "!doc": "两位数显示",
"!type": "fn(x: number) -> string"
- },
+ },
"splitImage": {
- "!doc": "等比例切分一张图片
例如：core.splitImage(core.material.images.images['npc48.png'], 32, 48); // 把npc48.png切分成若干32×48px的小人
image: 图片名（支持映射前的中文名）或图片对象（参见上面的例子），获取不到时返回[]
width: 子图的宽度，单位为像素。原图总宽度必须是其倍数，不填视为32
height: 子图的高度，单位为像素。原图总高度必须是其倍数，不填视为正方形
返回值：子图组成的数组，在原图中呈先行后列，从左到右、从上到下排列。",
+ "!doc": "等比例切分一张图片
例如：core.splitImage(core.material.images.images['npc48.png'], 32, 48); // 把npc48.png切分成若干32×48px的小人
image: 图片名（支持映射前的中文名）或图片对象（参见上面的例子），获取不到时返回[]
width: 子图的宽度，单位为像素。原图总宽度必须是其倍数，不填视为32
height: 子图的高度，单位为像素。原图总高度必须是其倍数，不填视为正方形
返回值：子图组成的数组，在原图中呈先行后列，从左到右、从上到下排列。",
"!type": "fn(image?: string|image, width?: number, height?: number) -> [image]"
- },
+ },
"decompress": {
- "!doc": "解压缩一个数据",
+ "!doc": "解压缩一个数据",
"!type": "fn(value: ?)"
- },
+ },
"showWithAnimate": {
- "!doc": "动画显示某对象",
+ "!doc": "动画显示某对象",
"!type": "fn(obj?: ?, speed?: number, callback?: fn())"
- },
+ },
"subarray": {
- "!doc": "判定一个数组是否为另一个数组的前缀，用于录像接续播放。请注意函数名没有大写字母
例如：core.subarray(['ad', '米库', '小精灵', '小破草', '小艾'], ['ad', '米库', '小精灵']); // ['小破草', '小艾']
a: 可能的母数组，不填或比b短将返回null
b: 可能的前缀，不填或比a长将返回null
返回值：如果b不是a的前缀将返回null，否则将返回a去掉此前缀后的剩余数组",
+ "!doc": "判定一个数组是否为另一个数组的前缀，用于录像接续播放。请注意函数名没有大写字母
例如：core.subarray(['ad', '米库', '小精灵', '小破草', '小艾'], ['ad', '米库', '小精灵']); // ['小破草', '小艾']
a: 可能的母数组，不填或比b短将返回null
b: 可能的前缀，不填或比a长将返回null
返回值：如果b不是a的前缀将返回null，否则将返回a去掉此前缀后的剩余数组",
"!type": "fn(a?: [?], b?: [?]) -> [?]|null"
- },
+ },
"turnDirection": {
- "!doc": "计算应当转向某个方向
turn: 转向的方向，可为 up,down,left,right,:left,:right,:back 七种
direction: 当前方向",
+ "!doc": "计算应当转向某个方向
turn: 转向的方向，可为 up,down,left,right,:left,:right,:back 七种
direction: 当前方向",
"!type": "fn(turn: string, direction?: string) -> string"
- },
+ },
"myconfirm": {
- "!doc": "显示确认框，类似core.drawConfirmBox()，但不打断事件流
例如：core.myconfirm('重启游戏？', core.restart); // 弹窗询问玩家是否重启游戏
hint: 弹窗的内容，支持 ${} 语法
yesCallback: 确定后的回调函数
noCallback: 取消后的回调函数，可选",
+ "!doc": "显示确认框，类似core.drawConfirmBox()，但不打断事件流
例如：core.myconfirm('重启游戏？', core.restart); // 弹窗询问玩家是否重启游戏
hint: 弹窗的内容，支持 ${} 语法
yesCallback: 确定后的回调函数
noCallback: 取消后的回调函数，可选",
"!type": "fn(hint: string, yesCallback?: fn(), noCallback?: fn())"
- },
+ },
"calValue": {
- "!doc": "计算一个表达式的值，支持status:xxx等的计算。
例如：core.calValue('status:hp + status:def'); // 计算主角的生命值加防御力
value: 待求值的表达式
prefix: 独立开关前缀，一般可省略
返回值：求出的值",
+ "!doc": "计算一个表达式的值，支持status:xxx等的计算。
例如：core.calValue('status:hp + status:def'); // 计算主角的生命值加防御力
value: 待求值的表达式
prefix: 独立开关前缀，一般可省略
返回值：求出的值",
"!type": "fn(value: string, prefix?: string)"
- },
+ },
"encodeRoute": {
- "!doc": "录像压缩缩
例如：core.encodeRoute(core.status.route); // 压缩当前录像
route: 原始录像，自定义内容（不予压缩，原样写入）必须由0-9A-Za-z和下划线、冒号组成，所以中文和数组需要用JSON.stringify预处理再base64压缩才能交由一压
返回值：一压的结果",
+ "!doc": "录像压缩缩
例如：core.encodeRoute(core.status.route); // 压缩当前录像
route: 原始录像，自定义内容（不予压缩，原样写入）必须由0-9A-Za-z和下划线、冒号组成，所以中文和数组需要用JSON.stringify预处理再base64压缩才能交由一压
返回值：一压的结果",
"!type": "fn(route: [string]) -> string"
- },
+ },
"decodeBase64": {
- "!doc": "base64解密
例如：core.decodeBase64('YWJjZA=='); // \"abcd\"
str: 密文
返回值：明文",
+ "!doc": "base64解密
例如：core.decodeBase64('YWJjZA=='); // \"abcd\"
str: 密文
返回值：明文",
"!type": "fn(str: string) -> string"
- },
+ },
"http": {
- "!doc": "发送一个HTTP请求 [异步]
type: 请求类型，只能为GET或POST
url: 目标地址
formData: 如果是POST请求则为表单数据
success: 成功后的回调
error: 失败后的回调",
+ "!doc": "发送一个HTTP请求 [异步]
type: 请求类型，只能为GET或POST
url: 目标地址
formData: 如果是POST请求则为表单数据
success: 成功后的回调
error: 失败后的回调",
"!type": "fn(type: string, url: string, formData: ?, success?: fn(data: string), error?: fn(message: string), mimeType?: string, responseType?: string, onprogress?: fn(loaded: number, total: number))"
- },
+ },
"getGuid": {
"!doc": "获得或生成浏览器唯一的guid",
"!type": "fn() -> string"
},
"getLocalStorage": {
- "!doc": "获得本地存储",
+ "!doc": "获得本地存储",
"!type": "fn(key: string, defaultValue?: ?)"
- },
+ },
"arrayToRGB": {
- "!doc": "颜色数组转字符串
例如：core.arrayToRGB([102, 204, 255]); // \"#66ccff\"
color: 一行三列的数组，必须为不大于255的自然数
返回值：该颜色的#xxxxxx字符串表示",
+ "!doc": "颜色数组转字符串
例如：core.arrayToRGB([102, 204, 255]); // \"#66ccff\"
color: 一行三列的数组，必须为不大于255的自然数
返回值：该颜色的#xxxxxx字符串表示",
"!type": "fn(color: [number]) -> string"
- },
+ },
"arrayToRGBA": {
- "!doc": "颜色数组转字符串
例如：core.arrayToRGBA([102, 204, 255, 0.3]); // \"rgba(102,204,255,0.3)\"
color: 一行三列或一行四列的数组，前三个元素必须为不大于255的自然数。第四个元素（如果有）必须为0或不大于1的数字，第四个元素不填视为1
返回值：该颜色的rgba(...)字符串表示",
+ "!doc": "颜色数组转字符串
例如：core.arrayToRGBA([102, 204, 255, 0.3]); // \"rgba(102,204,255,0.3)\"
color: 一行三列或一行四列的数组，前三个元素必须为不大于255的自然数。第四个元素（如果有）必须为0或不大于1的数字，第四个元素不填视为1
返回值：该颜色的rgba(...)字符串表示",
"!type": "fn(color: [number]) -> string"
- },
+ },
"formatBigNumber": {
- "!doc": "大数字格式化，单位为10000的倍数（w,e,z,j,g），末尾四舍五入
例如：core.formatBigNumber(123456789, false); // \"12346w\"
x: 原数字
onMap: 可选，true表示用于地图显伤，结果总字符数最多为5，否则最多为6
返回值：格式化结果",
+ "!doc": "大数字格式化，单位为10000的倍数（w,e,z,j,g），末尾四舍五入
例如：core.formatBigNumber(123456789, false); // \"12346w\"
x: 原数字
onMap: 可选，true表示用于地图显伤，结果总字符数最多为5，否则最多为6
返回值：格式化结果",
"!type": "fn(x: number, onMap?: bool) -> string"
- },
+ },
"removeLocalForage": {
- "!doc": "移除本地数据库的数据",
+ "!doc": "移除本地数据库的数据",
"!type": "fn(key: string, successCallback?: fn(), errorCallback?: fn())"
- },
+ },
"matchWildcard": {
- "!doc": "通配符匹配，用于搜索图块等批量处理。
例如：core.playSound(core.matchWildcard('*Key', itemId) ? 'item.mp3' : 'door.mp3'); // 判断捡到的是钥匙还是别的道具，从而播放不同的音效
pattern: 模式串，每个星号表示任意多个（0个起）字符
string: 待测串
返回值：true表示匹配成功，false表示匹配失败",
+ "!doc": "通配符匹配，用于搜索图块等批量处理。
例如：core.playSound(core.matchWildcard('*Key', itemId) ? 'item.mp3' : 'door.mp3'); // 判断捡到的是钥匙还是别的道具，从而播放不同的音效
pattern: 模式串，每个星号表示任意多个（0个起）字符
string: 待测串
返回值：true表示匹配成功，false表示匹配失败",
"!type": "fn(pattern: string, string: string) -> bool"
- },
+ },
"setLocalStorage": {
- "!doc": "设置本地存储",
+ "!doc": "设置本地存储",
"!type": "fn(key: string, value?: ?)"
- },
+ },
"hideWithAnimate": {
- "!doc": "动画使某对象消失",
+ "!doc": "动画使某对象消失",
"!type": "fn(obj?: ?, speed?: number, callback?: fn())"
- },
+ },
"copy": {
- "!doc": "尝试复制一段文本到剪切板。",
+ "!doc": "尝试复制一段文本到剪切板。",
"!type": "fn(data: string) -> bool"
- },
+ },
"isset": {
- "!doc": "判断一个值是否不为null，undefined和NaN
例如：core.isset(0/0); // false，因为0/0等于NaN
v: 待测值，可选
返回值：false表示待测值为null、undefined、NaN或未填写，true表示为其他值。",
+ "!doc": "判断一个值是否不为null，undefined和NaN
例如：core.isset(0/0); // false，因为0/0等于NaN
v: 待测值，可选
返回值：false表示待测值为null、undefined、NaN或未填写，true表示为其他值。",
"!type": "fn(v?: ?) -> bool"
- },
+ },
"replaceValue": {
- "!doc": "对一个表达式中的特殊规则进行替换，如status:xxx等。
例如：core.replaceValue('status:atk+item:yellowKey'); // 把这两个冒号表达式替换为core.getStatus('hp')和core.itemCount('yellowKey')这样的函数调用
value: 模板字符串，注意独立开关不会被替换
返回值：替换完毕后的字符串",
+ "!doc": "对一个表达式中的特殊规则进行替换，如status:xxx等。
例如：core.replaceValue('status:atk+item:yellowKey'); // 把这两个冒号表达式替换为core.getStatus('hp')和core.itemCount('yellowKey')这样的函数调用
value: 模板字符串，注意独立开关不会被替换
返回值：替换完毕后的字符串",
"!type": "fn(value: string) -> string"
- },
+ },
"getLocalForage": {
- "!doc": "从本地数据库读出一段数据",
+ "!doc": "从本地数据库读出一段数据",
"!type": "fn(key: string, defaultValue?: ?, successCallback?: fn(data: ?), errorCallback?: fn())"
- },
+ },
"inArray": {
- "!doc": "判定array是不是一个数组，以及element是否在该数组中。
array: 可能的数组，不为数组或不填将导致返回值为false
element: 待查找的元素
返回值：如果array为数组且具有element这项，就返回true，否则返回false",
+ "!doc": "判定array是不是一个数组，以及element是否在该数组中。
array: 可能的数组，不为数组或不填将导致返回值为false
element: 待查找的元素
返回值：如果array为数组且具有element这项，就返回true，否则返回false",
"!type": "fn(array?: ?, element?: ?) -> bool"
- },
+ },
"setGlobal": {
- "!doc": "设置一个全局存储，适用于global:xxx，录像播放时将忽略此函数。
例如：core.setBlobal('一周目已通关', true); // 设置全局存储“一周目已通关”为true，方便二周目游戏中的新要素。
key: 全局变量名称，支持中文
value: 全局变量的新值，不填或null表示清除此全局存储",
+ "!doc": "设置一个全局存储，适用于global:xxx，录像播放时将忽略此函数。
例如：core.setBlobal('一周目已通关', true); // 设置全局存储“一周目已通关”为true，方便二周目游戏中的新要素。
key: 全局变量名称，支持中文
value: 全局变量的新值，不填或null表示清除此全局存储",
"!type": "fn(key: string, value?: ?)"
- },
+ },
"rand2": {
- "!doc": "支持SL的随机数，并计入录像
例如：1 + core.rand2(6); // 随机生成一个小于7的正整数，模拟骰子的效果
num: 正整数，0或不填会被视为2147483648
返回值：属于 [0, num) 的随机数",
+ "!doc": "支持SL的随机数，并计入录像
例如：1 + core.rand2(6); // 随机生成一个小于7的正整数，模拟骰子的效果
num: 正整数，0或不填会被视为2147483648
返回值：属于 [0, num) 的随机数",
"!type": "fn(num?: number) -> number"
- },
+ },
"setStatusBarInnerHTML": {
- "!doc": "填写非自绘状态栏
例如：core.setStatusBarInnerHTML('hp', core.status.hero.hp, 'color: #66CCFF'); // 更新状态栏中的主角生命，使用加载画面的宣传色
name: 状态栏项的名称，如'hp', 'atk', 'def'等。必须是core.statusBar中的一个合法项
value: 要填写的内容，大数字会被格式化为至多6个字符，无中文的内容会被自动设为斜体
css: 额外的css样式，可选。如更改颜色等",
+ "!doc": "填写非自绘状态栏
例如：core.setStatusBarInnerHTML('hp', core.status.hero.hp, 'color: #66CCFF'); // 更新状态栏中的主角生命，使用加载画面的宣传色
name: 状态栏项的名称，如'hp', 'atk', 'def'等。必须是core.statusBar中的一个合法项
value: 要填写的内容，大数字会被格式化为至多6个字符，无中文的内容会被自动设为斜体
css: 额外的css样式，可选。如更改颜色等",
"!type": "fn(name: string, value: ?, css?: string)"
- },
+ },
"matchRegex": {
- "!doc": "是否满足正则表达式",
+ "!doc": "是否满足正则表达式",
"!type": "fn(pattern: string, string: string) -> string"
- },
+ },
"push": {
- "!doc": "将b（可以是另一个数组）插入数组a的末尾，此函数用于弥补a.push(b)中b只能是单项的不足。
例如：core.push(todo, {type: 'unfollow'}); // 在事件指令数组todo的末尾插入“取消所有跟随者”指令
a: 原数组
b: 待插入的新末项或后缀数组
返回值：插入完毕后的新数组，它是改变原数组a本身得到的",
+ "!doc": "将b（可以是另一个数组）插入数组a的末尾，此函数用于弥补a.push(b)中b只能是单项的不足。
例如：core.push(todo, {type: 'unfollow'}); // 在事件指令数组todo的末尾插入“取消所有跟随者”指令
a: 原数组
b: 待插入的新末项或后缀数组
返回值：插入完毕后的新数组，它是改变原数组a本身得到的",
"!type": "fn(a: [?], b: ?) -> [?]"
- },
+ },
"formatSize": {
- "!doc": "格式化文件大小",
+ "!doc": "格式化文件大小",
"!type": "fn(size: number) -> string"
}
- },
+ },
"actions": {
"!doc": "主要是处理一些和用户交互相关的内容。",
"onup": {
- "!doc": "当点击（触摸）事件放开时",
+ "!doc": "当点击（触摸）事件放开时",
"!type": "fn(loc: {x: number, y: number, size: number})"
- },
+ },
"pressKey": {
- "!doc": "按住某个键时",
+ "!doc": "按住某个键时",
"!type": "fn(keyCode: number)"
- },
+ },
"keyUp": {
- "!doc": "根据放开键的code来执行一系列操作",
+ "!doc": "根据放开键的code来执行一系列操作",
"!type": "fn(keyCode: number, altKey?: bool, fromReplay?: bool)"
- },
+ },
"ondown": {
- "!doc": "点击（触摸）事件按下时",
+ "!doc": "点击（触摸）事件按下时",
"!type": "fn(loc: {x: number, y: number, size: number})"
- },
+ },
"registerAction": {
- "!doc": "此函数将注册一个用户交互行为。
action: 要注册的交互类型，如 ondown, onclick, keyDown 等等。
name: 你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
func: 执行函数。
如果func返回true，则不会再继续执行其他的交互函数；否则会继续执行其他的交互函数。
priority: 优先级；优先级高的将会被执行。此项可不填，默认为0",
+ "!doc": "此函数将注册一个用户交互行为。
action: 要注册的交互类型，如 ondown, onclick, keyDown 等等。
name: 你的自定义名称，可被注销使用；同名重复注册将后者覆盖前者。
func: 执行函数。
如果func返回true，则不会再继续执行其他的交互函数；否则会继续执行其他的交互函数。
priority: 优先级；优先级高的将会被执行。此项可不填，默认为0",
"!type": "fn(action: string, name: string, func: string|fn(params: ?), priority?: number)"
- },
+ },
"onkeyDown": {
- "!doc": "按下某个键时",
+ "!doc": "按下某个键时",
"!type": "fn(e: Event)"
- },
+ },
"keyDown": {
- "!doc": "根据按下键的code来执行一系列操作",
+ "!doc": "根据按下键的code来执行一系列操作",
"!type": "fn(keyCode: number)"
- },
+ },
"onStatusBarClick": {
- "!doc": "点击自绘状态栏时",
+ "!doc": "点击自绘状态栏时",
"!type": "fn(e?: Event)"
- },
+ },
"longClick": {
- "!doc": "长按",
+ "!doc": "长按",
"!type": "fn(x: number, y: number, px: number, py: number, fromEvent?: bool)"
- },
+ },
"unregisterAction": {
- "!doc": "注销一个用户交互行为",
+ "!doc": "注销一个用户交互行为",
"!type": "fn(action: string, name: string)"
- },
+ },
"keyDownCtrl": {
- "!doc": "长按Ctrl键时",
+ "!doc": "长按Ctrl键时",
"!type": "fn() -> bool"
- },
+ },
"onclick": {
- "!doc": "具体点击屏幕上(x,y)点时，执行的操作",
+ "!doc": "具体点击屏幕上(x,y)点时，执行的操作",
"!type": "fn(x: number, y: number, px: number, py: number, stepPostfix?: [?])"
- },
+ },
"doRegisteredAction": {
- "!doc": "执行一个用户交互行为",
+ "!doc": "执行一个用户交互行为",
"!type": "fn(action: string, params: ?)"
- },
+ },
"onkeyUp": {
- "!doc": "放开某个键时",
+ "!doc": "放开某个键时",
"!type": "fn(e: Event)"
- },
+ },
"onmousewheel": {
- "!doc": "滑动鼠标滚轮时的操作",
+ "!doc": "滑动鼠标滚轮时的操作",
"!type": "fn(direct: number)"
- },
+ },
"onmove": {
- "!doc": "当在触摸屏上滑动时",
+ "!doc": "当在触摸屏上滑动时",
"!type": "fn(loc: {x: number, y: number, size: number})"
}
- },
+ },
"loader": {
"!doc": "资源加载相关的函数",
"loadImages": {
- "!doc": "加载一系列图片",
+ "!doc": "加载一系列图片",
"!type": "fn(dir: string, names: [string], toSave: ?, callback?: fn()) "
- },
+ },
"loadImagesFromZip": {
- "!doc": "从zip中加载一系列图片",
+ "!doc": "从zip中加载一系列图片",
"!type": "fn(url: string, names: [string], toSave?: ?, onprogress?: ?, onfinished?: ?)"
- },
+ },
"loadBgm": {
- "!doc": "加载一个bgm",
+ "!doc": "加载一个bgm",
"!type": "fn(name: string)"
- },
+ },
"loadOneMusic": {
- "!doc": "加载一个音乐或音效",
+ "!doc": "加载一个音乐或音效",
"!type": "fn(name: string)"
- },
+ },
"freeBgm": {
- "!doc": "释放一个bgm的缓存",
+ "!doc": "释放一个bgm的缓存",
"!type": "fn(name: string)"
- },
+ },
"loadOneSound": {
- "!doc": "加载一个音效",
+ "!doc": "加载一个音效",
"!type": "fn(name: string)"
- },
+ },
"loadImage": {
- "!doc": "加载某一张图片",
+ "!doc": "加载某一张图片",
"!type": "fn(dir: name, imgName: name, callback?: fn())"
}
- },
+ },
"maps": {
"!doc": "负责一切和地图相关的处理内容，包括如下几个方面：
- 地图的初始化，保存和读取，地图数组的生成
- 是否可移动或瞬间移动的判定
- 地图的绘制
- 获得某个点的图块信息
- 启用和禁用图块，改变图块
- 移动/跳跃图块，淡入淡出图块
- 全局动画控制，动画的绘制",
"noPass": {
- "!doc": "判定某个点是否不可被踏入（不基于主角生命值和图块cannotIn属性）
例如：core.noPass(0, 0); // 判断地图左上角能否被踏入
x: 目标点的横坐标
y: 目标点的纵坐标
floorId: 目标点所在的地图id，不填视为当前地图
返回值：true表示可踏入",
+ "!doc": "判定某个点是否不可被踏入（不基于主角生命值和图块cannotIn属性）
例如：core.noPass(0, 0); // 判断地图左上角能否被踏入
x: 目标点的横坐标
y: 目标点的纵坐标
floorId: 目标点所在的地图id，不填视为当前地图
返回值：true表示可踏入",
"!type": "fn(x: number, y: number, floorId?: string) -> bool"
- },
+ },
"drawAnimate": {
- "!doc": "播放动画，注意即使指定了主角的坐标也不会跟随主角移动，如有需要请使用core.drawHeroAnimate(name, callback)函数
例如：core.drawAnimate('attack', core.nextX(), core.nextY(), false, core.vibrate); // 在主角面前一格播放普攻动画，动画停止后视野左右抖动1秒
name: 动画文件名，不含后缀
x: 横坐标
y: 纵坐标
alignWindow: 是否是相对窗口的坐标
callback: 动画停止后的回调函数，可选
返回值：一个数字，可作为core.stopAnimate()的参数来立即停止播放（届时还可选择是否执行此次播放的回调函数）",
+ "!doc": "播放动画，注意即使指定了主角的坐标也不会跟随主角移动，如有需要请使用core.drawHeroAnimate(name, callback)函数
例如：core.drawAnimate('attack', core.nextX(), core.nextY(), false, core.vibrate); // 在主角面前一格播放普攻动画，动画停止后视野左右抖动1秒
name: 动画文件名，不含后缀
x: 横坐标
y: 纵坐标
alignWindow: 是否是相对窗口的坐标
callback: 动画停止后的回调函数，可选
返回值：一个数字，可作为core.stopAnimate()的参数来立即停止播放（届时还可选择是否执行此次播放的回调函数）",
"!type": "fn(name: string, x: number, y: number, alignWindow: bool, callback?: fn()) -> number"
- },
+ },
"drawHeroAnimate": {
"!doc": "播放跟随勇士的动画
name: 动画名
callback: 动画停止后的回调函数，可选
返回值：一个数字，可作为core.stopAnimate()的参数来立即停止播放（届时还可选择是否执行此次播放的回调函数）",
"!type": "fn(name: string, callback?: fn()) -> number"
@@ -3089,85 +3089,85 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(name?: string) -> [number]"
},
"getBlockCls": {
- "!doc": "判定某个点的图块类型
例如：if(core.getBlockCls(x1, y1) != 'enemys' && core.getBlockCls(x2, y2) != 'enemy48') core.openDoor(x3, y3); // 另一个简单的机关门事件，打败或炸掉这一对不同身高的敌人就开门
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块类型，即“地形、四帧动画、矮敌人、高敌人、道具、矮npc、高npc、自动元件、额外地形”之一",
+ "!doc": "判定某个点的图块类型
例如：if(core.getBlockCls(x1, y1) != 'enemys' && core.getBlockCls(x2, y2) != 'enemy48') core.openDoor(x3, y3); // 另一个简单的机关门事件，打败或炸掉这一对不同身高的敌人就开门
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块类型，即“地形、四帧动画、矮敌人、高敌人、道具、矮npc、高npc、自动元件、额外地形”之一",
"!type": "fn(x: number, y: number, floorId?: string, showDisable?: bool) -> string"
- },
+ },
"drawMap": {
- "!doc": "地图重绘
例如：core.drawMap(); // 重绘当前地图，常用于更改贴图或改变自动元件后的刷新
floorId: 地图id，可省略表示当前楼层
callback: 重绘完毕后的回调函数，可选",
+ "!doc": "地图重绘
例如：core.drawMap(); // 重绘当前地图，常用于更改贴图或改变自动元件后的刷新
floorId: 地图id，可省略表示当前楼层
callback: 重绘完毕后的回调函数，可选",
"!type": "fn(floorId?: string)"
- },
+ },
"nearStair": {
- "!doc": "当前位置是否在楼梯边；在楼传平面塔模式下对箭头也有效",
+ "!doc": "当前位置是否在楼梯边；在楼传平面塔模式下对箭头也有效",
"!type": "fn() -> bool"
- },
+ },
"turnBlock": {
- "!doc": "事件转向",
+ "!doc": "事件转向",
"!type": "fn(direction?: string, x?: number, y?: number, floorId?: string)"
- },
+ },
"getMapArray": {
- "!doc": "生成事件层矩阵
例如：core.getMapArray('MT0'); // 生成主塔0层的事件层矩阵，隐藏的图块视为0
floorId: 地图id，不填视为当前地图
showDisable: 可选，true表示隐藏的图块也会被表示出来
返回值：事件层矩阵，注意对其阵元的访问是[y][x]",
+ "!doc": "生成事件层矩阵
例如：core.getMapArray('MT0'); // 生成主塔0层的事件层矩阵，隐藏的图块视为0
floorId: 地图id，不填视为当前地图
showDisable: 可选，true表示隐藏的图块也会被表示出来
返回值：事件层矩阵，注意对其阵元的访问是[y][x]",
"!type": "fn(floorId?: string, noCache?: bool) -> [[number]]"
- },
+ },
"getMapNumber": {
"!doc": "获得事件层某个点的数字",
"!type": "fn(x: number, y: number, floorId?: string, noCache?: bool) -> number"
},
"jumpBlock": {
- "!doc": "跳跃图块；从V2.7开始不再有音效
例如：core.jumpBlock(0, 0, 0, 0); // 令地图左上角的图块原地跳跃半秒，再花半秒淡出
sx: 起点的横坐标
sy: 起点的纵坐标
ex: 终点的横坐标
ey: 终点的纵坐标
time: 单步和淡出用时，单位为毫秒。不填视为半秒
keep: 是否不淡出，true表示不淡出
callback: 落地或淡出后的回调函数，可选",
+ "!doc": "跳跃图块；从V2.7开始不再有音效
例如：core.jumpBlock(0, 0, 0, 0); // 令地图左上角的图块原地跳跃半秒，再花半秒淡出
sx: 起点的横坐标
sy: 起点的纵坐标
ex: 终点的横坐标
ey: 终点的纵坐标
time: 单步和淡出用时，单位为毫秒。不填视为半秒
keep: 是否不淡出，true表示不淡出
callback: 落地或淡出后的回调函数，可选",
"!type": "fn(sx: number, sy: number, ex: number, ey: number, time?: number, keep?: bool, callback?: fn())"
- },
+ },
"replaceBlock": {
- "!doc": "批量替换图块
例如：core.replaceBlock(21, 22, core.floorIds); // 把游戏中地上当前所有的黄钥匙都变成蓝钥匙
fromNumber: 旧图块的数字
toNumber: 新图块的数字
floorId: 地图id或其数组，不填视为当前地图",
+ "!doc": "批量替换图块
例如：core.replaceBlock(21, 22, core.floorIds); // 把游戏中地上当前所有的黄钥匙都变成蓝钥匙
fromNumber: 旧图块的数字
toNumber: 新图块的数字
floorId: 地图id或其数组，不填视为当前地图",
"!type": "fn(fromNumber: number, toNumber: number, floorId?: string|[string])"
- },
+ },
"drawBlock": {
- "!doc": "绘制一个图块",
+ "!doc": "绘制一个图块",
"!type": "fn(block?: block, animate?: number)"
- },
+ },
"resetMap": {
- "!doc": "重置地图",
+ "!doc": "重置地图",
"!type": "fn(floorId?: string|[string])"
- },
+ },
"animateSetBlock": {
- "!doc": "动画形式转变某点图块",
+ "!doc": "动画形式转变某点图块",
"!type": "fn(number: number|string, x: number, y: number, floorId?: string, time?: number, callback?: fn())"
- },
+ },
"animateSetBlocks": {
- "!doc": "动画形式同时转变若干点图块",
+ "!doc": "动画形式同时转变若干点图块",
"!type": "fn(number: number|string, locs: [?], floorId?: string, time?: number, callback?: fn())"
- },
+ },
"compressMap": {
- "!doc": "压缩地图",
+ "!doc": "压缩地图",
"!type": "fn(mapArr: [[number]], floorId?: string) -> [[number]]"
- },
+ },
"enemyExists": {
- "!doc": "某个点是否存在（指定的）怪物",
+ "!doc": "某个点是否存在（指定的）怪物",
"!type": "fn(x: number, y: number, id?: string, floorId?: string) -> bool"
- },
+ },
"npcExists": {
- "!doc": "某个点是否存在NPC",
+ "!doc": "某个点是否存在NPC",
"!type": "fn(x: number, y: number, floorId?: string) -> bool"
- },
+ },
"getBlockByNumber": {
- "!doc": "根据数字获得图块",
+ "!doc": "根据数字获得图块",
"!type": "fn(number: number) -> block"
- },
+ },
"removeBlock": {
- "!doc": "删除一个图块，对应于「隐藏事件」并同时删除
例如：core.removeBlock(0, 0); // 尝试删除地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
+ "!doc": "删除一个图块，对应于「隐藏事件」并同时删除
例如：core.removeBlock(0, 0); // 尝试删除地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
"!type": "fn(x: number, y: number, floorId?: string)"
- },
+ },
"hideBlock": {
- "!doc": "隐藏一个图块，对应于「隐藏事件」且不删除
例如：core.hideBlock(0, 0); // 隐藏地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
+ "!doc": "隐藏一个图块，对应于「隐藏事件」且不删除
例如：core.hideBlock(0, 0); // 隐藏地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
"!type": "fn(x: number, y: number, floorId?: string)"
- },
+ },
"removeBlockByIndex": {
- "!doc": "根据block的索引删除该块",
+ "!doc": "根据block的索引删除该块",
"!type": "fn(index: number, floorId?: string)"
- },
+ },
"stairExists": {
- "!doc": "某个点是否存在楼梯",
+ "!doc": "某个点是否存在楼梯",
"!type": "fn(x: number, y: number, floorId?: string) -> bool"
- },
+ },
"isMapBlockDisabled": {
"!doc": "某个点图块是否被强制启用或禁用",
"!type": "fn(floorId?: string, x?: number, y?: number, flags?: ?) -> bool"
@@ -3185,35 +3185,35 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(filter?: ?, x?: number, y?: number, floorId?: string)"
},
"decompressMap": {
- "!doc": "解压缩地图",
+ "!doc": "解压缩地图",
"!type": "fn(mapArr: [[number]], floorId?: string) -> [[number]]"
- },
+ },
"automaticRoute": {
- "!doc": "自动寻路
例如：core.automaticRoute(0, 0); // 自动寻路到地图左上角
destX: 目标点的横坐标
destY: 目标点的纵坐标
返回值：每步走完后主角的loc属性组成的一维数组",
+ "!doc": "自动寻路
例如：core.automaticRoute(0, 0); // 自动寻路到地图左上角
destX: 目标点的横坐标
destY: 目标点的纵坐标
返回值：每步走完后主角的loc属性组成的一维数组",
"!type": "fn(destX: number, destY: number) -> [{x: number, y: number, direction: string}]"
- },
+ },
"resizeMap": {
- "!doc": "更改地图画布的尺寸",
+ "!doc": "更改地图画布的尺寸",
"!type": "fn(floorId?: string)"
- },
+ },
"getFgNumber": {
- "!doc": "判定某点的前景层的数字
例如：core.getFgNumber(); // 判断主角脚下的前景层图块的数字
x: 横坐标，不填为勇士坐标
y: 纵坐标，不填为勇士坐标floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存而强制重算",
+ "!doc": "判定某点的前景层的数字
例如：core.getFgNumber(); // 判断主角脚下的前景层图块的数字
x: 横坐标，不填为勇士坐标
y: 纵坐标，不填为勇士坐标floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存而强制重算",
"!type": "fn(x: number, y: number, floorId?: string, noCache?: bool) -> number"
- },
+ },
"moveBlock": {
- "!doc": "移动图块
例如：core.moveBlock(0, 0, ['down']); // 令地图左上角的图块下移一格
x: 起点的横坐标
y: 起点的纵坐标
steps: 步伐数组
time: 单步和淡出用时，单位为毫秒。不填视为半秒
keep: 是否不淡出，true表示不淡出
callback: 移动或淡出后的回调函数，可选",
+ "!doc": "移动图块
例如：core.moveBlock(0, 0, ['down']); // 令地图左上角的图块下移一格
x: 起点的横坐标
y: 起点的纵坐标
steps: 步伐数组
time: 单步和淡出用时，单位为毫秒。不填视为半秒
keep: 是否不淡出，true表示不淡出
callback: 移动或淡出后的回调函数，可选",
"!type": "fn(x: number, y: number, steps: [string], time?: number, keep?: bool, callback?: fn())"
- },
+ },
"getBgNumber": {
- "!doc": "判定某点的背景层的数字
例如：core.getBgNumber(); // 判断主角脚下的背景层图块的数字
x: 横坐标，不填为勇士坐标
y: 纵坐标，不填为勇士坐标
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存而强制重算",
+ "!doc": "判定某点的背景层的数字
例如：core.getBgNumber(); // 判断主角脚下的背景层图块的数字
x: 横坐标，不填为勇士坐标
y: 纵坐标，不填为勇士坐标
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存而强制重算",
"!type": "fn(x?: number, y?: number, floorId?: string, noCache?: bool) -> number"
- },
+ },
"getIdOfThis": {
- "!doc": "获得当前事件点的ID",
+ "!doc": "获得当前事件点的ID",
"!type": "fn(id?: string) -> string"
- },
+ },
"searchBlock": {
- "!doc": "搜索图块, 支持通配符和正则表达式
例如：core.searchBlock('*Door'); // 搜索当前地图的所有门
id: 图块id，支持星号表示任意多个（0个起）字符
floorId: 地图id或数组，不填视为当前地图
showDisable: 隐藏点是否计入，true表示计入
返回值：一个详尽的数组，一般只用到其长度",
+ "!doc": "搜索图块, 支持通配符和正则表达式
例如：core.searchBlock('*Door'); // 搜索当前地图的所有门
id: 图块id，支持星号表示任意多个（0个起）字符
floorId: 地图id或数组，不填视为当前地图
showDisable: 隐藏点是否计入，true表示计入
返回值：一个详尽的数组，一般只用到其长度",
"!type": "fn(id: string, floorId?: string|[string], showDisable?: bool) -> [{floorId: string, index: number, x: number, y: number, block: block}]"
},
"searchBlockWithFilter": {
@@ -3221,41 +3221,41 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(blockFilter: fn(block: block) -> bool, floorId?: string|[string], showDisable?: bool): [{floorId: string, index: number, x: number, y: number, block: block}]"
},
"hideBgFgMap": {
- "!doc": "隐藏前景/背景地图",
+ "!doc": "隐藏前景/背景地图",
"!type": "fn(name?: string, loc?: [number]|[[number]], floorId?: string, callback?: fn())"
- },
+ },
"getBlockInfo": {
- "!doc": "获得某个图块或素材的信息，包括ID，cls，图片，坐标，faceIds等等",
+ "!doc": "获得某个图块或素材的信息，包括ID，cls，图片，坐标，faceIds等等",
"!type": "fn(block?: number|string|block) -> blockInfo"
- },
+ },
"getFaceDownId": {
"!doc": "获得某个图块对应行走图朝向向下的那一项的id；如果不存在行走图绑定则返回自身id。",
"!type": "fn(block?: string|number|block) -> string"
},
"canMoveDirectlyArray": {
- "!doc": "获得某些点可否通行的信息",
+ "!doc": "获得某些点可否通行的信息",
"!type": "fn(locs?: [[number]])"
- },
+ },
"hideFloorImage": {
- "!doc": "隐藏一个楼层贴图",
+ "!doc": "隐藏一个楼层贴图",
"!type": "fn(loc?: [number]|[[number]], floorId?: string, callback?: fn())"
- },
+ },
"extractBlocks": {
- "!doc": "根据需求解析出blocks",
+ "!doc": "根据需求解析出blocks",
"!type": "fn(map?: ?)"
- },
+ },
"extractBlocksForUI": {
- "!doc": "根据需求为UI解析出blocks",
+ "!doc": "根据需求为UI解析出blocks",
"!type": "fn(map?: ?, flags?: ?)"
- },
+ },
"getBlockId": {
- "!doc": "判定某个点的图块id
例如：if(core.getBlockId(x1, y1) != 'greenSlime' && core.getBlockId(x2, y2) != 'redSlime') core.openDoor(x3, y3); // 一个简单的机关门事件，打败或炸掉这一对绿头怪和红头怪就开门
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块id，该点无图块则返回null",
+ "!doc": "判定某个点的图块id
例如：if(core.getBlockId(x1, y1) != 'greenSlime' && core.getBlockId(x2, y2) != 'redSlime') core.openDoor(x3, y3); // 一个简单的机关门事件，打败或炸掉这一对绿头怪和红头怪就开门
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块id，该点无图块则返回null",
"!type": "fn(x: number, y: number, floorId?: string, showDisable?: bool) -> string"
- },
+ },
"getBlockNumber": {
- "!doc": "判定某个点的图块数字
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块数字，该点无图块则返回null",
+ "!doc": "判定某个点的图块数字
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图
showDisable: 隐藏点是否不返回null，true表示不返回null
返回值：图块数字，该点无图块则返回null",
"!type": "fn(x: number, y: number, floorId?: string, showDisable?: bool) -> number"
- },
+ },
"getBlockOpacity": {
"!doc": "获得某个点图块的不透明度",
"!type": "fn(x?: number, y?: number, floorId?: string, showDisable?: bool) -> number"
@@ -3265,208 +3265,208 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(x?: number, y?: number, floorId?: string, showDisable?: bool) -> ?"
},
"loadFloor": {
- "!doc": "从文件或存档中加载某个楼层",
+ "!doc": "从文件或存档中加载某个楼层",
"!type": "fn(floorId?: string, map?: ?)"
- },
+ },
"generateMovableArray": {
- "!doc": "可通行性判定
例如：core.generateMovableArray(); // 判断当前地图主角从各点能向何方向移动
floorId: 地图id，不填视为当前地图
返回值：从各点可移动方向的三维数组",
+ "!doc": "可通行性判定
例如：core.generateMovableArray(); // 判断当前地图主角从各点能向何方向移动
floorId: 地图id，不填视为当前地图
返回值：从各点可移动方向的三维数组",
"!type": "fn(floorId?: string) -> [[[string]]]"
- },
+ },
"terrainExists": {
- "!doc": "某个点是否存在（指定的）地形",
+ "!doc": "某个点是否存在（指定的）地形",
"!type": "fn(x: number, y: number, id?: string, floorId?: string) -> bool"
- },
+ },
"getBlockById": {
- "!doc": "根据ID获得图块",
+ "!doc": "根据ID获得图块",
"!type": "fn(id: string) -> block"
- },
+ },
"drawBg": {
- "!doc": "绘制背景层（含贴图，其与背景层矩阵的绘制顺序可通过复写此函数来改变）
例如：core.drawBg(); // 绘制当前地图的背景层
floorId: 地图id，不填视为当前地图
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
+ "!doc": "绘制背景层（含贴图，其与背景层矩阵的绘制顺序可通过复写此函数来改变）
例如：core.drawBg(); // 绘制当前地图的背景层
floorId: 地图id，不填视为当前地图
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
"!type": "fn(floorId?: string, ctx?: CanvasRenderingContext2D)"
- },
+ },
"showBlock": {
- "!doc": "显示（隐藏或显示的）图块，此函数将被“显示事件”指令和勾选了“不消失”的“移动/跳跃事件”指令（如阻击怪）的终点调用
例如：core.showBlock(0, 0); // 显示地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
+ "!doc": "显示（隐藏或显示的）图块，此函数将被“显示事件”指令和勾选了“不消失”的“移动/跳跃事件”指令（如阻击怪）的终点调用
例如：core.showBlock(0, 0); // 显示地图左上角的图块
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
"!type": "fn(x: number, y: number, floorId?: string)"
- },
+ },
"getMapBlocksObj": {
- "!doc": "以x,y的形式返回每个点的事件",
+ "!doc": "以x,y的形式返回每个点的事件",
"!type": "fn(floorId?: string, noCache?: bool)"
- },
+ },
"removeGlobalAnimate": {
- "!doc": "删除一个或所有全局动画",
+ "!doc": "删除一个或所有全局动画",
"!type": "fn(x?: number, y?: number, name?: string)"
- },
+ },
"drawEvents": {
- "!doc": "绘制事件层
例如：core.drawEvents(); // 绘制当前地图的事件层
floorId: 地图id，不填视为当前地图
blocks: 一般不需要
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
+ "!doc": "绘制事件层
例如：core.drawEvents(); // 绘制当前地图的事件层
floorId: 地图id，不填视为当前地图
blocks: 一般不需要
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
"!type": "fn(floorId?: string, blocks?: [block], ctx?: CanvasRenderingContext2D)"
- },
+ },
"canMoveDirectly": {
- "!doc": "能否瞬移到某点，并求出节约的步数。
例如：core.canMoveDirectly(0, 0); // 能否瞬移到地图左上角
destX: 目标点的横坐标
destY: 目标点的纵坐标
返回值：正数表示节约的步数，-1表示不可瞬移",
+ "!doc": "能否瞬移到某点，并求出节约的步数。
例如：core.canMoveDirectly(0, 0); // 能否瞬移到地图左上角
destX: 目标点的横坐标
destY: 目标点的纵坐标
返回值：正数表示节约的步数，-1表示不可瞬移",
"!type": "fn(destX: number, destY: number) -> number"
- },
+ },
"saveMap": {
- "!doc": "将当前地图重新变成数字，以便于存档",
+ "!doc": "将当前地图重新变成数字，以便于存档",
"!type": "fn(floorId?: string)"
- },
+ },
"drawBoxAnimate": {
- "!doc": "绘制UI层的box动画",
+ "!doc": "绘制UI层的box动画",
"!type": "fn()"
- },
+ },
"setBgFgBlock": {
- "!doc": "转变图层块
例如：core.setBgFgBlock('bg', 167, 6, 6); // 把当前地图背景层的中心块改为滑冰
name: 背景还是前景
number: 新图层块的数字（也支持纯数字字符串如'1'）或id
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
+ "!doc": "转变图层块
例如：core.setBgFgBlock('bg', 167, 6, 6); // 把当前地图背景层的中心块改为滑冰
name: 背景还是前景
number: 新图层块的数字（也支持纯数字字符串如'1'）或id
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
"!type": "fn(name: string, number: number|string, x: number, y: number, floorId?: string)"
- },
+ },
"drawFg": {
- "!doc": "绘制前景层（含贴图，其与前景层矩阵的绘制顺序可通过复写此函数来改变）
例如：core.drawFg(); // 绘制当前地图的前景层
floorId: 地图id，不填视为当前地图
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
+ "!doc": "绘制前景层（含贴图，其与前景层矩阵的绘制顺序可通过复写此函数来改变）
例如：core.drawFg(); // 绘制当前地图的前景层
floorId: 地图id，不填视为当前地图
ctx: 某画布的ctx，用于绘制缩略图，一般不需要",
"!type": "fn(floorId?: string, ctx?: CanvasRenderingContext2D)"
- },
+ },
"getBlock": {
- "!doc": "获得某个点的block",
+ "!doc": "获得某个点的block",
"!type": "fn(x: number, y: number, floorId?: string, showDisable?: bool) -> block"
- },
+ },
"initBlock": {
- "!doc": "初始化一个图块",
+ "!doc": "初始化一个图块",
"!type": "fn(x: number, y: number, id: string|number, addInfo?: bool, eventFloor?: ?) -> block"
- },
+ },
"addGlobalAnimate": {
- "!doc": "添加一个全局动画",
+ "!doc": "添加一个全局动画",
"!type": "fn(block?: block)"
- },
+ },
"animateBlock": {
- "!doc": "显示/隐藏某个块时的动画效果",
+ "!doc": "显示/隐藏某个块时的动画效果",
"!type": "fn(loc?: [number]|[[number]], type?: string|number, time?: number, callback?: fn())"
- },
+ },
"loadMap": {
- "!doc": "将存档中的地图信息重新读取出来",
+ "!doc": "将存档中的地图信息重新读取出来",
"!type": "fn(data?: ?, floorId?: string, flags?: ?)"
- },
+ },
"setBlock": {
- "!doc": "转变图块
例如：core.setBlock(1, 0, 0); // 把地图左上角变成黄墙
number: 新图块的数字（也支持纯数字字符串如'1'）或id
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
+ "!doc": "转变图块
例如：core.setBlock(1, 0, 0); // 把地图左上角变成黄墙
number: 新图块的数字（也支持纯数字字符串如'1'）或id
x: 横坐标
y: 纵坐标
floorId: 地图id，不填视为当前地图",
"!type": "fn(number: number|string, x: number, y: number, floorId?: string)"
- },
+ },
"getFgMapArray": {
- "!doc": "生成前景层矩阵
例如：core.getFgMapArray('MT0'); // 生成主塔0层的前景层矩阵，使用缓存
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存
返回值：前景层矩阵，注意对其阵元的访问是[y][x]",
+ "!doc": "生成前景层矩阵
例如：core.getFgMapArray('MT0'); // 生成主塔0层的前景层矩阵，使用缓存
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存
返回值：前景层矩阵，注意对其阵元的访问是[y][x]",
"!type": "fn(floorId?: string, noCache?: bool) -> [[number]]"
- },
+ },
"getBgMapArray": {
- "!doc": "生成背景层矩阵
例如：core.getBgMapArray('MT0'); // 生成主塔0层的背景层矩阵，使用缓存
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存
返回值：背景层矩阵，注意对其阵元的访问是[y][x]",
+ "!doc": "生成背景层矩阵
例如：core.getBgMapArray('MT0'); // 生成主塔0层的背景层矩阵，使用缓存
floorId: 地图id，不填视为当前地图
noCache: 可选，true表示不使用缓存
返回值：背景层矩阵，注意对其阵元的访问是[y][x]",
"!type": "fn(floorId?: string, noCache?: bool) -> [[number]]"
- },
+ },
"canMoveHero": {
- "!doc": "单点单朝向的可通行性判定；受各图层cannotInOut、起点cannotMove和canGoDeadZone影响，不受canPass和noPass影响
x: 起点横坐标，不填视为主角当前的
y: 起点纵坐标，不填视为主角当前的
direction: 移动的方向，不填视为主角面对的方向
floorId: 地图id，不填视为当前地图",
+ "!doc": "单点单朝向的可通行性判定；受各图层cannotInOut、起点cannotMove和canGoDeadZone影响，不受canPass和noPass影响
x: 起点横坐标，不填视为主角当前的
y: 起点纵坐标，不填视为主角当前的
direction: 移动的方向，不填视为主角面对的方向
floorId: 地图id，不填视为当前地图",
"!type": "fn(x?: number, y?: number, direction?: string, floorId?: string) -> bool"
- },
+ },
"drawThumbnail": {
- "!doc": "绘制缩略图
例如：core.drawThumbnail(); // 绘制当前地图的缩略图
floorId: 地图id，不填视为当前地图
blocks: 一般不需要
options: 绘制信息，可选。可以增绘主角位置和朝向、采用不同于游戏中的主角行走图、增绘显伤、提供flags用于存读档，同时包含要绘制到的画布名或画布的ctx或还有其他信息，如起绘坐标、绘制大小、是否绘制全图、截取中心",
+ "!doc": "绘制缩略图
例如：core.drawThumbnail(); // 绘制当前地图的缩略图
floorId: 地图id，不填视为当前地图
blocks: 一般不需要
options: 绘制信息，可选。可以增绘主角位置和朝向、采用不同于游戏中的主角行走图、增绘显伤、提供flags用于存读档，同时包含要绘制到的画布名或画布的ctx或还有其他信息，如起绘坐标、绘制大小、是否绘制全图、截取中心",
"!type": "fn(floorId?: string, blocks?: [block], options?: ?)"
- },
+ },
"hideBlockByIndex": {
- "!doc": "根据图块的索引来隐藏图块",
+ "!doc": "根据图块的索引来隐藏图块",
"!type": "fn(index?: number, floorId?: string)"
- },
+ },
"getNumberById": {
- "!doc": "根据图块id得到数字（地图矩阵中的值）
例如：core.getNumberById('yellowWall'); // 1
id: 图块id
返回值：图块的数字，定义在project\\maps.js（请注意和project\\icons.js中的“图块索引”相区分！）",
+ "!doc": "根据图块id得到数字（地图矩阵中的值）
例如：core.getNumberById('yellowWall'); // 1
id: 图块id
返回值：图块的数字，定义在project\\maps.js（请注意和project\\icons.js中的“图块索引”相区分！）",
"!type": "fn(id: string) -> number"
- },
+ },
"removeBlockByIndexes": {
- "!doc": "一次性删除多个block",
+ "!doc": "一次性删除多个block",
"!type": "fn(indexes?: [number], floorId?: string)"
- },
+ },
"hideBlockByIndexes": {
- "!doc": "一次性隐藏多个block",
+ "!doc": "一次性隐藏多个block",
"!type": "fn(indexes?: [number], floorId?: string)"
- },
+ },
"generateGroundPattern": {
- "!doc": "生成groundPattern",
+ "!doc": "生成groundPattern",
"!type": "fn(floorId?: string)"
- },
+ },
"showBgFgMap": {
- "!doc": "显示前景/背景地图",
+ "!doc": "显示前景/背景地图",
"!type": "fn(name?: string, loc?: [number]|[[number]], floorId?: string, callback?: fn())"
- },
+ },
"showFloorImage": {
- "!doc": "显示一个楼层贴图",
+ "!doc": "显示一个楼层贴图",
"!type": "fn(loc?: [number]|[[number]], floorId?: string, callback?: fn())"
}
- },
+ },
"ui": {
"!doc": "负责一切UI界面的绘制。主要包括三个部分：
- 设置某个画布的属性与在某个画布上绘制的相关API
- 具体的某个UI界面的绘制
- 动态创建画布相关的API",
"resizeCanvas": {
- "!doc": "重新设置一个自定义画布的大小",
+ "!doc": "重新设置一个自定义画布的大小",
"!type": "fn(name: string, x: number, y: number)"
- },
+ },
"deleteCanvas": {
- "!doc": "删除一个自定义画布
name: 画布名，也可以传入一个函数对所有画布进行筛选",
+ "!doc": "删除一个自定义画布
name: 画布名，也可以传入一个函数对所有画布进行筛选",
"!type": "fn(name: string|fn(name: string) -> bool)"
},
"deleteAllCanvas": {
- "!doc": "清空所有的自定义画布",
+ "!doc": "清空所有的自定义画布",
"!type": "fn()"
},
"drawIcon": {
- "!doc": "在某个canvas上绘制一个图标",
+ "!doc": "在某个canvas上绘制一个图标",
"!type": "fn(name: string|CanvasRenderingContext2D, id: string, x: number, y: number, w?: number, h?: number, frame?: number)"
- },
+ },
"drawFly": {
- "!doc": "绘制楼层传送器",
+ "!doc": "绘制楼层传送器",
"!type": "fn(page?: ?)"
- },
+ },
"setOpacity": {
- "!doc": "设置某个canvas整体的透明度；此函数直接改变画布本身，对已经绘制的内容也生效
如果仅想对接下来的绘制生效请使用setAlpha",
+ "!doc": "设置某个canvas整体的透明度；此函数直接改变画布本身，对已经绘制的内容也生效
如果仅想对接下来的绘制生效请使用setAlpha",
"!type": "fn(name: string|CanvasRenderingContext2D, opacity: number)"
},
"getTextContentHeight": {
- "!doc": "获得某段文字的预计绘制高度；参数说明详见 drawTextContent",
+ "!doc": "获得某段文字的预计绘制高度；参数说明详见 drawTextContent",
"!type": "fn(content: string, config?: ?)"
},
"drawArrow": {
- "!doc": "在某个canvas上绘制一个箭头",
+ "!doc": "在某个canvas上绘制一个箭头",
"!type": "fn(name: string|CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number, style?: string, lineWidth?: number)"
},
"strokeEllipse": {
- "!doc": "在某个canvas上绘制一个椭圆的边框",
+ "!doc": "在某个canvas上绘制一个椭圆的边框",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, a: number, b: number, angle?: number, style?: string, lineWidth?: number)"
- },
+ },
"fillCircle": {
- "!doc": "在某个canvas上绘制一个圆",
+ "!doc": "在某个canvas上绘制一个圆",
"!url": "https://www.w3school.com.cn/tags/canvas_arc.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, r: number, style?: string)"
- },
+ },
"strokeRoundRect": {
- "!doc": "在某个canvas上绘制一个圆角矩形的边框",
+ "!doc": "在某个canvas上绘制一个圆角矩形的边框",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, style?: string, lineWidth?: number, angle?: number)"
- },
+ },
"getContextByName": {
- "!doc": "根据画布名找到一个画布的context；支持系统画布和自定义画布。如果不存在画布返回null。
也可以传画布的context自身，则返回自己。",
+ "!doc": "根据画布名找到一个画布的context；支持系统画布和自定义画布。如果不存在画布返回null。
也可以传画布的context自身，则返回自己。",
"!type": "fn(canvas: string|CanvasRenderingContext2D) -> CanvasRenderingContext2D"
- },
+ },
"drawImage": {
- "!doc": "在一个画布上绘制图片
后面的8个坐标参数与canvas的drawImage的八个参数完全相同。
name: 可以是系统画布之一，也可以是任意自定义动态创建的画布名 画布名称或者画布的context
image: 要绘制的图片，可以是一个全塔属性中定义的图片名（会从images中去获取；支持加':x',':y',':o'翻转），图片本身，或者一个画布。
angle：旋转角度",
+ "!doc": "在一个画布上绘制图片
后面的8个坐标参数与canvas的drawImage的八个参数完全相同。
name: 可以是系统画布之一，也可以是任意自定义动态创建的画布名 画布名称或者画布的context
image: 要绘制的图片，可以是一个全塔属性中定义的图片名（会从images中去获取；支持加':x',':y',':o'翻转），图片本身，或者一个画布。
angle：旋转角度",
"!url": "http://www.w3school.com.cn/html5/canvas_drawimage.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, image: string|image, x: number, y: number, w?: number, h?: number, x1?: number, y1?: number, w1?: number, h1?: number, angle?: number)"
- },
+ },
"drawTip": {
- "!doc": "左上角绘制一段提示
text: 要提示的字符串，支持${}语法
id: 要绘制的图标ID
frame: 要绘制该图标的第几帧",
+ "!doc": "左上角绘制一段提示
text: 要提示的字符串，支持${}语法
id: 要绘制的图标ID
frame: 要绘制该图标的第几帧",
"!type": "fn(text: string, id?: string, frame?: number)"
- },
+ },
"drawBackground": {
- "!doc": "绘制一个背景图，可绘制winskin或纯色背景；支持小箭头绘制",
+ "!doc": "绘制一个背景图，可绘制winskin或纯色背景；支持小箭头绘制",
"!type": "fn(left: string, top: string, right: string, bottom: string, posInfo?: {px: number, py: number, direction: string})"
- },
+ },
"fillEllipse": {
- "!doc": "在某个canvas上绘制一个椭圆",
+ "!doc": "在某个canvas上绘制一个椭圆",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, a: number, b: number, angle?: number, style?: string)"
- },
+ },
"setFillStyle": {
- "!doc": "设置某个canvas的绘制属性（如颜色等）",
+ "!doc": "设置某个canvas的绘制属性（如颜色等）",
"!url": "https://www.w3school.com.cn/tags/canvas_fillstyle.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, style: string)"
- },
+ },
"drawText": {
- "!doc": "地图中间绘制一段文字",
+ "!doc": "地图中间绘制一段文字",
"!type": "fn(contents: string, callback?: fn())"
- },
- "drawConfirmBox":{
+ },
+ "drawConfirmBox": {
"!doc": "绘制一个确认框
此项会打断事件流，如需不打断版本的请使用core.myconfirm()
text: 要绘制的内容，支持 ${} 语法
yesCallback: 点击确认后的回调
noCallback: 点击取消后的回调",
"!type": "fn(text: string, yesCallback?: fn(), noCallback?: fn())"
},
@@ -3479,144 +3479,144 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(codes?: number|[number])"
},
"fillPolygon": {
- "!doc": "在某个canvas上绘制一个多边形",
+ "!doc": "在某个canvas上绘制一个多边形",
"!type": "fn(name: string|CanvasRenderingContext2D, nodes?: [[number]], style?: string)"
- },
+ },
"fillText": {
- "!doc": "在某个画布上绘制一段文字
text: 要绘制的文本
style: 绘制的样式
font: 绘制的字体
最大宽度，超过此宽度会自动放缩",
+ "!doc": "在某个画布上绘制一段文字
text: 要绘制的文本
style: 绘制的样式
font: 绘制的字体
最大宽度，超过此宽度会自动放缩",
"!url": "https://www.w3school.com.cn/tags/canvas_filltext.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, text: string, x: number, y: number, style?: string, font?: string, maxWidth?: number)"
- },
+ },
"setTextBaseline": {
- "!doc": "设置某个canvas的基准线
baseline: 可为alphabetic, top, hanging, middle, ideographic, bottom",
+ "!doc": "设置某个canvas的基准线
baseline: 可为alphabetic, top, hanging, middle, ideographic, bottom",
"!url": "https://www.w3school.com.cn/tags/canvas_textbaseline.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, baseline: string)"
},
"loadCanvas": {
- "!doc": "加载某个canvas状态",
+ "!doc": "加载某个canvas状态",
"!type": "fn(name: string|CanvasRenderingContext2D)"
- },
+ },
"splitLines": {
- "!doc": "字符串自动换行的分割",
+ "!doc": "字符串自动换行的分割",
"!type": "fn(name: string|CanvasRenderingContext2D, text: string, maxWidth?: number, font?: string)"
- },
+ },
"setAlpha": {
- "!doc": "设置某个canvas接下来绘制的不透明度；不会影响已经绘制的内容
返回设置之前画布的不透明度
如果需要修改画布本身的不透明度请使用setOpacity",
+ "!doc": "设置某个canvas接下来绘制的不透明度；不会影响已经绘制的内容
返回设置之前画布的不透明度
如果需要修改画布本身的不透明度请使用setOpacity",
"!url": "https://www.w3school.com.cn/tags/canvas_globalalpha.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, alpha: number) -> number"
- },
+ },
"setFilter": {
"!doc": "设置某个canvas接下来绘制的filter",
"!type": "fn(name: string|CanvasRenderingContext2D, style: string)"
},
"setLineWidth": {
- "!doc": "设置某个canvas的线宽度",
+ "!doc": "设置某个canvas的线宽度",
"!url": "https://www.w3school.com.cn/tags/canvas_linewidth.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, lineWidth: number)"
},
"drawTextBox": {
- "!doc": "绘制一个对话框",
+ "!doc": "绘制一个对话框",
"!type": "fn(content: string, showAll?: bool)"
- },
+ },
"relocateCanvas": {
- "!doc": "重新定位一个自定义画布",
+ "!doc": "重新定位一个自定义画布",
"!type": "fn(name: string, x: number, y: number, useDelta: bool)"
- },
+ },
"rotateCanvas": {
"!doc": "设置一个自定义画布的旋转角度
centerX, centerY: 旋转中心（以屏幕像素为基准）；不填视为图片正中心。",
"!type": "fn(name: string, angle: number, centerX?: number, centerY?: number)"
},
"closePanel": {
- "!doc": "结束一切事件和绘制，关闭UI窗口，返回游戏进程",
+ "!doc": "结束一切事件和绘制，关闭UI窗口，返回游戏进程",
"!type": "fn()"
- },
+ },
"textImage": {
- "!doc": "文本图片化",
+ "!doc": "文本图片化",
"!type": "fn(content: string, lineHeight?: number) -> image"
- },
+ },
"drawStatusBar": {
- "!doc": "绘制状态栏",
+ "!doc": "绘制状态栏",
"!type": "fn()"
- },
+ },
"setStrokeStyle": {
- "!doc": "设置某个canvas边框属性",
+ "!doc": "设置某个canvas边框属性",
"!url": "https://www.w3school.com.cn/tags/canvas_strokestyle.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, style: string)"
- },
+ },
"clearUI": {
- "!doc": "清空UI层内容",
+ "!doc": "清空UI层内容",
"!type": "fn()"
- },
+ },
"drawWindowSkin": {
- "!doc": "绘制WindowSkin",
+ "!doc": "绘制WindowSkin",
"!type": "fn(background: string, ctx: string|CanvasRenderingContext2D, x: number, y: number, w: string, h: string, direction?: string, px?: number, py?: number)"
},
"fillRect": {
- "!doc": "绘制一个矩形。
x,y: 绘制的坐标
width,height: 绘制的长宽
style: 绘制的样式
angle: 旋转的角度，弧度制，如Math.PI/2代表90度",
+ "!doc": "绘制一个矩形。
x,y: 绘制的坐标
width,height: 绘制的长宽
style: 绘制的样式
angle: 旋转的角度，弧度制，如Math.PI/2代表90度",
"!url": "https://www.w3school.com.cn/tags/canvas_fillrect.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, width: number, height: number, style?: string, angle?: number)"
- },
+ },
"drawScrollText": {
- "!doc": "绘制滚动字幕",
+ "!doc": "绘制滚动字幕",
"!type": "fn(content: string, time: number, lineHeight?: number, callback?: fn())"
- },
+ },
"strokePolygon": {
- "!doc": "在某个canvas上绘制一个多边形的边框",
+ "!doc": "在某个canvas上绘制一个多边形的边框",
"!type": "fn(name: string|CanvasRenderingContext2D, nodes?: [[number]], style?: string, lineWidth?: number)"
- },
+ },
"strokeCircle": {
- "!doc": "在某个canvas上绘制一个圆的边框",
+ "!doc": "在某个canvas上绘制一个圆的边框",
"!url": "https://www.w3school.com.cn/tags/canvas_arc.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, r: ?, style?: string, lineWidth?: number)"
},
"drawWaiting": {
- "!doc": "绘制等待界面",
+ "!doc": "绘制等待界面",
"!type": "fn(text: string)"
- },
+ },
"setFont": {
- "!doc": "设置某个canvas的文字字体",
+ "!doc": "设置某个canvas的文字字体",
"!url": "https://www.w3school.com.cn/tags/canvas_font.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, font: string)"
- },
+ },
"drawChoices": {
- "!doc": "绘制一个选项界面",
+ "!doc": "绘制一个选项界面",
"!type": "fn(content?: string, choices?: [?], width?: number, ctx?: string|CanvasRenderingContext2D)"
- },
+ },
"setFontForMaxWidth": {
- "!doc": "根据最大宽度自动缩小字体",
+ "!doc": "根据最大宽度自动缩小字体",
"!type": "fn(name: string|CanvasRenderingContext2D, text: string, maxWidth: number, font?: ?) -> string"
- },
+ },
"clearMap": {
- "!doc": "清空某个画布图层
name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。
如果name也可以是'all'，若为all则为清空所有系统画布。",
+ "!doc": "清空某个画布图层
name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。
如果name也可以是'all'，若为all则为清空所有系统画布。",
"!url": "https://www.w3school.com.cn/tags/canvas_clearrect.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x?: number, y?: number, width?: number, height?: number)"
- },
+ },
"drawTextContent": {
- "!doc": "绘制一段文字到某个画布上面
ctx: 要绘制到的画布
content: 要绘制的内容；转义字符不允许保留 \\t, \\b 和 \\f
config: 绘制配置项，目前暂时包含如下内容（均为可选）
left, top：起始点位置；maxWidth：单行最大宽度；color：默认颜色；align：左中右
fontSize：字体大小；lineHeight：行高；time：打字机间隔；font：字体名
返回值：绘制信息",
+ "!doc": "绘制一段文字到某个画布上面
ctx: 要绘制到的画布
content: 要绘制的内容；转义字符不允许保留 \\t, \\b 和 \\f
config: 绘制配置项，目前暂时包含如下内容（均为可选）
left, top：起始点位置；maxWidth：单行最大宽度；color：默认颜色；align：左中右
fontSize：字体大小；lineHeight：行高；time：打字机间隔；font：字体名
返回值：绘制信息",
"!type": "fn(ctx: string|CanvasRenderingContext2D, content: string, config: ?)"
- },
+ },
"calWidth": {
- "!doc": "计算某段文字的宽度",
+ "!doc": "计算某段文字的宽度",
"!url": "https://www.w3school.com.cn/tags/canvas_measuretext.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, text: string, font?: string) -> number"
- },
+ },
"fillArc": {
- "!doc": "在某个canvas上绘制一个扇形",
+ "!doc": "在某个canvas上绘制一个扇形",
"!url": "https://www.w3school.com.cn/tags/canvas_arc.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, r: number, start: number, end: number, style?: string)"
},
"strokeArc": {
- "!doc": "在某个canvas上绘制一段弧",
+ "!doc": "在某个canvas上绘制一段弧",
"!url": "https://www.w3school.com.cn/tags/canvas_arc.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, r: number, start: number, end: number, style?: string, lineWidth?: number)"
- },
+ },
"drawLine": {
- "!doc": "在某个canvas上绘制一条线",
+ "!doc": "在某个canvas上绘制一条线",
"!url": "https://www.w3school.com.cn/tags/canvas_lineto.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x1: number, y1: number, x2: number, y2: number, style?: string, lineWidth?: number)"
- },
+ },
"drawPagination": {
- "!doc": "绘制分页",
+ "!doc": "绘制分页",
"!type": "fn(page?: ?, totalPage?: ?, y?: number)"
},
"getToolboxItems": {
@@ -3624,36 +3624,36 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(cls: string) -> [string]"
},
"strokeRect": {
- "!doc": "绘制一个矩形的边框
style: 绘制的样式
lineWidth: 线宽
angle: 旋转角度，弧度制，如Math.PI/2为90度",
+ "!doc": "绘制一个矩形的边框
style: 绘制的样式
lineWidth: 线宽
angle: 旋转角度，弧度制，如Math.PI/2为90度",
"!url": "https://www.w3school.com.cn/tags/canvas_strokerect.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, width: number, height: number, style?: string, lineWidth?: number, angle?: number)"
- },
+ },
"drawBook": {
- "!doc": "绘制怪物手册",
+ "!doc": "绘制怪物手册",
"!type": "fn(index?: ?)"
- },
+ },
"fillRoundRect": {
- "!doc": "在某个canvas上绘制一个圆角矩形",
+ "!doc": "在某个canvas上绘制一个圆角矩形",
"!type": "fn(name: string|CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number, style?: string, angle?: number)"
- },
+ },
"fillBoldText": {
- "!doc": "在某个画布上绘制一个描边文字
text: 要绘制的文本
style: 绘制的样式
strokeStyle: 要绘制的描边颜色
font: 绘制的字体
maxWidth: 最大宽度，超过此宽度会自动放缩",
+ "!doc": "在某个画布上绘制一个描边文字
text: 要绘制的文本
style: 绘制的样式
strokeStyle: 要绘制的描边颜色
font: 绘制的字体
maxWidth: 最大宽度，超过此宽度会自动放缩",
"!type": "fn(name: string|CanvasRenderingContext2D, text: string, x: number, y: number, style?: string, strokeStyle?: string, font?: string, maxWidth?: number)"
},
"saveCanvas": {
- "!doc": "保存某个canvas状态",
+ "!doc": "保存某个canvas状态",
"!type": "fn(name: string|CanvasRenderingContext2D)"
},
"createCanvas": {
- "!doc": "动态创建一个画布。
name： 要创建的画布名，如果已存在则会直接取用当前存在的。
x,y: 创建的画布相对窗口左上角的像素坐标
width,height: 创建的长宽。
zIndex: 创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
返回创建的画布的context，也可以通过core.dymCanvas[name]调用。",
+ "!doc": "动态创建一个画布。
name： 要创建的画布名，如果已存在则会直接取用当前存在的。
x,y: 创建的画布相对窗口左上角的像素坐标
width,height: 创建的长宽。
zIndex: 创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
返回创建的画布的context，也可以通过core.dymCanvas[name]调用。",
"!type": "fn(name: string, x: number, y: number, width: number, height: number, zIndex: number) -> CanvasRenderingContext2D"
- },
+ },
"setTextAlign": {
- "!doc": "设置某个canvas的对齐",
+ "!doc": "设置某个canvas的对齐",
"!url": "https://www.w3school.com.cn/tags/canvas_textalign.asp",
"!type": "fn(name: string|CanvasRenderingContext2D, align: string)"
},
- },
+ },
"enemys": {
"!doc": "定义了一系列和怪物相关的API函数。",
"getEnemys": {
@@ -3677,17 +3677,17 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(enemy: string|enemy) -> number"
},
"getSpecialHint": {
- "!doc": "获得某种敌人的某种特殊属性的介绍
例如：core.getSpecialHint('bat', 1) // '先攻：怪物首先攻击'
enemy: 敌人id或敌人对象，用于确定属性的具体数值，否则可选
special: 属性编号，可以是该敌人没有的属性
返回值：属性的介绍，以属性名加中文冒号开头",
+ "!doc": "获得某种敌人的某种特殊属性的介绍
例如：core.getSpecialHint('bat', 1) // '先攻：怪物首先攻击'
enemy: 敌人id或敌人对象，用于确定属性的具体数值，否则可选
special: 属性编号，可以是该敌人没有的属性
返回值：属性的介绍，以属性名加中文冒号开头",
"!type": "fn(enemy: string|enemy, special: number) -> string"
- },
+ },
"getSpecialText": {
- "!doc": "获得某种敌人的全部特殊属性名称
例如：core.getSpecialText('greenSlime') // ['先攻', '3连击', '破甲', '反击']
enemy: 敌人id或敌人对象，如core.material.enemys.greenSlime
返回值：字符串数组",
+ "!doc": "获得某种敌人的全部特殊属性名称
例如：core.getSpecialText('greenSlime') // ['先攻', '3连击', '破甲', '反击']
enemy: 敌人id或敌人对象，如core.material.enemys.greenSlime
返回值：字符串数组",
"!type": "fn(enemy: string|enemy) -> [string]"
},
"hasSpecial": {
- "!doc": "判定某种特殊属性的有无
例如：core.hasSpecial('greenSlime', 1) // 判定绿头怪有无先攻属性
special: 敌人id或敌人对象或正整数数组或自然数
test: 待检查的属性编号
",
+ "!doc": "判定某种特殊属性的有无
例如：core.hasSpecial('greenSlime', 1) // 判定绿头怪有无先攻属性
special: 敌人id或敌人对象或正整数数组或自然数
test: 待检查的属性编号
",
"!type": "fn(special: number|[number]|string|number, test: number) -> bool"
- },
+ },
"nextCriticals": {
"!doc": "获得某只敌人接下来的若干个临界及其减伤，算法基于useLoop开关选择回合法或二分法
例如：core.nextCriticals('greenSlime', 9, 0, 0, 'MT0') // 绿头怪接下来的9个临界
enemy: 敌人id或敌人对象
number: 要计算的临界数量，可选，默认为1
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回：两列的二维数组，每行表示一个临界及其减伤",
"!type": "fn(enemy: string|enemy, number?: number, x?: number, y?: number, floorId?: string) -> [[number]]"
@@ -3697,9 +3697,9 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(enemy: string|enemy, k?: number, x?: number, y?: number, floorId?: string) -> number"
},
"canBattle": {
- "!doc": "判定主角当前能否打败某只敌人
例如：core.canBattle('greenSlime',0,0,'MT0') // 能否打败主塔0层左上角的绿头怪（假设有）
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：true表示可以打败，false表示无法打败",
+ "!doc": "判定主角当前能否打败某只敌人
例如：core.canBattle('greenSlime',0,0,'MT0') // 能否打败主塔0层左上角的绿头怪（假设有）
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：true表示可以打败，false表示无法打败",
"!type": "fn(enemy: string|enemy, x?: number, y?: number, floorId?: string) -> bool"
- },
+ },
"getEnemyInfo": {
"!doc": "获得怪物真实属性
hero: 可选，此时的勇士属性
此函数将会计算包括坚固、模仿、光环等若干效果，将同时被怪物手册和伤害计算调用",
"!type": "fn(enemy: string|enemy, hero?: ?, x?: number, y?: number, floorId?: string) -> {hp: number, atk: number, def: number, money: number, exp: number, special: [number], point: number, guards: [?]}"
@@ -3709,11 +3709,11 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(enemy: string|enemy, hero?: ?, x?: number, y?: number, floorId?: string) -> {damage: number, per_damage: number, hero_per_damage: number, init_damage: number, mon_hp: number, mon_atk: number, mon_def: number, turn: number}"
},
"getDamage": {
- "!doc": "获得某只敌人对主角的总伤害
例如：core.getDamage('greenSlime',0,0,'MT0') // 绿头怪的总伤害
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：总伤害，如果因为没有破防或无敌怪等其他原因无法战斗，则返回null",
+ "!doc": "获得某只敌人对主角的总伤害
例如：core.getDamage('greenSlime',0,0,'MT0') // 绿头怪的总伤害
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：总伤害，如果因为没有破防或无敌怪等其他原因无法战斗，则返回null",
"!type": "fn(enemy: string|enemy, x?: number, y?: number, floorId?: string) -> number"
},
"getDamageString": {
- "!doc": "获得某只敌人的地图显伤，包括颜色
例如：core.getDamageString('greenSlime', 0, 0, 'MT0') // 绿头怪的地图显伤
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：damage: 表示伤害值或为'???'，color: 形如'#RrGgBb'",
+ "!doc": "获得某只敌人的地图显伤，包括颜色
例如：core.getDamageString('greenSlime', 0, 0, 'MT0') // 绿头怪的地图显伤
enemy: 敌人id或敌人对象
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
floorId: 敌人所在的地图，可选
返回值：damage: 表示伤害值或为'???'，color: 形如'#RrGgBb'",
"!type": "fn(enemy: string|enemy, x?: number, y?: number, floorId?: string) -> {color: string, damage: string}"
},
"getCurrentEnemys": {
@@ -3724,101 +3724,101 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!doc": "检查某些楼层是否还有漏打的（某种）敌人
例如：core.hasEnemyLeft('greenSlime', ['sample0', 'sample1']) // 样板0层和1层是否有漏打的绿头怪
enemyId: 敌人id，可选，null表示任意敌人
floorId: 地图id或其数组，可选，不填为当前地图
返回值：地图中是否还存在该种敌人",
"!type": "fn(enemyId?: string, floorId?: string|[string]) -> bool"
}
- },
+ },
"events": {
"!doc": "events.js将处理所有和事件相关的操作，主要分为五个部分：
- 游戏的开始和结束
- 系统事件的处理
- 自定义事件的处理
- 点击状态栏图标所进行的操作
- 一些具体事件的执行内容",
"afterChangeFloor": {
- "!doc": "转换楼层结束的事件",
+ "!doc": "转换楼层结束的事件",
"!type": "fn(floorId?: string)"
- },
+ },
"popEventLoc": {
- "!doc": "将当前点坐标入栈",
+ "!doc": "将当前点坐标入栈",
"!type": "fn()"
- },
+ },
"afterOpenDoor": {
- "!doc": "开一个门后触发的事件",
+ "!doc": "开一个门后触发的事件",
"!type": "fn(doorId?: string, x?: number, y?: number)"
- },
+ },
"checkLvUp": {
- "!doc": "检查升级事件",
+ "!doc": "检查升级事件",
"!type": "fn()"
- },
+ },
"insertAction": {
- "!doc": "插入一段事件；此项不可插入公共事件，请用 core.insertCommonEvent
例如：core.insertAction('一段文字'); // 插入一个显示文章
action: 单个事件指令，或事件指令数组
x: 新的当前点横坐标，可选
y: 新的当前点纵坐标，可选
callback: 新的回调函数，可选
addToLast: 插入的位置，true表示插入到末尾，否则插入到开头",
+ "!doc": "插入一段事件；此项不可插入公共事件，请用 core.insertCommonEvent
例如：core.insertAction('一段文字'); // 插入一个显示文章
action: 单个事件指令，或事件指令数组
x: 新的当前点横坐标，可选
y: 新的当前点纵坐标，可选
callback: 新的回调函数，可选
addToLast: 插入的位置，true表示插入到末尾，否则插入到开头",
"!type": "fn(action: string|?|[?], x?: number, y?: number, callback?: fn(), addToLast?: bool)"
- },
+ },
"unfollow": {
- "!doc": "取消跟随
name: 取消跟随的行走图，不填则取消全部跟随者",
+ "!doc": "取消跟随
name: 取消跟随的行走图，不填则取消全部跟随者",
"!type": "fn(name?: string)"
- },
+ },
"hasVisitedFloor": {
- "!doc": "是否到达过某个楼层",
+ "!doc": "是否到达过某个楼层",
"!type": "fn(floorId?: string) -> bool"
- },
+ },
"startEvents": {
- "!doc": "开始执行一系列自定义事件",
+ "!doc": "开始执行一系列自定义事件",
"!type": "fn(list?: [?], x?: number, y?: number, callback?: fn())"
- },
+ },
"setHeroIcon": {
- "!doc": "更改主角行走图
例如：core.setHeroIcon('npc48.png', true); // 把主角从阳光变成样板0层左下角的小姐姐，但不立即刷新
name: 新的行走图文件名，可以是全塔属性中映射前的中文名。映射后会被存入core.status.hero.image
noDraw: true表示不立即刷新（刷新会导致大地图下视野重置到以主角为中心）",
+ "!doc": "更改主角行走图
例如：core.setHeroIcon('npc48.png', true); // 把主角从阳光变成样板0层左下角的小姐姐，但不立即刷新
name: 新的行走图文件名，可以是全塔属性中映射前的中文名。映射后会被存入core.status.hero.image
noDraw: true表示不立即刷新（刷新会导致大地图下视野重置到以主角为中心）",
"!type": "fn(name: string, noDraw?: bool)"
- },
+ },
"changingFloor": {
- "!doc": "楼层转换中",
+ "!doc": "楼层转换中",
"!type": "fn(floorId?: string, heroLoc?: {x: number, y: number, direction: string})"
- },
+ },
"setEvents": {
- "!doc": "直接设置事件列表",
+ "!doc": "直接设置事件列表",
"!type": "fn(list?: [?], x?: number, y?: number, callback?: fn())"
- },
+ },
"setValue": {
- "!doc": "数值操作",
+ "!doc": "数值操作",
"!type": "fn(name: string, operator: string, value: ?, prefix?: string)"
- },
+ },
"precompile": {
- "!doc": "预编辑事件",
+ "!doc": "预编辑事件",
"!type": "fn(data?: ?)"
- },
+ },
"vibrate": {
- "!doc": "视野抖动
例如：core.vibrate(); // 视野抖动1秒
direction: 抖动方向；可填 horizontal(左右)，vertical（上下），diagonal1（左上右下），diagonal2（左下右上）
time: 抖动时长
speed: 抖动速度
power: 抖动幅度
callback: 抖动平息后的回调函数，可选",
+ "!doc": "视野抖动
例如：core.vibrate(); // 视野抖动1秒
direction: 抖动方向；可填 horizontal(左右)，vertical（上下），diagonal1（左上右下），diagonal2（左下右上）
time: 抖动时长
speed: 抖动速度
power: 抖动幅度
callback: 抖动平息后的回调函数，可选",
"!type": "fn(direction?: string, time?: number, speed?: number, power?: number, callback?: fn())"
- },
+ },
"confirmRestart": {
- "!doc": "询问是否需要重新开始",
+ "!doc": "询问是否需要重新开始",
"!type": "fn()"
- },
+ },
"battle": {
- "!doc": "战斗，如果填写了坐标就会删除该点的敌人并触发战后事件
例如：core.battle('greenSlime'); // 和从天而降的绿头怪战斗（如果打得过）
id: 敌人id，必填
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
force: true表示强制战斗，可选
callback: 回调函数，可选",
+ "!doc": "战斗，如果填写了坐标就会删除该点的敌人并触发战后事件
例如：core.battle('greenSlime'); // 和从天而降的绿头怪战斗（如果打得过）
id: 敌人id，必填
x: 敌人的横坐标，可选
y: 敌人的纵坐标，可选
force: true表示强制战斗，可选
callback: 回调函数，可选",
"!type": "fn(id: string, x?: number, y?: number, force?: bool, callback?: fn())"
- },
+ },
"follow": {
- "!doc": "跟随
name: 要跟随的一个合法的4x4的行走图名称，需要在全塔属性注册",
+ "!doc": "跟随
name: 要跟随的一个合法的4x4的行走图名称，需要在全塔属性注册",
"!type": "fn(name: string)"
- },
+ },
"beforeBattle": {
- "!doc": "战斗前触发的事件；返回false代表不进行战斗",
+ "!doc": "战斗前触发的事件；返回false代表不进行战斗",
"!type": "fn(enemyId?: string, x?: number, y?: number) -> bool"
- },
+ },
"registerEvent": {
- "!doc": "注册一个自定义事件
type: 事件类型
func: 事件的处理函数，可接受(data, x, y, prefix)参数
data为事件内容，x和y为当前点坐标（可为null），prefix为当前点前缀",
+ "!doc": "注册一个自定义事件
type: 事件类型
func: 事件的处理函数，可接受(data, x, y, prefix)参数
data为事件内容，x和y为当前点坐标（可为null），prefix为当前点前缀",
"!type": "fn(type: string, func: fn(data: ?, x?: number, y?: number, prefix?: string))"
- },
+ },
"flyTo": {
- "!doc": "飞往某一层",
+ "!doc": "飞往某一层",
"!type": "fn(toId?: string, callback?: fn()) -> bool"
- },
+ },
"afterGetItem": {
- "!doc": "获得一个道具后的事件",
+ "!doc": "获得一个道具后的事件",
"!type": "fn(id?: string, x?: number, y?: number, isGentleClick?: bool)"
- },
+ },
"doAction": {
- "!doc": "执行下一个事件指令，常作为回调
例如：core.setCurtain([0,0,0,1], null, null, core.doAction); // 事件中的原生脚本，配合勾选“不自动执行下一个事件”来达到此改变色调只持续到下次场景切换的效果",
+ "!doc": "执行下一个事件指令，常作为回调
例如：core.setCurtain([0,0,0,1], null, null, core.doAction); // 事件中的原生脚本，配合勾选“不自动执行下一个事件”来达到此改变色调只持续到下次场景切换的效果",
"!type": "fn()"
- },
+ },
"openBook": {
- "!doc": "点击怪物手册时的打开操作",
+ "!doc": "点击怪物手册时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"save": {
"!doc": "点击存档按钮时的打开操作",
"!type": "fn(fromUserAction?: bool)"
@@ -3828,11 +3828,11 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(fromUserAction?: bool)"
},
"getNextItem": {
- "!doc": "轻按获得面前的物品或周围唯一物品
noRoute: 若为true则不计入录像",
+ "!doc": "轻按获得面前的物品或周围唯一物品
noRoute: 若为true则不计入录像",
"!type": "fn(noRoute?: bool)"
- },
+ },
"hasAsync": {
- "!doc": "当前是否有未处理完毕的异步事件（不包含动画和音效）",
+ "!doc": "当前是否有未处理完毕的异步事件（不包含动画和音效）",
"!type": "fn() -> bool"
},
"stopAsync": {
@@ -3840,21 +3840,21 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn()"
},
"openEquipbox": {
- "!doc": "点击装备栏时的打开操作",
+ "!doc": "点击装备栏时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"recoverEvents": {
- "!doc": "恢复一个事件",
+ "!doc": "恢复一个事件",
"!type": "fn(data?: ?)"
- },
+ },
"setGlobalFlag": {
- "!doc": "设置一个系统开关
例如：core.setGlobalFlag('steelDoorWithoutKey', true); // 使全塔的所有铁门都不再需要钥匙就能打开
name: 系统开关的英文名
value: 开关的新值，您可以用!core.flags[name]简单地表示将此开关反转",
+ "!doc": "设置一个系统开关
例如：core.setGlobalFlag('steelDoorWithoutKey', true); // 使全塔的所有铁门都不再需要钥匙就能打开
name: 系统开关的英文名
value: 开关的新值，您可以用!core.flags[name]简单地表示将此开关反转",
"!type": "fn(name: string, value: bool)"
- },
+ },
"moveImage": {
- "!doc": "移动一张图片并/或改变其透明度
例如：core.moveImage(1, null, 0.5); // 1秒内把1号图片变为50%透明
code: 图片编号
to: 新的左上角坐标，省略表示原地改变透明度
opacityVal: 新的透明度，省略表示不变
time: 移动用时，单位为毫秒。不填视为1秒
callback: 图片移动完毕后的回调函数，可选",
+ "!doc": "移动一张图片并/或改变其透明度
例如：core.moveImage(1, null, 0.5); // 1秒内把1号图片变为50%透明
code: 图片编号
to: 新的左上角坐标，省略表示原地改变透明度
opacityVal: 新的透明度，省略表示不变
time: 移动用时，单位为毫秒。不填视为1秒
callback: 图片移动完毕后的回调函数，可选",
"!type": "fn(code: number, to?: [number], opacityVal?: number, moveMode?: string, time?: number, callback?: fn())"
- },
+ },
"rotateImage": {
"!doc": "旋转一张图片
code: 图片编号
center: 旋转中心像素坐标（以屏幕为基准）；不填视为图片本身中心
angle: 旋转角度；正数为顺时针，负数为逆时针
moveMode: 旋转模式
time: 旋转用时，单位为毫秒。不填视为1秒
callback: 图片旋转完毕后的回调函数，可选",
"!type": "fn(code: number, center?: [number], angle?: number, moveMode?: string, time?: number, callback?: fn())"
@@ -3872,37 +3872,37 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(code: number)"
},
"openSettings": {
- "!doc": "点击设置按钮时的操作",
+ "!doc": "点击设置按钮时的操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"afterPushBox": {
- "!doc": "推箱子后的事件",
+ "!doc": "推箱子后的事件",
"!type": "fn()"
- },
+ },
"unregisterSystemEvent": {
- "!doc": "注销一个系统事件",
+ "!doc": "注销一个系统事件",
"!type": "fn(type: string)"
- },
+ },
"trigger": {
- "!doc": "触发(x,y)点的系统事件；会执行该点图块的script属性，同时支持战斗（会触发战后）、道具（会触发道具后）、楼层切换等等
callback: 执行完毕的回调函数
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "触发(x,y)点的系统事件；会执行该点图块的script属性，同时支持战斗（会触发战后）、道具（会触发道具后）、楼层切换等等
callback: 执行完毕的回调函数
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(x?: number, y?: number, callback?: fn())"
- },
+ },
"restart": {
- "!doc": "重新开始游戏；此函数将回到标题页面",
+ "!doc": "重新开始游戏；此函数将回到标题页面",
"!type": "fn()"
- },
+ },
"doEvent": {
- "!doc": "执行一个自定义事件",
+ "!doc": "执行一个自定义事件",
"!type": "fn(data?: ?, x?: number, y?: number, prefix?: string)"
- },
+ },
"win": {
- "!doc": "游戏获胜事件",
+ "!doc": "游戏获胜事件",
"!type": "fn(reason?: string, norank?: bool, noexit?: bool)"
- },
+ },
"setGlobalAttribute": {
- "!doc": "设置全塔属性",
+ "!doc": "设置全塔属性",
"!type": "fn(name: string, value: string)"
- },
+ },
"setNameMap": {
"!doc": "设置文件别名",
"!type": "fn(name: string, value?: string)"
@@ -3912,89 +3912,89 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(data: ?)"
},
"openToolbox": {
- "!doc": "点击工具栏时的打开操作",
+ "!doc": "点击工具栏时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"setVolume": {
- "!doc": "调节bgm的音量
例如：core.setVolume(0, 100, core.jumpHero); // 0.1秒内淡出bgm，然后主角原地跳跃半秒
value: 新的音量，为0或不大于1的正数。注意系统设置中是这个值的平方根的十倍
time: 渐变用时，单位为毫秒。不填或小于100毫秒都视为0
callback: 渐变完成后的回调函数，可选",
+ "!doc": "调节bgm的音量
例如：core.setVolume(0, 100, core.jumpHero); // 0.1秒内淡出bgm，然后主角原地跳跃半秒
value: 新的音量，为0或不大于1的正数。注意系统设置中是这个值的平方根的十倍
time: 渐变用时，单位为毫秒。不填或小于100毫秒都视为0
callback: 渐变完成后的回调函数，可选",
"!type": "fn(value: number, time?: number, callback?: fn())"
- },
+ },
"pushEventLoc": {
- "!doc": "将当前点坐标入栈",
+ "!doc": "将当前点坐标入栈",
"!type": "fn(x?: number, y?: number, floorId?: string) -> bool"
- },
+ },
"openKeyBoard": {
- "!doc": "点击虚拟键盘时的打开操作",
+ "!doc": "点击虚拟键盘时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"insertCommonEvent": {
- "!doc": "插入一个公共事件
例如：core.insertCommonEvent('加点事件', [3]);
name: 公共事件名；如果公共事件不存在则直接忽略
args: 参数列表，为一个数组，将依次赋值给 flag:arg1, flag:arg2, ...
x: 新的当前点横坐标，可选
y: 新的当前点纵坐标，可选
callback： 新的回调函数，可选
addToLast: 插入的位置，true表示插入到末尾，否则插入到开头",
+ "!doc": "插入一个公共事件
例如：core.insertCommonEvent('加点事件', [3]);
name: 公共事件名；如果公共事件不存在则直接忽略
args: 参数列表，为一个数组，将依次赋值给 flag:arg1, flag:arg2, ...
x: 新的当前点横坐标，可选
y: 新的当前点纵坐标，可选
callback： 新的回调函数，可选
addToLast: 插入的位置，true表示插入到末尾，否则插入到开头",
"!type": "fn(name?: string, args?: [?], x?: number, y?: number, callback?: fn(), addToLast?: bool)"
- },
+ },
"hideImage": {
- "!doc": "隐藏一张图片
例如：core.hideImage(1, 1000, core.jumpHero); // 1秒内淡出1号图片，然后主角原地跳跃半秒
code: 图片编号
time: 淡出时间，单位为毫秒
callback: 图片完全消失后的回调函数，可选",
+ "!doc": "隐藏一张图片
例如：core.hideImage(1, 1000, core.jumpHero); // 1秒内淡出1号图片，然后主角原地跳跃半秒
code: 图片编号
time: 淡出时间，单位为毫秒
callback: 图片完全消失后的回调函数，可选",
"!type": "fn(code: number, time?: number, callback?: fn())"
- },
+ },
"visitFloor": {
- "!doc": "到达某楼层",
+ "!doc": "到达某楼层",
"!type": "fn(floorId?: string)"
- },
+ },
"openQuickShop": {
- "!doc": "点击快捷商店按钮时的打开操作",
+ "!doc": "点击快捷商店按钮时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"afterBattle": {
- "!doc": "战斗结束后触发的事件",
+ "!doc": "战斗结束后触发的事件",
"!type": "fn(enemyId?: string, x?: number, y?: number)"
- },
+ },
"pushBox": {
- "!doc": "推箱子",
+ "!doc": "推箱子",
"!type": "fn(data?: ?)"
- },
+ },
"autoEventExecuted": {
- "!doc": "当前是否执行过某个自动事件",
+ "!doc": "当前是否执行过某个自动事件",
"!type": "fn(symbol?: string, value?: ?) -> bool"
},
"onSki": {
- "!doc": "当前是否在冰上",
+ "!doc": "当前是否在冰上",
"!type": "fn(number?: number) -> bool"
- },
+ },
"showImage": {
- "!doc": "显示一张图片
例如：core.showImage(1, core.material.images.images['winskin.png'], [0,0,128,128], [0,0,416,416], 0.5, 1000); // 裁剪winskin.png的最左边128×128px，放大到铺满整个视野，1秒内淡入到50%透明，编号为1
code: 图片编号，为不大于50的正整数，加上100后就是对应画布层的z值，较大的会遮罩较小的，注意色调层的z值为125，UI层为140
image: 图片文件名（可以是全塔属性中映射前的中文名）或图片对象（见上面的例子）
sloc: 一行且至多四列的数组，表示从原图裁剪的左上角坐标和宽高，可选
loc: 一行且至多四列的数组，表示图片在视野中的左上角坐标和宽高，可选
opacityVal: 不透明度，为小于1的正数。不填视为1
time: 淡入时间，单位为毫秒。不填视为0
callback: 图片完全显示出来后的回调函数，可选",
+ "!doc": "显示一张图片
例如：core.showImage(1, core.material.images.images['winskin.png'], [0,0,128,128], [0,0,416,416], 0.5, 1000); // 裁剪winskin.png的最左边128×128px，放大到铺满整个视野，1秒内淡入到50%透明，编号为1
code: 图片编号，为不大于50的正整数，加上100后就是对应画布层的z值，较大的会遮罩较小的，注意色调层的z值为125，UI层为140
image: 图片文件名（可以是全塔属性中映射前的中文名）或图片对象（见上面的例子）
sloc: 一行且至多四列的数组，表示从原图裁剪的左上角坐标和宽高，可选
loc: 一行且至多四列的数组，表示图片在视野中的左上角坐标和宽高，可选
opacityVal: 不透明度，为小于1的正数。不填视为1
time: 淡入时间，单位为毫秒。不填视为0
callback: 图片完全显示出来后的回调函数，可选",
"!type": "fn(code: number, image: string|image, sloc?: [number], loc?: [number], opacityVal?: number, time?: number, callback?: fn())"
- },
+ },
"getItem": {
- "!doc": "获得道具并提示，如果填写了坐标就会删除该点的该道具
例如：core.getItem('book'); // 获得敌人手册并提示
id: 道具id，必填
num: 获得的数量，不填视为1，填了就别填坐标了
x: 道具的横坐标，可选
y: 道具的纵坐标，可选
callback: 回调函数，可选",
+ "!doc": "获得道具并提示，如果填写了坐标就会删除该点的该道具
例如：core.getItem('book'); // 获得敌人手册并提示
id: 道具id，必填
num: 获得的数量，不填视为1，填了就别填坐标了
x: 道具的横坐标，可选
y: 道具的纵坐标，可选
callback: 回调函数，可选",
"!type": "fn(id: string, num?: number, x?: number, y?: number, callback?: fn())"
- },
+ },
"registerSystemEvent": {
- "!doc": "注册一个系统事件
type: 事件名
func: 为事件的处理函数，可接受(data,callback)参数",
+ "!doc": "注册一个系统事件
type: 事件名
func: 为事件的处理函数，可接受(data,callback)参数",
"!type": "fn(type: string, func: fn(data?: ?, callback?: fn()))"
- },
+ },
"startGame": {
- "!doc": "开始新游戏
例如：core.startGame('咸鱼乱撞', 0, ''); // 开始一局咸鱼乱撞难度的新游戏，随机种子为0
hard: 难度名，会显示在左下角（横屏）或右下角（竖屏）
seed: 随机种子，相同的种子保证了录像的可重复性
route: 经由base64压缩后的录像，用于从头开始的录像回放
callback: 回调函数，可选",
+ "!doc": "开始新游戏
例如：core.startGame('咸鱼乱撞', 0, ''); // 开始一局咸鱼乱撞难度的新游戏，随机种子为0
hard: 难度名，会显示在左下角（横屏）或右下角（竖屏）
seed: 随机种子，相同的种子保证了录像的可重复性
route: 经由base64压缩后的录像，用于从头开始的录像回放
callback: 回调函数，可选",
"!type": "fn(hard: string, seed: number, route: string, callback?: fn())"
- },
+ },
"doSystemEvent": {
- "!doc": "执行一个系统事件",
+ "!doc": "执行一个系统事件",
"!type": "fn(type: string, data?: ?, callback?: fn())"
- },
+ },
"resetGame": {
- "!doc": "初始化游戏",
+ "!doc": "初始化游戏",
"!type": "fn(hero?: ?, hard?: ?, floorId?: string, maps?: ?, values?: ?)"
- },
+ },
"setFloorInfo": {
- "!doc": "设置一项楼层属性并刷新状态栏
例如：core.setFloorInfo('ratio', 2, 'MT0'); // 把主塔0层的血瓶和宝石变为双倍效果
name: 要修改的属性名
values: 属性的新值。
floorId: 楼层id，不填视为当前层
prefix: 独立开关前缀，一般不需要",
+ "!doc": "设置一项楼层属性并刷新状态栏
例如：core.setFloorInfo('ratio', 2, 'MT0'); // 把主塔0层的血瓶和宝石变为双倍效果
name: 要修改的属性名
values: 属性的新值。
floorId: 楼层id，不填视为当前层
prefix: 独立开关前缀，一般不需要",
"!type": "fn(name: string, values: ?, floorId?: string, prefix?: string)"
- },
+ },
"openDoor": {
- "!doc": "开门（包括三种基础墙）
例如：core.openDoor(0, 0, true, core.jumpHero); // 打开左上角的门，需要钥匙，然后主角原地跳跃半秒
x: 门的横坐标
y: 门的纵坐标
needKey: true表示需要钥匙，会导致机关门打不开
callback: 门完全打开后或打不开时的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "开门（包括三种基础墙）
例如：core.openDoor(0, 0, true, core.jumpHero); // 打开左上角的门，需要钥匙，然后主角原地跳跃半秒
x: 门的横坐标
y: 门的纵坐标
needKey: true表示需要钥匙，会导致机关门打不开
callback: 门完全打开后或打不开时的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(x: number, y: number, needKey?: bool, callback?: fn())"
- },
+ },
"setEnemy": {
- "!doc": "设置一项敌人属性并计入存档
例如：core.setEnemy('greenSlime', 'def', 0); // 把绿头怪的防御设为0
id: 敌人id
name: 属性的英文缩写
value: 属性的新值，可选
operator: 运算操作符如+=，可选
prefix: 独立开关前缀，一般不需要，下同",
+ "!doc": "设置一项敌人属性并计入存档
例如：core.setEnemy('greenSlime', 'def', 0); // 把绿头怪的防御设为0
id: 敌人id
name: 属性的英文缩写
value: 属性的新值，可选
operator: 运算操作符如+=，可选
prefix: 独立开关前缀，一般不需要，下同",
"!type": "fn(id: string, name: string, value: ?, operator?: string, prefix?: string)"
- },
+ },
"setEnemyOnPoint": {
"!doc": "设置某个点的敌人属性。如果该点不是怪物，则忽略此函数。
例如：core.setEnemyOnPoint(3, 5, null, 'atk', 100, '+='); // 仅将(3,5)点怪物的攻击力加100。",
"!type": "fn(x: number, y: number, floorId?: string, name: string, value: ?, operator?: string, prefix?: string)"
@@ -4008,55 +4008,55 @@ var terndefs_f6783a0a_522d_417e_8407_94c67b692e50 = [
"!type": "fn(fromX: number, fromY: number, toX: number, toY: number, floorId?: string)"
},
"autoEventExecuting": {
- "!doc": "当前是否在执行某个自动事件",
+ "!doc": "当前是否在执行某个自动事件",
"!type": "fn(symbol?: string, value?: ?) -> bool"
- },
+ },
"checkAutoEvents": {
- "!doc": "检测自动事件",
+ "!doc": "检测自动事件",
"!type": "fn()"
- },
+ },
"showGif": {
- "!doc": "绘制一张动图或擦除所有动图
例如：core.showGif(); // 擦除所有动图
name: 动图文件名，可以是全塔属性中映射前的中文名
x: 动图在视野中的左上角横坐标
y: 动图在视野中的左上角纵坐标",
+ "!doc": "绘制一张动图或擦除所有动图
例如：core.showGif(); // 擦除所有动图
name: 动图文件名，可以是全塔属性中映射前的中文名
x: 动图在视野中的左上角横坐标
y: 动图在视野中的左上角纵坐标",
"!type": "fn(name?: string, x?: number, y?: number)"
- },
+ },
"unregisterEvent": {
- "!doc": "注销一个自定义事件",
+ "!doc": "注销一个自定义事件",
"!type": "fn(type: string)"
- },
+ },
"jumpHero": {
- "!doc": "主角跳跃，跳跃勇士。ex和ey为目标点的坐标，可以为null表示原地跳跃。time为总跳跃时间。
例如：core.jumpHero(); // 主角原地跳跃半秒
ex: 跳跃后的横坐标
ey: 跳跃后的纵坐标
time: 跳跃时长，单位为毫秒。不填视为半秒
callback: 跳跃完毕后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "主角跳跃，跳跃勇士。ex和ey为目标点的坐标，可以为null表示原地跳跃。time为总跳跃时间。
例如：core.jumpHero(); // 主角原地跳跃半秒
ex: 跳跃后的横坐标
ey: 跳跃后的纵坐标
time: 跳跃时长，单位为毫秒。不填视为半秒
callback: 跳跃完毕后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(ex?: number, ey?: number, time?: number, callback?: fn())"
- },
+ },
"closeDoor": {
- "!doc": "关门，目标点必须为空地
例如：core.closeDoor(0, 0, 'yellowWall', core.jumpHero); // 在左上角关掉一堵黄墙，然后主角原地跳跃半秒
x: 横坐标
y: 纵坐标
id: 门的id，也可以用三种基础墙
callback: 门完全关上后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "关门，目标点必须为空地
例如：core.closeDoor(0, 0, 'yellowWall', core.jumpHero); // 在左上角关掉一堵黄墙，然后主角原地跳跃半秒
x: 横坐标
y: 纵坐标
id: 门的id，也可以用三种基础墙
callback: 门完全关上后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(x: number, y: number, id: string, callback?: fn())"
- },
+ },
"eventMoveHero": {
- "!doc": "强制移动主角（包括后退），这个函数的作者已经看不懂这个函数了
例如：core.eventMoveHero(['forward'], 125, core.jumpHero); // 主角强制前进一步，用时1/8秒，然后主角原地跳跃半秒
steps: 步伐数组，注意后退时跟随者的行为会很难看
time: 每步的用时，单位为毫秒。0或不填则取主角的移速，如果后者也不存在就取0.1秒
callback: 移动完毕后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "强制移动主角（包括后退），这个函数的作者已经看不懂这个函数了
例如：core.eventMoveHero(['forward'], 125, core.jumpHero); // 主角强制前进一步，用时1/8秒，然后主角原地跳跃半秒
steps: 步伐数组，注意后退时跟随者的行为会很难看
time: 每步的用时，单位为毫秒。0或不填则取主角的移速，如果后者也不存在就取0.1秒
callback: 移动完毕后的回调函数，可选
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(steps: [step], time?: number, callback?: fn())"
- },
+ },
"changeFloor": {
- "!doc": "场景切换
例如：core.changeFloor('MT0'); // 传送到主塔0层，主角坐标和朝向不变，黑屏时间取用户定义的值
floorId: 传送的目标地图id，可以填':before'和':next'分别表示楼下或楼上
stair: 传送的位置
heroLoc: 传送的坐标；会覆盖stair
time: 传送的黑屏时间，单位为毫秒；不填为用户设置值
callback: 传送的回调函数
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
+ "!doc": "场景切换
例如：core.changeFloor('MT0'); // 传送到主塔0层，主角坐标和朝向不变，黑屏时间取用户定义的值
floorId: 传送的目标地图id，可以填':before'和':next'分别表示楼下或楼上
stair: 传送的位置
heroLoc: 传送的坐标；会覆盖stair
time: 传送的黑屏时间，单位为毫秒；不填为用户设置值
callback: 传送的回调函数
【异步脚本，请勿在脚本中直接调用（而是使用对应的事件），否则可能导致录像出错】",
"!type": "fn(floorId: string, stair?: string, heroLoc?: {x?: number, y?: number, direction?: string}, time?: number, callback?: fn())"
- },
+ },
"getCommonEvent": {
- "!doc": "获得一个公共事件",
+ "!doc": "获得一个公共事件",
"!type": "fn(name: string) -> [?]"
- },
+ },
"lose": {
- "!doc": "游戏失败事件",
+ "!doc": "游戏失败事件",
"!type": "fn(reason?: string)"
- },
+ },
"gameOver": {
- "!doc": "游戏结束
例如：core.gameOver(); // 游戏失败
ending: 结局名，省略表示失败
fromReplay: true表示在播放录像，可选
norank: true表示不计入榜单，可选",
+ "!doc": "游戏结束
例如：core.gameOver(); // 游戏失败
ending: 结局名，省略表示失败
fromReplay: true表示在播放录像，可选
norank: true表示不计入榜单，可选",
"!type": "fn(ending?: string, fromReplay?: bool, norank?: bool)"
- },
+ },
"useFly": {
- "!doc": "点击楼层传送器时的打开操作",
+ "!doc": "点击楼层传送器时的打开操作",
"!type": "fn(fromUserAction?: bool)"
- },
+ },
"tryUseItem": {
- "!doc": "尝试使用一个道具
例如：core.tryUseItem('pickaxe'); // 尝试使用破墙镐
itemId: 道具id，其中敌人手册、传送器和飞行器会被特殊处理",
+ "!doc": "尝试使用一个道具
例如：core.tryUseItem('pickaxe'); // 尝试使用破墙镐
itemId: 道具id，其中敌人手册、传送器和飞行器会被特殊处理",
"!type": "fn(itemId: string)"
}
},
diff --git a/libs/core.js b/libs/core.js
index 8aece0b6..d6685e9a 100644
--- a/libs/core.js
+++ b/libs/core.js
@@ -521,9 +521,6 @@ core.prototype._forwardFunc = function (name, funcname) {
var parameters = (parameterInfo == null ? "" : parameterInfo[1]).replace(/\s*/g, '').replace(/,/g, ', ');
// core[funcname] = new Function(parameters, "return core."+name+"."+funcname+"("+parameters+");");
eval("core." + funcname + " = function (" + parameters + ") {\n\treturn core." + name + "." + funcname + "(" + parameters + ");\n}");
- if (name == 'plugin') {
- console.error("插件函数转发：core." + funcname + " = core.plugin." + funcname);
- }
}
core.prototype.doFunc = function (func, _this) {
diff --git a/project/functions.js b/project/functions.js
index 1f776f9d..0a8dd39f 100644
--- a/project/functions.js
+++ b/project/functions.js
@@ -1244,7 +1244,7 @@ var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
// 更新阻激夹域的伤害值
core.updateCheckBlock();
- // 更新全地图显伤
+ // updateDamage只能在此处执行！！更新全地图显伤
core.updateDamage();
},
"updateCheckBlock": function (floorId) {
diff --git a/runtime.d.ts b/runtime.d.ts
index e428f603..9ff9583d 100644
--- a/runtime.d.ts
+++ b/runtime.d.ts
@@ -1865,7 +1865,7 @@ declare class maps {
getPlayingAnimates(name?: string): Array
/** 加载某个楼层（从剧本或存档中） */
- loadFloor(floorId?: string, map?: any): ResolvedMap
+ loadFloor(floorId: string, map?: any): ResolvedMap
/** 根据需求解析出blocks */
extractBlocks(map?: any): void
diff --git a/启动服务.exe b/启动服务.exe
index 95cfac400007d94ffcfdb1cf1ac7b4593ca57cca..03dcc7ad06a5a6de0641dec733a774fdf66da966 100644
GIT binary patch
literal 59904
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
literal 57344
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