Merge remote-tracking branch 'refs/remotes/ckcz123/v2.x' into v2.x

.gitignore

@@ -1,7 +1,7 @@
 .vscode
-*ce5eec52_2fa1_447b_8dad_764e267a7fab*
 
 .DS_Store
+MTBuilder.app
 
 # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

B站视频教程.url

@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,2
+[InternetShortcut]
+IDList=
+URL=https://www.bilibili.com/video/av32781473/

HTML5魔塔样板使用说明文档.url

@@ -2,4 +2,4 @@
 Prop3=19,2
 [InternetShortcut]
 IDList=
-URL=https://ckcz123.github.io/mota-js/
+URL=https://h5mota.com/games/template/docs/

README.md

@@ -8,9 +8,9 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 * [List / HTML5魔塔游戏列表](https://h5mota.com/)
 * [Demo / 样板效果](https://ckcz123.com/games/template/)
 * [Docs / 使用文档说明](https://ckcz123.github.io/mota-js/)
-* [Video / 视频教程](http://www.bilibili.com/video/av17608025/)
+* [Video / 视频教程](https://www.bilibili.com/video/av32781473/)
 
-![样板](./docs/img/sample0.png)
+![样板](./_docs/img/sample0.png)
 
 ## 目录结构
 
@@ -25,8 +25,8 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 │ ├─ data.js         # 记录了一些初始化信息
 │ ├─ enemys.js       # 记录了怪物的信息，包括特殊属性、伤害计算公式、临界值计算等。
 │ ├─ events.js       # 处理事件的文件，所有自定义事件都会在此文件中进行处理
-│ ├─ icons.js        # 记录了图标信息
-│ ├─ items.js        # 道具的使用
+│ ├─ icons.js        # 图标信息，会被转发到project下
+│ ├─ items.js        # 道具信息，会被转发到project下
 │ ├─ loader.js       # 动态加载JS代码、图片、音效等
 │ ├─ maps.js         # 记录了地图信息，和地图绘制等操作
 │ ├─ ui.js           # UI绘制信息，主要负责绘制各个UI窗口。
@@ -38,27 +38,240 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 │ ├─ /sounds/        # 音效目录
 │ ├─ data.js         # 全局变量信息
 │ ├─ enemys.js       # 怪物属性数据
+│ ├─ events.js       # 公共事件
 │ ├─ functions.js    # 可能会被修改的脚本代码
 │ ├─ icons.js        # 素材和ID的对应关系定义
 │ ├─ items.js        # 道具的定义，获得道具的效果
-│ └─ maps.js         # 地图和数字的对应关系
-├── /常用工具/        # 一些常用工具，可以辅助造塔  
-│ ├─ RM动画导出器.exe      # 能从RMXP中导出动画，以供H5使用。 http://github.com/ckcz123/animate_export/
-│ ├─ JS代码压缩工具.exe    # 能对Javascript代码进行压缩和整合，从而减少IO请求量。 http://github.com/ckcz123/JSCompressor/
-│ ├─ 便捷PS工具.exe        # 能只用复制和粘贴来快速对素材进行PS操作。  http://github.com/ckcz123/ps/
-│ ├─ 地图生成器.exe        # 能从一张截图识别出来具体的数字数组，方便复刻已有的塔。 http://github.com/ckcz123/map_generator/
-│ └─ 伤害和临界值计算器.exe       # 一个能帮助计算怪物的伤害和临界值的小工具。 http://github.com/ckcz123/magic-tower-calculator/
-├── /启动服务(mac版).app/        # 启动服务的mac版本。  
+│ ├─ maps.js         # 地图和数字的对应关系
+│ └─ plugins.js      # 自定义插件
+├── /常用工具/        # 一些常用工具，可以辅助造塔；具体可参见下面的【相关工具】
 ├── editor.html      # 可视化地图编辑工具
 ├── editor-mobile.html      # 可视化地图编辑工具（手机版）
 ├── index.html       # 主程序，游戏的入口
 ├── main.js          # JS程序的入口，将动态对所需JS进行加载
 ├── style.css        # 游戏所需要用到的样式表
-└── 启动服务.exe      # 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。 http://github.com/ckcz123/mota-js-server/
+└── 启动服务.exe      # 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。
 ```
 
 ## 更新说明
 
+### 2019.5.2 V2.6.1
+
+* [x] 区域优化的录像播放功能，R键使用
+* [x] 强制战斗可以指定怪物坐标，将自动隐藏并执行该点战后事件
+* [x] flag:xxx也支持中文，例如 flag:2楼机关门
+* [x] 增加文件名映射，可以用中文映射到某个图片或bgm文件并使用
+* [x] 勇士宽度可以超过32（例如48x48的勇士行走图）
+* [x] 现在允许修改floorId和图块ID了（在表格下方）
+* [x] 增加事件：自动存档，返回标题界面；部分事件优化
+* [x] 商店长按空格可以连续加点
+* [x] 增设global:xxx使用全局存储，可被录像支持
+* [x] 支持\b[hero]和\b[null,x,y]来自动调整上下方向
+* [x] 支持\t[yellowKey]等只显示图标而没有标题
+* [x] 编辑器中前景层对于有事件的点半透明显示
+* [x] 存档改成1000页，长按上下页可快速翻页
+* [x] 录像播放初始默认暂停，N键可以单步执行
+* [x] 增设本地API文档，部分API和事件的优化
+* [x] 所有已知的bug修复，大量细节优化
+
+### 2019.4.13 V2.6
+
+* [x] 拆分整个项目，大幅重构代码，新增大量API
+* [x] 重写文档，尤其是脚本和API列表
+* [x] 现在可以对编辑器的表格的结构进行配置
+* [x] 可以收藏和高亮存档
+* [x] 独立出来的插件编写
+* [x] 新增事件：关门、显示确认框、后置循环处理
+* [x] 剧情文本的绘制可以设置居中选项
+* [x] 选项框的绘制可以增加图标
+* [x] 增加公共事件版的全局商店
+* [x] 公共事件现在可以传入参数
+* [x] 重写滑冰事件，现在滑冰在背景层了
+* [x] 将输入框改成自定义实现，避免部分设备不支持
+* [x] 状态栏文字可以自动放缩
+* [x] 显示图片和对话框立绘可以裁剪图片
+* [x] 修复所有已知bug，大量细节优化
+
+### 2019.2.19 V2.5.5
+
+* [x] 现在编辑器修改地图后可以直接读档生效，无需再重置地图或回放录像
+* [x] 存档方式优化，大幅降低单个存档的占用空间
+* [x] 脚本编辑器增加代码格式化的选项
+* [x] 事件和脚本编辑器中Ctrl+S可以进行保存
+* [x] 显示选择项提供颜色控制
+* [x] 事件的移动勇士增加前进和后退两个操作
+* [x] 事件编辑器的下拉框增加滚动条
+* [x] 通关后将询问是否进行评分
+* [x] 录像播放失败后可以回退到上个节点
+* [x] 修复已知的所有Bug，大量细节优化
+
+### 2019.2.4 V2.5.4
+
+* [x] 发布15x15的版本
+* [x] 独立出来的公共事件
+* [x] 支持多重装备（一个装备可以装到多个孔上）
+* [x] 工具栏按钮增添至8个，快捷商店和虚拟键盘同时显示
+* [x] 点击状态栏的金币图标也可以打开快捷商店
+* [x] 等待事件提供flag:px和flag:py在0~415之间
+* [x] 事件：呼出存读档界面；呼出怪物手册
+* [x] 事件：使用道具，暂停背景音乐，暂停所有音效
+* [x] type:trigger可以触发系统事件
+* [x] 独立开关
+* [x] 贴图也可以支持帧动画了
+* [x] 图块内置颜色选择器
+* [x] 标题界面增加音乐按钮
+* [x] 等待事件可被Ctrl（长按）跳过
+* [x] 部分Bug修复，大量细节优化，性能进一步得到提升
+
+### 2018.12.22 V2.5.3
+
+* [x] 标题界面事件化；现在可以用事件流来处理标题界面了
+* [x] 动态canvas管理；无限图层，可以任意创建图层并使用
+* [x] 状态栏canvas化，可以自行对状态栏进行绘制
+* [x] 手机端新增1-7按钮，可点工具栏进行切换
+* [x] 事件编辑器可以查看最近使用图块和搜索图块
+* [x] 事件编辑器中增加增加颜色选择器
+* [x] 对话框里`\f`可以自带立绘效果
+* [x] 图片相关事件全部修改为动态canvas实现
+* [x] 新增事件：滚动字幕
+* [x] 新增事件：等待所有异步事件执行完毕
+* [x] 新增事件：画面闪烁
+* [x] BGM缓存管理；新增事件：预加载BGM
+* [x] 新增天气：雾
+* [x] 每次到达楼层执行的事件`eachArrive`
+* [x] 可以控制某些图块无全局动画效果
+* [x] 背景/前景层的素材可以全局动画/动态Autotile效果
+* [x] 可以为每个装备单独设置是否按比例增加
+* [x] 地图编辑器中选中点高亮；双击选中素材；WASD平移大地图
+* [x] 修复所有Bug，部分代码重构，大量细节优化
+
+### 2018.11.30 V2.5.2
+
+* [x] 怪物和NPC的行走图和朝向问题
+* [x] 可以引入WindowSkin作为对话框的背景素材
+* [x] 允许使用\t[标题,1.png]来绘制大头像图
+* [x] 对话框的宽度可以根据文本长度自动调整
+* [x] \r[red]可以动态调整剧情文本的颜色
+* [x] 升级事件改用事件编辑器完成
+* [x] 每层楼都增添该层的并行事件处理
+* [x] 新增快捷键：N返回标题；P游戏主页；O打开工程
+* [x] 新增事件：设置全局属性或全局数值
+* [x] 新增事件：隐藏/显示状态栏
+* [x] 道具可以设置是否在回放时绘制道具栏或直接使用
+* [x] 可以同时异步移动/跳跃勇士和多个NPC
+* [x] 可以同时异步移动两张或以上的图片了
+* [x] 追加素材一次可以追加多个
+* [x] 菜单栏中新增虚拟键盘的弹出
+* [x] 修复所有已知Bug；部分细节优化
+
+### 2018.11.21 V2.5.1
+
+* [x] 新增事件type:insert，可以插入另一个地点的事件执行（公共事件）
+* [x] 可以使用\r来控制剧情文本部分文字的颜色
+* [x] 新增事件type:switch，多重分歧
+* [x] 绘制前景/背景层时淡化其他图层
+* [x] 追加素材的自动调整（如白底、不规范的素材）
+* [x] 浏览地图时：左上角/V开启显伤；右上角/Z查看当前层大地图
+* [x] 允许在受到领域夹击等伤害后禁用快捷商店
+* [x] 升级的扣除模式，即不显示经验值，只显示升级的所需剩余值
+* [x] 装备增加可装备条件判定
+* [x] 选项界面可以使用1-9快速选择
+* [x] 未开启状态的快捷商店用灰色显示
+* [x] 修复不能在背景/前景层绘图的Bug
+* [x] 手机端的地图编辑器也能有报错信息了
+* [x] 部分其他细节优化
+
+### 2018.10.31 V2.5
+
+* [x] 添加绘图模式支持；可以用户手动绘图和保存
+* [x] 内置主动技能：二倍斩的支持，可以仿照制作其他主动技能
+* [x] 将按键处理移动到脚本编辑中
+* [x] Alt+0\~9保存和读取当前套装
+* [x] 图块属性的cannotOut和cannotIn控制可通行方向（来造成悬崖效果）
+* [x] 支持动态Autotile自动元件（仅在事件层有效）
+* [x] 允许快捷商店使用共用的times
+* [x] 未启用的快捷商店可以隐藏或预览
+* [x] 开始剧情startText可以执行任意事件
+* [x] 对话窗口可以任意调节位置（上中下、距离顶部/底部的像素值）
+* [x] 楼层转换界面可以设置背景图片文字颜色等
+* [x] 数据统计进行分段描写，剑盾显示数值
+* [x] 现在可以在事件编辑器中注释内容了
+* [x] 存读档界面显示该存档的属性
+* [x] F7键可以开启debug模式
+* [x] R键可以从本地选取录像文件从头播放
+* [x] 吸血属性的显伤增加^；仇恨怪显示仇恨伤害
+* [x] 4键默认使用破冰稿或冰冻徽章或地震卷轴或上下楼器（依次判断是否存在）
+* [x] 血瓶的道具化选项；黄宝石增加加点选项
+* [x] 破炸飞增加默认音效
+* [x] 修复单击瞬移的拖动打怪问题
+* [x] 其他细节优化
+
+### 2018.10.27 V2.4.4
+
+* [x] tilesets可以设置图块属性（如可通行状态）
+* [x] 追加素材时可以更改图片色调
+* [x] 防作弊手段的进一步加强：打开控制台则禁止上传成绩
+* [x] 图块属性增加“是否可被破震”的选项
+* [x] 模仿怪物内置模仿临界计算器
+* [x] 部分其他细节优化
+
+### 2018.10.14 V2.4.3
+
+* [x] 并行事件处理
+* [x] 事件：设置楼层属性
+* [x] 增加光环属性，还可以制作区域光环效果
+* [x] 将部分代码移动到脚本编辑中
+* [x] 事件改变天气或画面色调，读档后仍有效
+* [x] Autotile自动元件的新增和注册
+* [x] 状态栏可以显示角色名字
+* [x] 浏览地图可以显伤
+* [x] 图片淡入淡出和移动图片可以将其保留
+* [x] 双击道具栏图标直接进入装备栏
+* [x] 可以设置剧情文本的字体大小
+* [x] 录像播放可以最高24倍速
+* [x] 1-6键快速设置录像播放速度；滚轮加减速
+* [x] 修复大地图的夹击Bug
+* [x] 部分其他细节优化
+
+### 2018.9.28 V2.4.2
+
+* [x] 允许导入tilesets直接使用，无需PS和注册
+* [x] tilesets的素材允许以矩形方式整体绘制
+* [x] Alt+0\~9保存素材，Ctrl+0\~9快速选中
+* [x] 增加了透明块的支持
+* [x] 装备允许按照百分比增加属性
+* [x] 多动画的同时播放
+* [x] 修复了打开存读档页面时闪屏的问题
+* [x] 修复了cannotMove仍然能轻按和瞬移的问题
+* [x] 所有已知Bug修复，部分代码重构和细节优化
+
+### 2018.9.18 V2.4.1
+
+* [x] 增加背景层和前景层的图块绘制，多层图块可叠加
+* [x] 背景层/前景层图块的显示、隐藏、修改等事件
+* [x] 专门的装备页面（Q键开启）；装备系统大改造
+* [x] 灯光和漆黑层效果，通过插件函数方式给出
+* [x] 将状态栏更新和阻激夹域的计算移动到脚本编辑中
+* [x] 增加控制免疫阻激夹域的flag:no_zone等
+* [x] 打字机效果时点击显示全部文字
+* [x] 修复更改画面色调的Bug
+* [x] 修复更改剧情文本属性后读档恢复原样的问题
+* [x] 部分细节优化
+
+### 2018.8.28 V2.4
+
+* [x] 大地图的支持
+* [x] 突破了5M的存档空间大小限制
+* [x] 事件：隐藏/显示贴图
+* [x] 事件：接收用户文本输入
+* [x] 同点多事件的颜色块绘制
+* [x] 录像播放时可以按PgUp/PgDn浏览地图
+* [x] 录像播放时对于瞬间移动绘制箭头
+* [x] 增加激光属性
+* [x] 可以在读档时E键直接指定编号
+* [x] 破炸飞可以在状态栏显示个数
+* [x] 部分细节优化，所有已知Bug修复
+
 ### 2018.7.21 V2.3.3
 
 * [x] 将怪物特殊属性定义和伤害计算函数移动到脚本编辑中
@@ -279,6 +492,16 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 
 * [x] 发布初版HTML5魔塔样板
 
+## 相关工具
+
+- [启动服务](http://github.com/ckcz123/mota-js-server/)： 一个本地的HTTP服务器，也能支撑前端的一些POST请求从而能拓展JS的IO功能。 
+- [RM动画导出器](http://github.com/ckcz123/animate_export/)：能从RMXP中导出动画，以供H5使用。
+- [JS代码压缩工具](http://github.com/ckcz123/JSCompressor/)：能对Javascript代码进行压缩和整合，从而减少IO请求量。 
+- [便捷PS工具](http://github.com/ckcz123/ps/)：能只用复制和粘贴来快速对素材进行PS操作。  
+- [地图生成器](http://github.com/ckcz123/map_generator/)：能从一张截图识别出来具体的数字数组，方便复刻已有的塔。 
+- [怪物数据导出器](http://github.com/ckcz123/enemy_export/)：能从RMXP中导出怪物数据，以供H5使用。
+- [伤害和临界值计算器](http://github.com/ckcz123/magic-tower-calculator/)：一个能帮助计算怪物的伤害和临界值的小工具。 
+
 ## 联系我们
 
 本样板主要由 [`ckcz123`](https://github.com/ckcz123) （百度ID `艾之葵`）编写。
@@ -302,6 +525,8 @@ HTML5魔塔交流群群号： `539113091`
 
 [@wadxm](https://github.com/wadxm) iOS平台的APP（因为苹果政策无法上架）和启动服务mac版的开发者。我们现在能在mac上制作魔塔得归功于他。
 
-[@fux4](https://github.com/fux4) 打通了RM和H5之间的障壁（从而使RM动画导出器和怪物数据导出器成为可能），同时也是部分新功能（如跳跃、跟随、画面震动）等的编写者。
+[@fux4](https://github.com/fux4) 打通了RM和H5之间的障壁（从而使RM动画导出器和怪物数据导出器成为可能），同时也是大地图和部分新功能（如跳跃、跟随、画面震动）等的编写者。
+
+[@tocque](https://github.com/tocque) 装备栏、动态创建图层等的编写者。
 
 以及[百度贴吧魔塔吧](https://tieba.baidu.com/f?kw=%E9%AD%94%E5%A1%94)和H5魔塔交流群`539113091`内的诸位魔塔爱好者们对本样板的大力支持！

V2.0版本简易造塔流程（For新人）.txt

@@ -1,78 +0,0 @@
-这只是一个最简单的造塔流程，更为详细的还是请参见视频或教程文档。
-
-1. 打开启动服务，地图编辑器。
-
-2. 切换到MT0层，然后开始绘制地图。可以在上面放置墙、门、道具或怪物等。
-如果提示“该素材未被定义”，请参见第7点。
-如果要从RMXP中复刻已有的塔的地图，请参见第11点。
-
-3. 切换到楼层属性，一项一项仔细进行楼层属性的编辑，如楼层名，firstArrive等等。
-将鼠标移动到表格的中间可以查看详细信息。
-firstArrive为初次到达楼层的事件，可以双击进行事件的编辑。有关事件请详见文档。
-
-3. 输入怪物数据：点击右边怪物，然后左边写怪物的攻防血等数值。
-将鼠标移动到表格的中间可以查看详细信息。
-如果是特殊属性怪物直接写特殊编号，多个特殊属性可以用 [1,2] 来表示。
-
-4. 在中间的下拉框切换全塔属性，一项一项仔细进行根据需求编辑。
-请注意"name"一项必须修改为“字母、数字、下划线组成的字符串”，否则会出现串档问题。
-startText（初始剧情）、shops（全局商店）、levelUp（升级）等都是可以双击方框进行编辑的。
-有关全局商店和升级等信息详见 教程文档 - 事件
-
-5. 给地图添加事件；可以给地图上的NPC增加事件，或者战斗/开门事件等。
-点击地图上的某个点，在左边进行编辑。
-event -- 该点的自定义事件（例如NPC，商店，等等）
-changeFloor -- 该点的楼层传送事件（楼梯/传送门）
-afterBattle -- 该点战斗后触发的战后事件
-afterOpenDoor -- 该点开门后触发的事件
-afterGetItem -- 该点获得道具后触发的事件
-等等。
-有关事件详细内容请参见 文档 - 事件。
-
-6. 新建楼层：切换到地图编辑，然后在框内输入新楼层的floorId，点击新建地图即可保存。
-创建的floorId必须是字母、数字和下划线组成，且不能以数字开头。
-不能为空白，不能和任何已有楼层的floorId重复。
-保存成功后刷新页面。
-
-删除楼层同理，不过请注意删除的会是当前的楼层而不是框中的内容。
-
-7. 关于素材未被定义的问题：如果点击某个怪物或NPC提示该素材未被定义，请在左边进行素材的注册。
-输入该素材的唯一ID（不能和其他素材的ID重复），和素材的唯一数字（1000以内，不能和其他的数字重复），
-保存并刷新，即注册成功。
-
-8. 添加新素材：请打开启动服务的便捷PS工具，然后左边读取你要添加到的图片（比如怪物是enemys.png，道具是items.png），
-右边读取你要导入的怪物素材，通过复制粘贴进行导入，再保存，刷新页面后按照第7点来进行素材的注册。
-
-9. 道具的自定义效果：如果需要自定义道具效果，请仿照其他的几个道具来写，更多信息详见文档。
-
-10. 报错处理：有时候刷新后可能页面变成空白，即无法正确加载。
-出现这种问题的原因往往是手动错误编辑了文件、新建楼层使用了不合法的floorId（比如中文或数字）、楼层floorId定义重复，等等。
-
-出现这种问题，（在Chrome浏览器中）请按Ctrl+Shift+I打开控制台，找到Console查看报错。
-一般都会具体到哪个楼层文件出错。
-
-解决方式：哪个楼层文件出错，请使用VSCode等打开project目录下的data.js文件，并将出错的那个楼层定义删除。
-
-举例，比如我在新建地图中写了 “水潭边” 这样一个楼层名（中文），然后新建并保存，刷新会出错。
-此时，打开控制台（Ctrl+Shift+I的Console），并查看报错，发现是该楼层错误。
-那么打开data.js文件，并将 "floorIds": [..., "水潭边"] 这里对它的楼层定义删除，再刷新即可。
-
-11. 从RMXP中导入已有的塔的地图。
-如果你想复刻老塔，则需使用启动服务的地图生成器。
-请确保老地图中的所有使用素材（地面/墙壁/门/道具/怪物等等）都已经被注册过（参见第7点）。
-
-打开windows自带的截图工具，并对地图进行截图。
-截图时请注意：必须截刚好13x13范围大小的地图，尽量对其边缘进行截取。
-如果不是13x13的范围大小，可能会导致地图生成器无响应。
-截图完毕后，请复制到剪切板，然后在地图生成器中点加载图片。等1-2秒，就可以看到截图被识别。
-点“复制地图”，然后在地图编辑器中切换到“地图编辑”，并粘贴到左边的框内，即可。
-如果存在个别识别问题，可以对这个别素材再进行重新绘制。
-
-如果出现大量识别问题，比如基本全是错的，则代表你的截图方式有问题。
-由于地图生成器的识别以左上角的图块为基准来找寻截图偏移量，请确保左上角一定要是一个能被很好识别的图块。
-建议：在RM的图层第三层，左上角放一个岩浆，再进行截图（保证截图的13x13的左上角是岩浆，从而可以确保定位），
-识别后再复制到地图编辑器中进行绘制。
-
---------------------------------
-
-HTML5魔塔交流群：539113091，如果有问题请加群提问。

_docs/V2.0.md

@@ -1,6 +1,6 @@
 # V2.0版本介绍
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 目前样板已经更新到V2.0版本以上，本章将对V2.0的一些内容进行介绍。
 

_docs/_api.md

@@ -1,6 +1,6 @@
 # 附录: API列表
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6**，上次更新时间：* {docsify-updated} *
 
 **这里只列出所有可能会被造塔者用到的常用API，更多的有关内容请在代码内进行查询。**
 
@@ -72,8 +72,17 @@ core.setItem('pickaxe', 10)
 将破墙镐个数设置为10个。这里可以写任何道具的ID。
 
 
+core.addItem('pickaxe', 2)
+将破墙镐的个数增加2个，无任何特效。这里可以写任何道具的ID。
+
+
 core.getItem('pickaxe', 4)
-另勇士获得四个破墙镐。这里可以写任何道具的ID。
+令勇士获得4个破墙镐。这里可以写任何道具的ID。
+和addItem相比，使用getItem会播放获得道具的音效，也会在左上角绘制获得提示。
+
+
+core.removeItem('pickaxe', 3)
+删除3个破墙镐。第二项可忽略，默认值为1。
 
 
 core.itemCount('pickaxe')
@@ -84,6 +93,15 @@ core.hasItem('pickaxe')
 返回当前是否存在某个道具。等价于 core.itemCount('pickaxe')>0 。
 
 
+core.getEquip(0)
+获得0号装备类型（武器）的当前装备的itemId。如果不存在则返回null。
+这里可以写任意装备类型，从0开始和全塔属性中的equipName一一对应。
+
+
+core.hasEquip('sword1')
+获得当前某个具体的装备是否处于正在被装备状态。
+
+
 core.setFlag('xyz', 2)
 设置某个flag/变量的值为2。这里可以写任何的flag变量名。
 
@@ -97,11 +115,18 @@ core.hasFlag('xyz')
 返回是否存在某个变量且不为0。等价于 core.getFlag('xyz', 0)!=0 。
 
 
+core.removeFlag('xyz')
+删除某个flag/变量。
+
+
 core.insertAction(list, x, y, callback)
 插入并执行一段自定义事件。在这里你可以写任意的自定义事件列表，有关详细写法请参见文档-事件。
 x和y如果设置则覆盖"当前事件点"的坐标，callback如果设置则覆盖事件执行完毕后的回调函数。
 例如： core.insertAction(["楼层切换", {"type":"changeFloor", "floorId": "MT3"}])
 将依次显示剧情文本，并执行一个楼层切换的自定义事件。
+--------
+从V2.5.4开始提出了“公共事件”的说法，这里也可以插入一个公共事件名。
+例如：core.insertAction("毒衰咒处理") 将插入公共事件“毒衰咒处理”。
 
 
 core.changeFloor(floorId, stair, heroLoc, time, callback)    [异步]
@@ -113,21 +138,18 @@ core.changeFloor('MT5', null, {'x': 3, 'y': 6}, 0) 无动画切换到MT5层的(3
 
 
 core.resetMap()
-重置当前楼层地图。
-当我们修改某一层地图后，进游戏读档，会发现修改的内容并没有被更新上去。
-这是因为，H5的存档是会存下来每一个楼层的地图的，读档会从档里面获得地图信息。
-此时，如果我们在某一层地图执行 core.resetMap() ，则可以立刻从剧本中读取并重置当前楼层地图。
-已经被修改过的内容也会相应出现。
-
+重置当前楼层地图和楼层属性。
+此函数参数有三种形式：
+ - 不加任何参数，表示重置当前层：core.resetMap()
+ - 加上一个floorId，表示重置某一层：core.resetMap("MT1")
+ - 使用一个数组，表示重置若干层：core.resetMap(["MT1", "MT2", "MT3"])
+---------------------------
+** 说明：从V2.5.5开始存档方式发生了改变，在编辑器修改了地图后现在将直接生效，无需再重置地图。
 
 R
 录像回放的快捷键；这不是一个控制台命令，但是也把它放在这里供使用。
 录像回放在修改地图或新增数据后会很有用。
 
-
-localStorage
-获得所有的存档数据。可以用 core.getLocalStorage('save1') 来具体获得某个存档。
-
 ```
 
 !> 一些相对高级的命令，针对有一定脚本经验的人
@@ -146,13 +168,20 @@ core.nextY(n)
 获得勇士面向的第n个位置的y坐标，n可以省略默认为1（即正前方）
 
 
+core.nearHero(x, y)
+判断某个点是否和勇士的距离不超过1。
+
+
 core.openDoor(id, x, y, needKey, callback)    [异步]
 尝试开门操作。id为目标点的ID，x和y为坐标，needKey表示是否需要使用钥匙，callback为开门完毕后的回调函数。
+id可为null代表使用地图上的值。
 例如：core.openDoor('yellowDoor', 10, 3, false, function() {console.log("1")})
+此函数返回true代表成功开门，并将执行callback回调；返回false代表无法开门，且不会执行回调函数。
 
 
 core.battle(id, x, y, force, callback)    [异步]
 执行战斗事件。id为怪物的id，x和y为坐标，force为bool值表示是否是强制战斗，callback为战斗完毕后的回调函数。
+id可为null代表使用地图上的值。
 例如：core.battle('greenSlime', null, null, true)
 
 
@@ -160,10 +189,8 @@ core.trigger(x, y)    [异步]
 触发某个地点的事件。
 
 
-core.clearMap(mapName)
-清空某个画布图层。
-mapName可为'bg', 'event', 'fg', 'event2', 'hero', 'animate', 'weather', 'ui', 'data', 'all'之一。
-如果mapName为'all'，则为清空所有画布；否则只清空对应的画布。
+core.isReplaying()
+当前是否正在录像播放中
 
 
 core.drawBlock(block)
@@ -211,30 +238,36 @@ core.showBlock(x, y, floorId)
 将某个点从禁用变成启用状态。
 
 
+core.hideBlock(x, y, floorId)
+将某个点从启用变成禁用状态，但不会对其进行删除。
+此函数不会实际将该块从地图中进行删除，而是将该点设置为禁用，以供以后可能的启用事件。
+
+
 core.removeBlock(x, y, floorId)
-将某个点删除或从启用变成禁用状态。
-如果该点不存在自定义事件（比如普通的怪物），则将直接从地图中删除。
-否则将该点设置为禁用，以供以后可能的启用事件。
+将从启用变成禁用状态，并尽可能将其从地图上删除。
+和hideBlock相比，如果该点不存在自定义事件（比如门或普通的怪物），则将直接从地图中删除。
+如果存在自定义事件，则简单的禁用它，以供以后可能的启用事件。
 
 
 core.setBlock(number, x, y, floorId)
 改变图块。number为要改变到的图块数字，x和y为坐标，floorId为楼层ID，可忽略表示当前楼层。
 
 
-core.useItem(itemId, callback)
-尝试使用某个道具。itemId为道具ID，callback为成功或失败后的回调。
+core.useItem(itemId, noRoute, callback)
+尝试使用某个道具。itemId为道具ID，noRoute如果为真则该道具的使用不计入录像。
+callback为成功或失败后的回调。
 
 
 core.canUseItem(itemId)
 返回当前能否使用某个道具。
 
 
-core.addItem(itemId, number)
-将某个道具增加number个。
+core.loadEquip(itemId, callback)
+装备上某个装备。itemId为装备的ID，callback为成功或失败后的回调。
 
 
-core.removeItem(itemId)
-将某个道具个数-1；如果道具个数归0则从道具列表删除。
+core.unloadEquip(equipType, callback)
+卸下某个部位的装备。equipType为装备类型，从0开始；callback为成功或失败后的回调。
 
 
 core.getNextItem()
@@ -258,7 +291,7 @@ core.replaceText(text)
 将一段文字中的${}进行计算并替换。
 
 
-core.calValue(value)
+core.calValue(value, prefix, need, times)
 计算表达式的实际值。这个函数可以传入status:atk等这样的参数。
 
 
@@ -266,6 +299,16 @@ core.getLocalStorage(key, defaultValue)
 从localStorage中获得某个数据（已被parse）；如果对应的key不存在则返回defaultValue。
 
 
+core.getLocalForage(key, defaultValue, successCallback, errorCallback)
+从localForage中获得某个数据（已被parse），如果对应的key不存在则返回defaultValue。
+如果成功则通过successCallback回调，失败则通过errorCallback回调。
+
+
+core.hasSave(index)
+判定当前某个存档位是否存在存档，返回true/false。
+index为存档编号，0代表自动存档，大于0则为正常的存档位。
+
+
 core.clone(data)
 深拷贝某个对象。
 
@@ -299,6 +342,21 @@ actions.js主要用来进行用户交互行为的处理。
 ========== core.control.XXX 和游戏控制相关的函数 ==========
 control.js主要用来进行游戏控制，比如行走控制、自动寻路、存读档等等游戏核心内容。
 
+core.control.setGameCanvasTranslate(canvasId, x, y)
+设置大地图的偏移量
+
+
+core.control.updateViewport()
+更新大地图的可见区域
+
+
+core.control.gatherFollowers()
+立刻聚集所有的跟随者
+
+
+core.control.replay()
+回放下一个操作
+
 
 ========== core.enemys.XXX 和怪物相关的函数 ==========
 enemys.js主要用来进行怪物相关的内容，比如怪物的特殊属性，伤害和临界计算等。
@@ -317,34 +375,36 @@ core.enemys.getSpecialHint(enemy, special)
 获得怪物某个（或全部）特殊属性的文字说明。
 
 
-core.enemys.canBattle(enemyId)
+core.enemys.canBattle(enemyId, x, y, floorId)
 返回当前能否战胜某个怪物。
+后面三个参数是怪物坐标和楼层。
 
 
-core.enemys.getDamage(enemyId)
+core.enemys.getDamage(enemyId, x, y, floorId)
 返回当前对某个怪物的战斗伤害。如果无法战斗，返回null。
+后面三个参数是怪物坐标和楼层。
 
 
 core.enemys.getExtraDamage(enemyId)
 返回某个怪物会对勇士造成的额外伤害（不可被魔防抵消），例如仇恨、固伤等等。
 
 
-core.enemys.nextCriticals(enemyId, number)
+core.enemys.nextCriticals(enemyId, number, x, y, floorId)
 返回一个列表，为接下来number（可忽略，默认为1）个该怪物的临界值和临界减伤。
 列表每一项类似 [x,y] 表示临界值为x，且临界减伤为y。
 如果无临界值，则返回空列表。
 
 
-core.enemys.getDefDamage(enemyId, k)
+core.enemys.getDefDamage(enemyId, k, x, y, floorId)
 获得k（可忽略，默认为1）防减伤值。
 
 
-core.enemys.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef)
+core.enemys.getDamageInfo(enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId)
 获得实际战斗信息，比如伤害，回合数，每回合伤害等等。
 此函数是实际战斗过程的计算。
 
 
-core.enemys.calDamage(enemy, hero_hp, hero_atk, hero_def, hero_mdef)
+core.enemys.calDamage(enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId)
 获得在某个勇士属性下怪物伤害；实际返回的是上面getDamageInfo中伤害的数值。
 
 
@@ -371,6 +431,10 @@ core.events.doAction()
 执行下一个事件。此函数中将对所有自定义事件类型分别处理。
 
 
+core.events.getCommonEvent(name)
+根据名称获得一个公共事件；如果不存在对应的公共事件则返回null。
+
+
 core.events.openShop(shopId, needVisited)    [异步]
 打开一个全局商店。needVisited表示是否需要该商店已被打开过。
 
@@ -391,6 +455,10 @@ core.events.setHeroIcon(name)
 items.js将处理和道具相关的内容，比如道具的使用，获取和删除等等。
 
 
+core.items.compareEquipment(equipId1, equipId2)
+比较两个装备的属性变化值
+
+
 ========== core.loader.XXX 和游戏加载相关的函数 ==========
 loader.js将主要用来进行资源的加载，比如加载音乐、图片、动画等等。
 
@@ -399,6 +467,10 @@ loader.js将主要用来进行资源的加载，比如加载音乐、图片、
 maps.js主要用来进行地图相关的的操作。包括绘制地图，获取地图上的点等等。
 
 
+core.maps.getNumberById(id)
+根据ID来获得对应的数字。如果该ID不存在对应的数字则返回0。
+
+
 core.maps.canMoveHero(x,y,direction,floorId)
 判断能否前往某个方向。x,y为坐标，可忽略为当前点；direction为方向，可忽略为当前方向。
 floorId为楼层ID，可忽略为当前楼层。
@@ -417,10 +489,113 @@ core.maps.removeBlockByIds(floorId, ids)
 根据索引删除或禁用若干块。
 
 
+core.maps.drawAnimate(name, x, y, callback)
+播放一段动画，name为动画名（需在全塔属性注册），x和y为坐标（0-12之间），callback可选，为播放完毕的回调函数。
+播放过程是异步的，如需等待播放完毕请使用insertAction插入一条type:waitAsync事件。
+此函数将随机返回一个数字id，为此异步动画的唯一标识符。
+
+
+core.maps.stopAnimate(id, doCallback)
+立刻停止一个异步动画。
+id为该动画的唯一标识符（由drawAnimate函数返回），doCallback可选，若为true则会执行该动画所绑定的回调函数。
+
+
 ========== core.ui.XXX 和对话框绘制相关的函数 ==========
 ui.js主要用来进行UI窗口的绘制，比如对话框、怪物手册、楼传器、存读档界面等等。
 
 
+core.ui.getContextByName(canvas)
+根据画布名找到一个画布的context；支持系统画布和自定义画布。如果不存在画布返回null。
+也可以传画布的context自身，则返回自己。
+
+
+core.clearMap(name)
+清空某个画布图层。
+name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。（下同）
+如果name也可以是'all'，若为all则为清空所有系统画布。
+
+
+core.ui.fillText(name, text, x, y, style, font)
+在某个画布上绘制一段文字。
+text为要绘制的文本，x,y为要绘制的坐标，style可选为绘制的样式，font可选为绘制的字体。（下同）
+
+
+core.ui.fillBoldText(name, text, x, y, style, font)
+在某个画布上绘制一个描黑边的文字。
+
+
+core.ui.fillRect(name, x, y, width, height, style)
+绘制一个矩形。style可选为绘制样式。
+
+
+core.ui.strokeRect(name, x, y, width, height, style)
+绘制一个矩形的边框。
+
+
+core.ui.drawLine(name, x1, y1, x2, y2, style, lineWidth)
+绘制一条线。lineWidth可选为线宽。
+
+
+core.ui.drawArrow(name, x1, y1, x2, y2, style, lineWidth)
+绘制一个箭头。
+
+
+core.ui.setFont(name, font) / core.ui.setLineWidth(name, lineWidth)
+设置一个画布的字体/线宽。
+
+
+core.ui.setAlpha(name, font) / core.ui.setOpacity(name, font)
+设置一个画布的绘制不透明度和画布本身的不透明度。
+两者区别如下：
+ - setAlpha是设置"接下来绘制的内容的不透明度"，不会对已经绘制的内容产生影响。比如setAlpha('ui', 0.5)则会在接下来的绘制中使用0.5的不透明度。
+ - setOpacity是设置"画布本身的不透明度"，已经绘制的内容也会产生影响。比如我已经在UI层绘制了一段文字，再setOpacity则也会看起来变得透明。
+尽量不要对系统画布使用setOpacity（因为会对已经绘制的内容产生影响），自定义创建的画布则不受此限制。
+
+
+core.ui.setFillStyle(name, style) / core.ui.setStrokeStyle(name, style)
+设置一个画布的填充样式/描边样式。
+
+
+core.ui.setTextAlign(name, align)
+设置一个画布的文字对齐模式。
+
+
+core.ui.calWidth(name, text, font)
+计算一段文字在画布上的绘制宽度
+font可选，如果存在则会先设置该画布上的字体。
+
+
+core.ui.drawImage(name, image, x, y, w, h, x1, y1, w1, h1)
+在一个画布上绘制图片。
+name为画布名，可以是系统画布之一，也可以是任意自定义动态创建的画布名；还可以直接传画布的context本身。
+image为要绘制的图片，可以是一个全塔属性中定义的图片名（会从images中去获取），图片本身，或者一个画布。
+后面的8个坐标参数与canvas的drawImage的八个参数完全相同。
+请查看 http://www.w3school.com.cn/html5/canvas_drawimage.asp 了解更多。
+
+
+core.ui.createCanvas(name, x, y, width, height, zIndex)
+动态创建一个画布。name为要创建的画布名，如果已存在则会直接取用当前存在的。
+x,y为创建的画布相对窗口左上角的像素坐标，width,height为创建的长宽。
+zIndex为创建的纵向高度（关系到画布之间的覆盖），z值高的将覆盖z值低的；系统画布的z值可在个性化中查看。
+返回创建的画布的context，也可以通过core.dymCanvas[name]调用。
+
+
+core.ui.relocateCanvas(name, x, y)
+重新定位一个自定义画布。
+
+
+core.ui.resizeCanvas(name, x, y)
+重新设置一个自定义画布的大小。
+
+
+core.ui.deleteCanvas(name)
+删除一个自定义画布。
+
+
+core.ui.deleteAllCanvas()
+清空所有的自定义画布。
+
+
 core.ui.drawThumbnail(floorId, canvas, blocks, x, y, size, heroLoc, heroIcon)
 绘制一个缩略图，比如楼传器界面，存读档界面等情况。
 floorId为目标楼层ID，canvas为要绘制到的图层，blocks为要绘制的所有图块。
@@ -440,6 +615,10 @@ core.utils.cropImage(image, size)
 纵向对图片进行切分（裁剪）。
 
 
+core.utils.push(a,b)
+向某个数组后插入另一个数组或元素
+
+
 core.utils.unshift(a, b)
 向某个数组前插入另一个数组或元素
 
@@ -452,14 +631,31 @@ core.utils.decodeBase64(str)
 Base64解密字符串
 
 
-core.utils.formatBigNumber(x)
+core.utils.formatBigNumber(x, onMap)
 大数据的格式化
 
 
+core.utils.subarray(a, b)
+检查b是否是a的从头开始子串。
+如果是，则返回a删去b的一段；否则返回null。
+
+
+core.utils.same(a, b)
+比较a和b两个对象是否相同
+
+
+core.utils.clamp(x, a, b)
+将x限制在[a,b]之间的范围内
+
+
 core.utils.arrayToRGB(color)
 将形如[255,0,0]之类的数组转成#FF0000这样的RGB形式。
 
 
+core.utils.arrayToRGBA(color)
+将形如[255,0,0,1]之类的数组转成rgba(255,0,0,1)这样的RGBA形式。
+
+
 core.utils.encodeRoute(list)
 压缩加密路线。可以使用core.encodeRoute(core.status.route)来压缩当前路线。
 

_docs/_sidebar.md

@@ -3,5 +3,5 @@
 - [元件说明](element)
 - [事件](event)
 - [个性化](personalization)
-- [V2.0版本介绍](V2.0)
+- [脚本](script)
 - [附录：API列表](api)

_docs/element.md

@@ -0,0 +1,484 @@
+# 元件说明
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+在本章中，将对样板里的各个元件进行说明。各个元件主要包括道具、门、怪物、楼梯等等。
+
+请打开样板0层 `sample0.js` 进行参照对比。
+
+![生成地图](./img/sample0.png)
+
+## 道具
+
+本塔目前支持的所有道具列表在样板0层中已全部给出。当你在样板0层中拿到某个宝物时会有提示，这里不再赘述，详见拿到该道具的说明。
+
+大多数宝物都有默认的效果，屠龙匕首暂未定义，如有自己的需求可参见[自定义道具效果](personalization#自定义道具效果)。
+
+拿到道具后将触发`afterGetItem`事件，有关事件的详细介绍请参见[事件](event)。
+
+如需修改某个道具的效果，在不同区域宝石数据发生变化等问题，请参见[自定义道具效果](personalization#自定义道具效果)的说明。
+
+**有关轻按，在data.js的系统变量中有定义。如果`enableGentleClick`为true，则鼠标（触摸屏）通过双击勇士，键盘通过空格可达到轻按效果，即不向前移动而获得前方物品。**
+
+## 装备
+
+如果需要让剑盾等变成装备，可以直接在`data.js`中设置`'equipment': true`即可。
+
+从V2.4.1开始，HTML5魔塔样板终于拥有了属于自己的装备页面。
+
+### 装备栏的设置，装备类型
+
+在全塔属性中，有一个`equipName`项，其定义了本塔的所有可装备的装备栏。
+
+其需要是一个不小于1且不大于6的数组，其中每一项为装备栏的名称，**建议是两个汉字**。
+
+例如下面这种写法就是定义了四个装备孔，名称分别为武器、防御、首饰和魔杖。
+
+``` js
+"equipName": ["武器","防具","首饰","魔杖"]
+```
+
+这么定义好后，装备类型即为每个装备孔的索引（从0开始）。
+
+即，武器的装备类型是0，防御的装备类型是1，首饰的装备类型是2，魔杖的装备类型是3。
+
+### 设置每个装备的属性
+
+如果要将一个道具设置为装备，首先需要将其`cls`设为`equips`。
+
+然后在图块属性的`equip`一项中设置装备的具体属性。该项写法如下:
+
+``` js
+{"type": 0, "atk": 0, "def": 0, "mdef"：0, "animate": "hand", "percentage": true}
+```
+
+type为该装备的类型，必填，和上面装备栏一一对应。例如，0就是武器，2就是首饰等等。
+
+atk/def/mdef为该装备分别增加的攻防魔防数值（支持负数）；如果不加也可省略不写。
+
+从V2.6开始，可以拓展到任何勇士的属性，如hpmax, atk, def, mdef, experience等等；自行添加的属性包括攻速speed也能使用。
+
+animate为该装备的攻击动画，仅对type为0时有效。具体可参见[动画和天气系统](#动画和天气系统)。
+
+percentage为该装备是否按比例增加属性。
+
+下面是几个写法例子。
+
+``` js
+{"type": 0, "atk": 10} // 装备类型是武器，效果是攻击+10，使用默认的攻击动画
+{"type": 0, "atk": 40, "animate": "sword"} // 装备类型为武器，效果是攻击+10，攻击动画是sword
+{"type": 1, "def": 40, "percentage": true} // 装备类型是防具，效果是防御提升40%
+{"type": 1, "def": 100, "mdef": 100} // 装备类型是防具，效果是防御和魔防各+100
+{"type": 3, "atk": -20, "def": 50, "mdef": 50} // 装备类型是魔杖，效果是攻击-20，防御和魔防各+50
+{"type": 2, "atk": -20, "def": 50, "mdef": 50, "percentage": true} // 装备类型是魔杖，效果是攻击下降20%，防御和魔防各提升50%
+```
+
+所有取值全部向下取整。
+
+值得注意的是，如果多个装备同时按比例增加属性，使用加法计算。比如武器增加30%攻击，防具增加10%攻击，最终合起来增加的是40%而不是43%的属性。
+
+### 检测是否存在装备
+
+可以使用`core.hasEquip(itemId)`来检测是否装上某个装备。
+
+使用`core.hasItem(itemId)`来检测是否存在一个未装上的装备。
+
+使用`core.getEquip(equipType)`来获得某个装备类型的当前装备。
+
+更多相关API详见[附录：API列表](api)。
+
+### 多重装备
+
+从V2.5.4开始，允许支持多重装备，即有若干的装备可共用若干的格子（例如永不复还那样）。
+
+要实现这一点，上面的写法有所改变。
+
+在全塔属性中的`equipName`项写法不变，不过可以写重复的装备孔名称。（但仍然最多只能写6个）
+
+``` js
+"equipName": ["武器", "武器", "武器", "防具", "防具", "首饰"] 
+```
+
+然后对于某个装备，将其`type`（装备类型）写对应的装备孔名称即可。
+
+``` js
+{"type": "武器", "atk": 20, "def": 0, ...}
+```
+
+这样写的话，则所有该名称的装备孔均可装上此装备。
+
+当尝试装上此装备时，会取最小的一个空的装备孔进行装备。如果没有空闲的装备孔，则会提示“请先卸下装备”。
+
+装备动画仍然会取第一个（装备类型为0）的装备的`animate`项，即使装备了多个有动画的武器。
+
+## 门
+
+本塔支持6种门，黄蓝红绿铁花。前五种门需要有对应的钥匙打开，花门只能通过调用`openDoor`事件进行打开。
+
+开门后可触发该层的`afterOpenDoor`事件，有关事件的详细介绍请参见[事件](event)。
+
+如果要新增自己的门，请参见[新增门和对应的钥匙](personalization#新增门和对应的钥匙)。
+
+## 暗墙
+
+本塔支持暗墙。
+
+要制作一个暗墙非常简单：在该点直接放一个普通墙壁，然后事件写“开门”，坐标为该点就行。
+
+``` js
+// 该点画一个普通的墙壁，比如`yellowWall`
+
+// 在该点的事件events中:
+"x,y": [
+    {"type": "openDoor"} // 直接使用开门事件，坐标可忽略表示当前点
+]
+```
+
+系统会自动调用animates中的开暗墙动画。
+
+目前只有如下ID支持以这种方式开门：
+
+``` text
+yellowDoor, blueDoor, redDoor, greenDoor, specialDoor, steelDoor,
+yellowWall, blueWall, whiteWall
+```
+
+## 怪物
+
+本塔支持的怪物列表参见`project/enemys.js`。其与images目录下的`enemys.png`素材按顺序一一对应。
+
+如有自己的怪物素材需求请参见[自定义素材](personalization#自定义素材)的内容。
+
+怪物可以有特殊属性，每个怪物可以有多个自定义属性。
+
+怪物的特殊属性所对应的数字（special）在脚本编辑中的`getSpecials`中定义，请勿对已有的属性进行修改。
+
+多属性可采用数组的写法，比如`'special': [1,3]`视为同时拥有先攻和坚固属性；`'special': [5,10,14,18]`视为拥有3连击、魔防、诅咒、阻击四个属性。
+
+怪物可以负伤，在全塔属性的全局变量`enableNegativeDamage`中指定。
+
+打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](event#加点事件)。
+
+如果全塔属性中的enableExperience为false，即不启用经验的话，怪物手册里将不显示怪物的经验值，打败怪物也不获得任何经验。
+
+拿到幸运金币后，打怪获得的金币将翻倍。
+
+如果怪物有`"notBomb": true`，则该系列诖怪物均不可被炸。
+
+N连击怪物的special是6，且我们可以为它定义n代表实际连击数。参见样板中剑王的写法。
+
+吸血怪需要给怪物设置value，代表吸血的比例。
+
+可以给吸血怪添加`'add': true`来将吸血的数值加到自身上。
+
+中毒怪让勇士中毒后，每步扣减的生命值由`data.js`中的values定义。
+
+衰弱怪让勇士衰弱后，攻防会下降一定比例或固定数值（直到衰弱状态解除恢复）；其在`data.js`中的values定义。
+
+诅咒怪将让勇士陷入诅咒状态，诅咒状态下杀怪不获得金币和经验值。
+
+领域怪需要在怪物后添加value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
+
+领域是十字伤害还是九宫格伤害由`zoneSquare`设定，如设置为true则为九宫格伤害，不指定或为false则为十字伤害。
+
+领域怪还可以设置`range`选项代表该领域怪的范围，不写则默认为1。
+
+**将`flag:no_zone`设置为true可以取消领域效果。**
+
+阻击怪同样需要设置value，代表阻击伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
+
+**将`flag:no_snipe`设置为true可以取消阻击效果。**
+
+!> 阻击怪后退的地点不能有任何事件存在，即使是已经被禁用的自定义事件！
+
+激光怪同样需要设置value，代表激光伤害的数值。
+
+请注意如果吸血、领域、阻击中任何两个同时存在，则value会冲突。**因此请勿将吸血、领域、阻击或激光放置在同一个怪物身上。**
+
+**将`flag:no_laser`设置为true可以免疫激光效果。**
+
+退化怪需要设置'atkValue'和'defValue'表示退化的数值；也可以不设置默认为0。
+
+夹击可以通过全塔属性中的`betweenAttackCeil`设为true可以将伤害向上取整。
+
+**将`flag:no_betweenAttack`设置为true可以免疫夹击效果。**
+
+固伤怪则需要设置`damage`选项，代表战前扣血数值。
+
+如有额外需求，可参见[自定义怪物属性](personalization#自定义自定义怪物属性)，里面讲了如何设置一个新的怪物属性。
+
+## 怪物和NPC的朝向问题
+
+从V2.5.2开始，对于人形怪物和NPC的朝向问题已经有着比较好的解决方式。
+
+首先明确一点的是，和RM不同，H5中即使是对同一个怪物/NPC的不同朝向，也需要分别将其各个朝向素材追加对应的图片上，并进行注册。
+
+### 怪物的朝向问题
+
+对于同一个怪物的不同朝向，需要对每个朝向创建一个怪物（属性完全相同），这样就可以在地图上绘制不同朝向的怪物。
+
+但是这样会存在一个问题，就是怪物手册中怪物的每个朝向都会显示成一个单独的怪物。
+
+为了避免这种情况的发生，在怪物的属性中存在一个`displayIdInBook`项，**我们可以指定该项来控制每个怪物在怪物手册中中显示成的怪物。**
+
+举个例子，假设我现在有个怪物，其向下的行走图ID是`E300`，其向左的行走图ID是`E301`，向右的行走图ID是`E302`。分别对这几个怪物填写完全相同的怪物属性。
+
+如果我在地图上同时绘制向下、向左和向右的该怪物，则确实能在地图上显示出来不同的朝向，但是在怪物手册中会同时显示这三种类型的怪物，观感较差。
+
+我们可以给`E301`和`E302`怪物属性中的`displayIdInBook`项填写为`"E300"`。
+
+这样的话，在怪物手册中，所有的E301和E302均会被视为E300并进行合并。即使只有一只朝向左的怪物（E301），怪物手册仍然会按E300进行显示。
+
+从而完美解决了同种怪物不同朝向在怪物手册的显示问题。
+
+### NPC的朝向问题
+
+和怪物不同的是，NPC朝向问题更复杂一点。
+
+在NPC的图块属性中，存在一个`faceIds`的项目，可以用其来绑定一个图块所对应的其他朝向的图块ID。
+
+举个例子，假设我存在一个NPC，其向上的图块ID是N333，向下的图块ID是N334，向左的图块ID是N335，不存在向右的图块ID。
+
+则可以在这几个图块属性中的`faceIds`中写：`{"up": "N333", "down": "N334", "left": "N335"}`。
+
+当勇士从左边撞上此怪物后，将从该图块的图块属性中的faceIds中寻求`left`所对应的ID。
+如果存在定义（如N335），则会在触发对话事件前改变当前图块为N335，看起来就是在对话前进行了转向，面向勇士。
+
+!> 请注意，在对话结束后朝向不会切换回来，因此如果有必要切换朝向请在事件结束前调用转变图块事件。
+
+同理，使用移动事件让NPC在行走时，不同朝向的行走会自动调用`faceIds`中不同朝向的ID所对应的行走图，看起来就是在行走时也可以不断转向了。
+
+从而，完美解决了NPC的朝向问题（碰触时面向勇士、行走时改变朝向）。
+
+## 路障，楼梯，传送门
+
+血网的伤害数值、中毒后每步伤害数值、衰弱时暂时攻防下降的数值，都在全塔属性的values内定义。
+
+路障同样会尽量被自动寻路绕过。
+
+有关楼梯和传送门，必须在该层样板的changeFloor里指定传送点的目标。
+
+floorId指定的是目标楼层的唯一标识符（ID）。
+
+也可以写`"floorId": ":before"`和`"floorId": ":next"`表示上一楼和下一楼。
+
+后面可以写stair到upFloor或downFloor，表示将前往目标楼层的上楼梯/下楼梯位置。你也可以写loc然后指定目标点的坐标。
+
+请注意的是，如果目标楼层有多个楼梯，写stair可能会导致到达的楼梯不确定，这时候请使用loc方式来指定具体的点位置。
+
+可以指定direction为up/left/right/down，指定后勇士将面向该方向。
+
+可以指定time，指定后切换动画时长为指定的数值。
+
+**从2.1.1开始，楼层属性中提供了`upFloor`和`downFloor`两项。如果设置此项（比如`"upFloor": [2,3]`），则写stair:upFloor或者楼传器的落点将用此点来替换楼梯位置（即类似于RM中的上箭头）。**
+
+## 剧情文本控制与对话框效果
+
+在写剧情文本时，可以：
+
+- 使用`\t[...]`来给文字加上标题和图标。如`\t[老人,man]`。
+- 使用`\b[...]`来制作对话框效果，如`\b[up,3,2]`。
+- 使用`\r[...]`来动态修改局部文本的颜色，如`\r[red]`。
+- 使用`${}`来计算一个表达式的值，如`${status:atk+status:def}`。
+- 使用`\f[...]`来同时插入一张立绘图，如`\f[1.png,100,200]`。
+- 使用`\\i[...]`来在对话框中绘制一个图标，如`\\i[fly]`。
+
+从V2.5.2开始，也允许绘制一张头像图在对话框中，只要通过`\t[1.png]`或`\t[标题,1.png]`的写法。
+
+**使用`\\i[...]`绘制图标请注意：在事件块中，允许只写一个反斜杠`\i`，系统会自动转义成`\\i`；但是在脚本中必须两个反斜杠都写上！**
+
+详细信息请参见[剧情文本控制](event#text：显示一段文字（剧情）)中的说明。
+
+从V2.5.2开始，可以用一张WindowSkin图片作为对话框的背景皮肤。
+
+使用时，需要将图片放在images目录下，并在全塔属性中予以注册。
+
+可以使用[设置剧情文本的属性](setText：设置剧情文本的属性)事件将对话框背景设置为需要的皮肤。
+
+!> 关于对话框效果请注意，现在是采用WindowSkin的右下角两个32x32的图片作为对话框尖角进行绘制。因此请尽量使用群文件或网盘的常用素材中给出的WindowSkin素材（均已进行对话框适配）。如需使用来自第三方的WindowSkin素材，请自行注意对话框的尖角问题，或弃用`\b`效果。
+
+另外一点是，V2.5.2以后，对话框`\b`可以根据文字长度来自动控制文本框宽度，其基本控制原理如下：
+
+- 如果用户存在手动换行`\n`，则选取**最长的一段话**作为文本框宽度。
+- 如果用户不存在手动换行，则会将文本框宽度调整为X行半的最佳宽度。
+- 文本框宽度存在上下界，最终宽度一定会控制在该范围内。
+
+该自动调整仅对`\b`的对话框效果有效。非对话框仍然会绘制整个界面的宽度。
+
+## 大地图
+
+从V2.4开始，H5魔塔开始支持大地图。
+
+大地图在创建时可以指定宽高，要求**宽和高都不得小于13（15x15版本则是不小于15），且宽高之积不超过1000**。
+
+大地图一旦创建成功则不得修改宽高数值。
+
+## 动画和天气系统
+
+现在我们的H5魔塔支持播放动画，也支持天气系统了。
+
+要播放动画，你需要先使用“RM动画导出器”将动画导出，放在animates目录下，然后在全塔属性的animates中定义。
+
+``` js
+// 在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名
+// 动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符
+"animates": ["hand", "sword", "zone", "yongchang", "thunder"]
+```
+
+!> 动画必须是animate格式，名称不能使用中文，不能带空格或特殊字符。
+
+导出动画时可能会进行一些压缩以节省流量，因此清晰度可能不如原版。
+
+从2.3.2开始，动画可以同时导出所用的音效。**如果导出音效，请确保将所用到的音效复制到了`sounds`目录下，并且在全塔属性中注册过。**
+
+动画播放时，是按照每秒20帧的速度（即50ms/帧）。
+
+定义完毕后，我们可以调用`animate`事件来播放该动画，有关事件的详细介绍请参见[事件](event)。
+
+!> 播放录像时，将默认忽略所有动画。
+
+目前天气系统支持雨和雪和雾两种天气。
+
+在每层楼的楼层属性中存在一个weather选项，表示该层楼的默认天气。
+
+``` js
+// 该层的默认天气。本项可忽略表示晴天，如果写则第一项为"rain"，"snow"或"fog"代表雨雪雾，第二项为1-10之间的数代表强度。
+"weather": ["snow",5] 
+```
+
+我们也可以使用`setWeather`事件来设置当前天气，有关事件的详细介绍请参见[事件](event)。
+
+## 背景音乐
+
+本塔支持BGM和SE的播放。
+
+要播放音乐和音效，你需要将对应的文件放在sounds目录下，然后在全塔属性中进行定义
+
+``` js
+// 在此存放所有的bgm，和文件名一致。
+// 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+"bgms": ["bgm.mp3"]
+
+// 在此存放所有的SE，和文件名一致
+"sounds": ["floor.mp3", "attack.mp3", "door.mp3", "item.mp3", "zone.mp3"]
+```
+
+!> 音频名不能使用中文，不能带空格或特殊字符。
+
+目前BGM支持主流的音乐格式，如mp3, ogg等。不支持mid格式的播放。
+
+定义完毕后，我们可以调用`playBgm`/`playSound`事件来播放对应的音乐/音效，有关事件的详细介绍请参见[事件](event)。
+
+**另外，考虑到用户的流量问题，将遵循如下规则：**
+
+- **如果用户当前使用的电脑，则默认开启音乐效果，并播放默认BGM**
+- **如果用户当前使用的手机，且处于Wifi状态，则默认开启音乐效果，并播放默认BGM**
+- **其他情况，将默认关闭音乐效果，只有在用户在菜单栏中点击“音乐开关”后才会播放音乐**
+
+!> iOS平台以及部分浏览器不支持获得当前网络状态，此时即使在使用Wifi也必须要用户点击“音乐开关”才能播放音乐。
+
+从V2.5.3开始，可以使用`loadBgm`事件来预加载一个bgm，这样到播放时无需等待，直接播放。
+
+同时BGM将使用LRU算法增加缓存机制。默认最多缓存4个BGM（在core.js的musicStatus.cachedBgmCount控制）。
+
+系统会自动释放最久未使用的BGM。
+
+也可以使用`freeBgm`事件来手动释放一个无需再用的bgm。
+
+## 录像
+
+HTML5魔塔一大亮点就是存在录像系统，可以很方便进行录像回放。
+
+当你在游戏的过程中，随着你的操作，录像也会被依次记录。游戏结束后将提示是否下载录像，上传成绩时也会上传你的录像信息。
+
+在菜单栏-同步存档中，可以直接对当前录像进行下载。
+
+!> 录像记录的是你当前的路线（本质上是模拟键盘操作），是一个纯文本文件，占用空间很小！
+
+录像的回放主要有两种方式：
+
+1. 保存成的录像文件(.h5route文件)：在标题界面点录像回放，再选择文件即可。
+2. 游戏过程中时的当前录像：随时按R可以进行回放；手机端则可调出虚拟键盘，再按R。
+
+录像播放过程中，可以进行如下操作：
+
+- **暂停/播放：** 按空格可以随时暂停或播放录像。
+- **加速：** 按X可以加速录像播放，最高可达6倍速。
+- **减速：** 按Z可以减速录像播放，最低可达0.3倍速。
+- **停止：** 按ESC可以立刻停止录像播放，并返回正常游戏。
+- **回退：** 按A可以回退到上一个录像节点（录像播放过程中每50步存一个录像节点）。
+- **存档：** 按S可以在录像播放过程中进行存档。
+- **查看手册：** 按C可以在录像播放过程中查看怪物手册。
+- **浏览地图：** 按PgUp/PgDn可以在录像播放过程中浏览地图。
+
+如果录像出现问题，请加群539113091找小艾反馈Bug。
+
+## 绘图模式
+
+从V2.5开始，样板提供了绘图模式，可以让玩家在画布上任意进行绘制，标记等。
+
+使用M键，或在菜单栏中可以进入绘图模式。
+
+**绘图的内容会自动保存，且以页面为生命周期，和存读档无关，返回标题并重新开始游戏后绘制的内容仍有效，但刷新页面就会消失。**
+
+你可以将绘制内容保存到文件，也可以从文件读取保存的绘制内容。
+
+绘图模式下，状态栏的图标也会相应改变，铅笔为绘制模式，橡皮为擦除模式，存读档为保存和读取绘图文件，退出为返回默认值。
+
+在浏览地图页面中也可以按楼传按钮或M键来开启/关闭该层的绘图显示。
+
+## 操作说明
+
+![](img/keyboard.png)
+
+<!--
+本塔主要支持鼠标（触摸屏）操作和键盘操作。
+
+鼠标（触摸屏）操作说明如下：
+
+- **点状态栏中图标：** 进行对应的操作
+- **点任意块：** 寻路并移动
+- **点任意块并拖动：** 指定寻路路线
+- **单击勇士：** 转向
+- **双击勇士：** 轻按（仅在轻按开关打开时有效）
+- **长按任意位置：** 打开虚拟键盘
+
+键盘操作快捷键如下：
+
+- **[CTRL]** 跳过对话
+- **[Z]** 转向
+- **[X]** 打开/关闭怪物手册
+- **[G]** 打开/关闭楼层传送器
+- **[A]** 读取自动存档
+- **[S/D]** 打开/关闭存/读档页面
+- **[V]** 打开/关闭快捷商店选择列表
+- **[T]** 打开/关闭工具栏
+- **[Q]** 打开/关闭装备栏
+- **[ESC]** 打开/关闭系统菜单
+- **[B]** 打开数据统计
+- **[H]** 打开帮助页面
+- **[R]** 回放录像
+- **[E]** 显示光标
+- **[SPACE]** 轻按（仅在轻按开关打开时有效）
+- **[M]** 绘图模式
+- **[PgUp/PgDn]** 浏览地图
+- **[1]** 快捷使用破墙镐
+- **[2]** 快捷使用炸弹/圣锤
+- **[3]** 快捷使用中心对称飞行器
+- **[4]** 快捷使用其他道具
+- **[Alt+0~9]** 快捷换装
+
+以上快捷键也能在游戏菜单中的操作说明中看到。
+-->
+
+&nbsp;
+
+&nbsp;
+
+上面就是整个样板中的各个元件说明。通过这种方式，你就已经可以做出一部没有任何事件的塔了。
+
+尝试着做一个两到三层的塔吧！
+
+==========================================================================================
+
+[继续阅读下一章：事件](event)

_docs/index.html

@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>HTML5魔塔样板</title>
+  <link rel="shortcut icon" type="image/png" href="./img/logo.png">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta http-equiv="pragma" content="no-cache">
+  <meta http-equiv="cache-control" content="no-cache">
+  <meta http-equiv="expires" content="0">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link href="https://cdn.bootcss.com/docsify/4.5.5/themes/vue.css" rel="stylesheet">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      homepage: 'index.md',
+      loadSidebar: true,
+      name: 'HTML5魔塔样板',
+      repo: 'https://github.com/ckcz123/mota-js',
+      // basepath: '../docs/',
+      
+        // Search Support
+      // search: {
+      //   maxAge: 43200000, // 过期时间，单位毫秒，默认一天
+      //   paths: 'auto',
+      //   placeholder: {
+      //     '/en/': 'Search',
+      //     '/': '搜索',
+      //   },
+      //   noData: {
+      //     '/en/': 'No Results',
+      //     '/': '找不到结果',
+      //   },
+      // },
+
+       // load sidebar from _sidebar.md
+      loadSidebar: '_sidebar',
+      subMaxLevel: 2,
+      autoHeader: true,
+      auto2top: true,
+      mergeNavbar: true,
+      formatUpdated: '{YYYY}-{MM}-{DD} {HH}:{mm}:{ss}',
+    }
+  </script>
+  <script src="https://cdn.bootcss.com/docsify/4.5.5/docsify.min.js"></script>
+</body>
+</html>

_docs/index.md

@@ -1,11 +1,10 @@
 # HTML5 魔塔样板说明文档
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 众所周知，魔塔的趋势是向移动端发展，贴吧中也常常能见到“求手机魔塔”的帖子。然而现有的工具中，NekoRPG有着比较大的局限性，游戏感较差，更是完全没法在iOS上运行。而一些APP的魔塔虽然可用，但是必须要下载安装，对于Android和iOS还必须开发不同的版本，非常麻烦。
 
 但是，现在我们有了HTML5。 HTML5的画布（canvas）以及它被Android/iOS内置浏览器所支持的特性，可以让我们做出真正意义上的全平台覆盖的魔塔。
-事实上，在贴吧的试水发布也证明了，H5魔塔确实是可以成功的。两部即使是复刻的魔塔也受到了不少人的追捧，其流畅的手感和全平台支持的特性，也让很多没办法打开电脑的人爱不释手。
 
 然而，一般而言使用非RMXP制作魔塔往往需要一定的编程技术，HTML5魔塔自然也不例外。但是，为了能让大家更加注重于“做塔”本身，而不用考虑做塔以外的各种脚本问题，我特意制作了这样一部HTML5的魔塔样板。
 
@@ -13,7 +12,7 @@
 
 继续查看文档的详细介绍，让你学会如何使用这一个样板来制作属于自己的HTML5魔塔。
 
-视频教程地址：[http://www.bilibili.com/video/av17608025/](http://www.bilibili.com/video/av17608025/) ，配合本教程观看效果更佳~
+本说明文档配有B站视频教程，对照查看效果更佳哦：[https://www.bilibili.com/video/av32781473/](https://www.bilibili.com/video/av32781473/)。
 
 ==========================================================================================
 

_docs/personalization.md

@@ -0,0 +1,717 @@
+# 个性化
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+有时候只靠样板本身可能是不够的。我们需要一些个性化、自定义的素材，道具效果，怪物属性，等等。
+
+## 图层的说明
+
+HTML5魔塔是使用画布（canvas）来绘制，存在若干个图层，它们之间有一个覆盖关系，后面的图层将覆盖前面的图层。
+
+所有图层从低往高依次如下：（加[B]的代表该层是大地图，[D]代表由系统按需动态创建，z-index代表该层的纵向高度）
+
+- bg**[B]**：背景层；绘制背景图层素材bgmap，和背景贴图 (z-index: 10)
+- event**[B]**：事件层；所有事件（道具、墙壁、NPC、怪物等）都绘制在这一层进行处理 (z-index: 30)
+- hero：勇士层；主要用来绘制勇士 (z-index: 40)
+- event2**[B]**：事件2层；本层主要用来绘制48x32的图片素材的上半部分（避免和勇士错位） (z-index: 50)
+- fg**[B]**：前景层；绘制前景图层素材fgmap，和前景贴图 (z-index: 60)
+- damage**[B]**：显伤层；主要用来绘制怪物显伤和领域显伤 (z-index: 65)
+- animate：动画层；主要用来绘制动画。 (z-index: 70)
+- weather**[D]**：天气层；主要用来绘制天气（雨/雪/雾） (z-index: 80)
+- route**[D]**：路线层；主要用来绘制勇士的行走路线图。 (z-index: 95)
+- paint**[D]**：绘图层；主要用来进行绘图模式。（z-index: 95)
+- curtain：色调层；用来控制当前楼层的画面色调 (z-index: 125)
+- image1\~50**[D]**：图片层；用来绘制图片等操作。（z-index: 100+code, 101~150）
+- ui：UI层；用来绘制一切UI窗口，如剧情文本、怪物手册、楼传器、系统菜单等等 (z-index: 140)
+- data：数据层；用来绘制一些顶层的或更新比较快的数据，如左上角的提示，战斗界面中数据的变化等等。 (z-index: 170)
+
+请注意：显示图片事件将自动创建一个图片层，z-index是100+图片编号。
+
+而，色调层的z-index是25，ui层的z-index是140；因此，图片编号在1~24的将被色调层遮挡，25~40的将被ui层遮挡，41~50的将遮挡UI层。
+
+### 动态创建canvas
+
+从V2.5.3开始，可以在H5样板中任意动态创建canvas并进行使用。
+
+使用`core.createCanvas(name, x, y, w, h, z)`来动态创建一个画布。
+
+其中name为动态canvas名称，x,y,w,h为创建的画布相对窗口左上角的像素坐标和长宽，z为画布的纵向高度。
+
+例如：`core.createCanvas('test', 10, 20, 100, 200, 74)` 创建了一个名为test的画布，其左上角相对窗口的像素坐标为(10,20)，宽100高200，纵向高度74（在动画层和天气层之间）。
+
+该函数会返回画布的context，也可以通过 `core.dymCanvas[name]` 来获得；例如 `core.dymCanvas.test` 就是我们上面创建的画布的context，然后进行操作。
+
+也可以简单的使用`core.fillText()`, `core.fillRect()`, `core.strokeRect()`等等对画布进行任意绘制。
+
+``` js
+core.fillText('test', '这是一段文字', 10, 30, '#FF0000', '16px Verdana'); // 绘制一段文本
+```
+
+使用 `core.deleteCanvas(name)` 删除一个动态创建的画布，例如 `core.deleteCanvas('test')`。
+
+`core.deleteAllCanvas()`可以删除所有动态创建的画布，`core.relocateCanvas(name, x, y)`和`core.resizeCanvas(name, x, y)`可以对画布的位置和大小进行改变。
+
+更多详细API请参见[API列表](api)。
+
+## 自定义素材
+
+所有素材的图片都在`images`目录下。
+- `animates.png` 为所有动画效果。主要是星空熔岩，开门，毒网，传送门之类的效果。为四帧。
+- `autotile*.png` 为Autotile块。
+- `enemys.png` 为所有怪物的图片。
+- `enemy48.png` 为所有48x32怪物的图片。
+- `heros.png` 为勇士行走图。
+- `items.png` 为所有道具的图标。
+- `npcs.png` 为所有NPC的图标。
+- `npc48.png` 为所有48x32的NPC图标。
+- `terrains.png` 为所有地形的图标。
+
+系统会读取`icon.js`文件，并获取每个ID对应的图标所在的位置。
+
+### 使用预定义的素材
+
+在images目录的“默认素材”下给定了若干预定义的自定义素材。
+
+如果你需要某个素材已经存在，则可以直接将其覆盖images目录下的同名文件，就能看到效果。
+
+### 背景和前景图层
+
+从V2.4.1开始，样板允许多个图层叠加，最多支持背景层、事件层和前景层三个图层。
+
+在地图编辑器中绘图时，下拉框选中“背景层”或“前景层”即可在对应的图层上绘图。
+
+其中背景层和前景层可以使用任何素材，以及使用自动元件（autotile）。
+
+可以使用`showBgFgMap`, `hideBgFgMap`, `setBgFgBlock`等事件对背景和前景图层进行操作。
+
+### 使用自己的图片作为某层楼的背景/前景素材
+
+由于HTML5功能（素材）有限，导致了对很多比较复杂的素材（比如房子内）等无法有着较好的绘图方式。
+
+为了解决这个问题，我们允许用户自己放置一张或多张图片作为某一层的背景/前景素材。
+
+要启用这个功能，我们首先需要在`data.js`中将可能的图片进行加载。
+
+``` js
+"images": [ // 在此存放所有可能使用的图片
+    // 图片可以被作为背景/前景图，也可以直接用自定义事件进行显示。
+    // 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+    // 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量
+    "bg.jpg", "house.png", "bed.png"// 依次向后添加
+];
+```
+
+!> 请使用网上的一些[在线图片压缩工具](http://compresspng.com/zh/)对图片进行压缩，以节省流量。
+
+之后，我们可以在每层剧本的`"images"`里来定义该层的默认背景/前景层的图片素材。
+
+从V2.5.4开始，贴图也允许进行帧动画，只要设置第五项的数值。
+
+``` js
+[[96,120,"bg.jpg",0]] // 背景图；你可以选择一张或多张图片来作为背景/前景素材。
+[] // 无任何背景图
+[[32,32,"house.png",0], [160,170,"bed.png",1]] // 在(32,32)放一个house.png在背景层，且(160,170)放bed.png在前景层
+[[96,120,"tree.png",2]] // 如果写2，则会自动调节遮挡效果
+[[64,0,"x.png",1,4]] // 这是一个前景层的4帧动画贴图
+```
+
+images为一个数组，代表当前层所有作为背景素材的图片信息。每一项为一个五元组，分别为该背景素材的x，y，图片名，遮挡方式和帧数。
+
+其中x和y分别为左上角的像素坐标；图片名则必须在全塔属性的images中定义过。
+
+第四项为遮挡方式，定义如下：
+
+- 0：该图片将全部画在背景层，被勇士所遮挡。举例：某些特殊地形等。
+- 1：该图片将全部画在前景层，可以遮挡勇士。举例：云彩等效果。
+- 2：该图片将上部分画在前景层，下部分画在背景层。从而可以达到一个“自动调节遮挡的效果”。举例：树、房子等等。
+
+!> 如果写2的话，最好让x，y和图片高度都是32的倍数！
+
+第五项为图片的帧数，可选。如果进行了设置，则会将该贴图视为帧动画，并切分成对应的帧数。
+
+例如，假设图片是100x100的，且帧数设为4，则视为四帧帧动画，每次绘制的图片大小实际上是25x100。
+
+关于楼层贴图和前景、背景层的层叠覆盖关系，默认是：**地板 - 背景贴图 - 背景图块 - 事件 - 勇士 - 前景贴图 - 前景图块**。
+
+可以通过修改`libs/maps.js`的`drawBg`和`drawFg`函数来改变其覆盖关系。
+
+``` js
+////// 绘制背景层 //////
+maps.prototype.drawBg = function (floorId, ctx) {
+    var onMap = ctx == null;
+    if (onMap) {
+        ctx = core.canvas.bg;
+        core.clearMap(ctx);
+    }
+    this._drawBg_drawBackground(floorId, ctx);
+    // ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制背景图块；后绘制的覆盖先绘制的。
+    this._drawFloorImages(floorId, ctx, 'bg');
+    this._drawBgFgMap(floorId, ctx, 'bg', onMap);
+}
+```
+
+楼层贴图可以被事件隐藏和显示，详见[隐藏贴图](event#hideFloorImg：隐藏贴图)的写法。
+
+**如果要让贴图的某些点不可通行，则可以使用noPass或者空气墙。**
+
+!> 小技巧：可以使用帧动画贴图来贴一些大型怪物，比如魔龙、章鱼，或者《永不复还》中的恐怖利刃等等。如果使用帧贴图来贴怪物，则可以使用一个“透明的怪物”放置在对应位置并写上具体属性数值（这样就可以进行战斗和显伤了）；然后可以使用[displayIdInBook](element#怪物的朝向问题)在怪物手册中将该透明怪物映射到另一个有素材的怪物ID上。战斗完毕后使用[隐藏贴图](event#hideFloorImg：隐藏贴图)事件将贴图隐藏即可。
+
+### 使用便捷PS工具生成素材
+
+如果我们有更多的素材要求，我们可以使用“便捷PS工具”进行处理。
+
+![便捷PS工具](img/ps.png)
+
+我们可以打开有需求改变的素材，和我们需要被替换的素材，然后简单的Ctrl+C和Ctrl+V操作即可。
+
+便捷PS工具同样支持图片色相的修改，和RMXP几乎完全相同。
+
+用这种方式，我们能极快地替换或素材，包括需要新增的怪物。
+
+### 添加素材到游戏
+
+在使用地图编辑器编辑的过程中，我们有可能会出现“该数字和ID未被定义”的错误提示。
+
+这是因为，该素材没有被定义，无法被游戏所识别。
+
+!> 在V2.0中，我们可以简单的在地图编辑器中新增素材，以及定义新增素材的ID和数字，但是仍然**强烈建议**对素材的机制进行了解。
+
+#### 素材的机制
+
+本塔所有的素材都拥有三个属性：**ID**，**索引**，**数字**。
+- **ID** 为该素材的唯一标识符，任何两个素材的ID都不能相同。
+- **索引** 为该素材的在对应图片上的图标索引，即该素材是图片上的第几个。
+- **数字** 为该素材的对应数字，以方便地图的生成和存储。
+
+**`ID-索引` 对应关系定义在icons.js文件中。该文件将唯一确定一个ID在图片上所在的位置。**
+
+**`ID-数字` 对应关系定义在maps.js文件中。该文件将唯一确定一个ID对应的数字是多少。**
+
+在V2.0中，我们可以在地图编辑器中很方便查看每个图块的三个属性信息。
+
+#### 注册素材
+
+在V2.0的地图编辑器中，要注册新素材，我们只需要在图块属性一栏输入新素材的ID和数字。
+
+![素材注册](./img/register.png)
+
+ID必须由数字字母下划线组成，数字在1000以内，且均不能和已有的进行重复。
+
+之后刷新编辑器即可。
+
+我们也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
+
+素材注册完毕后，即可在游戏中正常使用，也可以被地图生成器所识别（需要重开地图生成器）。
+
+#### Autotile自动元件的注册
+
+但是，通过上面这种方式，我们是没办法新增并注册Autotile的。
+
+除了替换样板现有的几个外，如果我们还需要新添加Autotile，则：
+
+1. 下拉框切到“追加素材”，导入文件到画板，然后导入一张Autotile自动元件图片。
+2. 下拉框选择autotile，然后点“追加”
+3. 看到成功的提示后刷新编辑器即可。
+
+### 额外素材
+
+从V2.4.2开始，HTML5魔塔样板开始支持额外素材。
+
+具体而言，通过上面的“素材导入”的方式，确实可以有效地添加素材到游戏。但是，如果想增加大量自定义素材，需要通过便捷PS工具将这些素材全部导入到`terrains.png`中，并且全部是单列，极度不友好。这也导致了野外风的制作相对变得很困难，增加了大量素材处理的工作量。
+
+额外素材就是为了解决这个问题而被提出。
+
+所谓`额外素材`，即用户可以自定导入任意张素材图片，无需PS，无需注册，即可直接在游戏中使用。这一点已经十分向RM靠拢了。
+
+要使用额外素材，请将你需要的素材图片放在`images`目录下，并在`全塔属性`的`tilesets`中定义图片名。
+
+**该素材的宽高必须都是32的倍数，且图片上的总图块数不超过1000（即最多有1000个32*32的图块在该图片上）。**
+
+```js
+// 在全塔属性中的tilesets导入素材
+"tilesets": ["1.png", "2.png"]    // 导入两个额外素材，文件名分别是1.png和2.png
+```
+
+刷新后，系统会自动加载该素材并添加到素材区。
+
+额外素材无需导入，无需注册。在`tilesets`中定义了图片后，即可直接使用绘图，无需再注册其数字和ID。其ID、索引和数字均为系统自动分配，且不允许修改。
+
+请注意，额外素材的ID、索引和数字，与该图片在tilesets数组中的index及该素材在图片上的位置都有关系。
+
+!> **因此如果对`tilesets`数组随意删除或修改顺序，可能会导致所有额外素材全部发生变化！这点请务必注意！！！**
+
+除此之外，额外素材在游戏中的使用和正式素材都是一致的，也能在前景或背景图层绘制。
+
+额外素材可以使用“tileset贴图”的方式进行绘制，一次绘制一个矩形区域。
+
+## 自定义道具效果
+
+本节中将继续介绍如何自己编辑一个道具的效果。
+
+道具效果的具体实现都在`items.js`中。
+
+### 即捡即用类道具（cls: items）
+
+对于即捡即用类道具，如宝石、血瓶、剑盾等，我们可以简单地修改`data.js`中的value一栏即可。
+
+如果你想要同种宝石在不同层效果不同的话，可以进行如下操作：
+
+1. 在楼层的item_ratio中定义宝石的比率（比如1-10的写1，11-20层写2等）
+2. 修改获得道具的itemEffect函数（编辑器中双击进行编辑）
+
+``` js
+// ratio为楼层的item_ratio值，可以进行翻倍宝石属性
+core.status.hero.atk += core.values.redJewel * ratio
+```
+
+这里我们可以直接写ratio来取用该楼层中定义的`item_ratio`的值。
+
+如果不是倍数增加（比如线性增加）也可以类似来写
+
+``` js
+// 一个二倍线性增加的例子
+core.status.hero.atk += core.values.redJewel + 2*ratio
+```
+
+### 消耗类道具（cls: tools）；永久类道具（cls: constants）
+
+如果要自己实现消耗类道具或永久类道具的使用效果，则需修改`items.js`中的canUseItem和useItem两个函数。
+
+具体过程比较复杂，需要一定的JS能力，在这里就不多说了，有需求可以找`艾之葵`进行了解。
+
+### 实战！拿到神圣盾后免疫吸血、领域、夹击效果
+
+1. 在itemEffect中修改拿到神圣盾时的效果，标记一个自定义Flag。
+``` js
+core.status.hero.def += core.values.shield5 * ratio;
+core.setFlag("shield5", true); // 增加一个自定义Flag：已经拿到神圣盾
+```
+2. 免疫吸血效果：在脚本编辑的getDamageInfo中，编辑成如果存在神圣盾标记，吸血伤害为0。
+``` js
+function (enemy, hero_hp, hero_atk, hero_def, hero_mdef, x, y, floorId) {
+// ... 上略
+    // 吸血
+    if (this.hasSpecial(mon_special, 11)) {
+        var vampireDamage = hero_hp * enemy.value;
+
+        // 如果有神圣盾免疫吸血等可以在这里写
+        // 也可以用hasItem或hasEquip来判断装备
+        if (core.hasFlag("shield5")) vampireDamage = 0; // 存在神圣盾，吸血伤害为0
+
+        vampireDamage = Math.floor(vampireDamage) || 0;
+        // 加到自身
+        if (enemy.add) // 如果加到自身
+            mon_hp += vampireDamage;
+
+        initDamage += vampireDamage;
+    }
+// ... 下略
+```
+3. 免疫领域、夹击、阻击效果：在2.4.1之后，可以直接将flag:no_zone设为true来免疫领域效果，其他几个同理。
+``` js
+// 写在获得道具后事件
+[
+    // 设置不同的flag可以分别无视对应的阻激夹域效果
+    {"type": "setValue", "name": "flag:no_zone", "value": "true"}, // 免疫领域
+    {"type": "setValue", "name": "flag:no_snipe", "value": "true"}, // 免疫阻击
+    {"type": "setValue", "name": "flag:no_laser", "value": "true"}, // 免疫激光
+    {"type": "setValue", "name": "flag:no_betweenAttack", "value": "true"}, // 免疫夹击
+]
+```
+4. 如果有更高的需求，例如想让吸血效果变成一半，则还是在上面这些地方进行对应的修改即可。
+
+## 新增门和对应的钥匙
+
+如果要新增一个门和对应的钥匙，需要进行如下几步：
+
+1. 在terrains.png中添加新的门的素材，并在地图编辑器中注册门的ID。该ID必须是以`Door`结尾，例如`abcDoor`。
+2. 在animates.png中添加开门的四格动画，然后直接打开icons.js文件，在animates下直接添加ID和索引信息，例如`'abcDoor': 34`。
+3. 在items.png中添加钥匙的素材，并在地图编辑器中注册钥匙的ID。该ID必须是和门对应且以`Key`结尾，例如`abcKey`。
+4. 该道具的cls应为`tools`，可以自行写道具描述，最下面几项均留`null`即可。
+
+!> **请勿在animates中对门的动画素材进行注册！而是请直接打开icons.js文件并添加ID和索引信息！！！**
+
+!> terrains和animates的门ID必须完全一致，且以`Door`结尾；所对应的钥匙ID应当是把`Door`换成`Key`，这样才能对应的上！
+
+## 覆盖楼传事件
+
+对于特殊的塔，我们可以考虑修改楼传事件来完成一些特殊的要求，比如镜子可以按楼传来切换表里。
+
+要修改楼传事件，需要进行如下两步：
+
+1. 重写楼传的点击事件。在插件中对`core.control.useFly进行重写`。详细代码参见[重写点击楼传事件](script#重写点击楼传事件)。
+2. 修改楼传的使用事件。和其他永久道具一样，在地图编辑器的图块属性中修改楼传的useItemEffect和canUseItemEffect两个内容。例如：
+``` js
+"useItemEffect": "core.insertAction([...])" // 执行某段自定义事件，或者其他脚本
+"canUseItemEffect": "true" // 任何时候可用
+```
+
+除了覆盖楼传事件外，对于快捷商店、虚拟键盘等等也可以进行覆盖，只不过是仿照上述代码重写对应的函数（`openQuickShop`,`openKeyBoard`）即可。
+
+## 自定义怪物属性
+
+如果你对现有的怪物不满意，想自行添加怪物属性也是可以的。具体参见脚本编辑的getSpecials。
+
+你需自己指定一个special数字，修改属性名和属性提示文字。后两者可以直接写字符串，或写个函数传入怪物。
+
+如果要修改伤害计算公式，请修改下面的getDamageInfo函数。请注意，如果无法战斗，该函数必须返回`null`。
+
+!> 如果改动了伤害计算公式，可能导致临界计算崩掉，因此建议将全塔属性中的`useLoop`置为true。
+
+对于毒衰弱怪物的战斗后结算在脚本编辑中的afterBattle函数中。
+
+对于领域、夹击、阻击怪物的检查在`control.js`中的checkBlock函数中。
+
+## 自定义快捷键
+
+如果需要绑定某个快捷键为处理一段事件，也是可行的。
+
+要修改按键，我们可以在脚本编辑的`onKeyUp`进行处理：
+
+比如，我们设置一个快捷键进行绑定，比如`Y`，其keycode是89。（有关每个键的keycode搜一下就能得到）
+
+然后在脚本编辑的`onKeyUp`函数的`switch`中进行处理。
+
+``` js
+case 89: // 使用该按键的keyCode，比如Y键就是89
+    // 还可以再判定altKey是否被按下，即 if (altKey) { ...
+
+    // ... 在这里写你要执行脚本
+    // **强烈建议所有新增的自定义快捷键均能给个对应的道具可点击，以方便手机端的行为**
+    if (core.hasItem('...')) {
+        core.status.route.push("key:0"); // 记录按键到录像中
+        core.useItem('...', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
+    }
+
+    break;
+```
+
+强烈建议所有新增的自定义快捷键均给个对应的永久道具可点击，以方便手机端的行为。
+
+使用`core.status.route.push("key:"+keyCode)`可以将这次按键记录在录像中。
+
+!> 如果记录了按键，且使用道具的话，需要将useItem的第二个参数设为true，避免重复记录！
+
+可以使用altKey来判断Alt键是否被同时按下。
+
+## 公共事件
+
+从V2.5.4开始，样板提供了“公共事件”下拉框，我们可以在里面用事件编辑器进行编辑，并通过`{"type":"insert"}`进行调用。
+
+![公共事件](./img/commonEvent.png)
+
+具体详见[插入公共事件或另一个地点的事件并执行](event#insert：插入公共事件或另一个地点的事件并执行)。
+
+当然，继续使用**插件**的写法也是可以的。
+
+## 插件系统
+
+在H5中，提供了“插件”系统。在V2.6中提供了一个插件下拉框，用户可以自行创建和写插件。
+
+在插件编写的过程中，我们可以使用任何[常见API](api)里面的代码调用；也可以通过`core.insertAction`来插入自定义事件执行。
+
+下面是一个很简单的例子，我编写一个插件函数，其效果是让勇士生命值变成原来的x倍，并令面前的图块消失。
+
+``` js
+this.myfunc = function(x) {
+    core.status.hero.hp *= x; // 勇士生命翻若干倍
+    core.insertAction([ // 自定义事件：令面前的图块消失。
+        {"type": "setValue", "name": "flag:x", "value": "core.nextX()"},
+        {"type": "setValue", "name": "flag:y", "value": "core.nextY()"},
+        {"type": "hide", "loc": ["flag:x", "flag:y"]}
+    ]);
+}
+```
+
+然后比如我们在某个道具的使用效果 `useItemEffect` 中写 `core.plugin.myfunc(2)` 即可调用此插件函数。也可以在战后事件或自定义脚本等位置来写。
+
+网站上也提供了一个[插件库](https://h5mota.com/plugins/)，欢迎大家把自己写的插件进行共享。
+
+从V2.6开始，在插件中用`this.xxx`定义的函数将会被转发到core中。例如上述的`myfunc`除了`core.plugin.myfunc`外也可以直接`core.myfunc`调用。
+
+详见[函数的转发](script#函数的转发)。
+
+## 标题界面事件化
+
+从V2.5.3开始，我们可以将标题界面的绘制和游戏开始用事件来完成。可以通过绘制画布、全塔属性，flags中的startUsingCanvas可以决定是否开启标题界面事件化。
+
+然后就可以使用“事件流”的形式来绘制标题界面、提供选项等等。
+
+在这里可以调用任意事件。例如，可以贴若干个图，可以事件切换楼层到某个剧情层再执行若干事件，等等。
+
+关于选项，样板默认给出的是最简单的choices事件；你也可以使用贴按钮图，循环处理+等待操作来定制自己的按钮点击效果。
+
+!> 开始游戏、读取存档、录像回放的效果已经默认给出，请不要修改或删减这些内容，以免出现问题。
+
+标题界面事件全部处理完后，将再继续执行startText事件。
+
+## 手机端按键模式
+
+从V2.5.3以后，我们可以给手机端增加按键了，这样将非常有利于技能的释放。
+
+用户在菜单栏打开“拓展键盘”后，在竖屏模式下点击工具栏，就会在工具栏按钮和快捷键模式之间进行切换。
+
+切换到快捷键模式后，可以点1-8，分别等价于在电脑端按键1-8。
+
+可以在脚本编辑的onKeyUp中定义每个快捷键的使用效果，比如使用道具或释放技能等。
+
+默认值下，1使用破，2使用炸，3使用飞，4使用其他存在的道具，5-8未定义。可以相应修改成自己的效果。
+
+也可以替换icons.png中的对应图标，以及修改main.js中`main.statusBar.image.btn1~8`中的onclick事件来自定义按钮和对应按键。
+
+非竖屏模式下、回放录像中、隐藏状态栏中，将不允许进行切换。
+
+## 自绘状态栏
+
+从V2.5.3开始允许自绘状态栏。要自绘状态栏，则应该打开全塔属性中的`statusCanvas`开关。
+
+自绘模式下，全塔属性中的`statusCanvasRowsOnMobile`将控制竖屏模式下的状态栏行数。
+
+开启自绘模式后，可以在脚本编辑的`drawStatusBar`中自行进行绘制。
+
+横屏模式下的状态栏为`129x416`（15x15则是`149x480`）；竖屏模式下的状态栏为`416*(32*rows+9)`（15x15是480）。
+
+具体可详见脚本编辑的`drawStatusBar`函数。
+
+## 自定义状态栏的显示项
+
+在V2.2以后，我们可以自定义状态栏背景图（全塔属性 - statusLeftBackground）等等。
+
+但是，如果我们还想新增其他项目的显示，比如攻速或者暴击，该怎么办？
+
+我们可以[自绘状态栏](#自绘状态栏)，或者采用下面两个方式之一来新增。
+
+### 利用已有项目
+
+一个最为简单的方式是，直接利用已有项目。
+
+例如，如果本塔中没有技能栏，则可以使用技能栏所对应的显示项。
+
+1. 覆盖project/icons.png中技能的图标
+2. 打开全塔属性的enableSkill开关
+3. 在脚本编辑-updateStatusBar中可以直接替换技能栏的显示内容
+
+```
+	// 设置技能栏
+	if (core.flags.enableSkill) {
+		// 替换成你想显示的内容，比如你定义的一个flag:abc。
+		core.setStatusBarInnerHTML('skill', core.getFlag("abc", 0));
+	}
+```
+
+### 额外新增新项目
+
+如果是在需要给状态栏新定义项目，则需要进行如下几个操作：
+
+1. 定义ID；比如攻速我就定义speed，暴击可以简单的定义baoji；你也可以定义其他的ID，但是不能和已有的重复。这里以speed为例。
+2. 在index.html的statusBar中（46行起），进行该状态栏项的定义。仿照其他几项，插在其应当显示的位置，注意替换掉相应的ID。
+``` html
+<div class="status" id="speedCol">
+    <img id="img-speed">
+    <p class='statusLabel' id='speed'></p>
+</div>
+```
+3. 在editor.html中的statusBar（383行起），仿照第二点同样添加；这一项如果不进行则会地图编辑器报错。editor-mobile.html同理。
+4. 使用便捷PS工具，打开project/icons.png，新增一行并将魔力的图标P上去；记下其索引比如37（从0开始数）。
+5. 在main.js的this.statusBar中增加图片、图标和内容的定义。
+``` js
+this.statusBar = {
+    'images': {
+        // ...其他略
+        'speed': document.getElementById("img-speed"), // 图片的定义
+    },
+    'icons': {
+        // ...其他略
+        'speed': 37, // 图标的定义，这里对应的是icons.png中的索引
+    },
+    // ...其他略
+    'speed': document.getElementById('speed'), // 显示内容（数据）的定义
+}
+```
+6. 显示内容的设置。在脚本编辑的updateStatusBar函数，可以对该状态栏显示内容进行设置，下面是几个例子。
+``` js
+// 设置其显示内容为status:speed值；需要在project/data.js中firstData的hero那里新增初始值`"speed": 0`。
+core.statusBar.speed.innerHTML = core.getStatus('speed');
+// 设置其显示内容为flag:speed值，无需额外进行定义。
+core.statusBar.speed.innerHTML = core.getFlag('speed', 0);
+```
+
+## 技能塔的支持
+
+要支持技能塔，可能需要如下几个方面：
+
+从V2.5开始，内置了"二倍斩"技能，可以仿照其制作自己的技能。
+
+- 魔力（和上限）的添加；技能的定义
+- 状态栏的显示
+- 技能的触发（按键与录像问题）
+- 技能的效果
+
+### 魔力的定义添加；技能的定义
+
+从V2.5开始，提供了status:mana选项，可以直接代表当前魔力值。
+
+如果要启用，需要开启全塔属性的enableMana选项。
+
+如果需要魔力上限，则可以使用flag:manaMax来表示当前的魔力最大值。
+
+同时，我们可以使用flag:skill表示当前开启的技能编号，flag:skillName表示当前开启的技能名称。
+
+如果flag:skill不为0，则代表当前处于某个技能开启状态，且状态栏显示flag:skillName值。伤害计算函数中只需要对flag:skill进行处理即可。
+
+!> 关于魔力上限：样板中默认没有提供status:manamax
+
+### 状态栏的显示
+
+从V2.5开始，魔力值和技能名的状态栏项目已经被添加，可以直接使用。
+
+在脚本编辑-updateStatusBar中，可以对状态栏显示内容进行修改。
+
+``` js
+// 设置魔力值
+if (core.flags.enableMana) {
+    // status:manamax 只有在非负时才生效。
+    if (core.status.hero.manamax != null && core.status.hero.manamax >= 0) {
+        core.status.hero.mana = Math.min(core.status.hero.mana, core.status.hero.manamax);
+        core.setStatusBarInnerHTML('mana', core.status.hero.mana + "/" + core.status.hero.manamax);
+    }
+    else {
+        core.setStatusBarInnerHTML("mana", core.status.hero.mana);
+    }
+}
+// 设置技能栏
+if (core.flags.enableSkill) {
+    // 可以用flag:skill表示当前开启的技能类型，flag:skillName显示技能名
+    core.statusBar.skill.innerHTML = core.getFlag('skillName', '无');
+}
+```
+
+### 技能的触发
+
+#### 使用道具作为技能
+
+由于手机端按键十分不方便，虚拟键盘不好用，因此强烈推荐**给每个技能设置一个道具图标，在道具栏点击使用！**
+
+下面是个很简单的例子，要制作一个技能"二倍斩"。
+
+我们可以设置一个道具，其cls是`constants`（永久道具），ID比如是`skill1`。
+
+该道具的使用判定`canUseItemEffect`是`true`（表示任意时候都可使用），使用效果`useItemEffect`是：
+
+``` js
+if (core.getFlag('skill', 0)==0) { // 判断当前是否已经开了技能
+    if (core.getStatus('mana')>=5) { // 这里要写当前能否开技能的条件判断，比如魔力值至少要多少
+        core.setFlag('skill', 1); // 开技能1
+        core.setFlag('skillName', '二倍斩'); // 设置技能名
+    }
+    else {
+        core.drawTip("魔力不足，无法开技能");
+    }
+}
+else { // 关闭技能
+    core.setFlag('skill', 0); // 关闭技能状态
+    core.setFlag('skillName', '无');
+}
+```
+
+简单的说，用flag:skill判断当前开启的技能，flag:skillName表示该技能名。（可在状态栏显示）
+
+该（技能）道具任何时候都可被使用；使用时，判断当前是否开启了技能，如果开启则关闭，没开则再判断是否允许开启（魔力值够不够等）。
+
+#### 快捷键触发技能
+
+在PC端，我们还可以按键触发技能。
+
+在技能的道具定义完毕后，再将该道具绑定到一个快捷键上。有关绑定按键请参见[自定义快捷键](#自定义快捷键)。
+
+下面是一个很简单的例子，当勇士按下W后，触发我们上面定义的二倍斩技能。
+
+``` js
+case 87: // W：开启技能“二倍斩”
+    // 检测技能栏是否开启，是否拥有“二倍斩”这个技能道具
+    if (core.flags.enableSkill && core.hasItem('skill1')) {
+        core.status.route.push("key:87");
+        core.useItem('skill1', true);
+    }
+    break;
+```
+
+在勇士处于停止的条件下，按下W键时，判断技能的道具是否存在，如果存在再使用它。
+
+!> 由于现在手机端存在拓展键盘，也强烈建议直接覆盖1-8的使用效果，这样手机端使用也非常方便。
+
+### 技能的效果
+
+最后一点就是技能的效果；其实到了这里就和RM差不多了。
+
+技能的效果要分的话有地图类技能，战斗效果类技能，后续影响类技能什么的，这里只介绍最简单的战斗效果类技能。
+
+其他的几类技能根据需求可能更为麻烦，有兴趣可自行进行研究。
+
+战斗效果内技能要改两个地方：战斗伤害计算，战后扣除魔力值。
+
+战斗伤害计算在脚本编辑的`getDamageInfo`函数，有需求直接修改这个函数即可。
+
+战后扣除魔力值则在脚本编辑的`afterBattle`中进行编辑即可。
+
+举个例子，我设置一个勇士的技能：二倍斩，开启技能消耗5点魔力，下一场战斗攻击力翻倍。
+
+那么，直接在脚本编辑的`getDamageInfo`中进行判断：
+
+``` js
+if (core.getFlag('skill', 0)==1) { // 开启了技能1
+    hero_atk *= 2; // 计算时攻击力翻倍
+}
+```
+
+然后在脚本编辑的`afterBattle`中进行魔力值的扣除：
+
+``` js
+// 战后的技能处理，比如扣除魔力值
+if (core.flags.enableSkill) {
+    // 检测当前开启的技能类型
+    var skill = core.getFlag('skill', 0);
+    if (skill==1) { // 技能1：二倍斩
+        core.status.hero.mana-=5; // 扣除5点魔力值
+    }
+    // 关闭技能
+    core.setFlag('skill', 0);
+    core.setFlag('skillName', '无');
+}
+```
+
+!> 开启技能后，建议将全塔属性的useLoop置为true，即改用循环计算临界值，这样临界计算才不会出问题！
+
+&nbsp;
+
+通过上述这几种方式，我们就能成功的让H5支持技能啦！
+
+## 系统使用的flag变量
+
+众所周知，自定义flag变量都可以任意定义并取用（未定义直接取用的flag默认值为0）。
+
+下面是一些可能会被系统设置或取用的flag变量：
+
+- **`flag:hard`**: 当前的难度标志；此flag变量在setInitData中被定义，可以直接取用来判定当前难度分歧。上传成绩时将根据此flag来对不同难度进行排序。
+- **`flag:posion`**, **`flag:weak`**, **`flag:curse`**: 中毒、衰弱、诅咒状态。
+- **`flag:no_zone`**, **`flag:no_snipe`**, **`flag:no_laser`**, **`flag:no_betweenAttack`**: 是否分别免疫领域、阻击、激光、夹击效果。
+- **`flag:hatred`**: 当前的仇恨数值。
+- **`flag:commonTimes`**: 全局商店共用次数时的访问次数。
+- **`flag:input`**: 接受用户输入的事件后，存放用户输入的结果。
+- **`flag:type`**, **`flag:keycode`**, **`flag:x`**, **`flag:y`**, **`flag:px`**, **`flag:py`**: 等待用户操作后，用户的操作类型，按键keycode或点击/像素坐标。
+- **`flag:skill`**, **`flag:skillName`**: 开启的技能编号和技能名。
+- **`flag:heroIcon`**: 当前的勇士行走图名称。
+- **`flag:saveEquips`**: 快速换装时保存的套装。
+- **`flag:__visited__`**: 当前访问过的楼层。
+- **`flag:__atk_buff__`**, **`flag:__def_buff__`**, **`flag:__mdef_buff__`**: 当前攻防魔防的实际计算比例加成。
+- **`flag:__color__`**, **`flag:__weather__`**, **`flag:__volume__`**: 当前的画面色调、天气和音量。
+- **`flag:__events__`**: 当前保存的事件列表，读档时会恢复（适用于在事件中存档）
+- **`flag:textAttribute`**, **`flag:globalAttribute`**, **`flag:globalFlags`**: 当前的剧情文本属性，当前的全局属性，当前的全局开关。
+- **`flag:cannotMoveDirectly`**, **`flag:__noClickMove__`**: 当前是否不允许瞬间移动，当前用户是否开启了单击瞬移。
+- **`flag:hideStatusBar`**, **`flag:showToolbox`**: 是否隐藏状态栏，是否显示工具栏。
+- **`flag:debug`**, **`flag:__consoleOpened__`**: 当前是否开启了调试模式，是否开启了控制台。
+- **`flag:__seed__`**, **`flag:__rand__`**: 伪随机数生成种子和当前的状态
+
+==========================================================================================
+
+[继续阅读脚本](script)

_docs/script.md

@@ -0,0 +1,354 @@
+# 脚本
+
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
+
+在V2.6版本中，基本对整个项目代码进行了重写，更加方便造塔者的使用和复写函数。
+
+## 控制台的使用
+
+在Chrome浏览器中，按（Ctrl+Shift+I）可打开控制台。
+
+![](img/console.jpg)
+
+控制台中有很多的标签，最常用的是`Console`, `Sources`和`Elements`。
+
+有关更详尽的控制台使用可自行搜索[Chrome开发者工具](https://www.baidu.com/s?wd=chrome%20%E5%BC%80%E5%8F%91%E8%80%85%E5%B7%A5%E5%85%B7)了解更多。
+
+### Console：命令行
+
+Console页为命令行。可以在这里输入一些命令进行调试。
+
+比如，进入游戏后，输入`core.status.hero.atk`即可获得勇士的当前攻击力数值。`core.status.hero.atk=100`可以设置攻击力为100。
+
+更多的API可参见[附录：API列表](#附录：API列表)。
+
+除此以外，游戏中的报错等信息也是可以在Console中进行查看的。
+
+![](img/console1.jpg)
+
+### Sources：断点调试
+
+Sources页可以查看JS源代码，并进行断点调试等。
+
+例如，如果相对脚本编辑中的伤害计算函数进行断点调试：
+1. 在左边找到`project/functions.js`，单击打开文件
+2. 并找到对应的行（可以Ctrl+F搜索），比如搜索`getDamageInfo`
+3. 在行号上点一下打断点，会出现一个蓝色标签
+
+之后，当代码运行到你的断点处时，将自动停止运行。
+
+![](img/sources.jpg)
+
+可以将鼠标移动到变量上，将弹窗形式显示这个变量的各项数值，从而查看变量值是否符合预期。
+
+图中红色框内有几个按钮，从左到右分别是：**继续执行**，**执行到下一行**，**进入当前函数**，**跳出当前函数**，**单步执行**。
+
+通过这几个按钮，可以一行一行的对代码进行执行，执行过程中能不断查看各个变量的数值变化，从而定位问题所在。
+
+红圈下方是Call Stack，即当前的函数调用链（从哪些地方调用过来的）。
+
+Sources还有更多有趣的功能，在此不做介绍，有兴趣的可自行网上搜索了解。
+
+### Elements：网页元素查看
+
+Elements页可以查看网页的源代码，调整css布局等。
+
+![](img/elements.jpg)
+
+不过对魔塔样板来说，最重要的是红圈中的按钮。点击此按钮可以进入**手机模式**。
+
+手机模式下，左边可以对屏幕分辨率进行调整和模拟。
+
+这可以很有效的帮我们进行测试样板在手机端的表现。
+
+## 整体项目架构
+
+``` text
+├── /_server/        # 为可视化地图编辑器提供一些支持的目录
+├── /libs/           # ---- 系统库目录 ----
+│ ├─ /thirdparty/    # 游戏所用到的第三方库文件
+│ ├─ actions.js      # 用户交互处理
+│ ├─ core.js         # 系统核心文件（游戏入口，接口&转发）
+│ ├─ control.js      # 游戏逻辑控制
+│ ├─ data.js         # 全塔属性等
+│ ├─ enemys.js       # 怪物相关处理
+│ ├─ events.js       # 各个事件的执行
+│ ├─ icons.js        # 图标和素材
+│ ├─ items.js        # 道具效果
+│ ├─ loader.js       # 各个资源加载
+│ ├─ maps.js         # 地图数据和绘制
+│ ├─ ui.js           # UI窗口绘制
+│ └─ utils.js        # 工具类函数
+├── /project/        # ---- 项目目录 ----
+│ ├─ /animates/      # 动画目录
+│ ├─ /floors/        # 楼层文件
+│ ├─ /images/        # 图片素材
+│ ├─ /sounds/        # bgm和音效
+│ ├─ data.js         # 全塔属性
+│ ├─ enemys.js       # 怪物属性
+│ ├─ events.js       # 公共事件
+│ ├─ functions.js    # 脚本编辑
+│ ├─ icons.js        # 素材和ID的对应关系定义
+│ ├─ items.js        # 道具的定义和效果
+│ ├─ maps.js         # 地图和数字的对应关系
+│ └─ plugins.js      # 自定义插件
+├── /常用工具/        # 辅助造塔的小工具
+├── editor.html      # 地图编辑器
+├── editor-mobile.html      # 手机版的地图编辑器
+├── index.html       # 主程序，游戏的入口
+├── main.js          # JS程序的入口，将动态对所需JS进行加载
+├── style.css        # 游戏所需要用到的样式表
+└── 启动服务.exe      # 一个本地的HTTP服务器，通过它来运行游戏
+```
+
+`_server`为**地图编辑器目录**，里面存放了地图编辑器相关的各项内容。
+
+`libs`为**系统库目录**，里面存放了各个系统核心函数。
+
+从V2.6开始，请勿直接修改libs下的代码，如有需要修改系统库函数请尝试在插件中[复写函数](#复写函数)。
+
+`project`为**项目目录**，你所造的塔的数据全部存放在project下。在不同样板之间接档也是直接迁移project目录即可。
+
+## 函数的转发
+
+在本样板中，`core.js`里面基本是没有定义什么函数的，所有的游戏内函数都在其他几个文件中实现。
+
+例如，常见的获得某个变量值`getFlag`是定义在`control.js`中的：
+
+```js
+////// 获得某个自定义变量或flag //////
+control.prototype.getFlag = function(name, defaultValue) {
+    if (!core.status.hero) return defaultValue;
+    var value = core.status.hero.flags[name];
+    return value != null ? value : defaultValue;
+}
+```
+
+也就是，我们可以通过`core.control.getFlag(name, value)`来调用此函数。
+
+但是这样会十分不便，我们希望能直接调用`core.getFlag(name, value)`，而不需要中间的control。
+
+为了达到这个目的，样板设置了**函数转发**，即**将其他文件中定义的函数，转发到core中执行**。
+
+上述`getFlag`代码的转发实际上是增加了如下函数：
+
+```js
+////// getFlag函数的转发 //////
+core.getFlag = function (name, defaultValue) {
+    return core.control.getFlag(name, defaultValue);
+}
+// 转发后，即可通过 core.getFlag() 来实际调用 core.control.getFlag()
+```
+
+转发是自动完成的，其满足如下两条规则：
+- **在libs中其他文件定义的函数，如果不以下划线`_`开头，就会进行转发。**
+- **如果core中已经存在同名函数，则会在控制台中打出一条报错信息，并不转发该函数。**
+
+具体函数的转发实现代码可参见`core.js`的`_forwardFunc`函数。
+
+!> 除此以外，插件中以`this.xxx`来定义的函数也会被转发！
+
+例如，你可以直接调用`core.drawLight()`来实际调用插件中的`core.plugin.drawLight`。
+
+## 插件编写
+
+插件编写是H5魔塔的一个重大特点，从V2.0.1引入，并逐渐发扬光大。
+
+对于有一定脚本经验的人来说，可以编写插件来实现各种各样的功能，包括且不仅限于拓展功能的实现，系统代码的复写等等。
+
+在V2.5.5以前，插件位置都在脚本编辑中；从V2.6开始则迁移到了新的下拉框中，并进行了切分。
+
+你也可以创建自己的插件。
+
+![](img/plugin.jpg)
+
+新的插件切分和原来的单插件使用方法完全一致，单纯进行了切分而已。可参见已有的`init`和`drawLight`的样例。
+
+拆分的意义主要是将各个可能的功能独立出来，避免单个框内内容太长，过大和混杂等。
+
+在V2.6中，应当每个独立的额外功能实现都新建一个自己的插件，这样也方便进行拓展，例如打包迁移到别的塔上，或发布在网页插件库中。
+
+另外一点需要注意的是，所有插件的初始化都会在系统资源加载之前，此时图片等资源尚未进行加载。
+
+在所有资源加载完毕时，将会执行init插件中的_afterLoadResources函数，可以在这里对资源进行一些操作，比如切分图片等。
+
+```js
+function () {
+	console.log("插件编写测试");
+
+	// 可以写一些直接执行的代码
+	// 在这里写的代码将会在【资源加载前】被执行，此时图片等资源尚未被加载。
+	// 请勿在这里对包括bgm，图片等资源进行操作。
+
+
+	this._afterLoadResources = function () {
+		// 本函数将在所有资源加载完毕后，游戏开启前被执行
+		// 可以在这个函数里面对资源进行一些操作，比如切分图片等。
+
+		// 这是一个将assets.png拆分成若干个32x32像素的小图片并保存的样例。
+		// var arr = core.splitImage("assets.png", 32, 32);
+		// for (var i = 0; i < arr.length; i++) {
+		//     core.material.images.images["asset"+i+".png"] = arr[i];
+		// }
+
+	}
+
+	// 可以在任何地方（如afterXXX或自定义脚本事件）调用函数，方法为 core.plugin.xxx();
+	// 从V2.6开始，插件中用this.XXX方式定义的函数也会被转发到core中，详见文档-脚本-函数的转发。
+}
+```
+
+网站上提供了一个插件库，[https://h5mota.com/plugins/](https://h5mota.com/plugins/)，上面有一些大家分享的插件，可供使用。
+
+可以查看附录中的[API列表](api)来查看所有的系统API内容。
+
+## 复写函数
+
+样板的功能毕竟是写死的，有时候我们也需要修改样板的一些行为。
+
+在V2.6以前，需要直接打开libs目录下的对应文件并进行修改。但是开libs下的文件就会出现各种问题：
+
+- 不容易记得自己修改过什么，而且如果改错了很麻烦
+  - 例如，直接修改了某函数加了新功能，结果过段时间发现不需要，想删掉，但是这时候已经很难找到自己改过了什么了。
+  - 或者，如果代码改错了，不断往上面打补丁，也只会使得libs越来越乱，最后连自己做过什么都不记得。
+- 不容易随着新样板接档进行迁移
+- 不方便能整理成新的插件在别的塔使用（总不能让别的塔也去修改libs吧）
+- ……
+
+好消息的是，从V2.6开始，我们再也不需要开文件了，而是可以直接在插件中对原始函数进行复写。
+
+函数复写的好处如下：
+
+- 不会影响系统原有代码。
+  - 即使写错了或不需要了，也只用把插件中的函数注释或删除即可，不会对原来的系统代码产生任何影响。
+- 清晰明了。很容易方便知道自己修改过什么，尤其是可以和系统原有代码进行对比。
+- 方便整理成新的插件，给其他的塔使用。
+
+一般而言，复写规则如下：
+
+**对xxx文件中的yyy函数进行复写，规则是`core.xxx.yyy = function (参数列表) { ... }`。**
+
+但是，对于`registerXXX`所注册的函数是无效的，例如直接复写`core.control._animationFrame_globalAnimate`函数是没有效果的。对于这种情况引入的函数，需要注册同名函数，可参见最下面的样例。
+
+下面是几个例子，从简单到复杂。
+
+### 重写怪物手册的背景图绘制，使用winskin而不是默认的黑色
+
+直接重写怪物手册的背景图绘制，使用`core.drawBackground`来用winskin绘制一个背景图。
+
+```js
+// 重写ui.js中的_drawBook_drawBackground函数
+core.ui._drawBook_drawBackground = function () {
+    // core.__PIXELS__为定义的一个宏，对于13x13的值是416，对于15x15的值是480
+    core.drawBackground(0, 0, core.__PIXELS__, core.__PIXELS__);
+}
+```
+
+### 重写点击楼传事件
+
+重写点击楼传事件，使得点击楼传按钮时能使用一个道具（比如item:fly）。
+
+```js
+// 重写events.js的useFly函数，即点击楼传按钮时的事件
+core.events.useFly = function (fromUserAction) {
+    if (core.isMoving()) {
+        core.drawTip("请先停止勇士行动");
+        return;
+    }
+    if (core.status.lockControl || core.status.event.id != null) return;
+    
+    if (core.canUseItem('fly')) core.useItem('fly');
+    else core.drawTip("当前无法使用"+core.material.items.fly.name);
+}
+```
+
+其他的几个按钮，如快捷商店`openQuickShop`，虚拟键盘`openKeyBoard`的重写也几乎完全一样。
+
+### 楼层切换时根据flag来播放不同的音效
+
+整体复制并重写整个楼传切换前的函数，将`core.playSound('floor.mp3')`替换成根据flag来判定。
+
+```js
+// 复制重写events.js中的_changeFloor_beforeChange，修改音效
+core.events._changeFloor_beforeChange = function (info, callback) {
+    // 直接替换原始函数中的 core.playSound('floor.mp3'); 
+    if (core.getFlag("floorSound") == 0) core.playSound('floor0.mp3');
+    if (core.getFlag("floorSound") == 1) core.playSound('floor1.mp3');
+    if (core.getFlag("floorSound") == 2) core.playSound('floor2.mp3');
+    // ...
+    
+    // 下面是原始函数中的剩余代码，保持不变
+    window.setTimeout(function () {
+        if (info.time == 0)
+            core.events._changeFloor_changing(info, callback);
+        else
+            core.showWithAnimate(core.dom.floorMsgGroup, info.time / 2, function () {
+                core.events._changeFloor_changing(info, callback);
+            });
+    }, 25)
+}
+```
+
+### 每次打开全局商店时播放一个音效
+
+打开全局商店是在`events.js`中的`openShop`函数，因此需要对其进行重写。
+
+然而，我们只需要在这个函数执行之前插一句音效播放，所以并不需要重写整个函数，而是直接插入一行就行。
+
+```js
+var openShop = core.events.openShop; // 先把原始函数用一个变量记录下来
+core.events.openShop = function (shopId, needVisited) {
+    core.playSound("shop.mp3"); // 播放一个音效
+    return openShop(shopId, needVisited); // 直接调用原始函数
+}
+```
+
+### 每次绘制地图前在控制台打出一条信息 
+
+绘制地图在`maps.js`的`drawMap`函数，因此需要对其进行重写。
+
+由于只需要额外在函数执行前增加一句控制台输出，所以直接插入一行即可。
+
+但是需要注意的是，`drawMap`中使用了`this._drawMap_drawAll()`，因此使用函数时需要用`call`或者`apply`来告知this是什么。
+
+```js
+var drawMap = core.maps.drawMap; // 先把原始函数用一个变量记录下来
+core.maps.drawMap = function (floorId, callback) {
+    console.log("drawMap..."); // 控制台打出一条信息
+    return drawMap.call(core.maps, floorId, callback); // 需要使用`call`来告知this是core.maps
+}
+```
+
+详见[call和apply的用法](https://www.jianshu.com/p/80ea0d1c04f8)。
+
+### 复写全局动画绘制函数
+
+全局动画绘制在`control.js`的`_animationFrame_globalAnimate`函数。
+
+注意到此函数是由`registerAnimationFrame`注册的，因此直接复写是无效的。
+
+其在control.js的注册的定义如下：
+
+```js
+// 注册全局动画函数
+this.registerAnimationFrame("globalAnimate", true, this._animationFrame_globalAnimate);
+```
+
+因此，可以在插件中自行注册一个**同名**的函数来覆盖原始的内容。
+
+```js
+// 插件中复写全局动画绘制函数
+this.myGlobalAnimate = function (timestamp) {
+    // ...... 实际复写的函数内容
+}
+
+// 注册同名（globalAnimate）函数来覆盖系统原始内容
+core.registerAnimationFrame("globalAnimate", true, "myGlobalAnimate");
+```
+
+
+==========================================================================================
+
+[继续阅读下一章：API列表](api)
+
+

_docs/start.md

@@ -1,6 +1,6 @@
 # 快速上手
 
-?> 目前版本**v2.3.3**，上次更新时间：* {docsify-updated} *
+?> 目前版本**v2.6.1**，上次更新时间：* {docsify-updated} *
 
 在这一节中，将详细介绍做一部塔的流程。现在，让我们来做一部单层塔！
 
@@ -10,6 +10,7 @@
 
 - Windows 8以上操作系统；Windows 7需要安装.Net Framework 4.0。（能打开同目录下的“启动服务.exe”即可）
   - Mac系统则需OS X 10.7及以上，能正确打开启动服务(Mac版).app即可。
+  - 安卓手机端需要下载最新版的HTML5安卓造塔器。
 - Chrome浏览器。其他浏览器可能会导致本地服务器产生闪退等现象。
 - 强烈推荐安装一个很好的文本编辑器：VSCode。在某些需要直接修改文件的场合，可能会非常重要。
 
@@ -19,7 +20,7 @@
 
 ## 启动HTTP服务
 
-在根目录下有一个“启动服务.exe”，运行之。（Mac版本则双击运行“启动服务(Mac版).app”）
+在根目录下有一个“启动服务.exe”，运行之。（Mac版本则双击运行“启动服务(Mac版).app”，手机端则使用造塔APP。）
 
 ![启动服务](img/server.png)
 
@@ -27,6 +28,7 @@
 * “地图编辑器”允许你以可视化的方式进行编辑地图。
 * “便捷PS工具”能让你很方便的对自定义素材进行添加。参见[自定义素材](personalization#自定义素材)。
 * “地图生成器”能让你从已有的截图（如RMXP项目）中立刻生成可被本样板识别的地图数据。
+* “怪物数据导出”能让你从RMXP中导出怪物数据而被H5魔塔使用。
 * “RM动画导出器”能让你从RMXP中导出动画而被H5魔塔使用。
 * “JS代码压缩工具”能对JS代码进行压缩，从而减少IO请求数和文件大小。
 * “伤害和临界值计算器”是一个很便捷的小工具，能对怪物的伤害和临界值进行计算。
@@ -49,19 +51,25 @@
 
 绘制地图时可以右键弹出菜单，移动图块和事件。
 
+从V2.4.2开始，可以使用`Alt+0~9`对一个图块素材快速保存，`Ctrl+0~9`来快速选用。
+
 ### 从RMXP导入已有的地图
 
+!> 注：现在已经不推荐此方法，如需从RM刻塔请使用 [RM转H5刻塔器使用教程](https://www.bilibili.com/video/av43125840) 进行操作。
+
 如果我们想复刻一个现有的，已经被RMXP所制作的塔，也有很便捷的方式，那就是用到我们的“地图生成器”。
 
 首先，我们打开RMXP和对应的项目，可以看到它的地图。
 
 ![绘制地图](./img/rmxp2.png)
 
-我们打开Windows自带的“截图工具”，并将整个地图有效区域截图下来，并将其复制到剪切板。
+我们打开地图编辑器，创建一个地图，宽高需要和RM中的地图一致。
+
+之后，我们打开Windows自带的“截图工具”，并将整个地图有效区域截图下来，并将其复制到剪切板。
 
 ![绘制地图](./img/rmxp3.png)
 
-截图时请注意：**只截取有效游戏空间内数据，并且有效空间内的范围必须是13x13。（如果地图小于13*13，请用星空或墙壁填充到13x13）。**
+截图时请注意：**只截取有效游戏空间内数据，并且有效空间内的范围必须是创建的地图的大小（至少为13x13）。**
 
 确认地图的图片文件已经复制到剪切板后，我们打开“地图生成器”，并点“加载图片”。大约1-2秒后，可以得到地图的数据。
 
@@ -71,7 +79,9 @@
 
 !> **地图生成器默认只支持已被定义的素材。如果有自定义素材需求（例如原版的1层小塔那种素材），请先[导入并注册素材](#素材注册)后再进行操作。**  
 
-!> **请确保截图范围刚好为13x13，并且保证每个位置的像素都是32x32。**
+!> **请确保截图范围为你创建的地图大小，并且保证每个位置的像素都是32x32。**
+
+!> **如果宽度超过13，地图生成器将无法显示完全，但是仍然可以粘贴到地图编辑器中进行修改。**
 
 !> **地图生成器靠左上角来确定偏移量，如果左上角是全黑或者星空之类的素材可能导致识别不准，此时请在左上角放置一个岩浆后再进行截图识别。**
 
@@ -169,10 +179,20 @@
 
 之后刷新编辑器即可。
 
-对于怪物和道具，我们也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
+也可以进行自动注册，只需要点击“自动注册”按钮，将对该栏下所有未注册的素材进行自动注册（自动分配ID和数字）。
 
 素材注册完毕后，即可在游戏中正常使用，也可以被地图生成器所识别（需要重开地图生成器）。
 
+### 额外素材
+
+从2.4.2开始，H5魔塔样板支持额外素材，你可以导入任意个类似RM中的tilesets文件，且无需注册即可使用。
+
+要使用额外素材，请在`全塔属性`中的`tilesets`项，添加额外素材的图片名称，刷新后即可在地图编辑器中使用。
+
+额外素材不可注册，其数字、ID和索引都是和该图块在图片上的位置相关，不可编辑。
+
+有关额外素材的更多说明参见[额外素材](personalization#额外素材)
+
 ## 控制台调试
 
 HTML5的塔都是可以进行控制台调试的。
@@ -197,20 +217,34 @@ HTML5的塔都是可以进行控制台调试的。
 - `core.getItem('pickaxe', 2)` 令勇士获得两个破墙镐。
 - `core.itemCount('pickaxe')` 返回勇士某个道具的个数。
 - `core.hasItem('pickaxe')` 返回勇士是否拥有某个道具。等价于`core.itemCount('pickaxe')!=0`。
+- `core.getEquip(0)` 返回0号装备类型（武器）的当前装备的itemId，不存在则返回null
+- `core.hasEquip('sword1')` 返回某个装备当前是否处于被装备状态
 - `core.setFlag('xxx', 1)` 设置某个flag/自定义变量的值。
 - `core.getFlag('xxx', 10)` 获得某个flag/自定义变量的值；如果该项不存在（未被定义），则返回第二个参数的值。
 - `core.hasFlag('xxx')` 返回是否存在某个变量且不为0。等价于`core.getFlag('xxx', 0)!=0`。
+- `core.removeFlag('xxx')` 删除某个flag/自定义变量
 - `core.insertAction(list)` 执行一段自定义事件。比如 `core.insertAction(["剧情文本"])` 将执行一个剧情文本显示事件。
 - `core.changeFloor('MT2', 'downFloor')` 立刻执行楼层切换到MT2层的下楼点位置。
 - `core.changeFloor('MT5', null, {'x': 4, 'y': 7})` 立刻切换楼层到MT5层的(4,7)点。
 - `core.getBlock(3, 5, 'MT1')` 获得当前地图上某一个块的信息。第三个参数为floorId，可省略表示当前楼层。
 - `core.getBlockId(3, 5, 'MT1')` 获得当前地图上某一个点的图块ID。第三个参数为floorId，可省略表示当前楼层。
-- `core.resetMap()` 重置当前层地图。**当修改地图后再读档，修改的地图不会立刻生效，此时可以使用resetMap来重置当前楼层的地图。**
-- `localStorage` 获得所有的存档数据。可以用 `core.getLocalStorage('save1')` 来具体获得某个存档。
+- `core.resetMap()` 重置当前层地图。
 - ……
 
 更多API和详细参数介绍可参见[API列表](api)。
 
+## 编辑器的基本操作
+
+- **Alt+0~9, Ctrl+0~9** 保存和读取当前选中图块
+- **W/A/S/D** 移动大地图
+- **Ctrl+Z** 撤销上次绘图
+- **Ctrl+Y** 重做上次绘图
+- **PgUp/PgDn** 切换楼层
+- **Ctrl+S** 保存事件编辑器/脚本编辑器
+- **地图上单击** 选中该点
+- **地图上双击** 选中该点图块
+- **地图上右键** 弹出菜单栏，包括选中、复制、清除等操作
+- **事件编辑器中Ctrl+C, Ctrl+X, 右键等** 执行相应操作
 
 ## 报错处理
 

_server/CodeMirror/LICENSE

@@ -19,3 +19,16 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+----------------------------------------------------------------
+
+The MIT License (MIT)
+
+Copyright (c) 2007-2018 Einar Lielmanis, Liam Newman, and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

_server/README.md

@@ -1,5 +1,9 @@
 # editor
 
+[重构](refactoring.md)
+
+>! 以下均是v2.0时的说明, 未及时改动
+
 本目录下所有文件,以及`../editor.html`和`../启动服务.exe`([源码](http://github.com/ckcz123/mota-js-server/))是地图编辑器的所有组件.
 
 `editor.js`,`editor_file.js`和`editor_mode.js`耦合较强,`editor_blockly.js`和`editor_multi.js`和`fs.js`基本可以独立使用.
@@ -29,7 +33,7 @@
 ``` js
 editor.mapInit();//清空地图
 editor.changeFloor('MT2')//切换地图
-editor.guid()//产生一个可以作为id的长随机字符串
+editor.util.guid()//产生一个可以作为id的长随机字符串
 ```
 
 `editor.updateMap`中画未定义快的报错
@@ -38,8 +42,6 @@ editor.guid()//产生一个可以作为id的长随机字符串
 
 提供了以下函数进行楼层`map`数组相关的操作
 ```javascript
-editor.file.getFloorFileList
-editor.file.loadFloorFile
 editor.file.saveFloorFile
 editor.file.saveFloorFileAs
 ```
@@ -70,7 +72,7 @@ editor.file.editFunctions(["change","['events']['afterChangeLight']","function(x
 生成表格并绑定事件的函数
 ```javascript
 editor.mode.loc();
-editor.mode.emenyitem();
+editor.mode.enemyitem();
 editor.mode.floor();
 editor.mode.tower();
 editor.mode.functions();
@@ -83,7 +85,7 @@ editor.mode.onmode('save');//保存
 editor.mode.onmode('nextChange');//下次onmode时前端进行切换
 
 editor.mode.onmode('loc');
-editor.mode.onmode('emenyitem');
+editor.mode.onmode('enemyitem');
 editor.mode.onmode('floor');
 editor.mode.onmode('tower');
 editor.mode.onmode('functions');
@@ -103,23 +105,6 @@ editor_mode.onmode(editor_mode._ids[node.getAttribute('id')]);
 
 `editor.mode.listen`中提供了追加素材的支持.
 
-处理注释的特殊指令
-```
-$range(evalstr:thiseval)$end
-  限制取值范围,要求修改后的eval(evalstr)为true
-$leaf(evalstr:thiseval)$end
-  强制指定为叶节点,如果eval(evalstr)为true
-
-//以下几个中选一个 [
-$select(evalstr)$end
-  渲染成<select>,选项为数组eval(evalstr)['values']
-$input(evalstr)$end
-  渲染成<input>
-$textarea(evalstr)$end
-  渲染成<textarea>
-默认选项为$textarea()$end
-// ]
-```
 
 ### editor_blockly.js
 
@@ -177,9 +162,3 @@ fs.readdir(path, callback)
 //所有参数不允许缺省
 ```
 
-## z-index
-
-目前主体部分使用了 0-15,75,100
-
-blockly使用 200,201  
-多行文本编辑器使用 300

_server/blockly/NOTICE.md

@@ -8,14 +8,6 @@ files
 copyed from  
 https://github.com/google/blockly.git
 
-
-### diff in blockly code
-blocks_compressed.js  
-line 44 ~ 48
-```javascript
-// change by zhaouv @ logic_compare output : "Boolean" -> null
-colour:"%{BKY_LOGIC_HUE}",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["<","LT"],["\u2264","LTE"],[">","GT"],["\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare",
-// change by zhaouv @ logic_operation output,check : "Boolean" -> null
-// change by zhaouv @ logic_negate output,check : "Boolean" -> null
-"logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:null},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:null}],inputsInline:!0,output:null,colour:"%{BKY_LOGIC_HUE}",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",
-```
+`Converter.bundle.min.js`  
+copyed from  
+https://github.com/zhaouv/antlr-blockly.git

_server/blockly/blocks_compressed.js

@@ -0,0 +1,171 @@
+// Do not edit this file; automatically generated by build.py.
+'use strict';
+
+
+Blockly.Blocks.colour={};Blockly.Constants={};Blockly.Constants.Colour={};Blockly.Constants.Colour.HUE=20;
+Blockly.defineBlocksWithJsonArray([{type:"colour_picker",message0:"%1",args0:[{type:"field_colour",name:"COLOUR",colour:"#ff0000"}],output:"Colour",helpUrl:"%{BKY_COLOUR_PICKER_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_PICKER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"colour_random",message0:"%{BKY_COLOUR_RANDOM_TITLE}",output:"Colour",helpUrl:"%{BKY_COLOUR_RANDOM_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RANDOM_TOOLTIP}"},{type:"colour_rgb",message0:"%{BKY_COLOUR_RGB_TITLE} %{BKY_COLOUR_RGB_RED} %1 %{BKY_COLOUR_RGB_GREEN} %2 %{BKY_COLOUR_RGB_BLUE} %3",
+args0:[{type:"input_value",name:"RED",check:"Number",align:"RIGHT"},{type:"input_value",name:"GREEN",check:"Number",align:"RIGHT"},{type:"input_value",name:"BLUE",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_RGB_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_RGB_TOOLTIP}"},{type:"colour_blend",message0:"%{BKY_COLOUR_BLEND_TITLE} %{BKY_COLOUR_BLEND_COLOUR1} %1 %{BKY_COLOUR_BLEND_COLOUR2} %2 %{BKY_COLOUR_BLEND_RATIO} %3",args0:[{type:"input_value",name:"COLOUR1",check:"Colour",
+align:"RIGHT"},{type:"input_value",name:"COLOUR2",check:"Colour",align:"RIGHT"},{type:"input_value",name:"RATIO",check:"Number",align:"RIGHT"}],output:"Colour",helpUrl:"%{BKY_COLOUR_BLEND_HELPURL}",style:"colour_blocks",tooltip:"%{BKY_COLOUR_BLEND_TOOLTIP}"}]);Blockly.Blocks.lists={};Blockly.Constants.Lists={};Blockly.Constants.Lists.HUE=260;
+Blockly.defineBlocksWithJsonArray([{type:"lists_create_empty",message0:"%{BKY_LISTS_CREATE_EMPTY_TITLE}",output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_CREATE_EMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_CREATE_EMPTY_HELPURL}"},{type:"lists_repeat",message0:"%{BKY_LISTS_REPEAT_TITLE}",args0:[{type:"input_value",name:"ITEM"},{type:"input_value",name:"NUM",check:"Number"}],output:"Array",style:"list_blocks",tooltip:"%{BKY_LISTS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_LISTS_REPEAT_HELPURL}"},{type:"lists_reverse",
+message0:"%{BKY_LISTS_REVERSE_MESSAGE0}",args0:[{type:"input_value",name:"LIST",check:"Array"}],output:"Array",inputsInline:!0,style:"list_blocks",tooltip:"%{BKY_LISTS_REVERSE_TOOLTIP}",helpUrl:"%{BKY_LISTS_REVERSE_HELPURL}"},{type:"lists_isEmpty",message0:"%{BKY_LISTS_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"list_blocks",tooltip:"%{BKY_LISTS_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_LISTS_ISEMPTY_HELPURL}"},{type:"lists_length",message0:"%{BKY_LISTS_LENGTH_TITLE}",
+args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"list_blocks",tooltip:"%{BKY_LISTS_LENGTH_TOOLTIP}",helpUrl:"%{BKY_LISTS_LENGTH_HELPURL}"}]);
+Blockly.Blocks.lists_create_with={init:function(){this.setHelpUrl(Blockly.Msg.LISTS_CREATE_WITH_HELPURL);this.setStyle("list_blocks");this.itemCount_=3;this.updateShape_();this.setOutput(!0,"Array");this.setMutator(new Blockly.Mutator(["lists_create_with_item"]));this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),
+10);this.updateShape_()},decompose:function(a){var b=a.newBlock("lists_create_with_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("lists_create_with_item");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;
+c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||
+this.appendDummyInput("EMPTY").appendField(Blockly.Msg.LISTS_CREATE_EMPTY_TITLE);for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);0==a&&b.appendField(Blockly.Msg.LISTS_CREATE_WITH_INPUT_WITH)}for(;this.getInput("ADD"+a);)this.removeInput("ADD"+a),a++}};
+Blockly.Blocks.lists_create_with_container={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TITLE_ADD);this.appendStatementInput("STACK");this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_CONTAINER_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_create_with_item={init:function(){this.setStyle("list_blocks");this.appendDummyInput().appendField(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TITLE);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_CREATE_WITH_ITEM_TOOLTIP);this.contextMenu=!1}};
+Blockly.Blocks.lists_indexOf={init:function(){var a=[[Blockly.Msg.LISTS_INDEX_OF_FIRST,"FIRST"],[Blockly.Msg.LISTS_INDEX_OF_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_INDEX_OF_HELPURL);this.setStyle("list_blocks");this.setOutput(!0,"Number");this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_INDEX_OF_INPUT_IN_LIST);this.appendValueInput("FIND").appendField(new Blockly.FieldDropdown(a),"END");this.setInputsInline(!0);var b=this;this.setTooltip(function(){return Blockly.Msg.LISTS_INDEX_OF_TOOLTIP.replace("%1",
+b.workspace.options.oneBasedIndex?"0":"-1")})}};
+Blockly.Blocks.lists_getIndex={init:function(){var a=[[Blockly.Msg.LISTS_GET_INDEX_GET,"GET"],[Blockly.Msg.LISTS_GET_INDEX_GET_REMOVE,"GET_REMOVE"],[Blockly.Msg.LISTS_GET_INDEX_REMOVE,"REMOVE"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_INDEX_HELPURL);this.setStyle("list_blocks");
+a=new Blockly.FieldDropdown(a,function(a){this.sourceBlock_.updateStatement_("REMOVE"==a)});this.appendValueInput("VALUE").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_INDEX_INPUT_IN_LIST);this.appendDummyInput().appendField(a,"MODE").appendField("","SPACE");this.appendDummyInput("AT");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_INDEX_TAIL);this.setInputsInline(!0);this.setOutput(!0);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=
+b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case "GET FROM_START":case "GET FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FROM;break;case "GET FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_FIRST;break;case "GET LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_LAST;break;case "GET RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_RANDOM;break;case "GET_REMOVE FROM_START":case "GET_REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM;break;case "GET_REMOVE FIRST":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST;break;case "GET_REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST;break;case "GET_REMOVE RANDOM":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM;break;case "REMOVE FROM_START":case "REMOVE FROM_END":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM;break;case "REMOVE FIRST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST;break;case "REMOVE LAST":e=Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST;break;case "REMOVE RANDOM":e=
+Blockly.Msg.LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+("FROM_START"==d?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP).replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("statement",!this.outputConnection);var b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){var b="true"==
+a.getAttribute("statement");this.updateStatement_(b);a="false"!=a.getAttribute("at");this.updateAt_(a)},updateStatement_:function(a){a!=!this.outputConnection&&(this.unplug(!0,!0),a?(this.setOutput(!1),this.setPreviousStatement(!0),this.setNextStatement(!0)):(this.setPreviousStatement(!1),this.setNextStatement(!1),this.setOutput(!0)))},updateAt_:function(a){this.removeInput("AT");this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.getInput("AT").appendField(b,"WHERE");Blockly.Msg.LISTS_GET_INDEX_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_setIndex={init:function(){var a=[[Blockly.Msg.LISTS_SET_INDEX_SET,"SET"],[Blockly.Msg.LISTS_SET_INDEX_INSERT,"INSERT"]];this.WHERE_OPTIONS=[[Blockly.Msg.LISTS_GET_INDEX_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_INDEX_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_INDEX_FIRST,"FIRST"],[Blockly.Msg.LISTS_GET_INDEX_LAST,"LAST"],[Blockly.Msg.LISTS_GET_INDEX_RANDOM,"RANDOM"]];this.setHelpUrl(Blockly.Msg.LISTS_SET_INDEX_HELPURL);this.setStyle("list_blocks");this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_IN_LIST);
+this.appendDummyInput().appendField(new Blockly.FieldDropdown(a),"MODE").appendField("","SPACE");this.appendDummyInput("AT");this.appendValueInput("TO").appendField(Blockly.Msg.LISTS_SET_INDEX_INPUT_TO);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setTooltip(Blockly.Msg.LISTS_SET_INDEX_TOOLTIP);this.updateAt_(!0);var b=this;this.setTooltip(function(){var a=b.getFieldValue("MODE"),d=b.getFieldValue("WHERE"),e="";switch(a+" "+d){case "SET FROM_START":case "SET FROM_END":e=
+Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FROM;break;case "SET FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_FIRST;break;case "SET LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_LAST;break;case "SET RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_SET_RANDOM;break;case "INSERT FROM_START":case "INSERT FROM_END":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FROM;break;case "INSERT FIRST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST;break;case "INSERT LAST":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_LAST;
+break;case "INSERT RANDOM":e=Blockly.Msg.LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM}if("FROM_START"==d||"FROM_END"==d)e+="  "+Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP.replace("%1",b.workspace.options.oneBasedIndex?"#1":"#0");return e})},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT").type==Blockly.INPUT_VALUE;a.setAttribute("at",b);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT");
+this.removeInput("ORDINAL",!0);a?(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):this.appendDummyInput("AT");var b=new Blockly.FieldDropdown(this.WHERE_OPTIONS,function(b){var c="FROM_START"==b||"FROM_END"==b;if(c!=a){var e=this.sourceBlock_;e.updateAt_(c);e.setFieldValue(b,"WHERE");return null}});this.moveInputBefore("AT","TO");this.getInput("ORDINAL")&&this.moveInputBefore("ORDINAL",
+"TO");this.getInput("AT").appendField(b,"WHERE")}};
+Blockly.Blocks.lists_getSublist={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_START,"FROM_START"],[Blockly.Msg.LISTS_GET_SUBLIST_END_FROM_END,"FROM_END"],[Blockly.Msg.LISTS_GET_SUBLIST_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.LISTS_GET_SUBLIST_HELPURL);this.setStyle("list_blocks");
+this.appendValueInput("LIST").setCheck("Array").appendField(Blockly.Msg.LISTS_GET_SUBLIST_INPUT_IN_LIST);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.LISTS_GET_SUBLIST_TAIL);this.setInputsInline(!0);this.setOutput(!0,"Array");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.LISTS_GET_SUBLIST_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),b=this.getInput("AT1").type==
+Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1","AT2"));Blockly.Msg.LISTS_GET_SUBLIST_TAIL&&this.moveInputBefore("TAIL",null)}};
+Blockly.Blocks.lists_sort={init:function(){this.jsonInit({message0:Blockly.Msg.LISTS_SORT_TITLE,args0:[{type:"field_dropdown",name:"TYPE",options:[[Blockly.Msg.LISTS_SORT_TYPE_NUMERIC,"NUMERIC"],[Blockly.Msg.LISTS_SORT_TYPE_TEXT,"TEXT"],[Blockly.Msg.LISTS_SORT_TYPE_IGNORECASE,"IGNORE_CASE"]]},{type:"field_dropdown",name:"DIRECTION",options:[[Blockly.Msg.LISTS_SORT_ORDER_ASCENDING,"1"],[Blockly.Msg.LISTS_SORT_ORDER_DESCENDING,"-1"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Array",style:"list_blocks",
+tooltip:Blockly.Msg.LISTS_SORT_TOOLTIP,helpUrl:Blockly.Msg.LISTS_SORT_HELPURL})}};
+Blockly.Blocks.lists_split={init:function(){var a=this,b=new Blockly.FieldDropdown([[Blockly.Msg.LISTS_SPLIT_LIST_FROM_TEXT,"SPLIT"],[Blockly.Msg.LISTS_SPLIT_TEXT_FROM_LIST,"JOIN"]],function(b){a.updateType_(b)});this.setHelpUrl(Blockly.Msg.LISTS_SPLIT_HELPURL);this.setStyle("list_blocks");this.appendValueInput("INPUT").setCheck("String").appendField(b,"MODE");this.appendValueInput("DELIM").setCheck("String").appendField(Blockly.Msg.LISTS_SPLIT_WITH_DELIMITER);this.setInputsInline(!0);this.setOutput(!0,
+"Array");this.setTooltip(function(){var b=a.getFieldValue("MODE");if("SPLIT"==b)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_SPLIT;if("JOIN"==b)return Blockly.Msg.LISTS_SPLIT_TOOLTIP_JOIN;throw Error("Unknown mode: "+b);})},updateType_:function(a){"SPLIT"==a?(this.outputConnection.setCheck("Array"),this.getInput("INPUT").setCheck("String")):(this.outputConnection.setCheck("String"),this.getInput("INPUT").setCheck("Array"))},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("mode",
+this.getFieldValue("MODE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("mode"))}};Blockly.Blocks.logic={};Blockly.Constants.Logic={};Blockly.Constants.Logic.HUE=210;
+Blockly.defineBlocksWithJsonArray([{type:"logic_boolean",message0:"%1",args0:[{type:"field_dropdown",name:"BOOL",options:[["%{BKY_LOGIC_BOOLEAN_TRUE}","TRUE"],["%{BKY_LOGIC_BOOLEAN_FALSE}","FALSE"]]}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_BOOLEAN_TOOLTIP}",helpUrl:"%{BKY_LOGIC_BOOLEAN_HELPURL}"},{type:"controls_if",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",
+name:"DO0"}],previousStatement:null,nextStatement:null,style:"logic_blocks",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",mutator:"controls_if_mutator",extensions:["controls_if_tooltip"]},{type:"controls_ifelse",message0:"%{BKY_CONTROLS_IF_MSG_IF} %1",args0:[{type:"input_value",name:"IF0",check:"Boolean"}],message1:"%{BKY_CONTROLS_IF_MSG_THEN} %1",args1:[{type:"input_statement",name:"DO0"}],message2:"%{BKY_CONTROLS_IF_MSG_ELSE} %1",args2:[{type:"input_statement",name:"ELSE"}],previousStatement:null,nextStatement:null,
+style:"logic_blocks",tooltip:"%{BKYCONTROLS_IF_TOOLTIP_2}",helpUrl:"%{BKY_CONTROLS_IF_HELPURL}",extensions:["controls_if_tooltip"]},{type:"logic_compare",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A"},{type:"field_dropdown",name:"OP",options:[["=","EQ"],["\u2260","NEQ"],["\u200f<","LT"],["\u200f\u2264","LTE"],["\u200f>","GT"],["\u200f\u2265","GTE"]]},{type:"input_value",name:"B"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_COMPARE_HELPURL}",extensions:["logic_compare",
+"logic_op_tooltip"]},{type:"logic_operation",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Boolean"},{type:"field_dropdown",name:"OP",options:[["%{BKY_LOGIC_OPERATION_AND}","AND"],["%{BKY_LOGIC_OPERATION_OR}","OR"]]},{type:"input_value",name:"B",check:"Boolean"}],inputsInline:!0,output:"Boolean",style:"logic_blocks",helpUrl:"%{BKY_LOGIC_OPERATION_HELPURL}",extensions:["logic_op_tooltip"]},{type:"logic_negate",message0:"%{BKY_LOGIC_NEGATE_TITLE}",args0:[{type:"input_value",name:"BOOL",
+check:"Boolean"}],output:"Boolean",style:"logic_blocks",tooltip:"%{BKY_LOGIC_NEGATE_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NEGATE_HELPURL}"},{type:"logic_null",message0:"%{BKY_LOGIC_NULL}",output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_NULL_TOOLTIP}",helpUrl:"%{BKY_LOGIC_NULL_HELPURL}"},{type:"logic_ternary",message0:"%{BKY_LOGIC_TERNARY_CONDITION} %1",args0:[{type:"input_value",name:"IF",check:"Boolean"}],message1:"%{BKY_LOGIC_TERNARY_IF_TRUE} %1",args1:[{type:"input_value",name:"THEN"}],message2:"%{BKY_LOGIC_TERNARY_IF_FALSE} %1",
+args2:[{type:"input_value",name:"ELSE"}],output:null,style:"logic_blocks",tooltip:"%{BKY_LOGIC_TERNARY_TOOLTIP}",helpUrl:"%{BKY_LOGIC_TERNARY_HELPURL}",extensions:["logic_ternary"]}]);
+Blockly.defineBlocksWithJsonArray([{type:"controls_if_if",message0:"%{BKY_CONTROLS_IF_IF_TITLE_IF}",nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_IF_TOOLTIP}"},{type:"controls_if_elseif",message0:"%{BKY_CONTROLS_IF_ELSEIF_TITLE_ELSEIF}",previousStatement:null,nextStatement:null,enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSEIF_TOOLTIP}"},{type:"controls_if_else",message0:"%{BKY_CONTROLS_IF_ELSE_TITLE_ELSE}",previousStatement:null,
+enableContextMenu:!1,style:"logic_blocks",tooltip:"%{BKY_CONTROLS_IF_ELSE_TOOLTIP}"}]);Blockly.Constants.Logic.TOOLTIPS_BY_OP={EQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_EQ}",NEQ:"%{BKY_LOGIC_COMPARE_TOOLTIP_NEQ}",LT:"%{BKY_LOGIC_COMPARE_TOOLTIP_LT}",LTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_LTE}",GT:"%{BKY_LOGIC_COMPARE_TOOLTIP_GT}",GTE:"%{BKY_LOGIC_COMPARE_TOOLTIP_GTE}",AND:"%{BKY_LOGIC_OPERATION_TOOLTIP_AND}",OR:"%{BKY_LOGIC_OPERATION_TOOLTIP_OR}"};
+Blockly.Extensions.register("logic_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Logic.TOOLTIPS_BY_OP));
+Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN={elseifCount_:0,elseCount_:0,mutationToDom:function(){if(!this.elseifCount_&&!this.elseCount_)return null;var a=document.createElement("mutation");this.elseifCount_&&a.setAttribute("elseif",this.elseifCount_);this.elseCount_&&a.setAttribute("else",1);return a},domToMutation:function(a){this.elseifCount_=parseInt(a.getAttribute("elseif"),10)||0;this.elseCount_=parseInt(a.getAttribute("else"),10)||0;this.rebuildShape_()},decompose:function(a){var b=
+a.newBlock("controls_if_if");b.initSvg();for(var c=b.nextConnection,d=1;d<=this.elseifCount_;d++){var e=a.newBlock("controls_if_elseif");e.initSvg();c.connect(e.previousConnection);c=e.nextConnection}this.elseCount_&&(a=a.newBlock("controls_if_else"),a.initSvg(),c.connect(a.previousConnection));return b},compose:function(a){a=a.nextConnection.targetBlock();this.elseCount_=this.elseifCount_=0;for(var b=[null],c=[null],d=null;a;){switch(a.type){case "controls_if_elseif":this.elseifCount_++;b.push(a.valueConnection_);
+c.push(a.statementConnection_);break;case "controls_if_else":this.elseCount_++;d=a.statementConnection_;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}this.updateShape_();this.reconnectChildBlocks_(b,c,d)},saveConnections:function(a){a=a.nextConnection.targetBlock();for(var b=1;a;){switch(a.type){case "controls_if_elseif":var c=this.getInput("IF"+b),d=this.getInput("DO"+b);a.valueConnection_=c&&c.connection.targetConnection;a.statementConnection_=
+d&&d.connection.targetConnection;b++;break;case "controls_if_else":d=this.getInput("ELSE");a.statementConnection_=d&&d.connection.targetConnection;break;default:throw TypeError("Unknown block type: "+a.type);}a=a.nextConnection&&a.nextConnection.targetBlock()}},rebuildShape_:function(){var a=[null],b=[null],c=null;this.getInput("ELSE")&&(c=this.getInput("ELSE").connection.targetConnection);for(var d=1;this.getInput("IF"+d);){var e=this.getInput("IF"+d),f=this.getInput("DO"+d);a.push(e.connection.targetConnection);
+b.push(f.connection.targetConnection);d++}this.updateShape_();this.reconnectChildBlocks_(a,b,c)},updateShape_:function(){this.getInput("ELSE")&&this.removeInput("ELSE");for(var a=1;this.getInput("IF"+a);)this.removeInput("IF"+a),this.removeInput("DO"+a),a++;for(a=1;a<=this.elseifCount_;a++)this.appendValueInput("IF"+a).setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSEIF),this.appendStatementInput("DO"+a).appendField(Blockly.Msg.CONTROLS_IF_MSG_THEN);this.elseCount_&&this.appendStatementInput("ELSE").appendField(Blockly.Msg.CONTROLS_IF_MSG_ELSE)},
+reconnectChildBlocks_:function(a,b,c){for(var d=1;d<=this.elseifCount_;d++)Blockly.Mutator.reconnect(a[d],this,"IF"+d),Blockly.Mutator.reconnect(b[d],this,"DO"+d);Blockly.Mutator.reconnect(c,this,"ELSE")}};Blockly.Extensions.registerMutator("controls_if_mutator",Blockly.Constants.Logic.CONTROLS_IF_MUTATOR_MIXIN,null,["controls_if_elseif","controls_if_else"]);
+Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION=function(){this.setTooltip(function(){if(this.elseifCount_||this.elseCount_){if(!this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_2;if(this.elseifCount_&&!this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_3;if(this.elseifCount_&&this.elseCount_)return Blockly.Msg.CONTROLS_IF_TOOLTIP_4}else return Blockly.Msg.CONTROLS_IF_TOOLTIP_1;return""}.bind(this))};Blockly.Extensions.register("controls_if_tooltip",Blockly.Constants.Logic.CONTROLS_IF_TOOLTIP_EXTENSION);
+Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN={onchange:function(a){this.prevBlocks_||(this.prevBlocks_=[null,null]);var b=this.getInputTargetBlock("A"),c=this.getInputTargetBlock("B");b&&c&&!b.outputConnection.checkType_(c.outputConnection)&&(Blockly.Events.setGroup(a.group),a=this.prevBlocks_[0],a!==b&&(b.unplug(),a&&!a.isShadow()&&this.getInput("A").connection.connect(a.outputConnection)),b=this.prevBlocks_[1],b!==c&&(c.unplug(),b&&!b.isShadow()&&this.getInput("B").connection.connect(b.outputConnection)),
+this.bumpNeighbours_(),Blockly.Events.setGroup(!1));this.prevBlocks_[0]=this.getInputTargetBlock("A");this.prevBlocks_[1]=this.getInputTargetBlock("B")}};Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION=function(){this.mixin(Blockly.Constants.Logic.LOGIC_COMPARE_ONCHANGE_MIXIN)};Blockly.Extensions.register("logic_compare",Blockly.Constants.Logic.LOGIC_COMPARE_EXTENSION);
+Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN={prevParentConnection_:null,onchange:function(a){var b=this.getInputTargetBlock("THEN"),c=this.getInputTargetBlock("ELSE"),d=this.outputConnection.targetConnection;if((b||c)&&d)for(var e=0;2>e;e++){var f=1==e?b:c;f&&!f.outputConnection.checkType_(d)&&(Blockly.Events.setGroup(a.group),d===this.prevParentConnection_?(this.unplug(),d.getSourceBlock().bumpNeighbours_()):(f.unplug(),f.bumpNeighbours_()),Blockly.Events.setGroup(!1))}this.prevParentConnection_=
+d}};Blockly.Extensions.registerMixin("logic_ternary",Blockly.Constants.Logic.LOGIC_TERNARY_ONCHANGE_MIXIN);Blockly.Blocks.loops={};Blockly.Constants.Loops={};Blockly.Constants.Loops.HUE=120;
+Blockly.defineBlocksWithJsonArray([{type:"controls_repeat_ext",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"input_value",name:"TIMES",check:"Number"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_repeat",message0:"%{BKY_CONTROLS_REPEAT_TITLE}",args0:[{type:"field_number",name:"TIMES",value:10,
+min:0,precision:1}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",tooltip:"%{BKY_CONTROLS_REPEAT_TOOLTIP}",helpUrl:"%{BKY_CONTROLS_REPEAT_HELPURL}"},{type:"controls_whileUntil",message0:"%1 %2",args0:[{type:"field_dropdown",name:"MODE",options:[["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_WHILE}","WHILE"],["%{BKY_CONTROLS_WHILEUNTIL_OPERATOR_UNTIL}","UNTIL"]]},{type:"input_value",name:"BOOL",check:"Boolean"}],
+message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_WHILEUNTIL_HELPURL}",extensions:["controls_whileUntil_tooltip"]},{type:"controls_for",message0:"%{BKY_CONTROLS_FOR_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"FROM",check:"Number",align:"RIGHT"},{type:"input_value",name:"TO",check:"Number",align:"RIGHT"},{type:"input_value",name:"BY",
+check:"Number",align:"RIGHT"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",args1:[{type:"input_statement",name:"DO"}],inputsInline:!0,previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOR_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_for_tooltip"]},{type:"controls_forEach",message0:"%{BKY_CONTROLS_FOREACH_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:null},{type:"input_value",name:"LIST",check:"Array"}],message1:"%{BKY_CONTROLS_REPEAT_INPUT_DO} %1",
+args1:[{type:"input_statement",name:"DO"}],previousStatement:null,nextStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FOREACH_HELPURL}",extensions:["contextMenu_newGetVariableBlock","controls_forEach_tooltip"]},{type:"controls_flow_statements",message0:"%1",args0:[{type:"field_dropdown",name:"FLOW",options:[["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK}","BREAK"],["%{BKY_CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE}","CONTINUE"]]}],previousStatement:null,style:"loop_blocks",helpUrl:"%{BKY_CONTROLS_FLOW_STATEMENTS_HELPURL}",
+extensions:["controls_flow_tooltip","controls_flow_in_loop_check"]}]);Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS={WHILE:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_WHILE}",UNTIL:"%{BKY_CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL}"};Blockly.Extensions.register("controls_whileUntil_tooltip",Blockly.Extensions.buildTooltipForDropdown("MODE",Blockly.Constants.Loops.WHILE_UNTIL_TOOLTIPS));Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS={BREAK:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK}",CONTINUE:"%{BKY_CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE}"};
+Blockly.Extensions.register("controls_flow_tooltip",Blockly.Extensions.buildTooltipForDropdown("FLOW",Blockly.Constants.Loops.BREAK_CONTINUE_TOOLTIPS));
+Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getField("VAR").getVariable(),c=b.name;if(!this.isCollapsed()&&null!=c){var d={enabled:!0};d.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c);b=Blockly.Variables.generateVariableFieldDom(b);c=document.createElement("block");c.setAttribute("type","variables_get");c.appendChild(b);d.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(d)}}}};
+Blockly.Extensions.registerMixin("contextMenu_newGetVariableBlock",Blockly.Constants.Loops.CUSTOM_CONTEXT_MENU_CREATE_VARIABLES_GET_MIXIN);Blockly.Extensions.register("controls_for_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOR_TOOLTIP}","VAR"));Blockly.Extensions.register("controls_forEach_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_CONTROLS_FOREACH_TOOLTIP}","VAR"));
+Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN={LOOP_TYPES:["controls_repeat","controls_repeat_ext","controls_forEach","controls_for","controls_whileUntil"],onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.LOOP_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?(this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.CONTROLS_FLOW_STATEMENTS_WARNING),this.isInFlyout||
+this.getInheritedDisabled()||this.setDisabled(!0))}}};Blockly.Extensions.registerMixin("controls_flow_in_loop_check",Blockly.Constants.Loops.CONTROL_FLOW_IN_LOOP_CHECK_MIXIN);Blockly.Blocks.math={};Blockly.Constants.Math={};Blockly.Constants.Math.HUE=230;
+Blockly.defineBlocksWithJsonArray([{type:"math_number",message0:"%1",args0:[{type:"field_number",name:"NUM",value:0}],output:"Number",helpUrl:"%{BKY_MATH_NUMBER_HELPURL}",style:"math_blocks",tooltip:"%{BKY_MATH_NUMBER_TOOLTIP}",extensions:["parent_tooltip_when_inline"]},{type:"math_arithmetic",message0:"%1 %2 %3",args0:[{type:"input_value",name:"A",check:"Number"},{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ADDITION_SYMBOL}","ADD"],["%{BKY_MATH_SUBTRACTION_SYMBOL}","MINUS"],["%{BKY_MATH_MULTIPLICATION_SYMBOL}",
+"MULTIPLY"],["%{BKY_MATH_DIVISION_SYMBOL}","DIVIDE"],["%{BKY_MATH_POWER_SYMBOL}","POWER"]]},{type:"input_value",name:"B",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ARITHMETIC_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_single",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_SINGLE_OP_ROOT}","ROOT"],["%{BKY_MATH_SINGLE_OP_ABSOLUTE}","ABS"],["-","NEG"],["ln","LN"],["log10","LOG10"],["e^","EXP"],["10^","POW10"]]},
+{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_SINGLE_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_trig",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_TRIG_SIN}","SIN"],["%{BKY_MATH_TRIG_COS}","COS"],["%{BKY_MATH_TRIG_TAN}","TAN"],["%{BKY_MATH_TRIG_ASIN}","ASIN"],["%{BKY_MATH_TRIG_ACOS}","ACOS"],["%{BKY_MATH_TRIG_ATAN}","ATAN"]]},{type:"input_value",name:"NUM",check:"Number"}],output:"Number",style:"math_blocks",
+helpUrl:"%{BKY_MATH_TRIG_HELPURL}",extensions:["math_op_tooltip"]},{type:"math_constant",message0:"%1",args0:[{type:"field_dropdown",name:"CONSTANT",options:[["\u03c0","PI"],["e","E"],["\u03c6","GOLDEN_RATIO"],["sqrt(2)","SQRT2"],["sqrt(\u00bd)","SQRT1_2"],["\u221e","INFINITY"]]}],output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTANT_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTANT_HELPURL}"},{type:"math_number_property",message0:"%1 %2",args0:[{type:"input_value",name:"NUMBER_TO_CHECK",check:"Number"},
+{type:"field_dropdown",name:"PROPERTY",options:[["%{BKY_MATH_IS_EVEN}","EVEN"],["%{BKY_MATH_IS_ODD}","ODD"],["%{BKY_MATH_IS_PRIME}","PRIME"],["%{BKY_MATH_IS_WHOLE}","WHOLE"],["%{BKY_MATH_IS_POSITIVE}","POSITIVE"],["%{BKY_MATH_IS_NEGATIVE}","NEGATIVE"],["%{BKY_MATH_IS_DIVISIBLE_BY}","DIVISIBLE_BY"]]}],inputsInline:!0,output:"Boolean",style:"math_blocks",tooltip:"%{BKY_MATH_IS_TOOLTIP}",mutator:"math_is_divisibleby_mutator"},{type:"math_change",message0:"%{BKY_MATH_CHANGE_TITLE}",args0:[{type:"field_variable",
+name:"VAR",variable:"%{BKY_MATH_CHANGE_TITLE_ITEM}"},{type:"input_value",name:"DELTA",check:"Number"}],previousStatement:null,nextStatement:null,style:"variable_blocks",helpUrl:"%{BKY_MATH_CHANGE_HELPURL}",extensions:["math_change_tooltip"]},{type:"math_round",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ROUND_OPERATOR_ROUND}","ROUND"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDUP}","ROUNDUP"],["%{BKY_MATH_ROUND_OPERATOR_ROUNDDOWN}","ROUNDDOWN"]]},{type:"input_value",name:"NUM",
+check:"Number"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ROUND_HELPURL}",tooltip:"%{BKY_MATH_ROUND_TOOLTIP}"},{type:"math_on_list",message0:"%1 %2",args0:[{type:"field_dropdown",name:"OP",options:[["%{BKY_MATH_ONLIST_OPERATOR_SUM}","SUM"],["%{BKY_MATH_ONLIST_OPERATOR_MIN}","MIN"],["%{BKY_MATH_ONLIST_OPERATOR_MAX}","MAX"],["%{BKY_MATH_ONLIST_OPERATOR_AVERAGE}","AVERAGE"],["%{BKY_MATH_ONLIST_OPERATOR_MEDIAN}","MEDIAN"],["%{BKY_MATH_ONLIST_OPERATOR_MODE}","MODE"],["%{BKY_MATH_ONLIST_OPERATOR_STD_DEV}",
+"STD_DEV"],["%{BKY_MATH_ONLIST_OPERATOR_RANDOM}","RANDOM"]]},{type:"input_value",name:"LIST",check:"Array"}],output:"Number",style:"math_blocks",helpUrl:"%{BKY_MATH_ONLIST_HELPURL}",mutator:"math_modes_of_list_mutator",extensions:["math_op_tooltip"]},{type:"math_modulo",message0:"%{BKY_MATH_MODULO_TITLE}",args0:[{type:"input_value",name:"DIVIDEND",check:"Number"},{type:"input_value",name:"DIVISOR",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_MODULO_TOOLTIP}",
+helpUrl:"%{BKY_MATH_MODULO_HELPURL}"},{type:"math_constrain",message0:"%{BKY_MATH_CONSTRAIN_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"Number"},{type:"input_value",name:"LOW",check:"Number"},{type:"input_value",name:"HIGH",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_CONSTRAIN_TOOLTIP}",helpUrl:"%{BKY_MATH_CONSTRAIN_HELPURL}"},{type:"math_random_int",message0:"%{BKY_MATH_RANDOM_INT_TITLE}",args0:[{type:"input_value",name:"FROM",check:"Number"},
+{type:"input_value",name:"TO",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_INT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_INT_HELPURL}"},{type:"math_random_float",message0:"%{BKY_MATH_RANDOM_FLOAT_TITLE_RANDOM}",output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_RANDOM_FLOAT_TOOLTIP}",helpUrl:"%{BKY_MATH_RANDOM_FLOAT_HELPURL}"},{type:"math_atan2",message0:"%{BKY_MATH_ATAN2_TITLE}",args0:[{type:"input_value",name:"X",check:"Number"},{type:"input_value",
+name:"Y",check:"Number"}],inputsInline:!0,output:"Number",style:"math_blocks",tooltip:"%{BKY_MATH_ATAN2_TOOLTIP}",helpUrl:"%{BKY_MATH_ATAN2_HELPURL}"}]);
+Blockly.Constants.Math.TOOLTIPS_BY_OP={ADD:"%{BKY_MATH_ARITHMETIC_TOOLTIP_ADD}",MINUS:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MINUS}",MULTIPLY:"%{BKY_MATH_ARITHMETIC_TOOLTIP_MULTIPLY}",DIVIDE:"%{BKY_MATH_ARITHMETIC_TOOLTIP_DIVIDE}",POWER:"%{BKY_MATH_ARITHMETIC_TOOLTIP_POWER}",ROOT:"%{BKY_MATH_SINGLE_TOOLTIP_ROOT}",ABS:"%{BKY_MATH_SINGLE_TOOLTIP_ABS}",NEG:"%{BKY_MATH_SINGLE_TOOLTIP_NEG}",LN:"%{BKY_MATH_SINGLE_TOOLTIP_LN}",LOG10:"%{BKY_MATH_SINGLE_TOOLTIP_LOG10}",EXP:"%{BKY_MATH_SINGLE_TOOLTIP_EXP}",POW10:"%{BKY_MATH_SINGLE_TOOLTIP_POW10}",
+SIN:"%{BKY_MATH_TRIG_TOOLTIP_SIN}",COS:"%{BKY_MATH_TRIG_TOOLTIP_COS}",TAN:"%{BKY_MATH_TRIG_TOOLTIP_TAN}",ASIN:"%{BKY_MATH_TRIG_TOOLTIP_ASIN}",ACOS:"%{BKY_MATH_TRIG_TOOLTIP_ACOS}",ATAN:"%{BKY_MATH_TRIG_TOOLTIP_ATAN}",SUM:"%{BKY_MATH_ONLIST_TOOLTIP_SUM}",MIN:"%{BKY_MATH_ONLIST_TOOLTIP_MIN}",MAX:"%{BKY_MATH_ONLIST_TOOLTIP_MAX}",AVERAGE:"%{BKY_MATH_ONLIST_TOOLTIP_AVERAGE}",MEDIAN:"%{BKY_MATH_ONLIST_TOOLTIP_MEDIAN}",MODE:"%{BKY_MATH_ONLIST_TOOLTIP_MODE}",STD_DEV:"%{BKY_MATH_ONLIST_TOOLTIP_STD_DEV}",RANDOM:"%{BKY_MATH_ONLIST_TOOLTIP_RANDOM}"};
+Blockly.Extensions.register("math_op_tooltip",Blockly.Extensions.buildTooltipForDropdown("OP",Blockly.Constants.Math.TOOLTIPS_BY_OP));
+Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation"),b="DIVISIBLE_BY"==this.getFieldValue("PROPERTY");a.setAttribute("divisor_input",b);return a},domToMutation:function(a){a="true"==a.getAttribute("divisor_input");this.updateShape_(a)},updateShape_:function(a){var b=this.getInput("DIVISOR");a?b||this.appendValueInput("DIVISOR").setCheck("Number"):b&&this.removeInput("DIVISOR")}};
+Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION=function(){this.getField("PROPERTY").setValidator(function(a){this.sourceBlock_.updateShape_("DIVISIBLE_BY"==a)})};Blockly.Extensions.registerMutator("math_is_divisibleby_mutator",Blockly.Constants.Math.IS_DIVISIBLEBY_MUTATOR_MIXIN,Blockly.Constants.Math.IS_DIVISIBLE_MUTATOR_EXTENSION);Blockly.Extensions.register("math_change_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_MATH_CHANGE_TOOLTIP}","VAR"));
+Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN={updateType_:function(a){"MODE"==a?this.outputConnection.setCheck("Array"):this.outputConnection.setCheck("Number")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("op",this.getFieldValue("OP"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("op"))}};Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION=function(){this.getField("OP").setValidator(function(a){this.updateType_(a)}.bind(this))};
+Blockly.Extensions.registerMutator("math_modes_of_list_mutator",Blockly.Constants.Math.LIST_MODES_MUTATOR_MIXIN,Blockly.Constants.Math.LIST_MODES_MUTATOR_EXTENSION);Blockly.Blocks.procedures={};
+Blockly.Blocks.procedures_defnoreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFNORETURN_COMMENT);
+this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFNORETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:function(a){this.hasStatements_!==a&&(a?(this.appendStatementInput("STACK").appendField(Blockly.Msg.PROCEDURES_DEFNORETURN_DO),this.getInput("RETURN")&&this.moveInputBefore("STACK","RETURN")):this.removeInput("STACK",!0),this.hasStatements_=
+a)},updateParams_:function(){var a="";this.arguments_.length&&(a=Blockly.Msg.PROCEDURES_BEFORE_PARAMS+" "+this.arguments_.join(", "));Blockly.Events.disable();try{this.setFieldValue(a,"PARAMS")}finally{Blockly.Events.enable()}},mutationToDom:function(a){var b=document.createElement("mutation");a&&b.setAttribute("name",this.getFieldValue("NAME"));for(var c=0;c<this.argumentVarModels_.length;c++){var d=document.createElement("arg"),e=this.argumentVarModels_[c];d.setAttribute("name",e.name);d.setAttribute("varid",
+e.getId());a&&this.paramIds_&&d.setAttribute("paramId",this.paramIds_[c]);b.appendChild(d)}this.hasStatements_||b.setAttribute("statements","false");return b},domToMutation:function(a){this.arguments_=[];this.argumentVarModels_=[];for(var b=0,c;c=a.childNodes[b];b++)if("arg"==c.nodeName.toLowerCase()){var d=c.getAttribute("name");c=c.getAttribute("varid")||c.getAttribute("varId");this.arguments_.push(d);c=Blockly.Variables.getOrCreateVariablePackage(this.workspace,c,d,"");null!=c?this.argumentVarModels_.push(c):
+console.log("Failed to create a variable with name "+d+", ignoring.")}this.updateParams_();Blockly.Procedures.mutateCallers(this);this.setStatements_("false"!==a.getAttribute("statements"))},decompose:function(a){var b=a.newBlock("procedures_mutatorcontainer");b.initSvg();this.getInput("RETURN")?b.setFieldValue(this.hasStatements_?"TRUE":"FALSE","STATEMENTS"):b.getInput("STATEMENT_INPUT").setVisible(!1);for(var c=b.getInput("STACK").connection,d=0;d<this.arguments_.length;d++){var e=a.newBlock("procedures_mutatorarg");
+e.initSvg();e.setFieldValue(this.arguments_[d],"NAME");e.oldLocation=d;c.connect(e.previousConnection);c=e.nextConnection}Blockly.Procedures.mutateCallers(this);return b},compose:function(a){this.arguments_=[];this.paramIds_=[];this.argumentVarModels_=[];for(var b=a.getInputTargetBlock("STACK");b;){var c=b.getFieldValue("NAME");this.arguments_.push(c);var d=this.workspace.getVariable(c,"");null!=d?this.argumentVarModels_.push(d):console.log("Failed to get variable named "+c+", ignoring.");this.paramIds_.push(b.id);
+b=b.nextConnection&&b.nextConnection.targetBlock()}this.updateParams_();Blockly.Procedures.mutateCallers(this);a=a.getFieldValue("STATEMENTS");if(null!==a&&(a="TRUE"==a,this.hasStatements_!=a))if(a)this.setStatements_(!0),Blockly.Mutator.reconnect(this.statementConnection_,this,"STACK"),this.statementConnection_=null;else{a=this.getInput("STACK").connection;if(this.statementConnection_=a.targetConnection)a=a.targetBlock(),a.unplug(),a.bumpNeighbours_();this.setStatements_(!1)}},getProcedureDef:function(){return[this.getFieldValue("NAME"),
+this.arguments_,!1]},getVars:function(){return this.arguments_},getVarModels:function(){return this.argumentVarModels_},renameVarById:function(a,b){var c=this.workspace.getVariableById(a);if(""==c.type){c=c.name;for(var d=this.workspace.getVariableById(b),e=!1,f=0;f<this.argumentVarModels_.length;f++)this.argumentVarModels_[f].getId()==a&&(this.arguments_[f]=d.name,this.argumentVarModels_[f]=d,e=!0);e&&(this.displayRenamedVar_(c,d.name),Blockly.Procedures.mutateCallers(this))}},updateVarName:function(a){for(var b=
+a.name,c=!1,d=0;d<this.argumentVarModels_.length;d++)if(this.argumentVarModels_[d].getId()==a.getId()){var e=this.arguments_[d];this.arguments_[d]=b;c=!0}c&&(this.displayRenamedVar_(e,b),Blockly.Procedures.mutateCallers(this))},displayRenamedVar_:function(a,b){this.updateParams_();if(this.mutator.isVisible())for(var c=this.mutator.workspace_.getAllBlocks(!1),d=0,e;e=c[d];d++)"procedures_mutatorarg"==e.type&&Blockly.Names.equals(a,e.getFieldValue("NAME"))&&e.setFieldValue(b,"NAME")},customContextMenu:function(a){if(!this.isInFlyout){var b=
+{enabled:!0},c=this.getFieldValue("NAME");b.text=Blockly.Msg.PROCEDURES_CREATE_DO.replace("%1",c);var d=document.createElement("mutation");d.setAttribute("name",c);for(var e=0;e<this.arguments_.length;e++)c=document.createElement("arg"),c.setAttribute("name",this.arguments_[e]),d.appendChild(c);c=document.createElement("block");c.setAttribute("type",this.callType_);c.appendChild(d);b.callback=Blockly.ContextMenu.callbackFactory(this,c);a.push(b);if(!this.isCollapsed())for(e=0;e<this.argumentVarModels_.length;e++)b=
+{enabled:!0},d=this.argumentVarModels_[e],c=d.name,b.text=Blockly.Msg.VARIABLES_SET_CREATE_GET.replace("%1",c),d=Blockly.Variables.generateVariableFieldDom(d),c=document.createElement("block"),c.setAttribute("type","variables_get"),c.appendChild(d),b.callback=Blockly.ContextMenu.callbackFactory(this,c),a.push(b)}},callType_:"procedures_callnoreturn"};
+Blockly.Blocks.procedures_defreturn={init:function(){var a=new Blockly.FieldTextInput("",Blockly.Procedures.rename);a.setSpellcheck(!1);this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_DEFRETURN_TITLE).appendField(a,"NAME").appendField("","PARAMS");this.appendValueInput("RETURN").setAlign(Blockly.ALIGN_RIGHT).appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setMutator(new Blockly.Mutator(["procedures_mutatorarg"]));(this.workspace.options.comments||this.workspace.options.parentWorkspace&&
+this.workspace.options.parentWorkspace.options.comments)&&Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT&&this.setCommentText(Blockly.Msg.PROCEDURES_DEFRETURN_COMMENT);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_DEFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_DEFRETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.setStatements_(!0);this.statementConnection_=null},setStatements_:Blockly.Blocks.procedures_defnoreturn.setStatements_,updateParams_:Blockly.Blocks.procedures_defnoreturn.updateParams_,
+mutationToDom:Blockly.Blocks.procedures_defnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_defnoreturn.domToMutation,decompose:Blockly.Blocks.procedures_defnoreturn.decompose,compose:Blockly.Blocks.procedures_defnoreturn.compose,getProcedureDef:function(){return[this.getFieldValue("NAME"),this.arguments_,!0]},getVars:Blockly.Blocks.procedures_defnoreturn.getVars,getVarModels:Blockly.Blocks.procedures_defnoreturn.getVarModels,renameVarById:Blockly.Blocks.procedures_defnoreturn.renameVarById,
+updateVarName:Blockly.Blocks.procedures_defnoreturn.updateVarName,displayRenamedVar_:Blockly.Blocks.procedures_defnoreturn.displayRenamedVar_,customContextMenu:Blockly.Blocks.procedures_defnoreturn.customContextMenu,callType_:"procedures_callreturn"};
+Blockly.Blocks.procedures_mutatorcontainer={init:function(){this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TITLE);this.appendStatementInput("STACK");this.appendDummyInput("STATEMENT_INPUT").appendField(Blockly.Msg.PROCEDURES_ALLOW_STATEMENTS).appendField(new Blockly.FieldCheckbox("TRUE"),"STATEMENTS");this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORCONTAINER_TOOLTIP);this.contextMenu=!1},onchange:function(a){if(this.workspace&&!this.workspace.isFlyout&&
+(a.type==Blockly.Events.BLOCK_DELETE||a.type==Blockly.Events.BLOCK_CREATE)){var b=this.workspace.getAllBlocks(),c=this.workspace.getAllVariables();if(a.type==Blockly.Events.BLOCK_DELETE){a=[];for(var d=0;d<b.length;d+=1)b[d].getFieldValue("NAME")&&a.push(b[d].getFieldValue("NAME"));for(b=0;b<c.length;b+=1)-1==a.indexOf(c[b].name)&&this.workspace.deleteVariableById(c[b].getId())}else if(a.type==Blockly.Events.BLOCK_CREATE&&(c=this.workspace.getBlockById(a.blockId),c.getField("NAME")&&(d=c.getFieldValue("NAME"),
+(a=this.workspace.getVariable(d))||(a=this.workspace.createVariable(d)),!c.previousConnection.isConnected()&&!c.nextConnection.isConnected())))for(d=0;d<b.length;d+=1)if(c.id!=b[d].id&&b[d].getFieldValue("NAME")==a.name){d=Blockly.Variables.generateUniqueName(this.workspace);a=this.workspace.createVariable(d);c.setFieldValue(a.name,"NAME");break}}}};
+Blockly.Blocks.procedures_mutatorarg={init:function(){var a=new Blockly.FieldTextInput("x",this.validator_);a.oldShowEditorFn_=a.showEditor_;a.showEditor_=function(){this.createdVariables_=[];this.oldShowEditorFn_()};this.appendDummyInput().appendField(Blockly.Msg.PROCEDURES_MUTATORARG_TITLE).appendField(a,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_MUTATORARG_TOOLTIP);this.contextMenu=!1;a.onFinishEditing_=
+this.deleteIntermediateVars_;a.createdVariables_=[];a.onFinishEditing_("x")},validator_:function(a){var b=Blockly.Mutator.findParentWs(this.sourceBlock_.workspace);a=a.replace(/[\s\xa0]+/g," ").replace(/^ | $/g,"");if(!a)return null;for(var c=this.sourceBlock_.workspace.getAllBlocks(),d=0;d<c.length;d+=1)if(c[d].id!=this.sourceBlock_.id&&c[d].getFieldValue("NAME")==a)return null;(c=b.getVariable(a,""))&&c.name!=a&&b.renameVarById(c.getId(),a);c||(c=b.createVariable(a,""))&&this.createdVariables_&&
+this.createdVariables_.push(c);return a},deleteIntermediateVars_:function(a){var b=Blockly.Mutator.findParentWs(this.sourceBlock_.workspace);if(b)for(var c=0;c<this.createdVariables_.length;c++){var d=this.createdVariables_[c];d.name!=a&&b.deleteVariableById(d.getId())}}};
+Blockly.Blocks.procedures_callnoreturn={init:function(){this.appendDummyInput("TOPROW").appendField(this.id,"NAME");this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLNORETURN_HELPURL);this.arguments_=[];this.argumentVarModels_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousDisabledState_=!1},getProcedureCall:function(){return this.getFieldValue("NAME")},renameProcedure:function(a,b){Blockly.Names.equals(a,
+this.getProcedureCall())&&(this.setFieldValue(b,"NAME"),this.setTooltip((this.outputConnection?Blockly.Msg.PROCEDURES_CALLRETURN_TOOLTIP:Blockly.Msg.PROCEDURES_CALLNORETURN_TOOLTIP).replace("%1",b)))},setProcedureParameters_:function(a,b){var c=Blockly.Procedures.getDefinition(this.getProcedureCall(),this.workspace),d=c&&c.mutator&&c.mutator.isVisible();d||(this.quarkConnections_={},this.quarkIds_=null);if(b)if(a.join("\n")==this.arguments_.join("\n"))this.quarkIds_=b;else{if(b.length!=a.length)throw RangeError("paramNames and paramIds must be the same length.");
+this.setCollapsed(!1);this.quarkIds_||(this.quarkConnections_={},this.quarkIds_=[]);c=this.rendered;this.rendered=!1;for(var e=0;e<this.arguments_.length;e++){var f=this.getInput("ARG"+e);f&&(f=f.connection.targetConnection,this.quarkConnections_[this.quarkIds_[e]]=f,d&&f&&-1==b.indexOf(this.quarkIds_[e])&&(f.disconnect(),f.getSourceBlock().bumpNeighbours_()))}this.arguments_=[].concat(a);this.argumentVarModels_=[];for(e=0;e<this.arguments_.length;e++)d=Blockly.Variables.getOrCreateVariablePackage(this.workspace,
+null,this.arguments_[e],""),this.argumentVarModels_.push(d);this.updateShape_();if(this.quarkIds_=b)for(e=0;e<this.arguments_.length;e++)d=this.quarkIds_[e],d in this.quarkConnections_&&(f=this.quarkConnections_[d],Blockly.Mutator.reconnect(f,this,"ARG"+e)||delete this.quarkConnections_[d]);(this.rendered=c)&&this.render()}},updateShape_:function(){for(var a=0;a<this.arguments_.length;a++){var b=this.getField("ARGNAME"+a);if(b){Blockly.Events.disable();try{b.setValue(this.arguments_[a])}finally{Blockly.Events.enable()}}else b=
+new Blockly.FieldLabel(this.arguments_[a]),this.appendValueInput("ARG"+a).setAlign(Blockly.ALIGN_RIGHT).appendField(b,"ARGNAME"+a).init()}for(;this.getInput("ARG"+a);)this.removeInput("ARG"+a),a++;if(a=this.getInput("TOPROW"))this.arguments_.length?this.getField("WITH")||(a.appendField(Blockly.Msg.PROCEDURES_CALL_BEFORE_PARAMS,"WITH"),a.init()):this.getField("WITH")&&a.removeField("WITH")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("name",this.getProcedureCall());
+for(var b=0;b<this.arguments_.length;b++){var c=document.createElement("arg");c.setAttribute("name",this.arguments_[b]);a.appendChild(c)}return a},domToMutation:function(a){var b=a.getAttribute("name");this.renameProcedure(this.getProcedureCall(),b);b=[];for(var c=[],d=0,e;e=a.childNodes[d];d++)"arg"==e.nodeName.toLowerCase()&&(b.push(e.getAttribute("name")),c.push(e.getAttribute("paramId")));this.setProcedureParameters_(b,c)},getVarModels:function(){return this.argumentVarModels_},onchange:function(a){if(this.workspace&&
+!this.workspace.isFlyout&&a.recordUndo)if(a.type==Blockly.Events.BLOCK_CREATE&&-1!=a.ids.indexOf(this.id)){var b=this.getProcedureCall();b=Blockly.Procedures.getDefinition(b,this.workspace);!b||b.type==this.defType_&&JSON.stringify(b.arguments_)==JSON.stringify(this.arguments_)||(b=null);if(!b){Blockly.Events.setGroup(a.group);a=document.createElement("xml");b=document.createElement("block");b.setAttribute("type",this.defType_);var c=this.getRelativeToSurfaceXY(),d=c.y+2*Blockly.SNAP_RADIUS;b.setAttribute("x",
+c.x+Blockly.SNAP_RADIUS*(this.RTL?-1:1));b.setAttribute("y",d);c=this.mutationToDom();b.appendChild(c);c=document.createElement("field");c.setAttribute("name","NAME");c.appendChild(document.createTextNode(this.getProcedureCall()));b.appendChild(c);a.appendChild(b);Blockly.Xml.domToWorkspace(a,this.workspace);Blockly.Events.setGroup(!1)}}else a.type==Blockly.Events.BLOCK_DELETE?(b=this.getProcedureCall(),b=Blockly.Procedures.getDefinition(b,this.workspace),b||(Blockly.Events.setGroup(a.group),this.dispose(!0,
+!1),Blockly.Events.setGroup(!1))):a.type==Blockly.Events.CHANGE&&"disabled"==a.element&&(b=this.getProcedureCall(),(b=Blockly.Procedures.getDefinition(b,this.workspace))&&b.id==a.blockId&&((b=Blockly.Events.getGroup())&&console.log("Saw an existing group while responding to a definition change"),Blockly.Events.setGroup(a.group),a.newValue?(this.previousDisabledState_=this.disabled,this.setDisabled(!0)):this.setDisabled(this.previousDisabledState_),Blockly.Events.setGroup(b)))},customContextMenu:function(a){var b=
+{enabled:!0};b.text=Blockly.Msg.PROCEDURES_HIGHLIGHT_DEF;var c=this.getProcedureCall(),d=this.workspace;b.callback=function(){var a=Blockly.Procedures.getDefinition(c,d);a&&(d.centerOnBlock(a.id),a.select())};a.push(b)},defType_:"procedures_defnoreturn"};
+Blockly.Blocks.procedures_callreturn={init:function(){this.appendDummyInput("TOPROW").appendField("","NAME");this.setOutput(!0);this.setStyle("procedure_blocks");this.setHelpUrl(Blockly.Msg.PROCEDURES_CALLRETURN_HELPURL);this.arguments_=[];this.quarkConnections_={};this.quarkIds_=null;this.previousDisabledState_=!1},getProcedureCall:Blockly.Blocks.procedures_callnoreturn.getProcedureCall,renameProcedure:Blockly.Blocks.procedures_callnoreturn.renameProcedure,setProcedureParameters_:Blockly.Blocks.procedures_callnoreturn.setProcedureParameters_,
+updateShape_:Blockly.Blocks.procedures_callnoreturn.updateShape_,mutationToDom:Blockly.Blocks.procedures_callnoreturn.mutationToDom,domToMutation:Blockly.Blocks.procedures_callnoreturn.domToMutation,getVarModels:Blockly.Blocks.procedures_callnoreturn.getVarModels,onchange:Blockly.Blocks.procedures_callnoreturn.onchange,customContextMenu:Blockly.Blocks.procedures_callnoreturn.customContextMenu,defType_:"procedures_defreturn"};
+Blockly.Blocks.procedures_ifreturn={init:function(){this.appendValueInput("CONDITION").setCheck("Boolean").appendField(Blockly.Msg.CONTROLS_IF_MSG_IF);this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN);this.setInputsInline(!0);this.setPreviousStatement(!0);this.setNextStatement(!0);this.setStyle("procedure_blocks");this.setTooltip(Blockly.Msg.PROCEDURES_IFRETURN_TOOLTIP);this.setHelpUrl(Blockly.Msg.PROCEDURES_IFRETURN_HELPURL);this.hasReturnValue_=!0},mutationToDom:function(){var a=
+document.createElement("mutation");a.setAttribute("value",Number(this.hasReturnValue_));return a},domToMutation:function(a){this.hasReturnValue_=1==a.getAttribute("value");this.hasReturnValue_||(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN))},onchange:function(){if(this.workspace.isDragging&&!this.workspace.isDragging()){var a=!1,b=this;do{if(-1!=this.FUNCTION_TYPES.indexOf(b.type)){a=!0;break}b=b.getSurroundParent()}while(b);a?("procedures_defnoreturn"==
+b.type&&this.hasReturnValue_?(this.removeInput("VALUE"),this.appendDummyInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!1):"procedures_defreturn"!=b.type||this.hasReturnValue_||(this.removeInput("VALUE"),this.appendValueInput("VALUE").appendField(Blockly.Msg.PROCEDURES_DEFRETURN_RETURN),this.hasReturnValue_=!0),this.setWarningText(null),this.isInFlyout||this.setDisabled(!1)):(this.setWarningText(Blockly.Msg.PROCEDURES_IFRETURN_WARNING),this.isInFlyout||this.getInheritedDisabled()||
+this.setDisabled(!0))}},FUNCTION_TYPES:["procedures_defnoreturn","procedures_defreturn"]};Blockly.Blocks.texts={};Blockly.Constants.Text={};Blockly.Constants.Text.HUE=160;
+Blockly.defineBlocksWithJsonArray([{type:"text",message0:"%1",args0:[{type:"field_input",name:"TEXT",text:""}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_TEXT_HELPURL}",tooltip:"%{BKY_TEXT_TEXT_TOOLTIP}",extensions:["text_quotes","parent_tooltip_when_inline"]},{type:"text_join",message0:"",output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_JOIN_HELPURL}",tooltip:"%{BKY_TEXT_JOIN_TOOLTIP}",mutator:"text_join_mutator"},{type:"text_create_join_container",message0:"%{BKY_TEXT_CREATE_JOIN_TITLE_JOIN} %1 %2",
+args0:[{type:"input_dummy"},{type:"input_statement",name:"STACK"}],style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_TOOLTIP}",enableContextMenu:!1},{type:"text_create_join_item",message0:"%{BKY_TEXT_CREATE_JOIN_ITEM_TITLE_ITEM}",previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:"%{BKY_TEXT_CREATE_JOIN_ITEM_TOOLTIP}",enableContextMenu:!1},{type:"text_append",message0:"%{BKY_TEXT_APPEND_TITLE}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_TEXT_APPEND_VARIABLE}"},{type:"input_value",
+name:"TEXT"}],previousStatement:null,nextStatement:null,style:"text_blocks",extensions:["text_append_tooltip"]},{type:"text_length",message0:"%{BKY_TEXT_LENGTH_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Number",style:"text_blocks",tooltip:"%{BKY_TEXT_LENGTH_TOOLTIP}",helpUrl:"%{BKY_TEXT_LENGTH_HELPURL}"},{type:"text_isEmpty",message0:"%{BKY_TEXT_ISEMPTY_TITLE}",args0:[{type:"input_value",name:"VALUE",check:["String","Array"]}],output:"Boolean",style:"text_blocks",
+tooltip:"%{BKY_TEXT_ISEMPTY_TOOLTIP}",helpUrl:"%{BKY_TEXT_ISEMPTY_HELPURL}"},{type:"text_indexOf",message0:"%{BKY_TEXT_INDEXOF_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"END",options:[["%{BKY_TEXT_INDEXOF_OPERATOR_FIRST}","FIRST"],["%{BKY_TEXT_INDEXOF_OPERATOR_LAST}","LAST"]]},{type:"input_value",name:"FIND",check:"String"}],output:"Number",style:"text_blocks",helpUrl:"%{BKY_TEXT_INDEXOF_HELPURL}",inputsInline:!0,extensions:["text_indexOf_tooltip"]},
+{type:"text_charAt",message0:"%{BKY_TEXT_CHARAT_TITLE}",args0:[{type:"input_value",name:"VALUE",check:"String"},{type:"field_dropdown",name:"WHERE",options:[["%{BKY_TEXT_CHARAT_FROM_START}","FROM_START"],["%{BKY_TEXT_CHARAT_FROM_END}","FROM_END"],["%{BKY_TEXT_CHARAT_FIRST}","FIRST"],["%{BKY_TEXT_CHARAT_LAST}","LAST"],["%{BKY_TEXT_CHARAT_RANDOM}","RANDOM"]]}],output:"String",style:"text_blocks",helpUrl:"%{BKY_TEXT_CHARAT_HELPURL}",inputsInline:!0,mutator:"text_charAt_mutator"}]);
+Blockly.Blocks.text_getSubstring={init:function(){this.WHERE_OPTIONS_1=[[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_START_FIRST,"FIRST"]];this.WHERE_OPTIONS_2=[[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_START,"FROM_START"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_FROM_END,"FROM_END"],[Blockly.Msg.TEXT_GET_SUBSTRING_END_LAST,"LAST"]];this.setHelpUrl(Blockly.Msg.TEXT_GET_SUBSTRING_HELPURL);this.setStyle("text_blocks");
+this.appendValueInput("STRING").setCheck("String").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_INPUT_IN_TEXT);this.appendDummyInput("AT1");this.appendDummyInput("AT2");Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL);this.setInputsInline(!0);this.setOutput(!0,"String");this.updateAt_(1,!0);this.updateAt_(2,!0);this.setTooltip(Blockly.Msg.TEXT_GET_SUBSTRING_TOOLTIP)},mutationToDom:function(){var a=document.createElement("mutation"),
+b=this.getInput("AT1").type==Blockly.INPUT_VALUE;a.setAttribute("at1",b);b=this.getInput("AT2").type==Blockly.INPUT_VALUE;a.setAttribute("at2",b);return a},domToMutation:function(a){var b="true"==a.getAttribute("at1");a="true"==a.getAttribute("at2");this.updateAt_(1,b);this.updateAt_(2,a)},updateAt_:function(a,b){this.removeInput("AT"+a);this.removeInput("ORDINAL"+a,!0);b?(this.appendValueInput("AT"+a).setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL"+a).appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX)):
+this.appendDummyInput("AT"+a);2==a&&Blockly.Msg.TEXT_GET_SUBSTRING_TAIL&&(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_GET_SUBSTRING_TAIL));var c=new Blockly.FieldDropdown(this["WHERE_OPTIONS_"+a],function(c){var d="FROM_START"==c||"FROM_END"==c;if(d!=b){var f=this.sourceBlock_;f.updateAt_(a,d);f.setFieldValue(c,"WHERE"+a);return null}});this.getInput("AT"+a).appendField(c,"WHERE"+a);1==a&&(this.moveInputBefore("AT1","AT2"),this.getInput("ORDINAL1")&&this.moveInputBefore("ORDINAL1",
+"AT2"))}};Blockly.Blocks.text_changeCase={init:function(){var a=[[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_UPPERCASE,"UPPERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_LOWERCASE,"LOWERCASE"],[Blockly.Msg.TEXT_CHANGECASE_OPERATOR_TITLECASE,"TITLECASE"]];this.setHelpUrl(Blockly.Msg.TEXT_CHANGECASE_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"CASE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_CHANGECASE_TOOLTIP)}};
+Blockly.Blocks.text_trim={init:function(){var a=[[Blockly.Msg.TEXT_TRIM_OPERATOR_BOTH,"BOTH"],[Blockly.Msg.TEXT_TRIM_OPERATOR_LEFT,"LEFT"],[Blockly.Msg.TEXT_TRIM_OPERATOR_RIGHT,"RIGHT"]];this.setHelpUrl(Blockly.Msg.TEXT_TRIM_HELPURL);this.setStyle("text_blocks");this.appendValueInput("TEXT").setCheck("String").appendField(new Blockly.FieldDropdown(a),"MODE");this.setOutput(!0,"String");this.setTooltip(Blockly.Msg.TEXT_TRIM_TOOLTIP)}};
+Blockly.Blocks.text_print={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_PRINT_TITLE,args0:[{type:"input_value",name:"TEXT"}],previousStatement:null,nextStatement:null,style:"text_blocks",tooltip:Blockly.Msg.TEXT_PRINT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_PRINT_HELPURL})}};
+Blockly.Blocks.text_prompt_ext={init:function(){var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]];this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");var b=this;a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendValueInput("TEXT").appendField(a,"TYPE");this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},
+updateType_:function(a){this.outputConnection.setCheck("NUMBER"==a?"Number":"String")},mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("type",this.getFieldValue("TYPE"));return a},domToMutation:function(a){this.updateType_(a.getAttribute("type"))}};
+Blockly.Blocks.text_prompt={init:function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);var a=[[Blockly.Msg.TEXT_PROMPT_TYPE_TEXT,"TEXT"],[Blockly.Msg.TEXT_PROMPT_TYPE_NUMBER,"NUMBER"]],b=this;this.setHelpUrl(Blockly.Msg.TEXT_PROMPT_HELPURL);this.setStyle("text_blocks");a=new Blockly.FieldDropdown(a,function(a){b.updateType_(a)});this.appendDummyInput().appendField(a,"TYPE").appendField(this.newQuote_(!0)).appendField(new Blockly.FieldTextInput(""),"TEXT").appendField(this.newQuote_(!1));
+this.setOutput(!0,"String");this.setTooltip(function(){return"TEXT"==b.getFieldValue("TYPE")?Blockly.Msg.TEXT_PROMPT_TOOLTIP_TEXT:Blockly.Msg.TEXT_PROMPT_TOOLTIP_NUMBER})},updateType_:Blockly.Blocks.text_prompt_ext.updateType_,mutationToDom:Blockly.Blocks.text_prompt_ext.mutationToDom,domToMutation:Blockly.Blocks.text_prompt_ext.domToMutation};
+Blockly.Blocks.text_count={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_COUNT_MESSAGE0,args0:[{type:"input_value",name:"SUB",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"Number",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_COUNT_TOOLTIP,helpUrl:Blockly.Msg.TEXT_COUNT_HELPURL})}};
+Blockly.Blocks.text_replace={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REPLACE_MESSAGE0,args0:[{type:"input_value",name:"FROM",check:"String"},{type:"input_value",name:"TO",check:"String"},{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REPLACE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REPLACE_HELPURL})}};
+Blockly.Blocks.text_reverse={init:function(){this.jsonInit({message0:Blockly.Msg.TEXT_REVERSE_MESSAGE0,args0:[{type:"input_value",name:"TEXT",check:"String"}],output:"String",inputsInline:!0,style:"text_blocks",tooltip:Blockly.Msg.TEXT_REVERSE_TOOLTIP,helpUrl:Blockly.Msg.TEXT_REVERSE_HELPURL})}};
+Blockly.Constants.Text.QUOTE_IMAGE_MIXIN={QUOTE_IMAGE_LEFT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAn0lEQVQI1z3OMa5BURSF4f/cQhAKjUQhuQmFNwGJEUi0RKN5rU7FHKhpjEH3TEMtkdBSCY1EIv8r7nFX9e29V7EBAOvu7RPjwmWGH/VuF8CyN9/OAdvqIXYLvtRaNjx9mMTDyo+NjAN1HNcl9ZQ5oQMM3dgDUqDo1l8DzvwmtZN7mnD+PkmLa+4mhrxVA9fRowBWmVBhFy5gYEjKMfz9AylsaRRgGzvZAAAAAElFTkSuQmCC",QUOTE_IMAGE_RIGHT_DATAURI:"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAwAAAAKCAQAAAAqJXdxAAAAqUlEQVQI1z3KvUpCcRiA8ef9E4JNHhI0aFEacm1o0BsI0Slx8wa8gLauoDnoBhq7DcfWhggONDmJJgqCPA7neJ7p934EOOKOnM8Q7PDElo/4x4lFb2DmuUjcUzS3URnGib9qaPNbuXvBO3sGPHJDRG6fGVdMSeWDP2q99FQdFrz26Gu5Tq7dFMzUvbXy8KXeAj57cOklgA+u1B5AoslLtGIHQMaCVnwDnADZIFIrXsoXrgAAAABJRU5ErkJggg==",
+QUOTE_IMAGE_WIDTH:12,QUOTE_IMAGE_HEIGHT:12,quoteField_:function(a){for(var b=0,c;c=this.inputList[b];b++)for(var d=0,e;e=c.fieldRow[d];d++)if(a==e.name){c.insertFieldAt(d,this.newQuote_(!0));c.insertFieldAt(d+2,this.newQuote_(!1));return}console.warn('field named "'+a+'" not found in '+this.toDevString())},newQuote_:function(a){a=this.RTL?!a:a;return new Blockly.FieldImage(a?this.QUOTE_IMAGE_LEFT_DATAURI:this.QUOTE_IMAGE_RIGHT_DATAURI,this.QUOTE_IMAGE_WIDTH,this.QUOTE_IMAGE_HEIGHT,a?"\u201c":"\u201d")}};
+Blockly.Constants.Text.TEXT_QUOTES_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.quoteField_("TEXT")};
+Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("items",this.itemCount_);return a},domToMutation:function(a){this.itemCount_=parseInt(a.getAttribute("items"),10);this.updateShape_()},decompose:function(a){var b=a.newBlock("text_create_join_container");b.initSvg();for(var c=b.getInput("STACK").connection,d=0;d<this.itemCount_;d++){var e=a.newBlock("text_create_join_item");e.initSvg();c.connect(e.previousConnection);c=
+e.nextConnection}return b},compose:function(a){var b=a.getInputTargetBlock("STACK");for(a=[];b;)a.push(b.valueConnection_),b=b.nextConnection&&b.nextConnection.targetBlock();for(b=0;b<this.itemCount_;b++){var c=this.getInput("ADD"+b).connection.targetConnection;c&&-1==a.indexOf(c)&&c.disconnect()}this.itemCount_=a.length;this.updateShape_();for(b=0;b<this.itemCount_;b++)Blockly.Mutator.reconnect(a[b],this,"ADD"+b)},saveConnections:function(a){a=a.getInputTargetBlock("STACK");for(var b=0;a;){var c=
+this.getInput("ADD"+b);a.valueConnection_=c&&c.connection.targetConnection;b++;a=a.nextConnection&&a.nextConnection.targetBlock()}},updateShape_:function(){this.itemCount_&&this.getInput("EMPTY")?this.removeInput("EMPTY"):this.itemCount_||this.getInput("EMPTY")||this.appendDummyInput("EMPTY").appendField(this.newQuote_(!0)).appendField(this.newQuote_(!1));for(var a=0;a<this.itemCount_;a++)if(!this.getInput("ADD"+a)){var b=this.appendValueInput("ADD"+a);0==a&&b.appendField(Blockly.Msg.TEXT_JOIN_TITLE_CREATEWITH)}for(;this.getInput("ADD"+
+a);)this.removeInput("ADD"+a),a++}};Blockly.Constants.Text.TEXT_JOIN_EXTENSION=function(){this.mixin(Blockly.Constants.Text.QUOTE_IMAGE_MIXIN);this.itemCount_=2;this.updateShape_();this.setMutator(new Blockly.Mutator(["text_create_join_item"]))};Blockly.Extensions.register("text_append_tooltip",Blockly.Extensions.buildTooltipWithFieldText("%{BKY_TEXT_APPEND_TOOLTIP}","VAR"));
+Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION=function(){var a=this;this.setTooltip(function(){return Blockly.Msg.TEXT_INDEXOF_TOOLTIP.replace("%1",a.workspace.options.oneBasedIndex?"0":"-1")})};
+Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN={mutationToDom:function(){var a=document.createElement("mutation");a.setAttribute("at",!!this.isAt_);return a},domToMutation:function(a){a="false"!=a.getAttribute("at");this.updateAt_(a)},updateAt_:function(a){this.removeInput("AT",!0);this.removeInput("ORDINAL",!0);a&&(this.appendValueInput("AT").setCheck("Number"),Blockly.Msg.ORDINAL_NUMBER_SUFFIX&&this.appendDummyInput("ORDINAL").appendField(Blockly.Msg.ORDINAL_NUMBER_SUFFIX));Blockly.Msg.TEXT_CHARAT_TAIL&&
+(this.removeInput("TAIL",!0),this.appendDummyInput("TAIL").appendField(Blockly.Msg.TEXT_CHARAT_TAIL));this.isAt_=a}};
+Blockly.Constants.Text.TEXT_CHARAT_EXTENSION=function(){this.getField("WHERE").setValidator(function(a){var b="FROM_START"==a||"FROM_END"==a;if(b!=this.isAt_){var d=this.sourceBlock_;d.updateAt_(b);d.setFieldValue(a,"WHERE");return null}});this.updateAt_(!0);var a=this;this.setTooltip(function(){var b=a.getFieldValue("WHERE"),c=Blockly.Msg.TEXT_CHARAT_TOOLTIP;("FROM_START"==b||"FROM_END"==b)&&(b="FROM_START"==b?Blockly.Msg.LISTS_INDEX_FROM_START_TOOLTIP:Blockly.Msg.LISTS_INDEX_FROM_END_TOOLTIP)&&
+(c+="  "+b.replace("%1",a.workspace.options.oneBasedIndex?"#1":"#0"));return c})};Blockly.Extensions.register("text_indexOf_tooltip",Blockly.Constants.Text.TEXT_INDEXOF_TOOLTIP_EXTENSION);Blockly.Extensions.register("text_quotes",Blockly.Constants.Text.TEXT_QUOTES_EXTENSION);Blockly.Extensions.registerMutator("text_join_mutator",Blockly.Constants.Text.TEXT_JOIN_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_JOIN_EXTENSION);
+Blockly.Extensions.registerMutator("text_charAt_mutator",Blockly.Constants.Text.TEXT_CHARAT_MUTATOR_MIXIN,Blockly.Constants.Text.TEXT_CHARAT_EXTENSION);Blockly.Blocks.variables={};Blockly.Constants.Variables={};Blockly.Constants.Variables.HUE=330;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableSetterGetter"]},{type:"variables_set",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",name:"VALUE"}],previousStatement:null,
+nextStatement:null,style:"variable_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableSetterGetter"]}]);
+Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){if("variables_get"==this.type)var b="variables_set",c=Blockly.Msg.VARIABLES_GET_CREATE_SET;else b="variables_get",c=Blockly.Msg.VARIABLES_SET_CREATE_GET;var d={enabled:0<this.workspace.remainingCapacity()},e=this.getField("VAR").getText();d.text=c.replace("%1",e);c=document.createElement("field");c.setAttribute("name","VAR");c.appendChild(document.createTextNode(e));e=document.createElement("block");
+e.setAttribute("type",b);e.appendChild(c);d.callback=Blockly.ContextMenu.callbackFactory(this,e);a.push(d)}else if("variables_get"==this.type||"variables_get_reporter"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},e=this.getField("VAR").getText(),d={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",e),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},a.unshift(b),a.unshift(d)}};
+Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableSetterGetter",Blockly.Constants.Variables.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);
+Blockly.Constants.VariablesDynamic={};Blockly.Constants.VariablesDynamic.HUE=310;
+Blockly.defineBlocksWithJsonArray([{type:"variables_get_dynamic",message0:"%1",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"}],output:null,style:"variable_dynamic_blocks",helpUrl:"%{BKY_VARIABLES_GET_HELPURL}",tooltip:"%{BKY_VARIABLES_GET_TOOLTIP}",extensions:["contextMenu_variableDynamicSetterGetter"]},{type:"variables_set_dynamic",message0:"%{BKY_VARIABLES_SET}",args0:[{type:"field_variable",name:"VAR",variable:"%{BKY_VARIABLES_DEFAULT_NAME}"},{type:"input_value",
+name:"VALUE"}],previousStatement:null,nextStatement:null,style:"variable_dynamic_blocks",tooltip:"%{BKY_VARIABLES_SET_TOOLTIP}",helpUrl:"%{BKY_VARIABLES_SET_HELPURL}",extensions:["contextMenu_variableDynamicSetterGetter"]}]);
+Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN={customContextMenu:function(a){if(!this.isInFlyout){var b=this.getFieldValue("VAR");var c=this.workspace.getVariableById(b).type;if("variables_get_dynamic"==this.type){b="variables_set_dynamic";var d=Blockly.Msg.VARIABLES_GET_CREATE_SET}else b="variables_get_dynamic",d=Blockly.Msg.VARIABLES_SET_CREATE_GET;var e={enabled:0<this.workspace.remainingCapacity()},f=this.getField("VAR").getText();e.text=d.replace("%1",f);
+d=document.createElement("field");d.setAttribute("name","VAR");d.setAttribute("variabletype",c);d.appendChild(document.createTextNode(f));f=document.createElement("block");f.setAttribute("type",b);f.appendChild(d);e.callback=Blockly.ContextMenu.callbackFactory(this,f);a.push(e)}else if("variables_get_dynamic"==this.type||"variables_get_reporter_dynamic"==this.type)b={text:Blockly.Msg.RENAME_VARIABLE,enabled:!0,callback:Blockly.Constants.Variables.RENAME_OPTION_CALLBACK_FACTORY(this)},f=this.getField("VAR").getText(),
+e={text:Blockly.Msg.DELETE_VARIABLE.replace("%1",f),enabled:!0,callback:Blockly.Constants.Variables.DELETE_OPTION_CALLBACK_FACTORY(this)},a.unshift(b),a.unshift(e)},onchange:function(){var a=this.getFieldValue("VAR");a=this.workspace.getVariableById(a);"variables_get_dynamic"==this.type?this.outputConnection.setCheck(a.type):this.getInput("VALUE").connection.setCheck(a.type)}};
+Blockly.Constants.VariablesDynamic.RENAME_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();Blockly.Variables.renameVariable(b,c)}};Blockly.Constants.VariablesDynamic.DELETE_OPTION_CALLBACK_FACTORY=function(a){return function(){var b=a.workspace,c=a.getField("VAR").getVariable();b.deleteVariableById(c.getId());b.refreshToolboxSelection()}};Blockly.Extensions.registerMixin("contextMenu_variableDynamicSetterGetter",Blockly.Constants.VariablesDynamic.CUSTOM_CONTEXT_MENU_VARIABLE_GETTER_SETTER_MIXIN);

_server/blockly/zh-hans.js

@@ -0,0 +1,435 @@
+// This file was automatically generated.  Do not modify.
+
+'use strict';
+
+goog.provide('Blockly.Msg.zh.hans');
+
+goog.require('Blockly.Msg');
+
+Blockly.Msg["ADD_COMMENT"] = "添加注释";
+Blockly.Msg["CANNOT_DELETE_VARIABLE_PROCEDURE"] = "不能删除变量“%1”，因为它是函数“%2”定义的一部分";
+Blockly.Msg["CHANGE_VALUE_TITLE"] = "更改值：";
+Blockly.Msg["CLEAN_UP"] = "整理块";
+Blockly.Msg["COLLAPSE_ALL"] = "折叠块";
+Blockly.Msg["COLLAPSE_BLOCK"] = "折叠块";
+Blockly.Msg["COLOUR_BLEND_COLOUR1"] = "颜色1";
+Blockly.Msg["COLOUR_BLEND_COLOUR2"] = "颜色2";
+Blockly.Msg["COLOUR_BLEND_HELPURL"] = "http://meyerweb.com/eric/tools/color-blend/";  // untranslated
+Blockly.Msg["COLOUR_BLEND_RATIO"] = "比例";
+Blockly.Msg["COLOUR_BLEND_TITLE"] = "混合";
+Blockly.Msg["COLOUR_BLEND_TOOLTIP"] = "把两种颜色以一个给定的比例(0.0-1.0)进行混合。";
+Blockly.Msg["COLOUR_PICKER_HELPURL"] = "https://zh.wikipedia.org/wiki/颜色";
+Blockly.Msg["COLOUR_PICKER_TOOLTIP"] = "从调色板中选择一种颜色。";
+Blockly.Msg["COLOUR_RANDOM_HELPURL"] = "http://randomcolour.com";  // untranslated
+Blockly.Msg["COLOUR_RANDOM_TITLE"] = "随机颜色";
+Blockly.Msg["COLOUR_RANDOM_TOOLTIP"] = "随机选择一种颜色。";
+Blockly.Msg["COLOUR_RGB_BLUE"] = "蓝色";
+Blockly.Msg["COLOUR_RGB_GREEN"] = "绿色";
+Blockly.Msg["COLOUR_RGB_HELPURL"] = "http://www.december.com/html/spec/colorper.html";  // untranslated
+Blockly.Msg["COLOUR_RGB_RED"] = "红色";
+Blockly.Msg["COLOUR_RGB_TITLE"] = "颜色";
+Blockly.Msg["COLOUR_RGB_TOOLTIP"] = "通过指定红色、绿色和蓝色的量创建一种颜色。所有的值必须在0和100之间。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#loop-termination-blocks";  // untranslated
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_OPERATOR_BREAK"] = "跳出循环";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_OPERATOR_CONTINUE"] = "继续下一轮循环";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_TOOLTIP_BREAK"] = "跳出包含它的循环。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_TOOLTIP_CONTINUE"] = "跳过本轮循环的剩余部分，并继进行续下一轮迭代。";
+Blockly.Msg["CONTROLS_FLOW_STATEMENTS_WARNING"] = "警告：这个块只能在循环内使用。";
+Blockly.Msg["CONTROLS_FOREACH_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#for-each";  // untranslated
+Blockly.Msg["CONTROLS_FOREACH_TITLE"] = "为列表 %2 里的每一项 %1";
+Blockly.Msg["CONTROLS_FOREACH_TOOLTIP"] = "遍历列表中的每一项，将变量“%1”设为所选项，并执行一些语句。";
+Blockly.Msg["CONTROLS_FOR_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#count-with";  // untranslated
+Blockly.Msg["CONTROLS_FOR_TITLE"] = "变量 %1 从 %2 数到 %3 每次增加 %4";
+Blockly.Msg["CONTROLS_FOR_TOOLTIP"] = "用变量%1记录从开始数值到终止数值之间的数值，数值按指定间隔增加，并执行指定的块。";
+Blockly.Msg["CONTROLS_IF_ELSEIF_TOOLTIP"] = "在这个if语句块中增加一个条件。";
+Blockly.Msg["CONTROLS_IF_ELSE_TOOLTIP"] = "在这个if语句块中添加一个最终的，包括所有其余情况的条件。";
+Blockly.Msg["CONTROLS_IF_HELPURL"] = "https://github.com/google/blockly/wiki/IfElse";  // untranslated
+Blockly.Msg["CONTROLS_IF_IF_TOOLTIP"] = "增加、删除或重新排列各节来重新配置这个if语句块。";
+Blockly.Msg["CONTROLS_IF_MSG_ELSE"] = "否则";
+Blockly.Msg["CONTROLS_IF_MSG_ELSEIF"] = "否则如果";
+Blockly.Msg["CONTROLS_IF_MSG_IF"] = "如果";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_1"] = "如果值为真，执行一些语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_2"] = "如果值为真，则执行第一块语句。否则，则执行第二块语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_3"] = "如果第一个值为真，则执行第一块的语句。否则，如果第二个值为真，则执行第二块的语句。";
+Blockly.Msg["CONTROLS_IF_TOOLTIP_4"] = "如果第一个值为真，则执行第一块对语句。否则，如果第二个值为真，则执行语句的第二块。如果没有值为真，则执行最后一块的语句。";
+Blockly.Msg["CONTROLS_REPEAT_HELPURL"] = "https://zh.wikipedia.org/wiki/For循环";
+Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"] = "执行";
+Blockly.Msg["CONTROLS_REPEAT_TITLE"] = "重复 %1 次";
+Blockly.Msg["CONTROLS_REPEAT_TOOLTIP"] = "多次执行一些语句。";
+Blockly.Msg["CONTROLS_WHILEUNTIL_HELPURL"] = "https://github.com/google/blockly/wiki/Loops#repeat";  // untranslated
+Blockly.Msg["CONTROLS_WHILEUNTIL_OPERATOR_UNTIL"] = "重复直到条件满足";
+Blockly.Msg["CONTROLS_WHILEUNTIL_OPERATOR_WHILE"] = "当条件满足时重复";
+Blockly.Msg["CONTROLS_WHILEUNTIL_TOOLTIP_UNTIL"] = "只要值为假，执行一些语句。";
+Blockly.Msg["CONTROLS_WHILEUNTIL_TOOLTIP_WHILE"] = "只要值为真，执行一些语句。";
+Blockly.Msg["DELETE_ALL_BLOCKS"] = "删除所有 %1 个块吗？";
+Blockly.Msg["DELETE_BLOCK"] = "删除块";
+Blockly.Msg["DELETE_VARIABLE"] = "删除变量“%1”";
+Blockly.Msg["DELETE_VARIABLE_CONFIRMATION"] = "要删除变量“%2”的%1个使用之处吗？";
+Blockly.Msg["DELETE_X_BLOCKS"] = "删除 %1 个块";
+Blockly.Msg["DISABLE_BLOCK"] = "禁用块";
+Blockly.Msg["DUPLICATE_BLOCK"] = "复制";
+Blockly.Msg["DUPLICATE_COMMENT"] = "复制注释";
+Blockly.Msg["ENABLE_BLOCK"] = "启用块";
+Blockly.Msg["EXPAND_ALL"] = "展开块";
+Blockly.Msg["EXPAND_BLOCK"] = "展开块";
+Blockly.Msg["EXTERNAL_INPUTS"] = "外部输入";
+Blockly.Msg["HELP"] = "帮助";
+Blockly.Msg["INLINE_INPUTS"] = "单行输入";
+Blockly.Msg["IOS_CANCEL"] = "取消";
+Blockly.Msg["IOS_ERROR"] = "错误";
+Blockly.Msg["IOS_OK"] = "确定";
+Blockly.Msg["IOS_PROCEDURES_ADD_INPUT"] = "+添加输入";
+Blockly.Msg["IOS_PROCEDURES_ALLOW_STATEMENTS"] = "允许的语句";
+Blockly.Msg["IOS_PROCEDURES_DUPLICATE_INPUTS_ERROR"] = "这个函数有多个输入。";
+Blockly.Msg["IOS_PROCEDURES_INPUTS"] = "输入";
+Blockly.Msg["IOS_VARIABLES_ADD_BUTTON"] = "添加";
+Blockly.Msg["IOS_VARIABLES_ADD_VARIABLE"] = "+添加变量";
+Blockly.Msg["IOS_VARIABLES_DELETE_BUTTON"] = "删除";
+Blockly.Msg["IOS_VARIABLES_EMPTY_NAME_ERROR"] = "你不能使用空白的变量名。";
+Blockly.Msg["IOS_VARIABLES_RENAME_BUTTON"] = "重命名";
+Blockly.Msg["IOS_VARIABLES_VARIABLE_NAME"] = "变量名";
+Blockly.Msg["LISTS_CREATE_EMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-empty-list";
+Blockly.Msg["LISTS_CREATE_EMPTY_TITLE"] = "创建空列表";
+Blockly.Msg["LISTS_CREATE_EMPTY_TOOLTIP"] = "返回一个列表，长度为 0，不包含任何数据记录";
+Blockly.Msg["LISTS_CREATE_WITH_CONTAINER_TITLE_ADD"] = "列表";
+Blockly.Msg["LISTS_CREATE_WITH_CONTAINER_TOOLTIP"] = "增加、删除或重新排列各部分以此重新配置这个列表块。";
+Blockly.Msg["LISTS_CREATE_WITH_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-list-with";
+Blockly.Msg["LISTS_CREATE_WITH_INPUT_WITH"] = "建立列表从";
+Blockly.Msg["LISTS_CREATE_WITH_ITEM_TOOLTIP"] = "将一个项添加到列表中。";
+Blockly.Msg["LISTS_CREATE_WITH_TOOLTIP"] = "建立一个具有任意数量项目的列表。";
+Blockly.Msg["LISTS_GET_INDEX_FIRST"] = "第一个";
+Blockly.Msg["LISTS_GET_INDEX_FROM_END"] = "倒数第#";
+Blockly.Msg["LISTS_GET_INDEX_FROM_START"] = "#";
+Blockly.Msg["LISTS_GET_INDEX_GET"] = "取得";
+Blockly.Msg["LISTS_GET_INDEX_GET_REMOVE"] = "取得并移除";
+Blockly.Msg["LISTS_GET_INDEX_LAST"] = "最后一个";
+Blockly.Msg["LISTS_GET_INDEX_RANDOM"] = "随机的";
+Blockly.Msg["LISTS_GET_INDEX_REMOVE"] = "移除";
+Blockly.Msg["LISTS_GET_INDEX_TAIL"] = "空白";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_FIRST"] = "返回列表中的第一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_FROM"] = "返回在列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_LAST"] = "返回列表中的最后一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_RANDOM"] = "返回列表中的随机一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FIRST"] = "移除并返回列表中的第一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_FROM"] = "移除并返回列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_LAST"] = "移除并返回列表中的最后一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_GET_REMOVE_RANDOM"] = "移除并返回列表中的随机一项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_FIRST"] = "移除列表中的第一项";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_FROM"] = "移除在列表中的指定位置的项。";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_LAST"] = "移除列表中的最后一项";
+Blockly.Msg["LISTS_GET_INDEX_TOOLTIP_REMOVE_RANDOM"] = "删除列表中的随机一项。";
+Blockly.Msg["LISTS_GET_SUBLIST_END_FROM_END"] = "到倒数第#";
+Blockly.Msg["LISTS_GET_SUBLIST_END_FROM_START"] = "到#";
+Blockly.Msg["LISTS_GET_SUBLIST_END_LAST"] = "到最后";
+Blockly.Msg["LISTS_GET_SUBLIST_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#getting-a-sublist";  // untranslated
+Blockly.Msg["LISTS_GET_SUBLIST_START_FIRST"] = "获取子列表从第一个";
+Blockly.Msg["LISTS_GET_SUBLIST_START_FROM_END"] = "获取子列表从最后一个#";
+Blockly.Msg["LISTS_GET_SUBLIST_START_FROM_START"] = "获取子列表从#";
+Blockly.Msg["LISTS_GET_SUBLIST_TAIL"] = "空白";
+Blockly.Msg["LISTS_GET_SUBLIST_TOOLTIP"] = "复制列表中指定的部分。";
+Blockly.Msg["LISTS_INDEX_FROM_END_TOOLTIP"] = "%1是最后一项。";
+Blockly.Msg["LISTS_INDEX_FROM_START_TOOLTIP"] = "%1是第一项。";
+Blockly.Msg["LISTS_INDEX_OF_FIRST"] = "寻找第一次出现的项";
+Blockly.Msg["LISTS_INDEX_OF_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#getting-items-from-a-list";  // untranslated
+Blockly.Msg["LISTS_INDEX_OF_LAST"] = "寻找最后一次出现的项";
+Blockly.Msg["LISTS_INDEX_OF_TOOLTIP"] = "返回在列表中的第一/最后一个匹配项的索引值。如果找不到项目则返回%1。";
+Blockly.Msg["LISTS_INLIST"] = "在列表中";
+Blockly.Msg["LISTS_ISEMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#is-empty";  // untranslated
+Blockly.Msg["LISTS_ISEMPTY_TITLE"] = "%1是空的";
+Blockly.Msg["LISTS_ISEMPTY_TOOLTIP"] = "如果改列表为空，则返回真。";
+Blockly.Msg["LISTS_LENGTH_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#length-of";  // untranslated
+Blockly.Msg["LISTS_LENGTH_TITLE"] = "%1的长度";
+Blockly.Msg["LISTS_LENGTH_TOOLTIP"] = "返回列表的长度。";
+Blockly.Msg["LISTS_REPEAT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#create-list-with";  // untranslated
+Blockly.Msg["LISTS_REPEAT_TITLE"] = "建立列表使用项 %1 重复 %2 次";
+Blockly.Msg["LISTS_REPEAT_TOOLTIP"] = "建立包含指定重复次数的值的列表。";
+Blockly.Msg["LISTS_REVERSE_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#reversing-a-list";
+Blockly.Msg["LISTS_REVERSE_MESSAGE0"] = "倒转%1";
+Blockly.Msg["LISTS_REVERSE_TOOLTIP"] = "倒转一个列表的拷贝。";
+Blockly.Msg["LISTS_SET_INDEX_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#in-list--set";  // untranslated
+Blockly.Msg["LISTS_SET_INDEX_INPUT_TO"] = "值为";
+Blockly.Msg["LISTS_SET_INDEX_INSERT"] = "插入在";
+Blockly.Msg["LISTS_SET_INDEX_SET"] = "设置";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_FIRST"] = "在列表的起始处添加该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_FROM"] = "插入在列表中指定位置的项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_LAST"] = "在列表的末尾处添加该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_INSERT_RANDOM"] = "在列表的随机位置插入该项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_FIRST"] = "设置列表中的第一项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_FROM"] = "设置在列表中指定位置的项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_LAST"] = "设置列表中的最后一项。";
+Blockly.Msg["LISTS_SET_INDEX_TOOLTIP_SET_RANDOM"] = "设置列表中的随机一项。";
+Blockly.Msg["LISTS_SORT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#sorting-a-list";
+Blockly.Msg["LISTS_SORT_ORDER_ASCENDING"] = "升序";
+Blockly.Msg["LISTS_SORT_ORDER_DESCENDING"] = "降序";
+Blockly.Msg["LISTS_SORT_TITLE"] = "排序%1 %2 %3";
+Blockly.Msg["LISTS_SORT_TOOLTIP"] = "排序一个列表的拷贝。";
+Blockly.Msg["LISTS_SORT_TYPE_IGNORECASE"] = "按字母排序，忽略大小写";
+Blockly.Msg["LISTS_SORT_TYPE_NUMERIC"] = "按数字排序";
+Blockly.Msg["LISTS_SORT_TYPE_TEXT"] = "按字母排序";
+Blockly.Msg["LISTS_SPLIT_HELPURL"] = "https://github.com/google/blockly/wiki/Lists#splitting-strings-and-joining-lists";
+Blockly.Msg["LISTS_SPLIT_LIST_FROM_TEXT"] = "从文本制作列表";
+Blockly.Msg["LISTS_SPLIT_TEXT_FROM_LIST"] = "从列表拆出文本";
+Blockly.Msg["LISTS_SPLIT_TOOLTIP_JOIN"] = "加入文本列表至一个文本，由分隔符分隔。";
+Blockly.Msg["LISTS_SPLIT_TOOLTIP_SPLIT"] = "拆分文本到文本列表，按每个分隔符拆分。";
+Blockly.Msg["LISTS_SPLIT_WITH_DELIMITER"] = "用分隔符";
+Blockly.Msg["LOGIC_BOOLEAN_FALSE"] = "假";
+Blockly.Msg["LOGIC_BOOLEAN_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#values";  // untranslated
+Blockly.Msg["LOGIC_BOOLEAN_TOOLTIP"] = "返回真或假。";
+Blockly.Msg["LOGIC_BOOLEAN_TRUE"] = "真";
+Blockly.Msg["LOGIC_COMPARE_HELPURL"] = "https://zh.wikipedia.org/wiki/不等";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_EQ"] = "如果两个输入结果相等，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_GT"] = "如果第一个输入结果比第二个大，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_GTE"] = "如果第一个输入结果大于或等于第二个输入结果，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_LT"] = "如果第一个输入结果比第二个小，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_LTE"] = "如果第一个输入结果小于或等于第二个输入结果，则返回真。";
+Blockly.Msg["LOGIC_COMPARE_TOOLTIP_NEQ"] = "如果两个输入结果不相等，则返回真。";
+Blockly.Msg["LOGIC_NEGATE_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#not";
+Blockly.Msg["LOGIC_NEGATE_TITLE"] = "非%1";
+Blockly.Msg["LOGIC_NEGATE_TOOLTIP"] = "如果输入结果为假，则返回真；如果输入结果为真，则返回假。";
+Blockly.Msg["LOGIC_NULL"] = "空";
+Blockly.Msg["LOGIC_NULL_HELPURL"] = "https://en.wikipedia.org/wiki/Nullable_type";  // untranslated
+Blockly.Msg["LOGIC_NULL_TOOLTIP"] = "返回空值。";
+Blockly.Msg["LOGIC_OPERATION_AND"] = "并且";
+Blockly.Msg["LOGIC_OPERATION_HELPURL"] = "https://github.com/google/blockly/wiki/Logic#logical-operations";  // untranslated
+Blockly.Msg["LOGIC_OPERATION_OR"] = "或";
+Blockly.Msg["LOGIC_OPERATION_TOOLTIP_AND"] = "如果两个输入结果都为真，则返回真。";
+Blockly.Msg["LOGIC_OPERATION_TOOLTIP_OR"] = "如果至少有一个输入结果为真，则返回真。";
+Blockly.Msg["LOGIC_TERNARY_CONDITION"] = "断言";
+Blockly.Msg["LOGIC_TERNARY_HELPURL"] = "https://zh.wikipedia.org/wiki/条件运算符";
+Blockly.Msg["LOGIC_TERNARY_IF_FALSE"] = "如果为假";
+Blockly.Msg["LOGIC_TERNARY_IF_TRUE"] = "如果为真";
+Blockly.Msg["LOGIC_TERNARY_TOOLTIP"] = "检查“断言”里的条件语句。如果条件为真，则返回“如果为真”的值，否则，则返回“如果为假”的值。";
+Blockly.Msg["MATH_ADDITION_SYMBOL"] = "+";  // untranslated
+Blockly.Msg["MATH_ARITHMETIC_HELPURL"] = "https://zh.wikipedia.org/wiki/算术";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_ADD"] = "返回两个数值的和。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_DIVIDE"] = "返回两个数值的商。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_MINUS"] = "返回两个数值的差值。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_MULTIPLY"] = "返回两个数值的乘积。";
+Blockly.Msg["MATH_ARITHMETIC_TOOLTIP_POWER"] = "返回以第一个数值为底数，以第二个数值为幂的结果。";
+Blockly.Msg["MATH_ATAN2_HELPURL"] = "https://zh.wikipedia.org/wiki/反正切2";
+Blockly.Msg["MATH_ATAN2_TITLE"] = "点(x:%1,y:%2)的方位角";
+Blockly.Msg["MATH_ATAN2_TOOLTIP"] = "返回点（X，Y）的反正切值，范围为-180到180度。";
+Blockly.Msg["MATH_CHANGE_HELPURL"] = "https://zh.wikipedia.org/wiki/加法";
+Blockly.Msg["MATH_CHANGE_TITLE"] = "将 %1 改为 %2";
+Blockly.Msg["MATH_CHANGE_TOOLTIP"] = "为变量“%1”增加一个数值。";
+Blockly.Msg["MATH_CONSTANT_HELPURL"] = "https://zh.wikipedia.org/wiki/数学常数";
+Blockly.Msg["MATH_CONSTANT_TOOLTIP"] = "返回一个常见常量：π (3.141…)、e (2.718…)、φ (1.618…)、平方根 (1.414…)、开平方根 (0.707…)或∞ (无限大)。";
+Blockly.Msg["MATH_CONSTRAIN_HELPURL"] = "https://en.wikipedia.org/wiki/Clamping_(graphics)";  // untranslated
+Blockly.Msg["MATH_CONSTRAIN_TITLE"] = "将 %1 限制在 最低 %2 到最高 %3 之间";
+Blockly.Msg["MATH_CONSTRAIN_TOOLTIP"] = "将一个数值限制在两个指定的数值范围（含边界）之间。";
+Blockly.Msg["MATH_DIVISION_SYMBOL"] = "÷";  // untranslated
+Blockly.Msg["MATH_IS_DIVISIBLE_BY"] = "可被整除";
+Blockly.Msg["MATH_IS_EVEN"] = "是偶数";
+Blockly.Msg["MATH_IS_NEGATIVE"] = "是负数";
+Blockly.Msg["MATH_IS_ODD"] = "是奇数";
+Blockly.Msg["MATH_IS_POSITIVE"] = "是正数";
+Blockly.Msg["MATH_IS_PRIME"] = "是质数";
+Blockly.Msg["MATH_IS_TOOLTIP"] = "检查一个数值是否是偶数、奇数、质数、自然数、正数、负数或者是否能被某数整除。返回真或假。";
+Blockly.Msg["MATH_IS_WHOLE"] = "是整数";
+Blockly.Msg["MATH_MODULO_HELPURL"] = "https://zh.wikipedia.org/wiki/模除";
+Blockly.Msg["MATH_MODULO_TITLE"] = "取 %1 ÷ %2 的余数";
+Blockly.Msg["MATH_MODULO_TOOLTIP"] = "返回这两个数字相除后的余数。";
+Blockly.Msg["MATH_MULTIPLICATION_SYMBOL"] = "×";  // untranslated
+Blockly.Msg["MATH_NUMBER_HELPURL"] = "https://zh.wikipedia.org/wiki/数";
+Blockly.Msg["MATH_NUMBER_TOOLTIP"] = "一个数值。";
+Blockly.Msg["MATH_ONLIST_HELPURL"] = "";  // untranslated
+Blockly.Msg["MATH_ONLIST_OPERATOR_AVERAGE"] = "列表平均值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MAX"] = "列表最大值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MEDIAN"] = "列表中位数";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MIN"] = "列表最小值";
+Blockly.Msg["MATH_ONLIST_OPERATOR_MODE"] = "列表中的众数";
+Blockly.Msg["MATH_ONLIST_OPERATOR_RANDOM"] = "列表随机项";
+Blockly.Msg["MATH_ONLIST_OPERATOR_STD_DEV"] = "列表的标准差";
+Blockly.Msg["MATH_ONLIST_OPERATOR_SUM"] = "列表中数值的和";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_AVERAGE"] = "返回列表中的数值的平均值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MAX"] = "返回列表中最大值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MEDIAN"] = "返回列表中数值的中位数。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MIN"] = "返回列表中最小值。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_MODE"] = "返回列表中的出现次数最多的项的列表。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_RANDOM"] = "从列表中返回一个随机的元素。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_STD_DEV"] = "返回列表的标准差。";
+Blockly.Msg["MATH_ONLIST_TOOLTIP_SUM"] = "返回列表中的所有数值的和。";
+Blockly.Msg["MATH_POWER_SYMBOL"] = "^";  // untranslated
+Blockly.Msg["MATH_RANDOM_FLOAT_HELPURL"] = "https://zh.wikipedia.org/wiki/随机数生成器";
+Blockly.Msg["MATH_RANDOM_FLOAT_TITLE_RANDOM"] = "随机小数";
+Blockly.Msg["MATH_RANDOM_FLOAT_TOOLTIP"] = "返回一个介于0.0到1.0之间（含边界）的随机数。";
+Blockly.Msg["MATH_RANDOM_INT_HELPURL"] = "https://zh.wikipedia.org/wiki/随机数生成器";
+Blockly.Msg["MATH_RANDOM_INT_TITLE"] = "从 %1 到 %2 范围内的随机整数";
+Blockly.Msg["MATH_RANDOM_INT_TOOLTIP"] = "返回一个限制在两个指定数值的范围（含边界）之间的随机整数。";
+Blockly.Msg["MATH_ROUND_HELPURL"] = "https://zh.wikipedia.org/wiki/数值修约";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUND"] = "四舍五入";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUNDDOWN"] = "向下舍入";
+Blockly.Msg["MATH_ROUND_OPERATOR_ROUNDUP"] = "向上舍入";
+Blockly.Msg["MATH_ROUND_TOOLTIP"] = "数字向上或向下舍入。";
+Blockly.Msg["MATH_SINGLE_HELPURL"] = "https://zh.wikipedia.org/wiki/平方根";
+Blockly.Msg["MATH_SINGLE_OP_ABSOLUTE"] = "绝对值";
+Blockly.Msg["MATH_SINGLE_OP_ROOT"] = "平方根";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_ABS"] = "返回一个数值的绝对值。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_EXP"] = "返回一个数值的e次幂。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_LN"] = "返回一个数值的自然对数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_LOG10"] = "返回一个数值的以10为底的对数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_NEG"] = "返回一个数值的相反数。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_POW10"] = "返回一个数值的10次幂。";
+Blockly.Msg["MATH_SINGLE_TOOLTIP_ROOT"] = "返回一个数的平方根。";
+Blockly.Msg["MATH_SUBTRACTION_SYMBOL"] = "-";  // untranslated
+Blockly.Msg["MATH_TRIG_ACOS"] = "acos";  // untranslated
+Blockly.Msg["MATH_TRIG_ASIN"] = "asin";  // untranslated
+Blockly.Msg["MATH_TRIG_ATAN"] = "atan";  // untranslated
+Blockly.Msg["MATH_TRIG_COS"] = "cos";  // untranslated
+Blockly.Msg["MATH_TRIG_HELPURL"] = "https://zh.wikipedia.org/wiki/三角函数";
+Blockly.Msg["MATH_TRIG_SIN"] = "sin";  // untranslated
+Blockly.Msg["MATH_TRIG_TAN"] = "tan";  // untranslated
+Blockly.Msg["MATH_TRIG_TOOLTIP_ACOS"] = "返回一个数值的反余弦值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_ASIN"] = "返回一个数值的反正弦值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_ATAN"] = "返回一个数值的反正切值。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_COS"] = "返回指定角度的余弦值(非弧度）。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_SIN"] = "返回指定角度的正弦值(非弧度）。";
+Blockly.Msg["MATH_TRIG_TOOLTIP_TAN"] = "返回指定角度的正切值(非弧度）。";
+Blockly.Msg["NEW_COLOUR_VARIABLE"] = "创建颜色变量...";
+Blockly.Msg["NEW_NUMBER_VARIABLE"] = "创建数字变量...";
+Blockly.Msg["NEW_STRING_VARIABLE"] = "创建字符串变量...";
+Blockly.Msg["NEW_VARIABLE"] = "创建变量...";
+Blockly.Msg["NEW_VARIABLE_TITLE"] = "新变量的名称：";
+Blockly.Msg["NEW_VARIABLE_TYPE_TITLE"] = "新变量的类型：";
+Blockly.Msg["ORDINAL_NUMBER_SUFFIX"] = "空白";
+Blockly.Msg["PROCEDURES_ALLOW_STATEMENTS"] = "允许声明";
+Blockly.Msg["PROCEDURES_BEFORE_PARAMS"] = "与：";
+Blockly.Msg["PROCEDURES_CALLNORETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_CALLNORETURN_TOOLTIP"] = "运行用户定义的函数“%1”。";
+Blockly.Msg["PROCEDURES_CALLRETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_CALLRETURN_TOOLTIP"] = "运行用户定义的函数“%1”，并使用它的输出值。";
+Blockly.Msg["PROCEDURES_CALL_BEFORE_PARAMS"] = "与：";
+Blockly.Msg["PROCEDURES_CREATE_DO"] = "创建“%1”";
+Blockly.Msg["PROCEDURES_DEFNORETURN_COMMENT"] = "描述该功能...";
+Blockly.Msg["PROCEDURES_DEFNORETURN_DO"] = "空白";
+Blockly.Msg["PROCEDURES_DEFNORETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_DEFNORETURN_PROCEDURE"] = "做点什么";
+Blockly.Msg["PROCEDURES_DEFNORETURN_TITLE"] = "至";
+Blockly.Msg["PROCEDURES_DEFNORETURN_TOOLTIP"] = "创建一个不带输出值的函数。";
+Blockly.Msg["PROCEDURES_DEFRETURN_HELPURL"] = "https://zh.wikipedia.org/wiki/子程序";
+Blockly.Msg["PROCEDURES_DEFRETURN_RETURN"] = "返回";
+Blockly.Msg["PROCEDURES_DEFRETURN_TOOLTIP"] = "创建一个有输出值的函数。";
+Blockly.Msg["PROCEDURES_DEF_DUPLICATE_WARNING"] = "警告：此函数具有重复参数。";
+Blockly.Msg["PROCEDURES_HIGHLIGHT_DEF"] = "突出显示函数定义";
+Blockly.Msg["PROCEDURES_IFRETURN_HELPURL"] = "http://c2.com/cgi/wiki?GuardClause";
+Blockly.Msg["PROCEDURES_IFRETURN_TOOLTIP"] = "如果值为真，则返回第二个值。";
+Blockly.Msg["PROCEDURES_IFRETURN_WARNING"] = "警告：这个块只能在函数内部使用。";
+Blockly.Msg["PROCEDURES_MUTATORARG_TITLE"] = "输入名称：";
+Blockly.Msg["PROCEDURES_MUTATORARG_TOOLTIP"] = "添加函数输入。";
+Blockly.Msg["PROCEDURES_MUTATORCONTAINER_TITLE"] = "输入";
+Blockly.Msg["PROCEDURES_MUTATORCONTAINER_TOOLTIP"] = "添加、移除或重新排此函数的输入。";
+Blockly.Msg["REDO"] = "重做";
+Blockly.Msg["REMOVE_COMMENT"] = "删除注释";
+Blockly.Msg["RENAME_VARIABLE"] = "重命名变量...";
+Blockly.Msg["RENAME_VARIABLE_TITLE"] = "将所有“%1”变量重命名为:";
+Blockly.Msg["TEXT_APPEND_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
+Blockly.Msg["TEXT_APPEND_TITLE"] = "向%1附加文本%2";
+Blockly.Msg["TEXT_APPEND_TOOLTIP"] = "将一些文本追加到变量“%1”里。";
+Blockly.Msg["TEXT_CHANGECASE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#adjusting-text-case";  // untranslated
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_LOWERCASE"] = "转为小写";
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_TITLECASE"] = "转为首字母大写";
+Blockly.Msg["TEXT_CHANGECASE_OPERATOR_UPPERCASE"] = "转为大写";
+Blockly.Msg["TEXT_CHANGECASE_TOOLTIP"] = "用不同的大小写模式复制并返回这段文字。";
+Blockly.Msg["TEXT_CHARAT_FIRST"] = "寻找第一个字母";
+Blockly.Msg["TEXT_CHARAT_FROM_END"] = "获取字符从倒数#";
+Blockly.Msg["TEXT_CHARAT_FROM_START"] = "获取字符从#";
+Blockly.Msg["TEXT_CHARAT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#extracting-text";  // untranslated
+Blockly.Msg["TEXT_CHARAT_LAST"] = "寻找最后一个字母";
+Blockly.Msg["TEXT_CHARAT_RANDOM"] = "寻找随机的字母";
+Blockly.Msg["TEXT_CHARAT_TAIL"] = "空白";
+Blockly.Msg["TEXT_CHARAT_TITLE"] = "在文本%1 里 %2";
+Blockly.Msg["TEXT_CHARAT_TOOLTIP"] = "返回位于指定位置的字母。";
+Blockly.Msg["TEXT_COUNT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#counting-substrings";
+Blockly.Msg["TEXT_COUNT_MESSAGE0"] = "计算%1在%2里出现的次数";
+Blockly.Msg["TEXT_COUNT_TOOLTIP"] = "计算在一段文本中，某个部分文本重复出现了多少次。";
+Blockly.Msg["TEXT_CREATE_JOIN_ITEM_TOOLTIP"] = "将一个项添加到文本中。";
+Blockly.Msg["TEXT_CREATE_JOIN_TITLE_JOIN"] = "加入";
+Blockly.Msg["TEXT_CREATE_JOIN_TOOLTIP"] = "添加、移除或重新排列各节来重新配置这个文本块。";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_FROM_END"] = "到最后一个字符#";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_FROM_START"] = "至字符#";
+Blockly.Msg["TEXT_GET_SUBSTRING_END_LAST"] = "到最后一个字符";
+Blockly.Msg["TEXT_GET_SUBSTRING_HELPURL"] = "https://github.com/google/blockly/wiki/Text#extracting-a-region-of-text";  // untranslated
+Blockly.Msg["TEXT_GET_SUBSTRING_INPUT_IN_TEXT"] = "从文本";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FIRST"] = "取得子串自第一个字符";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FROM_END"] = "取得子串自倒数#";
+Blockly.Msg["TEXT_GET_SUBSTRING_START_FROM_START"] = "取得子串自#";
+Blockly.Msg["TEXT_GET_SUBSTRING_TAIL"] = "空白";
+Blockly.Msg["TEXT_GET_SUBSTRING_TOOLTIP"] = "返回文本中指定的一部分。";
+Blockly.Msg["TEXT_INDEXOF_HELPURL"] = "https://github.com/google/blockly/wiki/Text#finding-text";  // untranslated
+Blockly.Msg["TEXT_INDEXOF_OPERATOR_FIRST"] = "寻找第一次出现的文本";
+Blockly.Msg["TEXT_INDEXOF_OPERATOR_LAST"] = "寻找最后一次出现的文本";
+Blockly.Msg["TEXT_INDEXOF_TITLE"] = "在文本 %1 里 %2  %3";
+Blockly.Msg["TEXT_INDEXOF_TOOLTIP"] = "返回第一个文本段在第二个文本段中的第一/最后一个匹配项的起始位置。如果未找到，则返回%1。";
+Blockly.Msg["TEXT_ISEMPTY_HELPURL"] = "https://github.com/google/blockly/wiki/Text#checking-for-empty-text";  // untranslated
+Blockly.Msg["TEXT_ISEMPTY_TITLE"] = "%1是空的";
+Blockly.Msg["TEXT_ISEMPTY_TOOLTIP"] = "如果给定的文本为空，则返回真。";
+Blockly.Msg["TEXT_JOIN_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-creation";  // untranslated
+Blockly.Msg["TEXT_JOIN_TITLE_CREATEWITH"] = "建立文本从";
+Blockly.Msg["TEXT_JOIN_TOOLTIP"] = "通过串起任意数量的项以建立一段文本。";
+Blockly.Msg["TEXT_LENGTH_HELPURL"] = "https://github.com/google/blockly/wiki/Text#text-modification";  // untranslated
+Blockly.Msg["TEXT_LENGTH_TITLE"] = "%1的长度";
+Blockly.Msg["TEXT_LENGTH_TOOLTIP"] = "返回给定文本的字母数（包括空格）。";
+Blockly.Msg["TEXT_PRINT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#printing-text";  // untranslated
+Blockly.Msg["TEXT_PRINT_TITLE"] = "输出%1";
+Blockly.Msg["TEXT_PRINT_TOOLTIP"] = "输出指定的文字、数字或其他值。";
+Blockly.Msg["TEXT_PROMPT_HELPURL"] = "https://github.com/google/blockly/wiki/Text#getting-input-from-the-user";  // untranslated
+Blockly.Msg["TEXT_PROMPT_TOOLTIP_NUMBER"] = "要求用户输入数字。";
+Blockly.Msg["TEXT_PROMPT_TOOLTIP_TEXT"] = "要求用户输入一些文本。";
+Blockly.Msg["TEXT_PROMPT_TYPE_NUMBER"] = "要求输入数字，并显示提示消息";
+Blockly.Msg["TEXT_PROMPT_TYPE_TEXT"] = "要求输入文本，并显示提示消息";
+Blockly.Msg["TEXT_REPLACE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#replacing-substrings";
+Blockly.Msg["TEXT_REPLACE_MESSAGE0"] = "在%3中，将%1替换为%2";
+Blockly.Msg["TEXT_REPLACE_TOOLTIP"] = "在一段文本中，将出现过的某部分文本都替换掉。";
+Blockly.Msg["TEXT_REVERSE_HELPURL"] = "https://github.com/google/blockly/wiki/Text#reversing-text";
+Blockly.Msg["TEXT_REVERSE_MESSAGE0"] = "翻转文本%1";
+Blockly.Msg["TEXT_REVERSE_TOOLTIP"] = "将文本中各个字符的顺序倒转。";
+Blockly.Msg["TEXT_TEXT_HELPURL"] = "https://zh.wikipedia.org/wiki/字符串";
+Blockly.Msg["TEXT_TEXT_TOOLTIP"] = "一个字、词语或一行文本。";
+Blockly.Msg["TEXT_TRIM_HELPURL"] = "https://github.com/google/blockly/wiki/Text#trimming-removing-spaces";  // untranslated
+Blockly.Msg["TEXT_TRIM_OPERATOR_BOTH"] = "消除其两侧的空白";
+Blockly.Msg["TEXT_TRIM_OPERATOR_LEFT"] = "消除其左侧的空白";
+Blockly.Msg["TEXT_TRIM_OPERATOR_RIGHT"] = "消除其右侧的空白";
+Blockly.Msg["TEXT_TRIM_TOOLTIP"] = "从某一端或同时从两端删除多余的空白，并返回这段文字的一个副本。";
+Blockly.Msg["TODAY"] = "今天";
+Blockly.Msg["UNDO"] = "撤销";
+Blockly.Msg["VARIABLES_DEFAULT_NAME"] = "项目";
+Blockly.Msg["VARIABLES_GET_CREATE_SET"] = "创建“设定%1”";
+Blockly.Msg["VARIABLES_GET_HELPURL"] = "https://github.com/google/blockly/wiki/Variables#get";  // untranslated
+Blockly.Msg["VARIABLES_GET_TOOLTIP"] = "返回此变量的值。";
+Blockly.Msg["VARIABLES_SET"] = "赋值 %1 为 %2";
+Blockly.Msg["VARIABLES_SET_CREATE_GET"] = "创建“获得%1”";
+Blockly.Msg["VARIABLES_SET_HELPURL"] = "https://github.com/google/blockly/wiki/Variables#set";  // untranslated
+Blockly.Msg["VARIABLES_SET_TOOLTIP"] = "设置此变量，以使它和输入值相等。";
+Blockly.Msg["VARIABLE_ALREADY_EXISTS"] = "名字叫“%1”的变量已经存在了。";
+Blockly.Msg["VARIABLE_ALREADY_EXISTS_FOR_ANOTHER_TYPE"] = "名字叫“%1”的变量已经有了另一个类型：“%2”。";
+Blockly.Msg["WORKSPACE_COMMENT_DEFAULT_TEXT"] = "说点什么...";
+Blockly.Msg["CONTROLS_FOREACH_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_FOR_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_IF_ELSEIF_TITLE_ELSEIF"] = Blockly.Msg["CONTROLS_IF_MSG_ELSEIF"];
+Blockly.Msg["CONTROLS_IF_ELSE_TITLE_ELSE"] = Blockly.Msg["CONTROLS_IF_MSG_ELSE"];
+Blockly.Msg["CONTROLS_IF_IF_TITLE_IF"] = Blockly.Msg["CONTROLS_IF_MSG_IF"];
+Blockly.Msg["CONTROLS_IF_MSG_THEN"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["CONTROLS_WHILEUNTIL_INPUT_DO"] = Blockly.Msg["CONTROLS_REPEAT_INPUT_DO"];
+Blockly.Msg["LISTS_CREATE_WITH_ITEM_TITLE"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["LISTS_GET_INDEX_HELPURL"] = Blockly.Msg["LISTS_INDEX_OF_HELPURL"];
+Blockly.Msg["LISTS_GET_INDEX_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_GET_SUBLIST_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_INDEX_OF_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["LISTS_SET_INDEX_INPUT_IN_LIST"] = Blockly.Msg["LISTS_INLIST"];
+Blockly.Msg["MATH_CHANGE_TITLE_ITEM"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["PROCEDURES_DEFRETURN_COMMENT"] = Blockly.Msg["PROCEDURES_DEFNORETURN_COMMENT"];
+Blockly.Msg["PROCEDURES_DEFRETURN_DO"] = Blockly.Msg["PROCEDURES_DEFNORETURN_DO"];
+Blockly.Msg["PROCEDURES_DEFRETURN_PROCEDURE"] = Blockly.Msg["PROCEDURES_DEFNORETURN_PROCEDURE"];
+Blockly.Msg["PROCEDURES_DEFRETURN_TITLE"] = Blockly.Msg["PROCEDURES_DEFNORETURN_TITLE"];
+Blockly.Msg["TEXT_APPEND_VARIABLE"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+Blockly.Msg["TEXT_CREATE_JOIN_ITEM_TITLE_ITEM"] = Blockly.Msg["VARIABLES_DEFAULT_NAME"];
+
+Blockly.Msg["MATH_HUE"] = "230";
+Blockly.Msg["LOOPS_HUE"] = "120";
+Blockly.Msg["LISTS_HUE"] = "260";
+Blockly.Msg["LOGIC_HUE"] = "210";
+Blockly.Msg["VARIABLES_HUE"] = "330";
+Blockly.Msg["TEXTS_HUE"] = "160";
+Blockly.Msg["PROCEDURES_HUE"] = "290";
+Blockly.Msg["COLOUR_HUE"] = "20";
+Blockly.Msg["VARIABLES_DYNAMIC_HUE"] = "310";

_server/colorPicker/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Peter Dematté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

_server/colorPicker/jsColor.js

@@ -0,0 +1,387 @@
+(function (window) {
+    window.jsColorPicker = function(selectors, config) {
+        var renderCallback = function(colors, mode) {
+                var options = this,
+                    input = options.input,
+                    patch = options.patch,
+                    RGB = colors.RND.rgb,
+                    HSL = colors.RND.hsl,
+                    AHEX = options.isIE8 ? (colors.alpha < 0.16 ? '0' : '') +
+                        (Math.round(colors.alpha * 100)).toString(16).toUpperCase() + colors.HEX : '',
+                    RGBInnerText = RGB.r + ',' + RGB.g + ',' + RGB.b,
+                    RGBAText = RGBInnerText + ',' + colors.alpha,
+                    isAlpha = colors.alpha !== 1 && !options.isIE8,
+                    colorMode = input.getAttribute('data-colorMode');
+
+                patch.style.cssText =
+                    'color:' + (colors.rgbaMixCustom.luminance > 0.22 ? '#222' : '#ddd') + ';' + // Black...???
+                    'background-color: rgba(' + RGBAText + ');' +
+                    'filter:' + (options.isIE8 ? 'progid:DXImageTransform.Microsoft.gradient(' + // IE<9
+                        'startColorstr=#' + AHEX + ',' + 'endColorstr=#' + AHEX + ')' : '');
+
+                input.value = RGBAText;
+
+                if (options.displayCallback) {
+                    options.displayCallback(colors, mode, options);
+                }
+            },
+            extractValue = function(elm) {
+                var val = elm.value || elm.getAttribute('value') || elm.style.backgroundColor || "0,0,0,1";
+                if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+$/.test(val)) return "rgba("+val+")";
+                if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+$/.test(val)) return "rgba("+val+",1)";
+                return null;
+            },
+            actionCallback = function(event, action) {
+                var options = this,
+                    colorPicker = colorPickers.current;
+
+                if (action === 'toMemory') {
+                    var memos = colorPicker.nodes.memos,
+                        backgroundColor = '',
+                        opacity = 0,
+                        cookieTXT = [];
+
+                    for (var n = 0, m = memos.length; n < m; n++) {
+                        backgroundColor = memos[n].style.backgroundColor;
+                        opacity = memos[n].style.opacity;
+                        opacity = Math.round((opacity === '' ? 1 : opacity) * 100) / 100;
+                        cookieTXT.push(backgroundColor.
+                            replace(/, /g, ',').
+                            replace('rgb(', 'rgba(').
+                            replace(')', ',' + opacity + ')')
+                        );
+                    }
+                    cookieTXT = '\'' + cookieTXT.join('\',\'') + '\'';
+                    ColorPicker.docCookies('colorPickerMemos' + (options.noAlpha ? 'NoAlpha' : ''), cookieTXT);
+                } else if (action === 'resizeApp') {
+                    ColorPicker.docCookies('colorPickerSize', colorPicker.color.options.currentSize);
+                } else if (action === 'modeChange') {
+                    var mode = colorPicker.color.options.mode;
+
+                    ColorPicker.docCookies('colorPickerMode', mode.type + '-' + mode.z);
+                }
+            },
+            createInstance = function(elm, config) {
+                var initConfig = {
+                        klass: window.ColorPicker,
+                        input: elm,
+                        patch: elm,
+                        isIE8: !!document.all && !document.addEventListener, // Opera???
+                        // *** animationSpeed: 200,
+                        // *** draggable: true,
+                        margin: {left: -1, top: 2},
+                        customBG: '#FFFFFF',
+                        // displayCallback: displayCallback,
+                        /* --- regular colorPicker options from this point --- */
+                        color: extractValue(elm),
+                        initStyle: 'display: none',
+                        mode: ColorPicker.docCookies('colorPickerMode') || 'hsv-h',
+                        // memoryColors: (function(colors, config) {
+                        //     return config.noAlpha ?
+                        //         colors.replace(/\,\d*\.*\d*\)/g, ',1)') : colors;
+                        // })($.docCookies('colorPickerMemos'), config || {}),
+                        memoryColors: ColorPicker.docCookies('colorPickerMemos' +
+                            ((config || {}).noAlpha ? 'NoAlpha' : '')),
+                        size: ColorPicker.docCookies('colorPickerSize') || 1,
+                        renderCallback: renderCallback,
+                        actionCallback: actionCallback
+                    };
+
+                for (var n in config) {
+                    initConfig[n] = config[n]; 
+                }
+                return new initConfig.klass(initConfig);
+            },
+            doEventListeners = function(elm, multiple, off) {
+                var onOff = off ? 'removeEventListener' : 'addEventListener',
+                    inputListener = function(e) {
+                        var index = multiple ? Array.prototype.indexOf.call(elms, this) : 0,
+                            colorPicker = colorPickers[index] ||
+                                (colorPickers[index] = createInstance(this, config)),
+                            options = colorPicker.color.options;
+
+                        options.color = extractValue(elm); // brings color to default on reset
+                        //检查颜色合法性
+                        if (options.color != null && options.color == options.color.match(/rgba\([0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+\)/)[0]) {
+                            var chec = options.color.match(/[0-9.]+/g);
+                            if (chec.length != 4)
+                                return;
+                            for (var i = 0; i < 3; i++) {
+                                if (chec[i] != chec[i].match(/\d+/)[0] || +chec[i] < 0 || +chec[i] > 255)
+                                    return;
+                            }
+                            if (chec[3] != chec[3].match(/\d+(\.\d+)?/)[0] || parseFloat(chec[3]) > 1 || parseFloat(chec[3] < 0))
+                                return;
+                            if (!multiple) {
+                                colorPicker.setColor(extractValue(elm), undefined, undefined, true);
+                                colorPicker.saveAsBackground();
+                            }
+                            colorPickers.current = colorPickers[index];
+                        }
+                    },
+                    createListener = function(e) {
+                        elm = document.getElementById("colorPicker");
+                        var input = elm,
+                            position = window.ColorPicker.getOrigin(input),
+                            index = multiple ? Array.prototype.indexOf.call(elms, elm) : 0,
+                            colorPicker = colorPickers[index] ||
+                                (colorPickers[index] = createInstance(elm, config)),
+                            options = colorPicker.color.options,
+                            colorPickerUI = colorPicker.nodes.colorPicker,
+                            appendTo = (options.appendTo || document.body),
+                            isStatic = /static/.test(window.getComputedStyle(appendTo).position),
+                            atrect = isStatic ? {left: 0, top: 0} : appendTo.getBoundingClientRect(),
+                            waitTimer = 0;
+                        
+                        options.color = extractValue(elm); // brings color to default on reset
+                        colorPickerUI.style.cssText = 
+                            'position: absolute;' + (!colorPickers[index].cssIsReady ? 'display: none;' : '') +
+                            'left:' + (position.left + options.margin.left - atrect.left) + 'px;' +
+                            'top:' + (position.top + +input.offsetHeight + options.margin.top - atrect.top) + 'px;';
+
+                        if (!multiple) {
+                            options.input = elm;
+                            options.patch = elm; // check again???
+                            colorPicker.setColor(extractValue(elm), undefined, undefined, true);
+                            colorPicker.saveAsBackground();
+                        }
+                        colorPickers.current = colorPickers[index];
+                        appendTo.appendChild(colorPickerUI);
+                        waitTimer = setInterval(function() { // compensating late style on onload in colorPicker
+                            if (colorPickers.current.cssIsReady) {
+                                waitTimer = clearInterval(waitTimer);
+                                colorPickerUI.style.display = 'block';
+                            }
+                        }, 10);
+                    },
+                    hideListener = function(e) {
+                        var colorPicker = colorPickers.current,
+                            colorPickerUI = (colorPicker ? colorPicker.nodes.colorPicker : undefined),
+                            animationSpeed = colorPicker ? colorPicker.color.options.animationSpeed : 0,
+                            isColorPicker = colorPicker && (function(elm) {
+                                while (elm) {
+                                    if ((elm.className || '').indexOf('cpPanel') !== -1) return elm;
+                                    elm = elm.parentNode;
+                                }
+                                return false;
+                            })(e.target),
+                            inputIndex = Array.prototype.indexOf.call(elms, e.target);
+
+                        if (isColorPicker && Array.prototype.indexOf.call(colorPickers, isColorPicker)) {
+                            if (e.target === colorPicker.nodes.exit) {
+                                colorPickerUI.parentNode.style.display = 'none';
+                                document.activeElement.blur();
+                            } else {
+                                // ...
+                            }
+                        } else if (inputIndex !== -1) {
+                            // ...
+                        } else if (colorPickerUI) {
+                            colorPickerUI.parentNode.style.display = 'none';
+                        }
+                    };
+                elm[onOff]('input', inputListener);
+                window.jsColorPicker.create = createListener;
+            },
+            // this is a way to prevent data binding on HTMLElements
+            colorPickers = window.jsColorPicker.colorPickers || [],
+            elms = document.querySelectorAll(selectors),
+            testColors = new window.Colors({customBG: config.customBG, allMixDetails: true});
+
+        window.jsColorPicker.colorPickers = colorPickers;
+
+        for (var n = 0, m = elms.length; n < m; n++) {
+            var elm = elms[n];
+
+            if (config === 'destroy') {
+                doEventListeners(elm, (config && config.multipleInstances), true);
+                if (colorPickers[n]) {
+                    colorPickers[n].destroyAll();
+                }
+            } else {
+                var color = extractValue(elm);
+                var value = color.split('(');
+
+                testColors.setColor(color);
+                if (config && config.init) {
+                    config.init(elm, testColors.colors);
+                }
+                elm.setAttribute('data-colorMode', value[1] ? value[0].substr(0, 3) : 'HEX');
+                doEventListeners(elm, (config && config.multipleInstances), false);
+                if (config && config.readOnly) {
+                    elm.readOnly = true;
+                }
+            }
+        };
+
+        return window.jsColorPicker.colorPickers;
+    };
+
+    window.ColorPicker.docCookies = function(key, val, options) {
+        var encode = encodeURIComponent, decode = decodeURIComponent,
+            cookies, n, tmp, cache = {},
+            days;
+
+        if (val === undefined) { // all about reading cookies
+            cookies = document.cookie.split(/;\s*/) || [];
+            for (n = cookies.length; n--; ) {
+                tmp = cookies[n].split('=');
+                if (tmp[0]) cache[decode(tmp.shift())] = decode(tmp.join('=')); // there might be '='s in the value...
+            }
+
+            if (!key) return cache; // return Json for easy access to all cookies
+            else return cache[key]; // easy access to cookies from here
+        } else { // write/delete cookie
+            options = options || {};
+
+            if (val === '' || options.expires < 0) { // prepare deleteing the cookie
+                options.expires = -1;
+                // options.path = options.domain = options.secure = undefined; // to make shure the cookie gets deleted...
+            }
+
+            if (options.expires !== undefined) { // prepare date if any
+                days = new Date();
+                days.setDate(days.getDate() + options.expires);
+            }
+
+            document.cookie = encode(key) + '=' + encode(val) +
+                (days            ? '; expires=' + days.toUTCString() : '') +
+                (options.path    ? '; path='    + options.path       : '') +
+                (options.domain  ? '; domain='  + options.domain     : '') +
+                (options.secure  ? '; secure'                        : '');
+        }
+    };
+})(this);
+
+// Added
+var colors = jsColorPicker('input.color', {
+    customBG: '#222',
+    readOnly: false,
+    // patch: false,
+    init: function(elm, colors) { // colors is a different instance (not connected to colorPicker)
+        elm.style.backgroundColor = elm.value;
+        elm.style.color = colors.rgbaMixCustom.luminance > 0.22 ? '#222' : '#ddd';
+    },
+    appendTo: document.getElementById("colorPanel"),
+    size: 1,
+});
+
+function openColorFromButton() {
+    delete window.jsColorPicker.confirm;
+    triggerColorPicker('414px', '53px');
+}
+
+function confirmColor() {
+    var colorPicker = document.getElementById("colorPicker");
+    if (window.jsColorPicker.confirm) { /* 存在块 */
+        // 检测需要是合法数值
+        var val = colorPicker.value;
+        if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+,[0-9. ]+$/.test(val)) val = "rgba("+val+")";
+        else if (/^[0-9 ]+,[0-9 ]+,[0-9 ]+$/.test(val)) val = "rgba("+val+",1)";
+        else val = null;
+        if (val) window.jsColorPicker.confirm(val);
+    }
+    else {
+        colorPicker.select();
+        document.execCommand("Copy");
+    }
+
+    triggerColorPicker();
+}
+
+function triggerColorPicker(left, top) {
+    var colorPanel = document.getElementById('colorPanel');
+    if (colorPanel.style.display=='none' && left && top) {
+        colorPanel.style.display = "inline-block";
+        colorPanel.style.left = left;
+        colorPanel.style.top = top;
+        window.jsColorPicker.create();
+    }
+    else {
+        colorPanel.style.display = 'none';
+        delete window.jsColorPicker.confirm;
+    }
+}
+
+Blockly.FieldColour.prototype.createWidget_ = function() {
+    Blockly.WidgetDiv.hide();
+
+    // console.log('here')
+    var self=this;
+    var pb=self.sourceBlock_
+    var args = MotaActionBlocks[pb.type].args
+    var targetf=args[args.indexOf(self.name)-1]
+
+    var getValue=function(){
+        // return self.getValue() // css颜色
+        return pb.getFieldValue(targetf);
+        // 也可以用 pb.getFieldValue(targetf) 获得颜色块左边的域的内容
+    }
+
+    var setValue=function(newValue){ // css颜色
+        self.setValue(newValue)
+        var c=new Colors();
+        c.setColor(newValue)
+        var rgbatext = [c.colors.webSmart.r,c.colors.webSmart.g,c.colors.webSmart.b,c.colors.alpha].join(",");
+        pb.setFieldValue(rgbatext, targetf) // 放在颜色块左边的域中
+    }
+
+    setTimeout(function () {
+        document.getElementById("colorPicker").value = getValue();
+        window.jsColorPicker.confirm = setValue;
+        // 设置位置
+        triggerColorPicker(Blockly.WidgetDiv.DIV.style.left, Blockly.WidgetDiv.DIV.style.top);
+    });
+
+    return document.createElement('table');
+};
+
+Blockly.FieldTextInput.prototype.showInlineEditor_ = function(quietInput) {
+  Blockly.WidgetDiv.show(this, this.sourceBlock_.RTL, this.widgetDispose_());
+  var div = Blockly.WidgetDiv.DIV;
+  // Create the input.
+  var htmlInput =
+      goog.dom.createDom(goog.dom.TagName.INPUT, 'blocklyHtmlInput');
+  htmlInput.setAttribute('spellcheck', this.spellcheck_);
+  var fontSize =
+      (Blockly.FieldTextInput.FONTSIZE * this.workspace_.scale) + 'pt';
+  div.style.fontSize = fontSize;
+  htmlInput.style.fontSize = fontSize;
+
+  Blockly.FieldTextInput.htmlInput_ = htmlInput;
+  div.appendChild(htmlInput);
+
+  htmlInput.value = htmlInput.defaultValue = this.text_;
+  htmlInput.oldValue_ = null;
+  this.validate_();
+  this.resizeEditor_();
+  if (!quietInput) {
+    htmlInput.focus();
+    htmlInput.select();
+  }
+
+  // console.log('here')
+  var self=this;
+  var pb=self.sourceBlock_
+  var args = MotaActionBlocks[pb.type].args
+  var targetf=args[args.indexOf(self.name)+1]
+
+  if(targetf && targetf.slice(0,7)==='Colour_'){
+    var inputDom = htmlInput;
+    // var getValue=function(){ // 获得自己的字符串
+    //     return pb.getFieldValue(self.name);
+    // }
+    var setValue = function(newValue){ // 设置右边颜色块的css颜色
+        pb.setFieldValue(newValue, targetf)
+    }
+    // 给inputDom绑事件
+    inputDom.oninput=function(){
+        var value=inputDom.value
+        if(/[0-9 ]+,[0-9 ]+,[0-9 ]+(,[0-9. ]+)?/.test(value)){
+            setValue('rgba('+value+')')
+        }
+    }
+  }
+
+  this.bindEvents_(htmlInput);
+};

_server/comment.js

@@ -1,382 +0,0 @@
-comment_c456ea59_6018_45ef_8bcc_211a24c627dc = 
-{
-    "_leaf": false,
-    "_type": "object",
-    "_data": {
-        "items": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "items": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "cls": {
-                            "_leaf": true,
-                            "_type": "select",
-                            "_select": {
-                                "values": [
-                                    "keys",
-                                    "items",
-                                    "constants",
-                                    "tools"
-                                ]
-                            },
-                            "_data": "只能取keys(钥匙) items(宝石、血瓶) constants(永久物品) tools(消耗道具)"
-                        },
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_string": true,
-                            "_data": "名称"
-                        },
-                        "text": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_string": true,
-                            "_data": "道具在道具栏中显示的描述"
-                        }
-                    }
-                },
-                "itemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为items的即捡即用类物品的效果。"
-                },
-                "itemEffectTip": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为items的即捡即用类物品，在获得时左上角额外显示的文字。"
-                },
-                "useItemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为tools或contants时的使用物品效果。"
-                },
-                "canUseItemEffect": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_lint": true,
-                    "_data": "cls为tools或contants时对当前能否使用该物品的判断。"
-                }
-            }
-        },
-        "items_template" : {'cls': 'items', 'name': '新物品'},
-        "enemys": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "name": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_string": true,
-                    "_data": "名称"
-                },
-                "hp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "生命值"
-                },
-                "atk": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "攻击力"
-                },
-                "def": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "防御力"
-                },
-                "money": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "金币"
-                },
-                "experience": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经验"
-                },
-                "point": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "加点"
-                },
-                "special": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "特殊属性\n\n0:无,1:先攻,2:魔攻,3:坚固,4:2连击,\n5:3连击,6:n连击,7:破甲,8:反击,9:净化,\n10:模仿,11:吸血,12:中毒,13:衰弱,14:诅咒,\n15:领域,16:夹击,17:仇恨,18:阻击,19:自爆,\n20:无敌,21:退化,22:固伤,23:重生\n\n多个属性例如用[1,4,11]表示先攻2连击吸血\n模仿怪的攻防设为0就好"
-                },
-                "value": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "特殊属性的数值\n领域怪需要加value表示领域伤害的数值\n吸血怪需要在后面添加value代表吸血比例"
-                },
-                "zoneSquare": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "领域怪zoneSquare代表是否九宫格伤害"
-                },
-                "range": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
-                    "_data": "range可选，代表领域伤害的范围；不加默认为1"
-                },
-                "notBomb": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "加入 \"notBomb\": true 代表该怪物不可被炸弹或圣锤炸掉"
-                },
-                "n": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "(thiseval==~~thiseval && thiseval>0)||thiseval==null",
-                    "_data": "多连击需要在后面指定n代表是几连击"
-                },
-                "add": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "代表吸血后是否加到自身"
-                },
-                "atkValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "退化时勇士下降的攻击力点数"
-                },
-                "defValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "退化时勇士下降的防御力点数"
-                },
-                "damage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==~~thiseval||thiseval==null",
-                    "_data": "战前扣血的点数"
-                }
-            }
-        },
-        "enemys_template" : {'name': '新敌人', 'hp': 0, 'atk': 0, 'def': 0, 'money': 0, 'experience': 0, 'point': 0, 'special': 0},
-        "maps": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "id": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块ID"
-                },
-                "idnum": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块数字"
-                },
-                "cls": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "false",
-                    "_data": "图块类别"
-                },
-                "trigger": {
-                    "_leaf": true,
-                    "_type": "select",
-                    "_select": {
-                        "values": [
-                            null,
-                            "openDoor",
-                            "passNet",
-                            "changeLight",
-                            "ski",
-                            "pushBox"
-                        ]
-                    },
-                    "_data": "图块的默认触发器"
-                },
-                "noPass": {
-                    "_leaf": true,
-                    "_type": "select",
-                    "_select": {
-                        "values": [
-                            null,
-                            true,
-                            false
-                        ]
-                    },
-                    "_data": "图块默认可通行状态"
-                }
-            }
-        },
-        "floors": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "floor": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "floorId": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "文件名和floorId需要保持完全一致 \n楼层唯一标识符仅能由字母、数字、下划线组成，且不能由数字开头 \n推荐用法：第20层就用MT20，第38层就用MT38，地下6层就用MT_6（用下划线代替负号），隐藏3层用MT3h（h表示隐藏），等等 \n楼层唯一标识符，需要和名字完全一致 \n这里不能更改floorId,请通过另存为来实现"
-                        },
-                        "title": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "楼层中文名，将在切换楼层和浏览地图时显示"
-                        },
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "显示在状态栏中的层数"
-                        },
-                        "width": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "地图x方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
-                        },
-                        "height": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "false",
-                            "_data": "地图y方向大小,这里不能更改,仅能在新建地图时设置,null视为13"
-                        },
-                        "canFlyTo": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）"
-                        },
-                        "canUseQuickShop": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该层是否允许使用快捷商店"
-                        },
-                        "cannotViewMap": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "该层是否不允许被浏览地图看到；如果勾上则浏览地图会跳过该层"
-                        },
-                        "upFloor": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
-                            "_data": "该层上楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:upFloor，以及楼传器的落点会被替换成该点而不是该层的上楼梯。"
-                        },
-                        "downFloor": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==null||((thiseval instanceof Array) && thiseval.length==2)",
-                            "_data": "该层上楼点，如[2,3]。\n如果此项不为null，则楼层转换时的stair:downFloor，以及楼传器的落点会被替换成该点而不是该层的下楼梯。"
-                        },
-                        "defaultGround": {
-                            "_leaf": true,
-                            "_type": "select",
-                            "_select": {
-                                "values": Object.keys(editor.core.icons.icons.terrains)
-                            },
-                            "_data": "默认地面的图块ID，此项修改后需要刷新才能看到效果。"
-                        },
-                        "images": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "背景/前景图；你可以选择若干张图片来作为背景/前景素材。详细用法请参见文档“自定义素材”中的说明。"
-                        },
-                        "color": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组如[255,0,0,0.3]"
-                        },
-                        "weather": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该层的默认天气。本项可忽略表示晴天，如果写则第一项为\"rain\"或\"snow\"代表雨雪，第二项为1-10之间的数代表强度。\n如[\"rain\", 8]代表8级雨天。"
-                        },
-                        "bgm": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "到达该层后默认播放的BGM。本项可忽略，或者为一个定义过的背景音乐如\"bgm.mp3\"。"
-                        },
-                        "item_ratio": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "(thiseval==~~thiseval && thiseval>=0)||thiseval==null",
-                            "_data": "每一层的宝石/血瓶效果，即获得宝石和血瓶时框内\"ratio\"的值。"
-                        },
-                        "firstArrive": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "firstArrive",
-                            "_data": "第一次到该楼层触发的事件，可以双击进入事件编辑器。"
-                        },
-                        "underGround": {
-                            "_leaf": true,
-                            "_type": "checkbox",
-                            "_bool": "bool",
-                            "_data": "是否是地下层；如果该项为true则同层传送将传送至上楼梯"
-                        }
-                    }
-                },
-                "loc": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "events": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "event",
-                            "_data": "该点的可能事件列表，可以双击进入事件编辑器。"
-                        },
-                        "changeFloor": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "changeFloor",
-                            "_data": "该点楼层转换事件；该事件不能和上面的events同时出现，否则会被覆盖"
-                        },
-                        "afterBattle": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterBattle",
-                            "_data": "该点战斗后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "afterGetItem": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterGetItem",
-                            "_data": "该点获得道具后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "afterOpenDoor": {
-                            "_leaf": true,
-                            "_type": "event",
-                            "_event": "afterOpenDoor",
-                            "_data": "该点开完门后可能触发的事件列表，可以双击进入事件编辑器。"
-                        },
-                        "cannotMove": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "该点不可通行的方向 \n 可以在这里定义该点不能前往哪个方向，可以达到悬崖之类的效果\n例如 [\"up\", \"left\"], // 代表该点不能往上和左走"
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

_server/css/editor.css

@@ -18,6 +18,28 @@ body {
     margin: 0 auto;
 }
 
+.cp-app {
+	z-index: 250;
+}
+
+#colorPanel {
+    position: fixed;
+    width: max-content;
+    height: 205px;
+    z-index: 240;
+    padding: 4px 6px;
+    margin-top: 6px;
+    background-color: #F5F5F5;
+    box-sizing: border-box;
+    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14), 0 3px 1px -2px rgba(0, 0, 0, .2), 0 1px 5px 0 rgba(0, 0, 0, .12);
+}
+
+#colorPicker {
+    margin: 2px 0; 
+    border-radius: 3px;
+    width: 104px;
+}
+
 #left, #mid, #right {
     border-radius: 2px;
     box-sizing: border-box;
@@ -32,10 +54,10 @@ body {
     height: 630px;
 }
 
-#editArea {
+#mapEditArea {
     position: absolute;
     width: 100%;
-    height: 70%;
+    height: 400px;
     left: 0;
     top: 0;
     /* padding: 10px 5px; */
@@ -45,7 +67,7 @@ body {
 #pout {
     display: block;
     width: 410px;
-    height: 100%;
+    height: 380px;
     box-sizing: border-box;
     margin-left: 22px;
     margin-top: 23px;
@@ -61,12 +83,31 @@ body {
 #editTip {
     position: absolute;
     width: 100%;
-    margin-bottom: 120px;
-    bottom: 0;
     left: 10px;
+    top: 430px;
 }
 
-#editArea p {
+#editBtns {
+    position: absolute;
+    width: 100%;
+    left: 10px;
+    top: 465px;
+}
+
+#newMaps {
+    position: absolute;
+    left: 10px;
+    top: 505px;
+}
+
+#newFloors {
+    position: absolute;
+    width: 100%;
+    left: 10px;
+    top: 530px;
+}
+
+#mapEditArea p {
     margin: 10px;
     display: block;
     width: 70%;
@@ -107,7 +148,6 @@ body {
     height: 180px;
     left: 0;
     bottom: 0;
-    border-top: 1px solid #ccc;
     padding: 10px 5px;
     margin-left: 8px;;
     box-sizing: border-box;
@@ -213,6 +253,15 @@ body {
     overflow: auto;
 }
 
+#iconImages {
+    z-index: 0;
+    overflow: hidden;
+}
+
+#iconImages img {
+    position: absolute;
+}
+
 .egameCanvas {
     position: absolute;
 }
@@ -392,3 +441,21 @@ table.row td {
 [v-cloak] {
     display: none !important;
 }
+
+#searchBlock {
+    width: 100px;
+    background-color: #E9EBF2;
+    border-radius: 10px;
+    outline: none;
+    padding-left: 20px;
+    height: 14px;
+}
+
+.searchLogo {
+    width: 15px;
+    height: 15px;
+    position: absolute;
+    left: 6px;
+    top: 6px;
+    background-image:url('data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIGJhc2VQcm9maWxlPSJmdWxsIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWxuczpldj0iaHR0cDovL3d3dy53My5vcmcvMjAwMS94bWwtZXZlbnRzIj4KPGc%2BCgk8cG9seWdvbiBmaWxsPSIjNjY2IiBwb2ludHM9IjkuMjA3LDYuMTI2IDcuNzkzLDcuNTQxIDExLjc5MywxMS41NDEgMTMuMjA3LDEwLjEyNiIgLz4KCTxwYXRoIGZpbGw9IiM2NjYiIGQ9Ik01LjkxNywyYzEuNjA4LDAsMi45MTcsMS4zMDgsMi45MTcsMi45MTdTNy41MjUsNy44MzMsNS45MTcsNy44MzNTMyw2LjUyNSwzLDQuOTE3UzQuMzA4LDIsNS45MTcsMgoJCSBNNS45MTcsMEMzLjIwMSwwLDEsMi4yMDEsMSw0LjkxN3MyLjIwMSw0LjkxNyw0LjkxNyw0LjkxN3M0LjkxNy0yLjIwMSw0LjkxNy00LjkxN0MxMC44MzMsMi4yMDEsOC42MzIsMCw1LjkxNywwTDUuOTE3LDB6IiAvPgo8L2c%2BCjwvc3ZnPgo%3D');
+}

_server/css/editor_mobile.css

@@ -37,7 +37,7 @@ body {
     position: absolute;
 }
 
-#editArea {
+#mapEditArea {
     position: absolute;
     width: 100%;
     height: 70%;
@@ -45,6 +45,7 @@ body {
     top: 0;
     /* padding: 10px 5px; */
     box-sizing: border-box;
+    display: none;
 }
 
 #pout {
@@ -63,7 +64,7 @@ body {
     overflow: auto;
 }
 
-#editArea p {
+#mapEditArea p {
     margin: 10px;
     display: block;
     width: 70%;
@@ -72,12 +73,39 @@ body {
     font-size: 14px;
 }
 
+#editTip {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 4vw;
+}
+
 #editTip .btn {
     float: right;
     margin-right: 20px;
     margin-top: 5px;
 }
 
+#editBtns {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 20vw;
+}
+
+#newMaps {
+    position: absolute;
+    left: 4vw;
+    top: 35vw;
+}
+
+#newFloors {
+    position: absolute;
+    width: 95vw;
+    left: 4vw;
+    top: 43vw;
+}
+
 #mid {
     position: absolute;
 }
@@ -112,7 +140,7 @@ body {
 
 #tip {
     float: right;
-    width: 50%;
+    width: 45%;
     /* height: 95%; */
     min-height: 9rem;
     padding: 5px 10px 10px 10px;
@@ -210,6 +238,15 @@ body {
     overflow: auto;
 }
 
+#iconImages {
+    z-index: 0;
+    overflow: hidden;
+}
+
+#iconImages img {
+    position: absolute;
+}
+
 .egameCanvas {
     position: absolute;
 }
@@ -279,6 +316,7 @@ div.col .coltd {
     width: 95vw;
     height: 16px;
     font-size: 13px;
+    display: none;
 }
 
 #mapColMark {
@@ -334,6 +372,7 @@ div.row .rowtd .rowtext{
     width: 4vw;
     height: 62vw;
     font-size: 12px;
+    display: none;
 }
 
 #mapRowMark {
@@ -426,3 +465,21 @@ div.row .rowtd .rowtext{
     bottom: 0;
     width: 100vw;
 }
+
+#colorPanel {
+    position: fixed;
+    width: max-content;
+    height: 205px;
+    z-index: 240;
+    padding: 4px 6px;
+    margin-top: 6px;
+    background-color: #F5F5F5;
+    box-sizing: border-box;
+    box-shadow: 0 2px 2px 0 rgba(0, 0, 0, .14), 0 3px 1px -2px rgba(0, 0, 0, .2), 0 1px 5px 0 rgba(0, 0, 0, .12);
+}
+
+#colorPicker {
+    margin: 2px 0;
+    border-radius: 3px;
+    width: 90px;
+}

_server/css/editor_mode.css

@@ -32,6 +32,7 @@
     position: fixed;
     top: 15px;
     left: 15px;
+    z-index: 20;
 }
 
 .leftTab .leftTabContent {

_server/data.comment.js

@@ -1,596 +0,0 @@
-data_comment_c456ea59_6018_45ef_8bcc_211a24c627dc = 
-{
-    "_leaf": false,
-    "_type": "object",
-    "_data": {
-        "main": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "floorIds": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在这里按顺序放所有的楼层；其顺序直接影响到楼层传送器、浏览地图和上/下楼器的顺序"
-                },
-                "images": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有可能使用的图片 \n  图片可以被作为背景图（的一部分），也可以直接用自定义事件进行显示。 \n 图片名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好 \n 建议对于较大的图片，在网上使用在线的“图片压缩工具(http://compresspng.com/zh/)”来进行压缩，以节省流量 \n 依次向后添加"
-                },
-                "animates": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有可能使用的动画，必须是animate格式，在这里不写后缀名 \n 动画必须放在animates目录下；文件名不能使用中文，不能带空格或特殊字符 \n \"jianji\", \"thunder\" \n 根据需求自行添加"
-                },
-                "bgms": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有的bgm，和文件名一致。第一项为默认播放项 \n 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
-                },
-                "sounds": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "在此存放所有的SE，和文件名一致 \n 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好"
-                },
-                "startBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "标题界面的背景，建议使用jpg格式以压缩背景图空间"
-                },
-                "startLogoStyle": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "标题样式：可以改变颜色，也可以写\"display: none\"来隐藏标题"
-                },
-                "levelChoose": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "难度选择:每个数组的第一个是其在标题界面显示的难度,第二个是在游戏内部传输的字符串,会显示在状态栏,修改此处后需要在project/functions中作相应更改"
-                },
-                "statusLeftBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "横屏时左侧状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "statusTopBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "竖屏时上方状态栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "toolsBackground": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "竖屏时下方道具栏的背景样式，可以定义背景图、平铺方式等。\n具体请网上搜索\"css background\"了解写法。\n如果弄一张图片作为背景图，推荐写法：\n\"url(project/images/XXX.png) 0 0/100% 100% no-repeat\"\n图片最好进行一些压缩等操作节省流量。"
-                },
-                "borderColor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "边框颜色，包括游戏边界的边框和对话框边框等。"
-                }
-            }
-        },
-        "firstData": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "title": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "游戏名，将显示在标题页面以及切换楼层的界面中"
-                },
-                "name": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "/^[a-zA-Z0-9_]{1,30}$/.test(thiseval)",
-                    "_data": "游戏的唯一英文标识符。由英文、数字、下划线组成，不能超过30个字符。\n此项必须修改，其将直接影响到存档的定位！"
-                },
-                "version": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "当前游戏版本；版本不一致的存档不能通用。"
-                },
-                "floorId": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "初始楼层的ID"
-                },
-                "hero": {
-                    "_leaf": false,
-                    "_type": "object",
-                    "_data": {
-                        "name": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "勇士名；可以改成喜欢的"
-                        },
-                        "lv": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_range": "thiseval==~~thiseval &&thiseval>0",
-                            "_data": "初始等级，该项必须为正整数"
-                        },
-                        "hpmax": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始生命上限，只有在enableHPMax开启时才有效"
-                        },
-                        "hp": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始生命值"
-                        },
-                        "atk": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始攻击"
-                        },
-                        "def": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始防御"
-                        },
-                        "mdef": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始魔防"
-                        },
-                        "money": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始金币"
-                        },
-                        "experience": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始经验"
-                        },
-                        "items": {
-                            "_leaf": false,
-                            "_type": "object",
-                            "_data": {
-                                "keys": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始三种钥匙个数"
-                                },
-                                "constants": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始永久道具个数，例如初始送手册可以写 {\"book\": 1}"
-                                },
-                                "tools": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "初始消耗道具个数，例如初始有两破可以写 {\"pickaxe\": 2}"
-                                }
-                            }
-                        },
-                        "flyRange": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "初始可飞的楼层；一般留空数组即可"
-                        },
-                        "loc": {
-                            "_leaf": false,
-                            "_type": "object",
-                            "_data": {
-                                "direction": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始方向"
-                                },
-                                "x": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始x坐标"
-                                },
-                                "y": {
-                                    "_leaf": true,
-                                    "_type": "textarea",
-                                    "_data": "勇士初始y坐标"
-                                }
-                            }
-                        },
-                        "flags": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "游戏过程中的变量或flags"
-                        },
-                        "steps": {
-                            "_leaf": true,
-                            "_type": "textarea",
-                            "_data": "行走步数统计"
-                        }
-                    }
-                },
-                "startText": {
-                    "_leaf": true,
-                    "_type": "event",
-                    "_event": "firstArrive",
-                    "_data": "游戏开始前剧情。\n可以双击进入事件编辑器。\n如果无剧情直接留一个空数组即可。"
-                },
-                "shops": {
-                    "_leaf": true,
-                    "_type": "event",
-                    "_event": "shop",
-                    "_data": "全局商店，是一个数组，可以双击进入事件编辑器。"
-                },
-                "levelUp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经验升级所需要的数值，是一个数组，可以双击进行编辑。 \n 第一项为初始等级，可以简单留空，也可以写name \n 每一个里面可以含有三个参数 need, name, effect \n need为所需要的经验数值，是一个正整数。请确保need所需的依次递增 \n name为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中 \n effect为本次升级所执行的操作，可由若干项组成，由分号分开 \n 其中每一项写法和上面的商店完全相同，同样必须是X+=Y的形式，Y是一个表达式，同样可以使用status:xxx或item:xxx代表勇士的某项数值/道具个数"
-                }
-            }
-        },
-        "values": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "lavaDamage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "经过血网受到的伤害"
-                },
-                "poisonDamage": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "中毒后每步受到的伤害"
-                },
-                "weakValue": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "衰弱状态下攻防减少的数值\n如果此项不小于1，则作为实际下降的数值（比如10就是攻防各下降10）\n如果在0到1之间则为下降的比例（比如0.3就是下降30%的攻防）"
-                },
-                "redJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "红宝石加攻击的数值"
-                },
-                "blueJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "蓝宝石加防御的数值"
-                },
-                "greenJewel": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "绿宝石加魔防的数值"
-                },
-                "redPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "红血瓶加血数值"
-                },
-                "bluePotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "蓝血瓶加血数值"
-                },
-                "yellowPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "黄血瓶加血数值"
-                },
-                "greenPotion": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "绿血瓶加血数值"
-                },
-                "sword0": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "空剑的攻击力，此项请保持为0"
-                },
-                "shield0": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "空盾的防御力，此项请保持为0"
-                },
-                "sword1": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "铁剑加攻数值"
-                },
-                "shield1": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "铁盾加防数值"
-                },
-                "sword2": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "银剑加攻数值"
-                },
-                "shield2": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "银盾加防数值"
-                },
-                "sword3": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "骑士剑加攻数值"
-                },
-                "shield3": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "骑士盾加防数值"
-                },
-                "sword4": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "圣剑加攻数值"
-                },
-                "shield4": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "圣盾加防数值"
-                },
-                "sword5": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "神圣剑加攻数值"
-                },
-                "shield5": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "神圣盾加防数值"
-                },
-                "moneyPocket": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "金钱袋加金币的数值"
-                },
-                "breakArmor": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "破甲的比例（战斗前，怪物附加角色防御的x倍作为伤害）"
-                },
-                "counterAttack": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "反击的比例（战斗时，怪物每回合附加角色攻击的x倍作为伤害，无视角色防御）"
-                },
-                "purify": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "净化的比例（战斗前，怪物附加勇士魔防的x倍作为伤害）"
-                },
-                "hatred": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "仇恨属性中，每杀死一个怪物获得的仇恨值"
-                },
-                "maxValidHp": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_range": "thiseval==null||thiseval>0",
-                    "_data": "最大合法生命值；如果此项不为null且用户通关血量超过本值，则视为作弊，不上传成绩"
-                },
-                "animateSpeed": {
-                    "_leaf": true,
-                    "_type": "textarea",
-                    "_data": "动画时间，一般300比较合适"
-                }
-            }
-        },
-        "flags": {
-            "_leaf": false,
-            "_type": "object",
-            "_data": {
-                "enableFloor": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示当前楼层"
-                },
-                "enableLv": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示当前等级"
-                },
-                "enableHPMax": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否是否启用生命上限"
-                },
-                "enableMDef": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏及战斗界面显示魔防（护盾）"
-                },
-                "enableMoney": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏、怪物手册及战斗界面显示金币"
-                },
-                "enableExperience": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏、怪物手册及战斗界面显示经验"
-                },
-                "enableLevelUp": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许等级提升（进阶）；如果上面enableExperience为false，则此项恒视为false"
-                },
-                "enableKeys": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示三色钥匙数量"
-                },
-                "enablePZF": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在状态栏显示破炸飞数量"
-                },
-                "enableDebuff": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否涉及毒衰咒；如果此项为false则不会在状态栏中显示毒衰咒的debuff"
-                },
-                "flyNearStair": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否需要在楼梯边使用传送器"
-                },
-                "pickaxeFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用破墙镐是否四个方向都破坏；如果false则只破坏面前的墙壁"
-                },
-                "bombFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用炸弹是否四个方向都会炸；如果false则只炸面前的怪物（即和圣锤等价）"
-                },
-                "snowFourDirections": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "使用冰冻徽章是否四个方向都会消除熔岩；如果false则只消除面前的熔岩"
-                },
-                "bigKeyIsBox": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "如果此项为true，则视为钥匙盒，红黄蓝钥匙+1；若为false，则视为大黄门钥匙"
-                },
-                "equipment": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "剑和盾是否直接作为装备。如果此项为true，则作为装备，需要在道具栏使用，否则将直接加属性。"
-                },
-                /*
-                "enableDeleteItem": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许删除（丢弃）道具"
-                },
-                */
-                "enableAddPoint": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持加点"
-                },
-                "enableNegativeDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持负伤害（回血）"
-                },
-                "hatredDecrease": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在和仇恨怪战斗后减一半的仇恨值，此项为false则和仇恨怪不会扣减仇恨值。"
-                },
-                "betweenAttackCeil": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "夹击方式是向上取整还是向下取整。如果此项为true则为向上取整，为false则为向下取整"
-                },
-                "useLoop": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否循环计算临界；如果此项为true则使用循环法（而不是回合数计算法）来算临界"
-                },
-                "startDirectly": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "点击“开始游戏”后是否立刻开始游戏而不显示难度选择界面"
-                },
-                "canOpenBattleAnimate": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许用户开启战斗过程；如果此项为false，则下面两项均强制视为false"
-                },
-                "showBattleAnimateConfirm": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否在游戏开始时提供“是否开启战斗动画”的选项"
-                },
-                "battleAnimate": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否默认显示战斗动画；用户可以手动在菜单栏中开关"
-                },
-                "displayEnemyDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图怪物显伤；用户可以手动在菜单栏中开关"
-                },
-                "displayCritical": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图显示临界；用户可以手动在菜单栏中开关"
-                },
-                "displayExtraDamage": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否地图高级显伤（领域、夹击等）；用户可以手动在菜单栏中开关"
-                },
-                "enableGentleClick": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许轻触（获得面前物品）"
-                },
-                "potionWhileRouting": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "寻路算法是否经过血瓶；如果该项为false，则寻路算法会自动尽量绕过血瓶"
-                },
-                "enableViewMaps": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否支持在菜单栏中查看所有楼层的地图"
-                },
-                "portalWithoutTrigger": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "经过楼梯、传送门时是否能“穿透”。\n穿透的意思是，自动寻路得到的的路径中间经过了楼梯，行走时是否触发楼层转换事件"
-                },
-                "canGoDeadZone": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许走到将死的领域上。如果此项为true，则可以走到将死的领域上"
-                },
-                "enableMoveDirectly": {
-                    "_leaf": true,
-                    "_type": "checkbox",
-                    "_bool": "bool",
-                    "_data": "是否允许瞬间移动"
-                }
-            }
-        }
-    }
-}

_server/editor_blockly.js

@@ -2,14 +2,19 @@ editor_blockly = function () {
 
     var editor_blockly = {};
 
-    initscript = String.raw`
+/////////////////initscript start/////////////////////////////
+// do not use String.raw because of highlighting
+// Comment tagged templates
+// https://marketplace.visualstudio.com/items?itemName=bierner.comment-tagged-templates
+    initscript = /* js */`
 (function(){
-  var getCategory = function(name){
+  var getCategory = function(name,custom){
     for(var node of document.getElementById('toolbox').children) {
       if(node.getAttribute('name')==name) return node;
     }
     var node = document.createElement('category');
     node.setAttribute('name',name);
+    if(custom)node.setAttribute('custom',custom);
     document.getElementById('toolbox').appendChild(node);
     return node;
   }
@@ -22,17 +27,6 @@ editor_blockly = function () {
         {"type": "hide", "time": 500},
       ],'event'),
       MotaActionBlocks['changeFloor_m'].xmlText(),
-      //MotaActionFunctions.actionParser.parse({"type": "choices", "choices": [
-      //  {"text": "攻击+\${point}", "action": [
-      //    {"type": "setValue", "name": "status:atk", "value": "status:atk+\${point}"},
-      //  ]},
-      //  {"text": "防御+\${2*point}", "action": [
-      //    {"type": "setValue", "name": "status:def", "value": "status:def+\${2*point}"},
-      //  ]},
-      //  {"text": "生命+\${200*point}", "action": [
-      //    {"type": "setValue", "name": "status:hp", "value": "status:hp+\${200*point}"},
-      //  ]},
-      //]},'point'),
       MotaActionFunctions.actionParser.parse([{
         "id": "moneyShop1",
         "name": "贪婪之神", 
@@ -40,45 +34,51 @@ editor_blockly = function () {
         "textInList": "1F金币商店", 
         "use": "money",
         "need": "20+10*times*(times+1)",  
-        "text": "勇敢的武士啊，给我\${need}金币就可以：", 
+        "text": "勇敢的武士啊，给我\\\${need}金币就可以：", 
         "choices": [ 
           {"text": "生命+800", "effect": "status:hp+=800"},
           {"text": "攻击+4", "effect": "status:atk+=4"},
           {"text": "防御+4", "effect": "status:def+=4"},
           {"text": "魔防+10", "effect": "status:mdef+=10"}
         ]
+      },{
+        "id": "keyShop1",
+        "textInList": "回收钥匙商店",
+        "commonEvent": "回收钥匙商店",
+        "args": ""
       }],'shop'),
       MotaActionBlocks['afterBattle_m'].xmlText(),
       MotaActionBlocks['afterGetItem_m'].xmlText(),
       MotaActionBlocks['afterOpenDoor_m'].xmlText(),
       MotaActionBlocks['firstArrive_m'].xmlText(),
+      MotaActionBlocks['eachArrive_m'].xmlText(),
+      MotaActionBlocks['level_m'].xmlText(),
+      MotaActionBlocks['commonEvent_m'].xmlText(),
     ],
     '显示文字':[
       MotaActionBlocks['text_0_s'].xmlText(),
       MotaActionBlocks['text_1_s'].xmlText(),
-      MotaActionFunctions.actionParser.parseList({"type": "choices", "text": "是否跳过剧情", "choices": [
-        {"text": "是", "action": []},
-        {"text": "否", "action": [
-          {"type": "autoText", "text": "\\t[小妖精,fairy]双击方块进入多行编辑\\n用户无法跳过自动剧情文本,大段剧情文本请添加“是否跳过剧情”的提示\\n自动剧情文本\\n自动剧情文本\\n自动剧情文本", "time" :3000},
-          {"type": "autoText", "text": "(可以右键方块后点复制)", "time" :3000},
-        ]},
-      ]}),
+      MotaActionBlocks['comment_s'].xmlText(),
+      MotaActionBlocks['autoText_s'].xmlText(),
+      MotaActionBlocks['scrollText_s'].xmlText(),
       MotaActionBlocks['setText_s'].xmlText(),
-      MotaActionBlocks['showImage_0_s'].xmlText(),
-      MotaActionBlocks['animateImage_0_s'].xmlText(),
-      MotaActionBlocks['animateImage_1_s'].xmlText(),
+      MotaActionBlocks['showImage_s'].xmlText(),
       MotaActionBlocks['showImage_1_s'].xmlText(),
+      MotaActionBlocks['hideImage_s'].xmlText(),
+      MotaActionBlocks['showTextImage_s'].xmlText(),
+      MotaActionBlocks['moveImage_s'].xmlText(),
       MotaActionBlocks['showGif_0_s'].xmlText(),
       MotaActionBlocks['showGif_1_s'].xmlText(),
-      MotaActionBlocks['moveImage_0_s'].xmlText(),
       MotaActionBlocks['tip_s'].xmlText(),
       MotaActionBlocks['win_s'].xmlText(),
       MotaActionBlocks['lose_s'].xmlText(),
+      MotaActionBlocks['restart_s'].xmlText(),
+      MotaActionBlocks['confirm_s'].xmlText(),
       MotaActionBlocks['choices_s'].xmlText([
         '选择剑或者盾','流浪者','man',MotaActionBlocks['choicesContext'].xmlText([
-          '剑',MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [3,3]}]),
+          '剑','','',null,MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [3,3]}]),
           MotaActionBlocks['choicesContext'].xmlText([
-            '盾',MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [9,3]}]),
+            '盾','','',null,MotaActionFunctions.actionParser.parseList([{"type": "openDoor", "loc": [9,3]}]),
           ])
         ])
       ]),
@@ -87,7 +87,15 @@ editor_blockly = function () {
       MotaActionBlocks['setValue_s'].xmlText([
         MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
       ]),
+      MotaActionBlocks['addValue_s'].xmlText([
+        MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
+      ]),
+      MotaActionBlocks['setFloor_s'].xmlText(),
+      MotaActionBlocks['setGlobalAttribute_s'].xmlText(),
+      MotaActionBlocks['setGlobalValue_s'].xmlText(),
+      MotaActionBlocks['setGlobalFlag_s'].xmlText(),
       MotaActionBlocks['input_s'].xmlText(),
+      MotaActionBlocks['input2_s'].xmlText(),
       MotaActionBlocks['update_s'].xmlText(),
       MotaActionBlocks['updateEnemys_s'].xmlText(),
       MotaActionBlocks['moveHero_s'].xmlText(),
@@ -96,49 +104,84 @@ editor_blockly = function () {
       MotaActionBlocks['changePos_0_s'].xmlText(),
       MotaActionBlocks['changePos_1_s'].xmlText(),
       MotaActionBlocks['battle_s'].xmlText(),
-      MotaActionBlocks['openDoor_s'].xmlText(),
+      MotaActionBlocks['useItem_s'].xmlText(),
       MotaActionBlocks['openShop_s'].xmlText(),
-      MotaActionBlocks['setBlock_s'].xmlText(),
+      MotaActionBlocks['disableShop_s'].xmlText(),
       MotaActionBlocks['setHeroIcon_s'].xmlText(),
       MotaActionBlocks['follow_s'].xmlText(),
       MotaActionBlocks['unfollow_s'].xmlText(),
     ],
+    '地图处理':[
+      MotaActionBlocks['battle_1_s'].xmlText(),
+      MotaActionBlocks['openDoor_s'].xmlText(),
+      MotaActionBlocks['closeDoor_s'].xmlText(),
+      MotaActionBlocks['show_s'].xmlText(),
+      MotaActionBlocks['hide_s'].xmlText(),
+      MotaActionBlocks['setBlock_s'].xmlText(),
+      MotaActionBlocks['move_s'].xmlText(),
+      MotaActionBlocks['jump_s'].xmlText(),
+      MotaActionBlocks['showBgFgMap_s'].xmlText(),
+      MotaActionBlocks['hideBgFgMap_s'].xmlText(),
+      MotaActionBlocks['setBgFgBlock_s'].xmlText(),
+      MotaActionBlocks['showFloorImg_s'].xmlText(),
+      MotaActionBlocks['hideFloorImg_s'].xmlText(),
+    ],
     '事件控制':[
       MotaActionBlocks['if_s'].xmlText(),
+      MotaActionBlocks['if_1_s'].xmlText(),
+      MotaActionFunctions.actionParser.parseList({"type": "switch", "condition": "判别值", "caseList": [
+        {"action": [{"type": "comment", "text": "当判别值是值的场合执行此事件"}]},
+        {"action": [], "nobreak": true},
+        {"case": "default", "action": [{"type": "comment", "text": "当没有符合的值的场合执行default事件"}]},
+      ]}),
       MotaActionBlocks['while_s'].xmlText(),
+      MotaActionBlocks['dowhile_s'].xmlText(),
       MotaActionBlocks['break_s'].xmlText(),
       MotaActionBlocks['continue_s'].xmlText(),
       MotaActionBlocks['revisit_s'].xmlText(),
       MotaActionBlocks['exit_s'].xmlText(),
-      MotaActionBlocks['show_s'].xmlText(),
-      MotaActionBlocks['hide_s'].xmlText(),
       MotaActionBlocks['trigger_s'].xmlText(),
-      MotaActionBlocks['move_s'].xmlText(),
-      MotaActionBlocks['jump_s'].xmlText(),
-      MotaActionBlocks['disableShop_s'].xmlText(),
+      MotaActionBlocks['insert_1_s'].xmlText(),
+      MotaActionBlocks['insert_2_s'].xmlText(),
     ],
     '特效/声音':[
       MotaActionBlocks['sleep_s'].xmlText(),
       MotaActionBlocks['wait_s'].xmlText(),
-      MotaActionBlocks['viberate_s'].xmlText(),
+      MotaActionBlocks['waitAsync_s'].xmlText(),
+      MotaActionBlocks['vibrate_s'].xmlText(),
       MotaActionBlocks['animate_s'].xmlText(),
-      MotaActionBlocks['setFg_0_s'].xmlText(),
-      MotaActionBlocks['setFg_1_s'].xmlText(),
+      MotaActionBlocks['showStatusBar_s'].xmlText(),
+      MotaActionBlocks['hideStatusBar_s'].xmlText(),
+      MotaActionBlocks['setCurtain_0_s'].xmlText(),
+      MotaActionBlocks['setCurtain_1_s'].xmlText(),
+      MotaActionBlocks['screenFlash_s'].xmlText(),
       MotaActionBlocks['setWeather_s'].xmlText(),
       MotaActionBlocks['playBgm_s'].xmlText(),
       MotaActionBlocks['pauseBgm_s'].xmlText(),
       MotaActionBlocks['resumeBgm_s'].xmlText(),
+      MotaActionBlocks['loadBgm_s'].xmlText(),
+      MotaActionBlocks['freeBgm_s'].xmlText(),
       MotaActionBlocks['playSound_s'].xmlText(),
+      MotaActionBlocks['stopSound_s'].xmlText(),
       MotaActionBlocks['setVolume_s'].xmlText(),
+      MotaActionBlocks['callBook_s'].xmlText(),
+      MotaActionBlocks['callSave_s'].xmlText(),
+      MotaActionBlocks['autoSave_s'].xmlText(),
+      MotaActionBlocks['callLoad_s'].xmlText(),
     ],
     '原生脚本':[
       MotaActionBlocks['function_s'].xmlText(),
+      MotaActionBlocks['unknown_s'].xmlText(),
     ],
     '值块':[
       MotaActionBlocks['setValue_s'].xmlText([
         MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
       ]),
+      MotaActionBlocks['addValue_s'].xmlText([
+        MotaActionBlocks['idString_1_e'].xmlText(['status','hp'])
+      ]),
       MotaActionBlocks['expression_arithmetic_0'].xmlText(),
+      MotaActionBlocks['evFlag_e'].xmlText(),
       MotaActionBlocks['negate_e'].xmlText(),
       MotaActionBlocks['bool_e'].xmlText(),
       MotaActionBlocks['idString_e'].xmlText(),
@@ -150,34 +193,34 @@ editor_blockly = function () {
       '<label text="检测音乐如果没有开启则系统提示开启"></label>',
       MotaActionFunctions.actionParser.parseList({"type": "if", "condition": "!core.musicStatus.bgmStatus",
         "true": [
-          "\t[系统提示]你当前音乐处于关闭状态，本塔开音乐游戏效果更佳"
+          "\\t[系统提示]你当前音乐处于关闭状态，本塔开音乐游戏效果更佳"
         ],
         "false": []
       }),
       '<label text="商店购买属性/钥匙"></label>',
       MotaActionFunctions.actionParser.parse([
-        {"type": "choices", "text": "\t[老人,man]少年，你需要钥匙吗？\n我这里有大把的！",
+        {"type": "choices", "text": "\\t[老人,man]少年，你需要钥匙吗？\\n我这里有大把的！",
         "choices": [
-            {"text": "黄钥匙（\${9+flag:shop_times}金币）", "action": [
+            {"text": "黄钥匙（\\\${9+flag:shop_times}金币）", "color": [255,255,0,1], "action": [
                 {"type": "if", "condition": "status:money>=9+flag:shop_times",
                     "true": [
-                        {"type": "setValue", "name": "status:money", "value": "status:money-(9+flag:shop_times)"},
-                        {"type": "setValue", "name": "item:yellowKey", "value": "item:yellowKey+1"},
+                        {"type": "addValue", "name": "status:money", "value": "-(9+flag:shop_times)"},
+                        {"type": "addValue", "name": "item:yellowKey", "value": "1"},
                     ],
                     "false": [
-                        "\t[老人,man]你的金钱不足！",
+                        "\\t[老人,man]你的金钱不足！",
                         {"type": "revisit"}
                     ]
                 }
             ]},
-            {"text": "蓝钥匙（\${18+2*flag:shop_times}金币）", "action": [
+            {"text": "蓝钥匙（\\\${18+2*flag:shop_times}金币）", "color": [0,0,255,1], "action": [
             ]},
             {"text": "离开", "action": [
                 {"type": "exit"}
             ]}
         ]
     },
-    {"type": "setValue", "name": "flag:shop_times", "value": "flag:shop_times+1"},
+    {"type": "addValue", "name": "flag:shop_times", "value": "1"},
     {"type": "revisit"}
       ], 'event'),  
       '<label text="战前剧情"></label>',
@@ -200,7 +243,7 @@ editor_blockly = function () {
       ],'afterBattle'),
       '<label text="打怪开门"></label>',
       MotaActionFunctions.actionParser.parse([
-        {"type": "setValue", "name": "flag:__door__", "value": "flag:__door__+1"},
+        {"type": "addValue", "name": "flag:__door__", "value": "1"},
         {"type": "if", "condition": "flag:__door__==2", 
           "true": [
             {"type": "openDoor", "loc": [10,5]}
@@ -227,15 +270,19 @@ editor_blockly = function () {
           }
         ]
       },'event'),
-
     ],
+    '最近使用事件':[
+      '<label text="此处只是占位符,实际定义在editor_blockly.searchBlockCategoryCallback中"></label>',
+    ]
   }
   var toolboxgap = '<sep gap="5"></sep>'
   //xml_text = MotaActionFunctions.actionParser.parse(obj,type||'event')
   //MotaActionBlocks['idString_e'].xmlText()
 
   for (var name in toolboxObj){
-    getCategory(name).innerHTML = toolboxObj[name].join(toolboxgap);
+    var custom = null;
+    if(name=='最近使用事件')custom='searchBlockCategory';
+    getCategory(name,custom).innerHTML = toolboxObj[name].join(toolboxgap);
   }
 
 var blocklyArea = document.getElementById('blocklyArea');
@@ -254,6 +301,23 @@ var workspace = Blockly.inject(blocklyDiv,{
   trashcan: false,
 });
 
+editor_blockly.searchBlockCategoryCallback = function(workspace) {
+  var xmlList = [];
+  var labels = editor_blockly.searchBlock();
+  for (var i = 0; i < labels.length; i++) {
+    var blockText = '<xml>' +
+        MotaActionBlocks[labels[i]].xmlText() +
+        '</xml>';
+    var block = Blockly.Xml.textToDom(blockText).firstChild;
+    block.setAttribute("gap", 5);
+    xmlList.push(block);
+  }
+  return xmlList;
+};
+
+workspace.registerToolboxCategoryCallback(
+  'searchBlockCategory', editor_blockly.searchBlockCategoryCallback);
+ 
 var onresize = function(e) {
   blocklyDiv.style.width = blocklyArea.offsetWidth + 'px';
   blocklyDiv.style.height = blocklyArea.offsetHeight + 'px';
@@ -268,13 +332,17 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
   //console.log(e);
   e.preventDefault();
   var hvScroll = e.shiftKey?'hScroll':'vScroll';
-  workspace.scrollbar[hvScroll].handlePosition_+=( ((e.deltaY||0)+(e.detail||0)) >0?20:-20);
+  var mousewheelOffsetValue=20/380*workspace.scrollbar[hvScroll].handleLength_*3;
+  workspace.scrollbar[hvScroll].handlePosition_+=( ((e.deltaY||0)+(e.detail||0)) >0?mousewheelOffsetValue:-mousewheelOffsetValue);
   workspace.scrollbar[hvScroll].onScroll_();
   workspace.setScale(workspace.scale);
 }
 
 var doubleClickCheck=[[0,'abc']];
 function omitedcheckUpdateFunction(event) {
+  if(event.type==='create'){
+    editor_blockly.addIntoLastUsedType(event.blockId);
+  }
   if(event.type==='ui'){
     var newClick = [new Date().getTime(),event.blockId];
     var lastClick = doubleClickCheck.shift();
@@ -298,7 +366,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
     }
   }
   try {
-    var code = Blockly.JavaScript.workspaceToCode(workspace);
+    var code = Blockly.JavaScript.workspaceToCode(workspace).replace(/\\\\i/g, '\\\\\\\\i');
     codeAreaHL.setValue(code);
   } catch (error) {
     codeAreaHL.setValue(String(error));
@@ -320,8 +388,57 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
   MotaActionFunctions.workspace = function(){
     return editor_blockly.workspace;
   }
+
+  // 因为在editor_blockly.parse里已经HTML转义过一次了,所以这里要覆盖掉以避免在注释中出现&lt;等
+  MotaActionFunctions.xmlText = function (ruleName,inputs,isShadow,comment) {
+    var rule = MotaActionBlocks[ruleName];
+    var blocktext = isShadow?'shadow':'block';
+    var xmlText = [];
+    xmlText.push('<'+blocktext+' type="'+ruleName+'">');
+    if(!inputs)inputs=[];
+    for (var ii=0,inputType;inputType=rule.argsType[ii];ii++) {
+      var input = inputs[ii];
+      var _input = '';
+      var noinput = (input===null || input===undefined);
+      if(noinput && inputType==='field') continue;
+      if(noinput) input = '';
+      if(inputType!=='field') {
+        var subList = false;
+        var subrulename = rule.args[ii];
+        subrulename=subrulename.split('_').slice(0,-1).join('_');
+        var subrule = MotaActionBlocks[subrulename];
+        if (subrule instanceof Array) {
+          subrulename=subrule[subrule.length-1];
+          subrule = MotaActionBlocks[subrulename];
+          subList = true;
+        }
+        _input = subrule.xmlText([],true);
+        if(noinput && !subList && !isShadow) {
+          //无输入的默认行为是: 如果语句块的备选方块只有一个,直接代入方块
+          input = subrule.xmlText();
+        }
+      }
+      xmlText.push('<'+inputType+' name="'+rule.args[ii]+'">');
+      xmlText.push(_input+input);
+      xmlText.push('</'+inputType+'>');
+    }
+    if(comment){
+      xmlText.push('<comment>');
+      xmlText.push(comment);
+      xmlText.push('</comment>');
+    }
+    var next = inputs[rule.args.length];
+    if (next) {//next
+      xmlText.push('<next>');
+      xmlText.push(next);
+      xmlText.push('</next>');
+    }
+    xmlText.push('</'+blocktext+'>');
+    return xmlText.join('');
+  }
 })();
 `;
+/////////////////initscript end  /////////////////////////////
 
     var input_ = '';
     editor_blockly.runOne = function () {
@@ -347,13 +464,13 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
     xhr.onreadystatechange = function () {
         if (xhr.readyState != 4) return;
         if (xhr.status != 200) {
-            alert("无法在file://下加载");
+            alert("图块描述文件加载失败, 请在'启动服务.exe'中打开编辑器");
             return;
         }
         input_ = xhr.responseText;
         editor_blockly.runOne();
     }
-    xhr.open('GET', '_server/blockly/MotaAction.g4', true);
+    xhr.open('GET', '_server/MotaAction.g4', true);
     xhr.send(null);
 
     codeAreaHL = CodeMirror.fromTextArea(document.getElementById("codeArea"), {
@@ -392,7 +509,8 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
         MotaActionFunctions.parse(
             eval('obj=' + codeAreaHL.getValue().replace(/[<>&]/g, function (c) {
                 return {'<': '&lt;', '>': '&gt;', '&': '&amp;'}[c];
-            })),
+            }).replace(/\\r/g, '\\\\r').replace(/\\f/g, '\\\\f')
+                .replace(/\\i/,'\\\\i')),
             document.getElementById('entryType').value
         );
     }
@@ -416,7 +534,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
 
     var blocklyWidgetDiv = document.getElementsByClassName('blocklyWidgetDiv');
     editor_blockly.show = function () {
-        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected = false;
+        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected(false);
         document.getElementById('left6').style = '';
         for (var ii = 0, node; node = blocklyWidgetDiv[ii]; ii++) {
             node.style.zIndex = 201;
@@ -466,6 +584,7 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
             return;
         }
         var code = Blockly.JavaScript.workspaceToCode(editor_blockly.workspace);
+        code = code.replace(/\\i/g, '\\\\i');
         eval('var obj=' + code);
         setvalue(JSON.stringify(obj));
     }
@@ -477,9 +596,13 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
             'text_0_s': 'EvalString_0',
             'text_1_s': 'EvalString_2',
             'autoText_s': 'EvalString_2',
+            'scrollText_s': 'EvalString_0',
+            'comment_s': 'EvalString_0',
             'choices_s': 'EvalString_0',
+            'showTextImage_s': 'EvalString_0',
             'function_s': 'RawEvalString_0',
             'shopsub': 'EvalString_3',
+            'confirm_s': 'EvalString_0',
         }
         var f = b ? textStringDict[b.type] : null;
         if (f) {
@@ -493,6 +616,98 @@ document.getElementById('blocklyDiv').onmousewheel = function(e){
         }
     }
 
+    editor_blockly.lastUsedType=[
+        'text_0_s',
+        'comment_s',
+        'show_s',
+        'hide_s',
+        'setValue_s',
+        'if_s',
+        'battle_s',
+        'openDoor_s',
+        'choices_s',
+        'setText_s',
+        'exit_s',
+        'revisit_s',
+        'sleep_s',
+        'setBlock_s',
+        'insert_1_s'
+    ]; // 最常用的15个图块
+    editor_blockly.lastUsedTypeNum=15;
+
+    editor_blockly.addIntoLastUsedType=function(blockId) {
+        var b = editor_blockly.workspace.getBlockById(blockId);
+        if(!b)return;
+        var blockType = b.type;
+        if(!blockType || blockType.indexOf("_s")!==blockType.length-2 || blockType==='pass_s')return;
+        editor_blockly.lastUsedType = editor_blockly.lastUsedType.filter(function (v) {return v!==blockType;});
+        if (editor_blockly.lastUsedType.length >= editor_blockly.lastUsedTypeNum)
+            editor_blockly.lastUsedType.pop();
+        editor_blockly.lastUsedType.unshift(blockType);
+
+        document.getElementById("searchBlock").value='';
+    }
+
+    // Index from 1 - 9
+    editor_blockly.openToolbox = function(index) {
+        // var element = document.getElementById(':'+index);
+        // if (element == null || element.getAttribute("aria-selected")=="true") return;
+        // element.click();
+        editor_blockly.workspace.toolbox_.tree_.setSelectedItem(editor_blockly.workspace.toolbox_.tree_.children_[index-1]);
+    }
+    editor_blockly.reopenToolbox = function(index) {
+        // var element = document.getElementById(':'+index);
+        // if (element == null) return;
+        // if (element.getAttribute("aria-selected")=="true") element.click();
+        // element.click();
+        editor_blockly.workspace.toolbox_.tree_.setSelectedItem(editor_blockly.workspace.toolbox_.tree_.children_[index-1]);
+        editor_blockly.workspace.getFlyout_().show(editor_blockly.workspace.toolbox_.tree_.children_[index-1].blocks);
+    }
+
+    editor_blockly.closeToolbox = function() {
+        /*
+        for (var i=1; i<=10; i++) {
+            var element = document.getElementById(':'+i);
+            if (element && element.getAttribute("aria-selected")=="true") {
+                element.click();
+                return;
+            }
+        }
+        */
+        editor_blockly.workspace.toolbox_.clearSelection();
+    }
+
+    var searchInput = document.getElementById("searchBlock");
+    searchInput.onfocus = function () {
+        editor_blockly.reopenToolbox(10);
+    }
+
+    searchInput.oninput = function () {
+        editor_blockly.reopenToolbox(10);
+    }
+
+    editor_blockly.searchBlock = function (value) {
+        if (value == null) value = searchInput.value;
+        value = value.toLowerCase();
+        if (value == '') return editor_blockly.lastUsedType;
+        var results = [];
+        for (var name in MotaActionBlocks) {
+            if (typeof name !== 'string' || name.indexOf("_s") !== name.length-2) continue;
+            var block = MotaActionBlocks[name];
+            if(block && block.json) {
+                if ((block.json.type||"").toLowerCase().indexOf(value)>=0
+                    || (block.json.message0||"").toLowerCase().indexOf(value)>=0
+                    || (block.json.tooltip||"").toLowerCase().indexOf(value)>=0) {
+                    results.push(name);
+                    if (results.length>=editor_blockly.lastUsedTypeNum)
+                        break;
+                }
+            }
+        }
+
+        return results.length == 0 ? editor_blockly.lastUsedType : results;
+    }
+
     return editor_blockly;
 }
 //editor_blockly=editor_blockly();

_server/editor_file.js

@@ -1,12 +1,16 @@
-editor_file = function (editor, callback) {
-
-    var editor_file = {};
+editor_file_wrapper = function (editor) {
+    editor_file_proto = function () {
 
+    }
 
+    // 这个函数之后挪到editor.table?
+    editor_file_proto.prototype.loadCommentjs=function(callback){
         var commentjs = {
             'comment': 'comment',
             'data.comment': 'dataComment',
             'functions.comment': 'functionsComment',
+            'events.comment': 'eventsComment',
+            'plugins.comment': 'pluginsComment',
         }
         for (var key in commentjs) {
             (function (key) {
@@ -15,867 +19,19 @@ editor_file = function (editor, callback) {
                 if (window.location.href.indexOf('_server') !== -1)
                     script.src = key + '.js';
                 else
-                script.src = '_server/' + key + '.js';
+                    script.src = '_server/table/' + key + '.js';
                 document.body.appendChild(script);
                 script.onload = function () {
-                editor_file[value] = eval(key.replace('.', '_') + '_c456ea59_6018_45ef_8bcc_211a24c627dc');
+                    editor.file[value] = eval(key.replace('.', '_') + '_c456ea59_6018_45ef_8bcc_211a24c627dc');
                     var loaded = Boolean(callback);
                     for (var key_ in commentjs) {
-                    loaded = loaded && editor_file[commentjs[key_]]
+                        loaded = loaded && editor.file[commentjs[key_]]
                     }
                     if (loaded) callback();
                 }
             })(key);
         }
+    }
 
 
-    editor_file.getFloorFileList = function (callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
 }
-        ;
-        /* var fs = editor.fs;
-        fs.readdir('project/floors',function(err, data){
-          callback([data,err]);
-        }); */
-        callback([editor.core.floorIds, null]);
-    }
-    //callback([Array<String>,err:String])
-    editor_file.loadFloorFile = function (filename, callback) {
-        //filename不含'/'不含'.js'
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        /* var fs = editor.fs;
-        fs.readFile('project/floors/'+filename+'.js','utf-8',function(err, data){
-          if (err!=null){callback(err);return;}
-          data=data.split('=');
-          data=[data[0],data.slice(1).join('=')];
-          var varnameId = data[0].split('.').slice(-1)[0].trim();
-          var filenameId = filename.split('/').slice(-1)[0].split('\\').slice(-1)[0];
-          eval('b3917d1d_71c2_41f2_a8aa_481b215ffb99='+data[1]);
-          var floorData = b3917d1d_71c2_41f2_a8aa_481b215ffb99;
-          delete(b3917d1d_71c2_41f2_a8aa_481b215ffb99);
-          var floorId = floorData.floorId;
-          if (varnameId!=filenameId || filenameId!=floorId){
-            callback('文件名,第一行的变量名以及floorId不一致');
-            return;
-          }
-          editor.currentFloorId = floorId;
-          editor.currentFloorData = floorData;
-          callback(null)
-        }); */
-        editor.currentFloorId = editor.core.status.floorId;
-        editor.currentFloorData = editor.core.floors[editor.currentFloorId];
-    }
-    //callback(err:String)
-    editor_file.saveFloorFile = function (callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        /* if (!isset(editor.currentFloorId) || !isset(editor.currentFloorData)) {
-          callback('未选中文件或无数据');
-        } */
-        var filename = 'project/floors/' + editor.currentFloorId + '.js';
-        var datastr = ['main.floors.', editor.currentFloorId, '=\n{'];
-        if (editor.currentFloorData.map == 'new') {
-            /*
-            editor.currentFloorData.map = editor.map.map(function (v) {
-                return v.map(function () {
-                    return 0
-                })
-            });
-            */
-            var width = parseInt(document.getElementById('newMapWidth').value);
-            var height = parseInt(document.getElementById('newMapHeight').value);
-            var row = [];
-            for (var i=0;i<width;i++) row.push(0);
-            editor.currentFloorData.map = [];
-            for (var i=0;i<height;i++) editor.currentFloorData.map.push(row);
-        }
-        else
-            editor.currentFloorData.map = editor.map.map(function (v) {
-                return v.map(function (v) {
-                    return v.idnum || v || 0
-                })
-            });
-        for (var ii in editor.currentFloorData)
-            if (editor.currentFloorData.hasOwnProperty(ii)) {
-                if (ii == 'map')
-                    datastr = datastr.concat(['\n"', ii, '": [\n', formatMap(editor.currentFloorData[ii]), '\n],']);
-                else
-                    datastr = datastr.concat(['\n"', ii, '": ', JSON.stringify(editor.currentFloorData[ii], null, 4), ',']);
-            }
-        datastr = datastr.concat(['\n}']);
-        datastr = datastr.join('');
-        alertWhenCompress();
-        fs.writeFile(filename, encode(datastr), 'base64', function (err, data) {
-            callback(err);
-        });
-    }
-    //callback(err:String)
-    editor_file.saveNewFile = function (saveFilename, callback) {
-        //saveAsFilename不含'/'不含'.js'
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        };
-        var currData=editor.currentFloorData;
-        var saveStatus = document.getElementById('newMapStatus').checked;
-        editor.currentFloorData = {
-            floorId: saveFilename,
-            title: saveStatus?currData.title:"新建楼层",
-            name: saveStatus?currData.name:"0",
-            width: parseInt(document.getElementById('newMapWidth').value),
-            height: parseInt(document.getElementById('newMapHeight').value),
-            canFlyTo: saveStatus?currData.canFlyTo:true,
-            canUseQuickShop: saveStatus?currData.canUseQuickShop:true,
-            cannotViewMap: saveStatus?currData.cannotViewMap:false,
-            images: [],
-            item_ratio: saveStatus?currData.item_ratio:1,
-            defaultGround: saveStatus?currData.defaultGround:"ground",
-            bgm: saveStatus?currData.bgm:null,
-            upFloor: null,
-            downFloor: null,
-            color: saveStatus?currData.color:null,
-            weather: saveStatus?currData.weather:null,
-            firstArrive: [],
-            events: {},
-            changeFloor: {},
-            afterBattle: {},
-            afterGetItem: {},
-            afterOpenDoor: {},
-            cannotMove: {}
-        };
-        Object.keys(editor.currentFloorData).forEach(function (t) {
-            if (!core.isset(editor.currentFloorData[t]))
-                delete editor.currentFloorData[t];
-        })
-        editor.currentFloorData.map = "new";
-        editor.currentFloorId = saveFilename;
-        editor_file.saveFloorFile(callback);
-    }
-    //callback(err:String)
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.autoRegister = function (info, callback) {
-
-        var iconActions = [];
-        var mapActions = [];
-        var templateActions = [];
-
-        var image = info.images;
-
-        if (image=='autotile') {
-            callback('不能对自动元件进行自动注册！');
-            return;
-        }
-        var c=image.toUpperCase().charAt(0);
-
-        // terrains id
-        var terrainsId = [];
-        Object.keys(core.material.icons.terrains).forEach(function (id) {
-            terrainsId[core.material.icons.terrains[id]]=id;
-        })
-
-        var allIds = [];
-        editor.ids.forEach(function (v) {
-            if (v.images==image) {
-                allIds[v.y]=true;
-            }
-        })
-
-        var per_height = image.indexOf('48')>=0?48:32;
-
-        var idnum=300;
-        for (var y=0; y<editor.widthsX[image][3]/per_height;y++) {
-            if (allIds[y]) continue;
-            while (editor.core.maps.blocksInfo[idnum]) idnum++;
-
-            // get id num
-            var id = c+idnum;
-
-            if (image=='terrains' && core.isset(terrainsId[y])) {
-                id=terrainsId[y];
-            }
-            else {
-                iconActions.push(["add", "['" + image + "']['" + id + "']", y])
-            }
-            mapActions.push(["add", "['" + idnum + "']", {'cls': image, 'id': id}])
-            if (image=='items')
-                templateActions.push(["add", "['items']['" + id + "']", editor_file.comment._data.items_template]);
-            else if (image.indexOf('enemy')==0)
-                templateActions.push(["add", "['" + id + "']", editor_file.comment._data.enemys_template]);
-            idnum++;
-        }
-
-        if (mapActions.length==0) {
-            callback("没有要注册的项！");
-            return;
-        }
-
-        var templist = [];
-        var tempcallback = function (err) {
-            templist.push(err);
-            if (templist.length == 3) {
-                if (templist[0] != null || templist[1] != null || templist[2] != null)
-                    callback((templist[0] || '') + '\n' + (templist[1] || '') + '\n' + (templist[2] || ''));
-                //这里如果一个成功一个失败会出严重bug
-                else
-                    callback(null);
-            }
-        }
-        if (iconActions.length>0)
-            saveSetting('icons', iconActions, tempcallback);
-        else tempcallback(null);
-
-        saveSetting('maps', mapActions, tempcallback);
-
-        if (image=='items')
-            saveSetting('items', templateActions, tempcallback);
-        else if (image.indexOf('enemy')==0)
-            saveSetting('enemys', templateActions, tempcallback);
-        else tempcallback(null);
-    }
-
-    editor_file.changeIdAndIdnum = function (id, idnum, info, callback) {
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        //检查maps中是否有重复的idnum或id
-        var change = -1;
-        for (var ii in editor.core.maps.blocksInfo) {
-            if (ii == idnum) {
-                //暂时只允许创建新的不允许修改已有的
-                //if (info.idnum==idnum){change=ii;break;}//修改id
-                callback('idnum重复了');
-                return;
-            }
-            if (editor.core.maps.blocksInfo[ii].id == id) {
-                //if (info.id==id){change=ii;break;}//修改idnum
-                callback('id重复了');
-                return;
-            }
-        }
-        /*
-        if (change!=-1 && change!=idnum){//修改idnum
-          editor.core.maps.blocksInfo[idnum] = editor.core.maps.blocksInfo[change];
-          delete(editor.core.maps.blocksInfo[change]);
-        } else if (change==idnum) {//修改id
-          var oldid = editor.core.maps.blocksInfo[idnum].id;
-          editor.core.maps.blocksInfo[idnum].id = id;
-          for(var ii in editor.core.icons.icons){
-            if (ii.hasOwnProperty(oldid)){
-              ii[id]=ii[oldid];
-              delete(ii[oldid]);
-            }
-          }
-        } else {//创建新的
-          editor.core.maps.blocksInfo[idnum]={'cls': info.images, 'id':id};
-          editor.core.icons.icons[info.images][id]=info.y;
-        }
-        */
-        var templist = [];
-        var tempcallback = function (err) {
-            templist.push(err);
-            if (templist.length == 2) {
-                if (templist[0] != null || templist[1] != null)
-                    callback((templist[0] || '') + '\n' + (templist[1] || ''));
-                //这里如果一个成功一个失败会出严重bug
-                else
-                    callback(null);
-            }
-        }
-        saveSetting('maps', [["add", "['" + idnum + "']", {'cls': info.images, 'id': id}]], tempcallback);
-        saveSetting('icons', [["add", "['" + info.images + "']['" + id + "']", info.y]], tempcallback);
-        if (info.images === 'items') {
-            saveSetting('items', [["add", "['items']['" + id + "']", editor_file.comment._data.items_template]], function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-            });
-        }
-        if (info.images === 'enemys' || info.images === 'enemy48') {
-            saveSetting('enemys', [["add", "['" + id + "']", editor_file.comment._data.enemys_template]], function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-            });
-        }
-
-        callback(null);
-    }
-    //callback(err:String)
-    editor_file.editItem = function (id, actionList, callback) {
-        /*actionList:[
-          ["change","['items']['name']","红宝石的新名字"],
-          ["add","['items']['新的和name同级的属性']",123],
-          ["change","['itemEffectTip']","'，攻击力+'+editor.core.values.redJewel"],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                var tempindex = value[1].indexOf(']') + 1;
-                value[1] = [value[1].slice(0, tempindex), "['" + id + "']", value[1].slice(tempindex)].join('');
-            });
-            saveSetting('items', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj_ = {};
-                        Object.keys(editor_file.comment._data.items._data).forEach(function (v) {
-                            if (isset(editor.core.items[v][id]) && v !== 'items')
-                                locObj_[v] = editor.core.items[v][id];
-                            else
-                                locObj_[v] = null;
-                        });
-                        locObj_['items'] = (function () {
-                            var locObj = Object.assign({}, editor.core.items.items[id]);
-                            Object.keys(editor_file.comment._data.items._data.items._data).forEach(function (v) {
-                                if (!isset(editor.core.items.items[id][v]))
-                                    locObj[v] = null;
-                            });
-                            return locObj;
-                        })();
-                        return locObj_;
-                    })(),
-                    editor_file.comment._data.items,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj_ = {};
-                    Object.keys(editor_file.comment._data.items._data).forEach(function (v) {
-                        if (isset(editor.core.items[v][id]) && v !== 'items')
-                            locObj_[v] = editor.core.items[v][id];
-                        else
-                            locObj_[v] = null;
-                    });
-                    locObj_['items'] = (function () {
-                        var locObj = Object.assign({}, editor.core.items.items[id]);
-                        Object.keys(editor_file.comment._data.items._data.items._data).forEach(function (v) {
-                            if (!isset(editor.core.items.items[id][v]))
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })();
-                    return locObj_;
-                })(),
-                editor_file.comment._data.items,
-                null]);
-        }
-        //只有items.cls是items的才有itemEffect和itemEffectTip,keys和constants和tools只有items
-    }
-    //callback([obj,commentObj,err:String])
-    editor_file.editEnemy = function (id, actionList, callback) {
-        /*actionList:[
-          ["change","['name']","初级巫师的新名字"],
-          ["add","['新的和name同级的属性']",123],
-          ["change","['bomb']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = "['" + id + "']" + value[1];
-            });
-            saveSetting('enemys', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
-                        Object.keys(editor_file.comment._data.enemys._data).forEach(function (v) {
-                            if (!isset(editor.core.enemys.enemys[id][v]))
-                            /* locObj[v]=editor.core.enemys.enemys[id][v];
-                          else */
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.enemys,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
-                    Object.keys(editor_file.comment._data.enemys._data).forEach(function (v) {
-                        if (!isset(editor.core.enemys.enemys[id][v]))
-                        /* locObj[v]=editor.core.enemys.enemys[id][v];
-                      else */
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.comment._data.enemys,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    editor_file.editMapBlocksInfo = function (idnum, actionList, callback) {
-        /*actionList:[
-          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
-          ["change","['afterBattle']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = "['" + idnum + "']" + value[1];
-            });
-            saveSetting('maps', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.core.maps.blocksInfo[idnum]);
-                        Object.keys(editor_file.comment._data.maps._data).forEach(function (v) {
-                            if (!isset(editor.core.maps.blocksInfo[idnum][v]))
-                                locObj[v] = null;
-                        });
-                        locObj.idnum = idnum;
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.maps,
-                    null]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.core.maps.blocksInfo[idnum]);
-                    Object.keys(editor_file.comment._data.maps._data).forEach(function (v) {
-                        if (!isset(editor.core.maps.blocksInfo[idnum][v]))
-                            locObj[v] = null;
-                    });
-                    locObj.idnum = idnum;
-                    return locObj;
-                })(),
-                editor_file.comment._data.maps,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editLoc = function (x, y, actionList, callback) {
-        /*actionList:[
-          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
-          ["change","['afterBattle']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            actionList.forEach(function (value) {
-                value[1] = value[1] + "['" + x + "," + y + "']";
-            });
-            saveSetting('floors', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = {};
-                        Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                            if (isset(editor.currentFloorData[v][x + ',' + y]))
-                                locObj[v] = editor.currentFloorData[v][x + ',' + y];
-                            else
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.floors._data.loc,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = {};
-                    Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                        if (isset(editor.currentFloorData[v][x + ',' + y]))
-                            locObj[v] = editor.currentFloorData[v][x + ',' + y];
-                        else
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.comment._data.floors._data.loc,
-                null]);
-        }
-
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editFloor = function (actionList, callback) {
-        /*actionList:[
-          ["change","['title']",'样板 3 层'],
-          ["change","['color']",null],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('floors', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = Object.assign({}, editor.currentFloorData);
-                        Object.keys(editor_file.comment._data.floors._data.floor._data).forEach(function (v) {
-                            if (!isset(editor.currentFloorData[v]))
-                            /* locObj[v]=editor.currentFloorData[v];
-                          else */
-                                locObj[v] = null;
-                        });
-                        Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                            delete(locObj[v]);
-                        });
-                        delete(locObj.map);
-                        return locObj;
-                    })(),
-                    editor_file.comment._data.floors._data.floor,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = Object.assign({}, editor.currentFloorData);
-                    Object.keys(editor_file.comment._data.floors._data.floor._data).forEach(function (v) {
-                        if (!isset(editor.currentFloorData[v]))
-                        /* locObj[v]=editor.currentFloorData[v];
-                      else */
-                            locObj[v] = null;
-                    });
-                    Object.keys(editor_file.comment._data.floors._data.loc._data).forEach(function (v) {
-                        delete(locObj[v]);
-                    });
-                    delete(locObj.map);
-                    return locObj;
-                })(),
-                editor_file.comment._data.floors._data.floor,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    editor_file.editTower = function (actionList, callback) {
-        /*actionList:[
-          ["change","['firstData']['version']",'Ver 1.0.1 (Beta)'],
-          ["change","['values']['lavaDamage']",200],
-        ]
-        为[]时只查询不修改
-        */
-        var data_obj = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('data', actionList, function (err) {
-                callback([
-                    (function () {
-                        //var locObj=Object.assign({'main':{}},editor.core.data);
-                        var locObj = Object.assign({}, data_obj, {'main': {}});
-                        Object.keys(editor_file.dataComment._data.main._data).forEach(function (v) {
-                            if (isset(editor.main[v]))
-                                locObj.main[v] = data_obj.main[v];
-                            else
-                                locObj[v] = null;
-                        });
-                        return locObj;
-                    })(),
-                    editor_file.dataComment,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    //var locObj=Object.assign({'main':{}},editor.core.data);
-                    var locObj = Object.assign({}, data_obj, {'main': {}});
-                    Object.keys(editor_file.dataComment._data.main._data).forEach(function (v) {
-                        if (isset(editor.main[v]))
-                            locObj.main[v] = data_obj.main[v];
-                        else
-                            locObj[v] = null;
-                    });
-                    return locObj;
-                })(),
-                editor_file.dataComment,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    var fmap = {};
-    var fjson = JSON.stringify(functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a, function (k, v) {
-        if (v instanceof Function) {
-            var id_ = editor.guid();
-            fmap[id_] = v.toString();
-            return id_;
-        } else return v
-    }, 4);
-    var fobj = JSON.parse(fjson);
-    editor_file.functionsMap = fmap;
-    editor_file.functionsJSON = fjson;
-    var buildlocobj = function (locObj) {
-        for (var key in locObj) {
-            if (typeof(locObj[key]) !== typeof('')) buildlocobj(locObj[key]);
-            else locObj[key] = fmap[locObj[key]];
-        }
-    };
-
-    editor_file.editFunctions = function (actionList, callback) {
-        /*actionList:[
-          ["change","['events']['afterChangeLight']","function(x,y){console.log(x,y)}"],
-          ["change","['ui']['drawAbout']","function(){...}"],
-        ]
-        为[]时只查询不修改
-        */
-        if (!isset(callback)) {
-            printe('未设置callback');
-            throw('未设置callback')
-        }
-        ;
-        if (isset(actionList) && actionList.length > 0) {
-            saveSetting('functions', actionList, function (err) {
-                callback([
-                    (function () {
-                        var locObj = JSON.parse(fjson);
-                        buildlocobj(locObj);
-                        return locObj;
-                    })(),
-                    editor_file.functionsComment,
-                    err]);
-            });
-        } else {
-            callback([
-                (function () {
-                    var locObj = JSON.parse(fjson);
-                    buildlocobj(locObj);
-                    return locObj;
-                })(),
-                editor_file.functionsComment,
-                null]);
-        }
-    }
-    //callback([obj,commentObj,err:String])
-
-    ////////////////////////////////////////////////////////////////////
-
-    var isset = function (val) {
-        if (val == undefined || val == null) {
-            return false;
-        }
-        return true
-    }
-
-    var formatMap = function (mapArr) {
-        //把二维数组格式化
-        var formatArrStr = '';
-        var arr = JSON.stringify(mapArr).replace(/\s+/g, '').split('],[');
-        var si=mapArr.length-1,sk=mapArr[0].length-1;
-        for (var i = 0; i <= si; i++) {
-            var a = [];
-            formatArrStr += '    [';
-            if (i == 0 || i == si) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
-            else a = arr[i].split(/\D+/);
-            for (var k = 0; k <= sk; k++) {
-                var num = parseInt(a[k]);
-                formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk ? '' : ',');
-            }
-            formatArrStr += ']' + (i == si ? '' : ',\n');
-        }
-        return formatArrStr;
-    }
-
-    var encode = function (str) {
-        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
-            return String.fromCharCode(parseInt(p1, 16))
-        }))
-    }
-
-    var alertWhenCompress = function(){
-        if(editor.useCompress===true){
-            editor.useCompress=null;
-            setTimeout("alert('当前游戏使用的是压缩文件,修改完成后请重新压缩')",1000)
-        }
-    }
-
-    var saveSetting = function (file, actionList, callback) {
-        //console.log(file);
-        //console.log(actionList);
-        alertWhenCompress();
-
-        if (file == 'icons') {
-            actionList.forEach(function (value) {
-                eval("icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = \n';
-            datastr += JSON.stringify(icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1, null, '\t');
-            fs.writeFile('project/icons.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'maps') {
-            actionList.forEach(function (value) {
-                eval("maps_90f36752_8815_4be8_b32b_d7fad1d0542e" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'maps_90f36752_8815_4be8_b32b_d7fad1d0542e = \n';
-            //datastr+=JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e,null,4);
-
-            var emap = {};
-            var estr = JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e, function (k, v) {
-                if (v.id != null) {
-                    var id_ = editor.guid();
-                    emap[id_] = JSON.stringify(v);
-                    return id_;
-                } else return v
-            }, '\t');
-            for (var id_ in emap) {
-                estr = estr.replace('"' + id_ + '"', emap[id_])
-            }
-            datastr += estr;
-
-            fs.writeFile('project/maps.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'items') {
-            actionList.forEach(function (value) {
-                eval("items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = \n';
-            datastr += JSON.stringify(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a, null, '\t');
-            fs.writeFile('project/items.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'enemys') {
-            actionList.forEach(function (value) {
-                eval("enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            var datastr = 'enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = \n';
-            var emap = {};
-            var estr = JSON.stringify(enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80, function (k, v) {
-                if (v.hp != null) {
-                    var id_ = editor.guid();
-                    emap[id_] = JSON.stringify(v);
-                    return id_;
-                } else return v
-            }, '\t');
-            for (var id_ in emap) {
-                estr = estr.replace('"' + id_ + '"', emap[id_])
-            }
-            datastr += estr;
-            fs.writeFile('project/enemys.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'data') {
-            actionList.forEach(function (value) {
-                eval("data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            if (data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds.indexOf(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId) < 0)
-                data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds[0];
-            var datastr = 'data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = \n';
-            datastr += JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, null, '\t');
-            fs.writeFile('project/data.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'functions') {
-            actionList.forEach(function (value) {
-                eval("fmap[fobj" + value[1] + ']=' + JSON.stringify(value[2]));
-            });
-            var fraw = fjson;
-            for (var id_ in fmap) {
-                fraw = fraw.replace('"' + id_ + '"', fmap[id_])
-            }
-            var datastr = 'functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = \n';
-            datastr += fraw;
-            fs.writeFile('project/functions.js', encode(datastr), 'base64', function (err, data) {
-                callback(err);
-            });
-            return;
-        }
-        if (file == 'floors') {
-            actionList.forEach(function (value) {
-                eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
-            });
-            editor_file.saveFloorFile(callback);
-            return;
-        }
-        callback('出错了,要设置的文件名不识别');
-    }
-
-    /*
-    $select({\"values\":[\"keys\",\"items\",\"constants\",\"tools\"]})$end
-    $range(thiseval==~~thiseval &&thiseval>0)$end
-    $leaf(true)$end
-    $select({\"values\":[true]})$end
-    $select({\"values\":[false]})$end
-    $select({\"values\":[true,false]})$end
-
-    */
-
-    /*
-    所有注释中的特殊指令
-    $range(evalstr:thiseval)$end
-      限制取值范围,要求修改后的eval(evalstr)为true
-    $leaf(evalstr:thiseval)$end
-      强制指定为叶节点,如果eval(evalstr)为true
-
-    //以下几个中选一个 [
-    $select(evalstr)$end
-      渲染成<select>,选项为数组eval(evalstr)['values']
-    $input(evalstr)$end
-      渲染成<input>
-    $textarea(evalstr)$end
-      渲染成<textarea>
-    默认选项为$textarea()$end
-    // ]
-
-    */
-    return editor_file;
-}
-//editor_file = editor_file(editor);

_server/editor_file_unsorted.js

@@ -0,0 +1,913 @@
+editor_file = function (editor, callback) {
+
+    var editor_file = new editor_file_proto();
+    editor.file=editor_file;
+
+    editor.file.loadCommentjs(callback);
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    editor.file.saveFloorFile = function (callback) {
+        checkCallback(callback);
+        /* if (!isset(editor.currentFloorId) || !isset(editor.currentFloorData)) {
+          callback('未选中文件或无数据');
+        } */
+        var filename = 'project/floors/' + editor.currentFloorId + '.js';
+        var datastr = ['main.floors.', editor.currentFloorId, '=\n'];
+
+        for(var ii=0,name;name=['map','bgmap','fgmap'][ii];ii++){
+            var mapArray=editor[name].map(function (v) {
+                return v.map(function (v) {
+                    return v.idnum || v || 0
+                })
+            });
+            editor.currentFloorData[name]=mapArray;
+        }
+        
+        // format 更改实现方式以支持undefined删除
+        var tempJsonObj=Object.assign({},editor.currentFloorData);
+        var tempMap=[['map',editor.util.guid()],['bgmap',editor.util.guid()],['fgmap',editor.util.guid()]];
+        tempMap.forEach(function(v){
+            v[2]=tempJsonObj[v[0]];
+            tempJsonObj[v[0]]=v[1];
+        });
+        var tempJson=JSON.stringify(tempJsonObj, null, 4);
+        tempMap.forEach(function(v){
+            tempJson=tempJson.replace('"'+v[1]+'"','[\n'+ formatMap(v[2],v[0]!='map')+ '\n]')
+        });
+        datastr = datastr.concat([tempJson]);
+        datastr = datastr.join('');
+        alertWhenCompress();
+        fs.writeFile(filename, encode(datastr), 'base64', function (err, data) {
+            callback(err);
+        });
+    }
+    //callback(err:String)
+    editor.file.saveNewFile = function (saveFilename, callback) {
+        //saveAsFilename不含'/'不含'.js'
+        checkCallback(callback);
+        var currData=editor.currentFloorData;
+        var saveStatus = document.getElementById('newMapStatus').checked;
+
+        var title = saveStatus?currData.title:"新建楼层";
+        var name = saveStatus?currData.name:"0";
+        if (/^mt\d+$/i.test(saveFilename)) {
+            name = saveFilename.substring(2);
+            title = "主塔 "+name+" 层";
+        }
+        
+        var width = parseInt(document.getElementById('newMapsWidth').value);
+        var height = parseInt(document.getElementById('newMapsHeight').value);
+        var row = [], map = [];
+        for (var i=0;i<width;i++) row.push(0);
+        for (var i=0;i<height;i++) map.push(row);
+        editor.currentFloorData = Object.assign(JSON.parse(JSON.stringify(editor.file.comment._data.floors_template)), {
+            floorId: saveFilename,
+            title: title,
+            name: name,
+            width: width,
+            height: height,
+            map: map,
+        },saveStatus?{
+            canFlyTo: currData.canFlyTo,
+            canUseQuickShop: currData.canUseQuickShop,
+            cannotViewMap: currData.cannotViewMap,
+            cannotMoveDirectly: currData.cannotMoveDirectly,
+            item_ratio: currData.item_ratio,
+            defaultGround: currData.defaultGround,
+            bgm: currData.bgm,
+            color: currData.color,
+            weather: currData.weather,
+        }:{});
+        
+        Object.keys(editor.currentFloorData).forEach(function (t) {
+            if (editor.currentFloorData[t] == null)
+                delete editor.currentFloorData[t];
+        })
+        editor.currentFloorId = saveFilename;
+        editor.file.saveFloorFile(callback);
+    }
+    editor.file.saveNewFiles = function (floorIdList, from, to, callback) {
+        checkCallback(callback);
+        var currData=editor.currentFloorData;
+        var saveStatus = document.getElementById('newMapsStatus').checked;
+
+        var calValue = function (text, i) {
+            return text.replace(/\${(.*?)}/g, function (word, value) {
+                return eval(value);
+            });
+        }
+
+        var width = parseInt(document.getElementById('newMapsWidth').value);
+        var height = parseInt(document.getElementById('newMapsHeight').value);
+
+        var row = [], map = [];
+        for (var i=0;i<width;i++) row.push(0);
+        for (var i=0;i<height;i++) map.push(row);
+
+        var filenames = floorIdList.map(function (v) {return "project/floors/"+v+".js";});
+        var datas = [];
+        for (var i=from;i<=to;i++) {
+            var datastr = ['main.floors.', floorIdList[i-from], '=\n{'];
+            var data = Object.assign(JSON.parse(JSON.stringify(editor.file.comment._data.floors_template)), {
+                floorId: floorIdList[i-from],
+                title: calValue(document.getElementById('newFloorTitles').value, i),
+                name: calValue(document.getElementById('newFloorNames').value, i),
+                width: width,
+                height: height,
+                map: map,
+            },saveStatus?{
+                canFlyTo: currData.canFlyTo,
+                canUseQuickShop: currData.canUseQuickShop,
+                cannotViewMap: currData.cannotViewMap,
+                cannotMoveDirectly: currData.cannotMoveDirectly,
+                item_ratio: currData.item_ratio,
+                defaultGround: currData.defaultGround,
+                bgm: currData.bgm,
+                color: currData.color,
+                weather: currData.weather,
+            }:{});
+            Object.keys(data).forEach(function (t) {
+                if (data[t] == null)
+                    delete data[t];
+                else {
+                    if (t=='map') {
+                        datastr = datastr.concat(['\n"', t, '": [\n', formatMap(data[t]), '\n],']);
+                    }
+                    else {
+                        datastr = datastr.concat(['\n"', t, '": ', JSON.stringify(data[t], null, 4), ',']);
+                    }
+                }
+            });
+            datastr = datastr.concat(['\n}']);
+            datastr = datastr.join('');
+            datas.push(encode(datastr));
+        }
+        alertWhenCompress();
+        fs.writeMultiFiles(filenames, datas, function (err, data) {
+            callback(err);
+        });
+    }
+
+    //callback(err:String)
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.autoRegister = function (info, callback) {
+
+        var iconActions = [];
+        var mapActions = [];
+        var templateActions = [];
+
+        var image = info.images;
+
+        if (image=='autotile') {
+            callback('不能对自动元件进行自动注册！');
+            return;
+        }
+        var c=image.toUpperCase().charAt(0);
+
+        // terrains id
+        var terrainsId = [];
+        Object.keys(core.material.icons.terrains).forEach(function (id) {
+            terrainsId[core.material.icons.terrains[id]]=id;
+        })
+
+        var allIds = [];
+        editor.ids.forEach(function (v) {
+            if (v.images==image) {
+                allIds[v.y]=true;
+            }
+        })
+
+        var per_height = image.endsWith('48')?48:32;
+
+        var idnum=300;
+        for (var y=0; y<editor.widthsX[image][3]/per_height;y++) {
+            if (allIds[y]) continue;
+            while (editor.core.maps.blocksInfo[idnum]) idnum++;
+
+            // get id num
+            var id = c+idnum;
+
+            if (image=='terrains' && terrainsId[y] != null) {
+                id=terrainsId[y];
+            }
+            else {
+                iconActions.push(["add", "['" + image + "']['" + id + "']", y])
+            }
+            mapActions.push(["add", "['" + idnum + "']", {'cls': image, 'id': id}])
+            if (image=='items')
+                templateActions.push(["add", "['items']['" + id + "']", editor.file.comment._data.items_template]);
+            else if (image.indexOf('enemy')==0)
+                templateActions.push(["add", "['" + id + "']", editor.file.comment._data.enemys_template]);
+            idnum++;
+        }
+
+        if (mapActions.length==0) {
+            callback("没有要注册的项！");
+            return;
+        }
+
+        var templist = [];
+        var tempcallback = function (err) {
+            templist.push(err);
+            if (templist.length == 3) {
+                if (templist[0] != null || templist[1] != null || templist[2] != null)
+                    callback((templist[0] || '') + '\n' + (templist[1] || '') + '\n' + (templist[2] || ''));
+                //这里如果一个成功一个失败会出严重bug
+                else
+                    callback(null);
+            }
+        }
+        if (iconActions.length>0)
+            saveSetting('icons', iconActions, tempcallback);
+        else tempcallback(null);
+
+        saveSetting('maps', mapActions, tempcallback);
+
+        if (image=='items')
+            saveSetting('items', templateActions, tempcallback);
+        else if (image.indexOf('enemy')==0)
+            saveSetting('enemys', templateActions, tempcallback);
+        else tempcallback(null);
+    }
+
+    editor.file.registerAutotile = function (filename, callback) {
+        var idnum = 140;
+        while (editor.core.maps.blocksInfo[idnum]) idnum++;
+
+        var iconActions = [];
+        var mapActions = [];
+
+        iconActions.push(["add", "['autotile']['" + filename + "']", 0]);
+        mapActions.push(["add", "['" + idnum + "']", {'cls': 'autotile', 'id': filename, 'noPass': true}]);
+
+        var templist = [];
+        var tempcallback = function (err) {
+            templist.push(err);
+            if (templist.length == 2) {
+                if (templist[0] != null || templist[1] != null)
+                    callback((templist[0] || '') + '\n' + (templist[1] || ''));
+                //这里如果一个成功一个失败会出严重bug
+                else
+                    callback(null);
+            }
+        }
+
+        saveSetting('icons', iconActions, tempcallback);
+        saveSetting('maps', mapActions, tempcallback);
+    }
+
+    editor.file.changeIdAndIdnum = function (id, idnum, info, callback) {
+        checkCallback(callback);
+        
+        var changeOrNew=core.isset(editor_mode.info.id)?'change':'new'
+        if(changeOrNew=='new'){
+            //检查maps中是否有重复的idnum或id
+            for (var ii in editor.core.maps.blocksInfo) {
+                if (ii == idnum) {
+                    callback('idnum重复了');
+                    return;
+                }
+                if (editor.core.maps.blocksInfo[ii].id == id) {
+                    callback('id重复了');
+                    return;
+                }
+            }
+            var templist = [];
+            var tempcallback = function (err) {
+                templist.push(err);
+                if (templist.length == 2) {
+                    if (templist[0] != null || templist[1] != null)
+                        callback((templist[0] || '') + '\n' + (templist[1] || ''));
+                    //这里如果一个成功一个失败会出严重bug
+                    else
+                        callback(null);
+                }
+            }
+            saveSetting('maps', [["add", "['" + idnum + "']", {'cls': info.images, 'id': id}]], tempcallback);
+            saveSetting('icons', [["add", "['" + info.images + "']['" + id + "']", info.y]], tempcallback);
+            if (info.images === 'items') {
+                saveSetting('items', [["add", "['items']['" + id + "']", editor.file.comment._data.items_template]], function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                });
+            }
+            if (info.images === 'enemys' || info.images === 'enemy48') {
+                saveSetting('enemys', [["add", "['" + id + "']", editor.file.comment._data.enemys_template]], function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                });
+            }
+
+            callback(null);
+
+        }else{
+            //检查maps中是否有重复的idnum或id
+            for (var ii in editor.core.maps.blocksInfo) {
+                if (editor.core.maps.blocksInfo[ii].id == id) {
+                    callback('id重复了');
+                    return;
+                }
+            }
+            idnum = info.idnum;
+
+            maps_90f36752_8815_4be8_b32b_d7fad1d0542e[idnum].id = id;
+
+            var arr=[icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1,items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a,{enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80:enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80}]
+            arr.forEach(function (obj) {
+                for(var jj in obj){
+                    var ii=obj[jj]
+                    if (ii.hasOwnProperty(info.id)){
+                        ii[id]=ii[info.id];
+                        delete(ii[info.id]);
+                    }
+                }
+            });
+
+            editor.file.save_icons_maps_items_enemys(callback)
+            
+        }
+    }
+    //callback(err:String)
+    editor.file.editItem = function (id, actionList, callback) {
+        /*actionList:[
+          ["change","['items']['name']","红宝石的新名字"],
+          ["add","['items']['新的和name同级的属性']",123],
+          ["change","['itemEffectTip']","'，攻击力+'+editor.core.values.redJewel"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                var tempindex = value[1].indexOf(']') + 1;
+                value[1] = [value[1].slice(0, tempindex), "['" + id + "']", value[1].slice(tempindex)].join('');
+            });
+            saveSetting('items', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj_ = {};
+                    Object.keys(editor.file.comment._data.items._data).forEach(function (v) {
+                        if (isset(editor.core.items[v][id]) && v !== 'items')
+                            locObj_[v] = editor.core.items[v][id];
+                        else
+                            locObj_[v] = null;
+                    });
+                    locObj_['items'] = (function () {
+                        var locObj = Object.assign({}, editor.core.items.items[id]);
+                        Object.keys(editor.file.comment._data.items._data.items._data).forEach(function (v) {
+                            if (!isset(editor.core.items.items[id][v]))
+                                locObj[v] = null;
+                        });
+                        return locObj;
+                    })();
+                    return locObj_;
+                })(),
+                editor.file.comment._data.items,
+                null]);
+        }
+        //只有items.cls是items的才有itemEffect和itemEffectTip,keys和constants和tools只有items
+    }
+    //callback([obj,commentObj,err:String])
+    editor.file.editEnemy = function (id, actionList, callback) {
+        /*actionList:[
+          ["change","['name']","初级巫师的新名字"],
+          ["add","['新的和name同级的属性']",123],
+          ["change","['bomb']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = "['" + id + "']" + value[1];
+            });
+            saveSetting('enemys', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = Object.assign({}, editor.core.enemys.enemys[id]);
+                    Object.keys(editor.file.comment._data.enemys._data).forEach(function (v) {
+                        if (!isset(editor.core.enemys.enemys[id][v]))
+                        /* locObj[v]=editor.core.enemys.enemys[id][v];
+                      else */
+                            locObj[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.comment._data.enemys,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    editor.file.editMapBlocksInfo = function (idnum, actionList, callback) {
+        /*actionList:[
+          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
+          ["change","['afterBattle']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            var tempmap=[];
+            for(var ii=0;ii<actionList.length;ii++){
+                var value=actionList[ii];
+                // 是tilesets 且未定义 且在这里是第一次定义
+                if(idnum>=editor.core.icons.tilesetStartOffset && !isset(editor.core.maps.blocksInfo[idnum]) && tempmap.indexOf(idnum)===-1){
+                    actionList.splice(ii,0,["add","['" + idnum + "']",{"cls": "tileset", "id": "X"+idnum, "noPass": true}]);
+                    tempmap.push(idnum);
+                    ii++;
+                }
+                value[1] = "['" + idnum + "']" + value[1];
+            }
+            saveSetting('maps', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var sourceobj=editor.core.maps.blocksInfo[idnum];
+                    if(!isset(sourceobj) && idnum>=editor.core.icons.tilesetStartOffset)sourceobj={"cls": "tileset", "id": "X"+idnum, "noPass": true}
+                    var locObj = Object.assign({}, sourceobj);
+                    Object.keys(editor.file.comment._data.maps._data).forEach(function (v) {
+                        if (!isset(sourceobj[v]))
+                            locObj[v] = null;
+                    });
+                    locObj.idnum = idnum;
+                    return locObj;
+                })(),
+                editor.file.comment._data.maps,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editLoc = function (x, y, actionList, callback) {
+        /*actionList:[
+          ["change","['events']",["\t[老人,magician]领域、夹击。\n请注意领域怪需要设置value为伤害数值，可参见样板中初级巫师的写法。"]],
+          ["change","['afterBattle']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = value[1] + "['" + x + "," + y + "']";
+            });
+            saveSetting('floorloc', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = {};
+                    Object.keys(editor.file.comment._data.floors._data.loc._data).forEach(function (v) {
+                        if (isset(editor.currentFloorData[v][x + ',' + y]))
+                            locObj[v] = editor.currentFloorData[v][x + ',' + y];
+                        else
+                            locObj[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.comment._data.floors._data.loc,
+                null]);
+        }
+
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editFloor = function (actionList, callback) {
+        /*actionList:[
+          ["change","['title']",'样板 3 层'],
+          ["change","['color']",null],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('floors', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = Object.assign({}, editor.currentFloorData);
+                    Object.keys(editor.file.comment._data.floors._data.floor._data).forEach(function (v) {
+                        if (!isset(editor.currentFloorData[v]))
+                        /* locObj[v]=editor.currentFloorData[v];
+                      else */
+                            locObj[v] = null;
+                    });
+                    Object.keys(editor.file.comment._data.floors._data.loc._data).forEach(function (v) {
+                        delete(locObj[v]);
+                    });
+                    delete(locObj.map);
+                    delete(locObj.bgmap);
+                    delete(locObj.fgmap);
+                    return locObj;
+                })(),
+                editor.file.comment._data.floors._data.floor,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editTower = function (actionList, callback) {
+        /*actionList:[
+          ["change","['firstData']['version']",'Ver 1.0.1 (Beta)'],
+          ["change","['values']['lavaDamage']",200],
+        ]
+        为[]时只查询不修改
+        */
+        var data_obj = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('data', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    //var locObj=Object.assign({'main':{}},editor.core.data);
+                    var locObj = Object.assign({}, data_obj, {'main': {}});
+                    Object.keys(editor.file.dataComment._data.main._data).forEach(function (v) {
+                        if (isset(editor.main[v]))
+                            locObj.main[v] = data_obj.main[v];
+                        else
+                            locObj.main[v] = null;
+                    });
+                    return locObj;
+                })(),
+                editor.file.dataComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var fmap = {};
+    var fjson = JSON.stringify(functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a, function (k, v) {
+        if (v instanceof Function) {
+            var id_ = editor.util.guid();
+            fmap[id_] = v.toString();
+            return id_;
+        } else return v
+    }, 4);
+    var fobj = JSON.parse(fjson);
+    editor.file.functionsMap = fmap;
+    editor.file.functionsJSON = fjson;
+    var buildlocobj = function (locObj) {
+        for (var key in locObj) {
+            if (typeof(locObj[key]) !== typeof('')) buildlocobj(locObj[key]);
+            else locObj[key] = fmap[locObj[key]];
+        }
+    };
+
+    editor.file.editFunctions = function (actionList, callback) {
+        /*actionList:[
+          ["change","['events']['afterChangeLight']","function(x,y){console.log(x,y)}"],
+          ["change","['ui']['drawAbout']","function(){...}"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('functions', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = JSON.parse(fjson);
+                    buildlocobj(locObj);
+                    return locObj;
+                })(),
+                editor.file.functionsComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    editor.file.editCommonEvent = function (actionList, callback) {
+        /*actionList:[
+          ["change","['test']",['123']],
+        ]
+        为[]时只查询不修改
+        */
+        var data_obj = events_c12a15a8_c380_4b28_8144_256cba95f760.commonEvent;
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            actionList.forEach(function (value) {
+                value[1] = "['commonEvent']" + value[1];
+            });
+            saveSetting('events', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                Object.assign({},data_obj),
+                editor.file.eventsComment._data.commonEvent,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var plmap = {};
+    var pljson = JSON.stringify(plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1, function (k, v) {
+        if (v instanceof Function) {
+            var id_ = editor.util.guid();
+            plmap[id_] = v.toString();
+            return id_;
+        } else if(v===null){
+            var id_ = editor.util.guid();
+            plmap[id_] = null;
+            return id_;
+        } return v
+    }, 4);
+    var plobj = JSON.parse(pljson);
+    editor.file.pluginsMap = plmap;
+    editor.file.pluginsObj = plobj;
+    var buildpllocobj = function (locObj) {
+        for (var key in locObj) {
+            if (typeof(locObj[key]) !== typeof('')) buildpllocobj(locObj[key]);
+            else locObj[key] = plmap[locObj[key]];
+        }
+    };
+
+    editor.file.editPlugins = function (actionList, callback) {
+        /*actionList:[
+          ["change","['test']","function(x,y){console.log(x,y)}"],
+        ]
+        为[]时只查询不修改
+        */
+        checkCallback(callback);
+        if (isset(actionList) && actionList.length > 0) {
+            saveSetting('plugins', actionList, function (err) {
+                callback([err]);
+            });
+        } else {
+            callback([
+                (function () {
+                    var locObj = JSON.parse(JSON.stringify(plobj));
+                    buildpllocobj(locObj);
+                    return locObj;
+                })(),
+                editor.file.pluginsComment,
+                null]);
+        }
+    }
+    //callback([obj,commentObj,err:String])
+
+    ////////////////////////////////////////////////////////////////////
+
+    var isset = function (val) {
+        if (val == undefined || val == null) {
+            return false;
+        }
+        return true
+    }
+
+    var checkCallback=function(callback){
+        if (!isset(callback)) {
+            printe('未设置callback');
+            throw('未设置callback')
+        }
+    }
+
+    var formatMap = function (mapArr,trySimplify) {
+        if(!mapArr || JSON.stringify(mapArr)==JSON.stringify([]))return '';
+        if(trySimplify){
+            //检查是否是全0二维数组
+            var jsoncheck=JSON.stringify(mapArr).replace(/\D/g,'');
+            if(jsoncheck==Array(jsoncheck.length+1).join('0'))return '';
+        }
+        //把二维数组格式化
+        var formatArrStr = '';
+        var arr = JSON.stringify(mapArr).replace(/\s+/g, '').split('],[');
+        var si=mapArr.length-1,sk=mapArr[0].length-1;
+        for (var i = 0; i <= si; i++) {
+            var a = [];
+            formatArrStr += '    [';
+            if (i == 0 || i == si) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
+            else a = arr[i].split(/\D+/);
+            for (var k = 0; k <= sk; k++) {
+                var num = parseInt(a[k]);
+                formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk ? '' : ',');
+            }
+            formatArrStr += ']' + (i == si ? '' : ',\n');
+        }
+        return formatArrStr;
+    }
+
+    var encode = editor.util.encode64
+
+    var alertWhenCompress = function(){
+        if(editor.useCompress===true){
+            editor.useCompress='alerted';
+            setTimeout("alert('当前游戏使用的是压缩文件,修改完成后请使用启动服务.exe->Js代码压缩工具重新压缩,或者把main.js的useCompress改成false来使用原始文件')",1000)
+        }
+    }
+
+    editor.file.save_icons_maps_items_enemys=function(callback){
+        var check=[]
+        saveSetting('icons',[],function(err){
+            if(err){callback(err);return;}
+            check.push('icons')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('maps',[],function(err){
+            if(err){callback(err);return;}
+            check.push('maps')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('items',[],function(err){
+            if(err){callback(err);return;}
+            check.push('items')
+            if(check.length==4)callback(null);
+        })
+        saveSetting('enemys',[],function(err){
+            if(err){callback(err);return;}
+            check.push('enemys')
+            if(check.length==4)callback(null);
+        })
+    }
+
+    var saveSetting = function (file, actionList, callback) {
+        //console.log(file);
+        //console.log(actionList);
+        alertWhenCompress();
+
+        if (file == 'icons') {
+            actionList.forEach(function (value) {
+                eval("icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1 = \n';
+            datastr += JSON.stringify(icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1, null, '\t');
+            fs.writeFile('project/icons.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'maps') {
+            actionList.forEach(function (value) {
+                eval("maps_90f36752_8815_4be8_b32b_d7fad1d0542e" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var maps_90f36752_8815_4be8_b32b_d7fad1d0542e = \n';
+            //datastr+=JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e,null,4);
+
+            var emap = {};
+            var estr = JSON.stringify(maps_90f36752_8815_4be8_b32b_d7fad1d0542e, function (k, v) {
+                if (v.id != null) {
+                    var id_ = editor.util.guid();
+                    emap[id_] = JSON.stringify(v);
+                    return id_;
+                } else return v
+            }, '\t');
+            for (var id_ in emap) {
+                estr = estr.replace('"' + id_ + '"', emap[id_])
+            }
+            datastr += estr;
+
+            fs.writeFile('project/maps.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'items') {
+            actionList.forEach(function (value) {
+                eval("items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a = \n';
+            datastr += JSON.stringify(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a, null, '\t');
+            fs.writeFile('project/items.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'enemys') {
+            actionList.forEach(function (value) {
+                eval("enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80 = \n';
+            var emap = {};
+            var estr = JSON.stringify(enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80, function (k, v) {
+                if (v.hp != null) {
+                    var id_ = editor.util.guid();
+                    emap[id_] = JSON.stringify(v);
+                    return id_;
+                } else return v
+            }, '\t');
+            for (var id_ in emap) {
+                estr = estr.replace('"' + id_ + '"', emap[id_])
+            }
+            datastr += estr;
+            fs.writeFile('project/enemys.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'data') {
+            actionList.forEach(function (value) {
+                eval("data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            if (data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds.indexOf(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId) < 0)
+                data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.firstData.floorId = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds[0];
+            var datastr = 'var data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = \n';
+            datastr += JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, null, '\t');
+            fs.writeFile('project/data.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'functions') {
+            actionList.forEach(function (value) {
+                eval("fmap[fobj" + value[1] + ']=' + JSON.stringify(value[2]));
+            });
+            var fraw = fjson;
+            for (var id_ in fmap) {
+                fraw = fraw.replace('"' + id_ + '"', fmap[id_])
+            }
+            var datastr = 'var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a = \n';
+            datastr += fraw;
+            fs.writeFile('project/functions.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'floorloc') {
+            actionList.forEach(function (value) {
+                // 检测null/undefined
+                if (value[2]==null)
+                    eval("delete editor.currentFloorData" + value[1]);
+                else
+                    eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            editor.file.saveFloorFile(callback);
+            return;
+        }
+        if (file == 'floors') {
+            actionList.forEach(function (value) {
+                eval("editor.currentFloorData" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            editor.file.saveFloorFile(callback);
+            return;
+        }
+        if (file == 'events') {
+            actionList.forEach(function (value) {
+                eval("events_c12a15a8_c380_4b28_8144_256cba95f760" + value[1] + '=' + JSON.stringify(value[2]));
+            });
+            var datastr = 'var events_c12a15a8_c380_4b28_8144_256cba95f760 = \n';
+            datastr += JSON.stringify(events_c12a15a8_c380_4b28_8144_256cba95f760, null, '\t');
+            fs.writeFile('project/events.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        if (file == 'plugins') {
+            actionList.forEach(function (value) {
+                if(value[0]==='add'){
+                    eval("plobj" + value[1] + '=' + JSON.stringify(value[2]));
+                } else {
+                    eval("plmap[plobj" + value[1] + ']=' + JSON.stringify(value[2]));
+                }
+            });
+            var plraw = JSON.stringify(plobj,null,4);
+            for (var id_ in plmap) {
+                plraw = plraw.replace('"' + id_ + '"', plmap[id_])
+            }
+            var datastr = 'var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = \n';
+            datastr += plraw;
+            fs.writeFile('project/plugins.js', encode(datastr), 'base64', function (err, data) {
+                callback(err);
+            });
+            return;
+        }
+        callback('出错了,要设置的文件名不识别');
+    }
+
+    return editor_file;
+}
+//editor_file = editor_file(editor);

_server/editor_game.js

@@ -0,0 +1,180 @@
+editor_game_wrapper = function (editor, main, core) {
+    // 原则上重构后只有此文件允许`\s(main|core)`形式的调用, 以及其初始化 editor_game_wrapper(editor, main, core)
+
+    editor_game = function () {
+        this.replacerRecord = {}
+    }
+
+
+    //////////////////// 修改数据相关 ////////////////////
+    // 三个 replacer 和 replacerRecord 暂时放在此处
+
+    editor_game.prototype.replacerForLoading = function (_key, value) {
+        var rmap = editor.game.replacerRecord;
+        if (value instanceof Function) {
+            var guid_ = editor.util.guid()
+            rmap[guid_] = value.toString()
+            return guid_
+        } else if (value === null) {
+            // 为了包含plugins的新建
+            var guid_ = editor.util.guid()
+            rmap[guid_] = null
+            return guid_
+        }
+        return value
+    }
+
+    editor_game.prototype.replacerForSaving = function (_key, value) {
+        var rmap = editor.game.replacerRecord;
+        if (rmap.hasOwnProperty(value)) {
+            return rmap[value]
+        }
+        return value
+    }
+
+    editor_game.prototype.getValue = function (field) {
+        var rmap = editor.game.replacerRecord;
+        var value = eval(field)
+        if (rmap.hasOwnProperty(oldval)) {
+            return rmap[value]
+        } else {
+            return value
+        }
+    }
+
+    editor_game.prototype.setValue = function (field, value) {
+        var rmap = editor.game.replacerRecord;
+        var oldval = eval(field)
+        if (rmap.hasOwnProperty(oldval)) {
+            rmap[value] = eval(value)
+        } else {
+            eval(field + '=' + value)
+        }
+    }
+
+    editor_game.prototype.replacerWithoutRecord = function (_key, value) {
+        if (value instanceof Function) {
+            return value.toString()
+        } else return value
+    }
+
+    editor_game.prototype.fixFunctionInGameData = function () {
+        var rf = editor.game.replacerWithoutRecord
+        core.floors = JSON.parse(JSON.stringify(core.floors, rf));
+        core.data = JSON.parse(JSON.stringify(core.data, rf));
+        data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d = JSON.parse(JSON.stringify(data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d, rf));
+    }
+
+    //////////////////// 加载游戏数据相关 ////////////////////
+
+    // 初始化数字与地图图块的对应
+    editor_game.prototype.idsInit = function (maps, icons) {
+        editor.ids = [0];
+        editor.indexs = [];
+        var MAX_NUM = 0;
+        var keys = Object.keys(maps_90f36752_8815_4be8_b32b_d7fad1d0542e);
+        for (var ii = 0; ii < keys.length; ii++) {
+            var v = ~~keys[ii];
+            if (v > MAX_NUM && v < core.icons.tilesetStartOffset) MAX_NUM = v;
+        }
+        editor.MAX_NUM = MAX_NUM;
+        var getInfoById = function (id) {
+            var block = maps.initBlock(0, 0, id);
+            if (Object.prototype.hasOwnProperty.call(block, 'event')) {
+                return block;
+            }
+        }
+        var point = 0;
+        for (var i = 0; i <= MAX_NUM; i++) {
+            var indexBlock = getInfoById(i);
+            editor.indexs[i] = [];
+            if (indexBlock) {
+                var id = indexBlock.event.id;
+                var indexId = indexBlock.id;
+                var allCls = Object.keys(icons);
+                if (i == 17) {
+                    editor.ids.push({ 'idnum': 17, 'id': id, 'images': 'terrains' });
+                    point++;
+                    editor.indexs[i].push(point);
+                    continue;
+                }
+                for (var j = 0; j < allCls.length; j++) {
+                    if (id in icons[allCls[j]]) {
+                        editor.ids.push({ 'idnum': indexId, 'id': id, 'images': allCls[j], 'y': icons[allCls[j]][id] });
+                        point++;
+                        editor.indexs[i].push(point);
+                    }
+                }
+            }
+        }
+        editor.indexs[0] = [0];
+
+        var startOffset = core.icons.tilesetStartOffset;
+        for (var i in core.tilesets) {
+            var imgName = core.tilesets[i];
+            var img = core.material.images.tilesets[imgName];
+            var width = Math.floor(img.width / 32), height = Math.floor(img.height / 32);
+            if (img.width % 32 || img.height % 32) {
+                alert(imgName + '的长或宽不是32的整数倍, 请修改后刷新页面');
+            }
+            if (img.width * img.height > 32 * 32 * 3000) {
+                alert(imgName + '上的图块数量超过了3000，请修改后刷新页面');
+            }
+            for (var id = startOffset; id < startOffset + width * height; id++) {
+                var x = (id - startOffset) % width, y = parseInt((id - startOffset) / width);
+                var indexBlock = getInfoById(id);
+                editor.ids.push({ 'idnum': id, 'id': indexBlock.event.id, 'images': imgName, "x": x, "y": y, isTile: true });
+                point++;
+                editor.indexs[id] = [point];
+            }
+            startOffset += core.icons.tilesetStartOffset;
+        }
+    }
+
+    // 获取当前地图
+    editor_game.prototype.fetchMapFromCore = function () {
+        var mapArray = core.maps.saveMap(core.status.floorId);
+        editor.map = mapArray.map(function (v) {
+            return v.map(function (v) {
+                var x = parseInt(v), y = editor.indexs[x];
+                if (y == null) {
+                    printe("素材数字" + x + "未定义。是不是忘了注册，或者接档时没有覆盖icons.js和maps.js？");
+                    y = [0];
+                }
+                return editor.ids[y[0]]
+            })
+        });
+        editor.currentFloorId = core.status.floorId;
+        editor.currentFloorData = core.floors[core.status.floorId];
+        for (var ii = 0, name; name = ['bgmap', 'fgmap'][ii]; ii++) {
+            var mapArray = editor.currentFloorData[name];
+            if (!mapArray || JSON.stringify(mapArray) == JSON.stringify([])) {//未设置或空数组
+                //与editor.map同形的全0
+                mapArray = eval('[' + Array(editor.map.length + 1).join('[' + Array(editor.map[0].length + 1).join('0,') + '],') + ']');
+            }
+            editor[name] = mapArray.map(function (v) {
+                return v.map(function (v) {
+                    var x = parseInt(v), y = editor.indexs[x];
+                    if (y == null) {
+                        printe("素材数字" + x + "未定义。是不是忘了注册，或者接档时没有覆盖icons.js和maps.js？");
+                        y = [0];
+                    }
+                    return editor.ids[y[0]]
+                })
+            });
+        }
+    }
+
+    // 获取地图列表
+    editor_game.prototype.getFloorFileList = function (callback) {
+        // callback([Array<String>,err:String])
+        editor.util.checkCallback(callback);
+        /* editor.fs.readdir('project/floors',function(err, data){
+          callback([data,err]);
+        }); */
+        callback([editor.core.floorIds, null]);
+    }
+
+    editor.constructor.prototype.game = new editor_game();
+}
+//editor_game_wrapper(editor);

_server/editor_mode.js

@@ -4,13 +4,16 @@ editor_mode = function (editor) {
     function editor_mode() {
         this.ids = {
             'loc': 'left2',
-            'emenyitem': 'left3',
+            'enemyitem': 'left3',
             'floor': 'left4',
             'tower': 'left5',
             'functions': 'left8',
 
             'map': 'left',
             'appendpic': 'left1',
+
+            'commonevent': 'left9',
+            'plugins': 'left10',
         }
         this._ids = {}
         this.dom = {}
@@ -18,6 +21,7 @@ editor_mode = function (editor) {
         this.mode = '';
         this.info = {};
         this.appendPic = {};
+        this.doubleClickMode='change';
     }
 
     editor_mode.prototype.init = function (callback) {
@@ -34,157 +38,9 @@ editor_mode = function (editor) {
         if (Boolean(callback)) callback();
     }
 
-/////////////////////////////////////////////////////////////////////////////
-    editor_mode.prototype.objToTable_ = function (obj, commentObj) {
-        var outstr = ["\n<tr><td>条目</td><td>注释</td><td>值</td></tr>\n"];
-        var guids = [];
-        var defaultcobj = {
-            _type: 'textarea',
-            _data: '',
-            _string: function (args) {//object~[field,cfield,vobj,cobj]
-                var thiseval = args.vobj;
-                return (typeof(thiseval) === typeof('')) && thiseval[0] === '"';
-            },
-            _leaf: function (args) {//object~[field,cfield,vobj,cobj]
-                var thiseval = args.vobj;
-                if (thiseval == null || thiseval == undefined) return true;//null,undefined
-                if (typeof(thiseval) === typeof('')) return true;//字符串
-                if (Object.keys(thiseval).length === 0) return true;//数字,true,false,空数组,空对象
-                return false;
-            },
-        }
-        var recursionParse = function (pfield, pcfield, pvobj, pcobj) {
-            for (var ii in pvobj) {
-                var field = pfield + "['" + ii + "']";
-                var cfield = pcfield + "['_data']['" + ii + "']";
-                var vobj = pvobj[ii];
-                var cobj = null;
-                if (pcobj && pcobj['_data'] && pcobj['_data'][ii]) {
-                    cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii]);
-                } else {
-                    if (pcobj && (pcobj['_data'] instanceof Function)) cobj = Object.assign({}, defaultcobj, pcobj['_data'](ii));
-                    else cobj = Object.assign({}, defaultcobj);
-                }
-                var args = {field: field, cfield: cfield, vobj: vobj, cobj: cobj}
-                if (cobj._leaf instanceof Function) cobj._leaf = cobj._leaf(args);
-                for (var key in cobj) {
-                    if (key === '_data') continue;
-                    if (cobj[key] instanceof Function) cobj[key] = cobj[key](args);
-                }
-                if (cobj._leaf) {
-                    var leafnode = editor_mode.objToTr_(obj, commentObj, field, cfield, vobj, cobj);
-                    outstr.push(leafnode[0]);
-                    guids.push(leafnode[1]);
-                } else {
-                    outstr.push(["<tr><td>----</td><td>----</td><td>", field, "</td></tr>\n"].join(''));
-                    recursionParse(field, cfield, vobj, cobj);
-                }
-            }
-        }
-        recursionParse("", "", obj, commentObj);
-        var checkRange = function (evalstr, thiseval) {
-            if (evalstr) {
-                return eval(evalstr);
-            }
-            return true;
-        }
-        var listen = function (guids) {
-            guids.forEach(function (guid) {
-                // tr>td[title=field]
-                //   >td[title=comment,cobj=cobj:json]
-                //   >td>div>input[value=thiseval]
-                var thisTr = document.getElementById(guid);
-                var input = thisTr.children[2].children[0].children[0];
-                var field = thisTr.children[0].getAttribute('title');
-                var cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
-                input.onchange = function () {
-                    var node = thisTr.parentNode;
-                    while (!editor_mode._ids.hasOwnProperty(node.getAttribute('id'))) {
-                        node = node.parentNode;
-                    }
-                    editor_mode.onmode(editor_mode._ids[node.getAttribute('id')]);
-                    var thiseval = null;
-                    if (input.checked != null) input.value = input.checked;
-                    try {
-                        thiseval = JSON.parse(input.value);
-                    } catch (ee) {
-                        printe(field + ' : ' + ee);
-                        throw ee;
-                    }
-                    if (checkRange(cobj._range, thiseval)) {
-                        editor_mode.addAction(['change', field, thiseval]);
-                        editor_mode.onmode('save');//自动保存
-                    } else {
-                        printe(field + ' : 输入的值不合要求,请鼠标放置在注释上查看说明');
-                    }
-                }
-                var dblclickfunc=function () {
-                    if (cobj._type === 'event') editor_blockly.import(guid, {type: cobj._event});
-                    if (cobj._type === 'textarea') editor_multi.import(guid, {lint: cobj._lint, string: cobj._string});
-                }
-                input.ondblclick = dblclickfunc
-                var doubleClickCheck=[0];
-                thisTr.onclick = function(){
-                    var newClick = new Date().getTime();
-                    var lastClick = doubleClickCheck.shift();
-                    doubleClickCheck.push(newClick);
-                    if(newClick-lastClick<500){
-                        dblclickfunc()
-                    }
-                }
-            });
-        }
-        return {"HTML": outstr.join(''), "guids": guids, "listen": listen};
-    }
-
-    editor_mode.prototype.objToTr_ = function (obj, commentObj, field, cfield, vobj, cobj) {
-        var guid = editor.guid();
-        var thiseval = vobj;
-        var comment = cobj._data;
-
-        var charlength = 10;
-
-        var shortField = field.split("']").slice(-2)[0].split("['").slice(-1)[0];
-        shortField = (shortField.length < charlength ? shortField : shortField.slice(0, charlength) + '...');
-
-        var commentHTMLescape = editor.HTMLescape(comment);
-        var shortCommentHTMLescape = (comment.length < charlength ? commentHTMLescape : editor.HTMLescape(comment.slice(0, charlength)) + '...');
-
-        var cobjstr = Object.assign({}, cobj);
-        delete cobjstr._data;
-        cobjstr = editor.HTMLescape(JSON.stringify(cobjstr));
-
-        var outstr = ['<tr id="', guid, '"><td title="', field, '">', shortField, '</td>',
-            '<td title="', commentHTMLescape, '" cobj="', cobjstr, '">', shortCommentHTMLescape, '</td>',
-            '<td><div class="etableInputDiv">', editor_mode.objToTd_(obj, commentObj, field, cfield, vobj, cobj), '</div></td></tr>\n',
-        ];
-        return [outstr.join(''), guid];
-    }
-
-    editor_mode.prototype.objToTd_ = function (obj, commentObj, field, cfield, vobj, cobj) {
-        var thiseval = vobj;
-        if (cobj._select) {
-            var values = cobj._select.values;
-            var outstr = ['<select>\n', "<option value='", JSON.stringify(thiseval), "'>", JSON.stringify(thiseval), '</option>\n'];
-            values.forEach(function (v) {
-                outstr.push(["<option value='", JSON.stringify(v), "'>", JSON.stringify(v), '</option>\n'].join(''))
-            });
-            outstr.push('</select>');
-            return outstr.join('');
-        } else if (cobj._input) {
-            return ["<input type='text' spellcheck='false' value='", JSON.stringify(thiseval), "'/>\n"].join('');
-        } else if (cobj._bool) {
-            return ["<input type='checkbox' ", (thiseval ? 'checked ' : ''), "/>\n"].join('');
-        } else {
-            var num = 0;//editor_mode.indent(field);
-            return ["<textarea spellcheck='false' >", JSON.stringify(thiseval, null, num), '</textarea>\n'].join('');
-        }
-    }
-
     editor_mode.prototype.indent = function (field) {
         var num = '\t';
         if (field.indexOf("['main']") === 0) return 0;
-        if (field.indexOf("['flyRange']") !== -1) return 0;
         if (field === "['special']") return 0;
         return num;
     }
@@ -196,75 +52,43 @@ editor_mode = function (editor) {
     editor_mode.prototype.doActionList = function (mode, actionList) {
         if (actionList.length == 0) return;
         printf('修改中...');
+        var cb=function(objs_){
+            if (objs_.slice(-1)[0] != null) {
+                printe(objs_.slice(-1)[0]);
+                throw(objs_.slice(-1)[0])
+            }
+            ;printf('修改成功');
+        }
         switch (mode) {
             case 'loc':
-
-                editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功');
-                    editor.drawEventBlock();
+                editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, actionList, function (objs_) {
+                    cb(objs_);
+                    editor.drawPosSelection();
                 });
                 break;
-            case 'emenyitem':
-
+            case 'enemyitem':
                 if (editor_mode.info.images == 'enemys' || editor_mode.info.images == 'enemy48') {
-                    editor.file.editEnemy(editor_mode.info.id, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功')
-                    });
+                    editor.file.editEnemy(editor_mode.info.id, actionList, cb);
                 } else if (editor_mode.info.images == 'items') {
-                    editor.file.editItem(editor_mode.info.id, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功')
-                    });
+                    editor.file.editItem(editor_mode.info.id, actionList, cb);
                 } else {
-                    editor.file.editMapBlocksInfo(editor_mode.info.idnum, actionList, function (objs_) {/*console.log(objs_);*/
-                        if (objs_.slice(-1)[0] != null) {
-                            printe(objs_.slice(-1)[0]);
-                            throw(objs_.slice(-1)[0])
-                        }
-                        ;printf('修改成功');
-                    });
+                    editor.file.editMapBlocksInfo(editor_mode.info.idnum, actionList, cb);
                 }
                 break;
             case 'floor':
-
-                editor.file.editFloor(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功');
-                });
+                editor.file.editFloor(actionList, cb);
                 break;
             case 'tower':
-
-                editor.file.editTower(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功')
-                });
+                editor.file.editTower(actionList, cb);
                 break;
             case 'functions':
-
-                editor.file.editFunctions(actionList, function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printf('修改成功')
-                });
+                editor.file.editFunctions(actionList, cb);
+                break;
+            case 'commonevent':
+                editor.file.editCommonEvent(actionList, cb);
+                break;
+            case 'plugins':
+                editor.file.editPlugins(actionList, cb);
                 break;
             default:
                 break;
@@ -275,7 +99,7 @@ editor_mode = function (editor) {
         if (editor_mode.mode != mode) {
             if (mode === 'save') editor_mode.doActionList(editor_mode.mode, editor_mode.actionList);
             if (editor_mode.mode === 'nextChange' && mode) editor_mode.showMode(mode);
-            editor_mode.mode = mode;
+            if (mode !== 'save') editor_mode.mode = mode;
             editor_mode.actionList = [];
         }
     }
@@ -285,10 +109,13 @@ editor_mode = function (editor) {
             editor_mode.dom[name].style = 'z-index:-1;opacity: 0;';
         }
         editor_mode.dom[mode].style = '';
+        editor_mode.doubleClickMode='change';
+        // clear
+        editor.drawEventBlock();
         if (editor_mode[mode]) editor_mode[mode]();
         document.getElementById('editModeSelect').value = mode;
         var tips = tip_in_showMode;
-        if (!selectBox.isSelected) printf('tips: ' + tips[~~(tips.length * Math.random())]);
+        if (!selectBox.isSelected()) printf('tips: ' + tips[~~(tips.length * Math.random())]);
     }
 
     editor_mode.prototype.loc = function (callback) {
@@ -300,52 +127,55 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editLoc(editor_mode.pos.x, editor_mode.pos.y, [], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_3d846fc4_7644_44d1_aa04_433d266a73df').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
-
+        editor.drawPosSelection();
         if (Boolean(callback)) callback();
     }
 
-    editor_mode.prototype.emenyitem = function (callback) {
+    editor_mode.prototype.enemyitem = function (callback) {
         //editor.info=editor.ids[editor.indexs[201]];
         if (!core.isset(editor.info)) return;
 
-        if (Object.keys(editor.info).length !== 0) editor_mode.info = editor.info;//避免editor.info被清空导致无法获得是物品还是怪物
+        if (Object.keys(editor.info).length !== 0 && editor.info.idnum!=17) editor_mode.info = editor.info;//避免editor.info被清空导致无法获得是物品还是怪物
 
         if (!core.isset(editor_mode.info.id)) {
             // document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML = '';
-            document.getElementById('enemyItemTable').style.display = 'none';
             document.getElementById('newIdIdnum').style.display = 'block';
+            document.getElementById('enemyItemTable').style.display = 'none';
+            document.getElementById('changeId').style.display = 'none';
             return;
         }
+
         document.getElementById('newIdIdnum').style.display = 'none';
         document.getElementById('enemyItemTable').style.display = 'block';
+        document.getElementById('changeId').style.display = 'block';
 
         var objs = [];
         if (editor_mode.info.images == 'enemys' || editor_mode.info.images == 'enemy48') {
             editor.file.editEnemy(editor_mode.info.id, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         } else if (editor_mode.info.images == 'items') {
             editor.file.editItem(editor_mode.info.id, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         } else {
             /* document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML='';
             return; */
             editor.file.editMapBlocksInfo(editor_mode.info.idnum, [], function (objs_) {
                 objs = objs_;
-                /*console.log(objs_)*/
+                //console.log(objs_)
             });
         }
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_a3f03d4c_55b8_4ef6_b362_b345783acd72').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
 
@@ -356,10 +186,10 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editFloor([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_4a3b1b09_b2fb_4bdf_b9ab_9f4cdac14c74').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
@@ -369,10 +199,10 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editTower([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_b6a03e4c_5968_4633_ac40_0dfdd2c9cde5').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
@@ -382,274 +212,46 @@ editor_mode = function (editor) {
         var objs = [];
         editor.file.editFunctions([], function (objs_) {
             objs = objs_;
-            /*console.log(objs_)*/
+            //console.log(objs_)
         });
         //只查询不修改时,内部实现不是异步的,所以可以这么写
-        var tableinfo = editor_mode.objToTable_(objs[0], objs[1]);
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
         document.getElementById('table_e260a2be_5690_476a_b04e_dacddede78b3').innerHTML = tableinfo.HTML;
         tableinfo.listen(tableinfo.guids);
         if (Boolean(callback)) callback();
     }
 
+    editor_mode.prototype.commonevent = function (callback) {
+        var objs = [];
+        editor.file.editCommonEvent([], function (objs_) {
+            objs = objs_;
+            //console.log(objs_)
+        });
+        //只查询不修改时,内部实现不是异步的,所以可以这么写
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
+        document.getElementById('table_b7bf0124_99fd_4af8_ae2f_0017f04a7c7d').innerHTML = tableinfo.HTML;
+        tableinfo.listen(tableinfo.guids);
+        if (Boolean(callback)) callback();
+    }
+    
+    editor_mode.prototype.plugins = function (callback) {
+        var objs = [];
+        editor.file.editPlugins([], function (objs_) {
+            objs = objs_;
+            //console.log(objs_)
+        });
+        //只查询不修改时,内部实现不是异步的,所以可以这么写
+        var tableinfo = editor.table.objToTable(objs[0], objs[1]);
+        document.getElementById('table_e2c034ec_47c6_48ae_8db8_4f8f32fea2d6').innerHTML = tableinfo.HTML;
+        tableinfo.listen(tableinfo.guids);
+        if (Boolean(callback)) callback();
+    }
+
 /////////////////////////////////////////////////////////////////////////////
 
     editor_mode.prototype.listen = function (callback) {
 
-        var newIdIdnum = document.getElementById('newIdIdnum');
-        newIdIdnum.children[2].onclick = function () {
-            if (newIdIdnum.children[0].value && newIdIdnum.children[1].value) {
-                var id = newIdIdnum.children[0].value;
-                var idnum = parseInt(newIdIdnum.children[1].value);
-                if (!core.isset(idnum)) {
-                    printe('不合法的idnum');
-                    return;
-                }
-                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
-                    printe('不合法的id，请使用字母、数字或下划线')
-                    return;
-                }
-                editor.file.changeIdAndIdnum(id, idnum, editor_mode.info, function (err) {
-                    if (err) {
-                        printe(err);
-                        throw(err)
-                    }
-                    printe('添加id的idnum成功,请F5刷新编辑器');
-                });
-            } else {
-                printe('请输入id和idnum');
-            }
-        }
-
-        newIdIdnum.children[4].onclick = function () {
-            editor.file.autoRegister(editor_mode.info, function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                printe('该列所有剩余项全部自动注册成功,请F5刷新编辑器');
-            })
-        }
-
-        var selectFloor = document.getElementById('selectFloor');
-        editor.file.getFloorFileList(function (floors) {
-            var outstr = [];
-            floors[0].forEach(function (floor) {
-                outstr.push(["<option value='", floor, "'>", floor, '</option>\n'].join(''));
-            });
-            selectFloor.innerHTML = outstr.join('');
-            selectFloor.value = core.status.floorId;
-            selectFloor.onchange = function () {
-                editor_mode.onmode('nextChange');
-                editor_mode.onmode('floor');
-                editor.changeFloor(selectFloor.value);
-            }
-        });
-
-        var saveFloor = document.getElementById('saveFloor');
-        saveFloor.onclick = function () {
-            editor_mode.onmode('');
-            editor.file.saveFloorFile(function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                ;printf('保存成功');
-            });
-        }
-
-        var newMap = document.getElementById('newMap');
-        var newFileName = document.getElementById('newFileName');
-        newMap.onclick = function () {
-            if (!newFileName.value) return;
-            if (core.floorIds.indexOf(newFileName.value)>=0) {
-                printe("该楼层已存在！");
-                return;
-            }
-            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newFileName.value)) {
-                printe("楼层名不合法！请使用字母、数字、下划线，且不能以数字开头！");
-                return;
-            }
-            var width = parseInt(document.getElementById('newMapWidth').value);
-            var height = parseInt(document.getElementById('newMapHeight').value);
-            if (!core.isset(width) || !core.isset(height) || width<13 || height<13 || width*height>1000) {
-                printe("新建地图的宽高都不得小于13，且宽高之积不能超过1000");
-                return;
-            }
-
-            editor_mode.onmode('');
-            editor.file.saveNewFile(newFileName.value, function (err) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                core.floorIds.push(newFileName.value);
-                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {/*console.log(objs_);*/
-                    if (objs_.slice(-1)[0] != null) {
-                        printe(objs_.slice(-1)[0]);
-                        throw(objs_.slice(-1)[0])
-                    }
-                    ;printe('新建成功,请F5刷新编辑器生效');
-                });
-            });
-        }
-
-        var ratio = 1;
-        var appendPicCanvas = document.getElementById('appendPicCanvas');
-        var bg = appendPicCanvas.children[0];
-        var source = appendPicCanvas.children[1];
-        var picClick = appendPicCanvas.children[2];
-        var sprite = appendPicCanvas.children[3];
-        var appendPicSelection = document.getElementById('appendPicSelection');
-
-        var selectAppend = document.getElementById('selectAppend');
-        var selectAppend_str = [];
-        ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48"].forEach(function (image) {
-            selectAppend_str.push(["<option value='", image, "'>", image, '</option>\n'].join(''));
-        });
-        selectAppend.innerHTML = selectAppend_str.join('');
-        selectAppend.onchange = function () {
-            var value = selectAppend.value;
-            var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-            editor_mode.appendPic.imageName = value;
-            var img = editor.material.images[value];
-            editor_mode.appendPic.toImg = img;
-            var num = ~~img.width / 32;
-            editor_mode.appendPic.num = num;
-            editor_mode.appendPic.index = 0;
-            var selectStr = '';
-            for (var ii = 0; ii < num; ii++) {
-                appendPicSelection.children[ii].style = 'left:0;top:0;height:' + (ysize - 6) + 'px';
-                selectStr += '{"x":0,"y":0},'
-            }
-            editor_mode.appendPic.selectPos = eval('[' + selectStr + ']');
-            for (var jj = num; jj < 4; jj++) {
-                appendPicSelection.children[jj].style = 'display:none';
-            }
-            sprite.style.width = (sprite.width = img.width) / ratio + 'px';
-            sprite.style.height = (sprite.height = img.height + ysize) / ratio + 'px';
-            sprite.getContext('2d').drawImage(img, 0, 0);
-        }
-        selectAppend.onchange();
-
-        var selectFileBtn = document.getElementById('selectFileBtn');
-        selectFileBtn.onclick = function () {
-            var loadImage = function (content, callback) {
-                var image = new Image();
-                try {
-                    image.src = content;
-                    if (image.complete) {
-                        callback(image);
-                        return;
-                    }
-                    image.onload = function () {
-                        callback(image);
-                    }
-                }
-                catch (e) {
-                    printe(e);
-                }
-            }
-            core.readFile(function (content) {
-                loadImage(content, function (image) {
-                    editor_mode.appendPic.img = image;
-                    editor_mode.appendPic.width = image.width;
-                    editor_mode.appendPic.height = image.height;
-                    var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-                    for (var ii = 0; ii < 3; ii++) {
-                        var newsprite = appendPicCanvas.children[ii];
-                        newsprite.style.width = (newsprite.width = Math.floor(image.width / 32) * 32) / ratio + 'px';
-                        newsprite.style.height = (newsprite.height = Math.floor(image.height / ysize) * ysize) / ratio + 'px';
-                    }
-
-                    //画灰白相间的格子
-                    var bgc = bg.getContext('2d');
-                    var colorA = ["#f8f8f8", "#cccccc"];
-                    var colorIndex;
-                    var sratio = 4;
-                    for (var ii = 0; ii < image.width / 32 * sratio; ii++) {
-                        colorIndex = 1 - ii % 2;
-                        for (var jj = 0; jj < image.height / 32 * sratio; jj++) {
-                            bgc.fillStyle = colorA[colorIndex];
-                            colorIndex = 1 - colorIndex;
-                            bgc.fillRect(ii * 32 / sratio, jj * 32 / sratio, 32 / sratio, 32 / sratio);
-                        }
-                    }
-
-                    //把导入的图片画出
-                    source.getContext('2d').drawImage(image, 0, 0);
-
-                    //重置临时变量
-                    selectAppend.onchange();
-                });
-            }, null, 'img');
-
-            return;
-        }
-
-        var left1 = document.getElementById('left1');
-        var eToLoc = function (e) {
-            var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
-            var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
-            var loc = {
-                'x': scrollLeft + e.clientX + appendPicCanvas.scrollLeft - left1.offsetLeft - appendPicCanvas.offsetLeft,
-                'y': scrollTop + e.clientY + appendPicCanvas.scrollTop - left1.offsetTop - appendPicCanvas.offsetTop,
-                'size': 32,
-                'ysize': selectAppend.value.indexOf('48') === -1 ? 32 : 48
-            };
-            return loc;
-        }//返回可用的组件内坐标
-
-        var locToPos = function (loc) {
-            var pos = {'x': ~~(loc.x / loc.size), 'y': ~~(loc.y / loc.ysize), 'ysize': loc.ysize}
-            return pos;
-        }
-
-        picClick.onclick = function (e) {
-            var loc = eToLoc(e);
-            var pos = locToPos(loc);
-            /*console.log(e,loc,pos);*/
-            var num = editor_mode.appendPic.num;
-            var ii = editor_mode.appendPic.index;
-            if (ii + 1 >= num) editor_mode.appendPic.index = ii + 1 - num;
-            else editor_mode.appendPic.index++;
-            editor_mode.appendPic.selectPos[ii] = pos;
-            appendPicSelection.children[ii].style = [
-                'left:', pos.x * 32, 'px;',
-                'top:', pos.y * pos.ysize, 'px;',
-                'height:', pos.ysize - 6, 'px;'
-            ].join('');
-        }
-
-        var appendConfirm = document.getElementById('appendConfirm');
-        appendConfirm.onclick = function () {
-            var ysize = selectAppend.value.indexOf('48') === -1 ? 32 : 48;
-            var sprited = sprite.getContext('2d');
-            //sprited.drawImage(img, 0, 0);
-            var height = editor_mode.appendPic.toImg.height;
-            var sourced = source.getContext('2d');
-            for (var ii = 0, v; v = editor_mode.appendPic.selectPos[ii]; ii++) {
-                // var imgData = sourced.getImageData(v.x * 32, v.y * ysize, 32, ysize);
-                // sprited.putImageData(imgData, ii * 32, height);
-                sprited.drawImage(editor_mode.appendPic.img, v.x * 32, v.y * ysize, 32, ysize,  ii * 32, height,  32, ysize)
-            }
-            var imgbase64 = sprite.toDataURL().split(',')[1];
-            fs.writeFile('./project/images/' + editor_mode.appendPic.imageName + '.png', imgbase64, 'base64', function (err, data) {
-                if (err) {
-                    printe(err);
-                    throw(err)
-                }
-                printe('追加素材成功,请F5刷新编辑器');
-            });
-        }
-
-        var editModeSelect = document.getElementById('editModeSelect');
-        editModeSelect.onchange = function () {
-            editor_mode.onmode('nextChange');
-            editor_mode.onmode(editModeSelect.value);
-            if(editor.isMobile)editor.showdataarea(false);
-        }
-
-        if (Boolean(callback)) callback();
+        // 移动至 editor_unsorted_2.js
     }
 
     var editor_mode = new editor_mode();

_server/editor_multi.js

@@ -1,3 +1,5 @@
+
+
 editor_multi = function () {
 
     var editor_multi = {};
@@ -19,6 +21,8 @@ editor_multi = function () {
         highlightSelectionMatches: { showToken: /\w/, annotateScrollbar: true }
     });
 
+    editor_multi.codeEditor = codeEditor;
+
     codeEditor.on("keyup", function (cm, event) {
         if (codeEditor.getOption("autocomplete") && !event.ctrlKey && (
             (event.keyCode >= 65 && event.keyCode <= 90) ||
@@ -35,7 +39,7 @@ editor_multi = function () {
     editor_multi.lintAutocomplete = false;
 
     editor_multi.show = function () {
-        if (typeof(selectBox) !== typeof(undefined)) selectBox.isSelected = false;
+        if (typeof (selectBox) !== typeof (undefined)) selectBox.isSelected(false);
         var valueNow = codeEditor.getValue();
         //try{eval('function _asdygakufyg_() { return '+valueNow+'\n}');editor_multi.lintAutocomplete=true;}catch(ee){}
         if (valueNow.slice(0, 8) === 'function') editor_multi.lintAutocomplete = true;
@@ -60,6 +64,24 @@ editor_multi = function () {
         return '\t';
     }
 
+    var _format = function () {
+        if (!editor_multi.lintAutocomplete) return;
+        codeEditor.setValue(js_beautify(codeEditor.getValue(), {
+            brace_style: "collapse-preserve-inline",
+            indent_with_tabs: true,
+            jslint_happy: true
+        }));
+    }
+
+    editor_multi.format = function () {
+        if (!editor_multi.lintAutocomplete) {
+            alert("只有代码才能进行格式化操作！");
+            return;
+        }
+        _format();
+    }
+
+
     editor_multi.import = function (id_, args) {
         var thisTr = document.getElementById(id_);
         if (!thisTr) return false;
@@ -81,7 +103,7 @@ editor_multi = function () {
             var tmap = {};
             var tstr = JSON.stringify(tobj, function (k, v) {
                 if (typeof (v) === typeof ('') && v.slice(0, 8) === 'function') {
-                    var id_ = editor.guid();
+                    var id_ = editor.util.guid();
                     tmap[id_] = v.toString();
                     return id_;
                 } else return v
@@ -106,11 +128,22 @@ editor_multi = function () {
             editor_multi.id = '';
             return;
         }
+
         if (editor_multi.id === 'callFromBlockly') {
+            // ----- 自动格式化
+            _format();
             editor_multi.id = '';
             editor_multi.multiLineDone();
             return;
         }
+
+        if (editor_multi.id === 'importFile') {
+            _format();
+            editor_multi.id = '';
+            editor_multi.writeFileDone();
+            return;
+        }
+
         var setvalue = function (value) {
             var thisTr = document.getElementById(editor_multi.id);
             editor_multi.id = '';
@@ -122,7 +155,7 @@ editor_multi = function () {
                 var tmap = {};
                 var tstr = JSON.stringify(tobj, function (k, v) {
                     if (v instanceof Function) {
-                        var id_ = editor.guid();
+                        var id_ = editor.util.guid();
                         tmap[id_] = v.toString();
                         return id_;
                     } else return v
@@ -135,6 +168,8 @@ editor_multi = function () {
             editor_multi.hide();
             input.onchange();
         }
+        // ----- 自动格式化
+        _format();
         setvalue(codeEditor.getValue() || '');
     }
 
@@ -155,6 +190,49 @@ editor_multi = function () {
         multiLineArgs[2](newvalue, multiLineArgs[0], multiLineArgs[1])
     }
 
+    var _fileValues = ['']
+    editor_multi.importFile = function (filename) {
+        editor_multi.id = 'importFile'
+        _fileValues[0] = filename
+        codeEditor.setValue('loading')
+        editor_multi.show();
+        fs.readFile(filename, 'base64', function (e, d) {
+            if (e) {
+                codeEditor.setValue('加载文件失败:\n' + e)
+                editor_multi.id = ''
+                return;
+            }
+            var str = editor.util.decode64(d)
+            codeEditor.setValue(str)
+            _fileValues[1] = str
+        })
+    }
+
+    editor_multi.writeFileDone = function () {
+        fs.writeFile(_fileValues[0], editor.util.encode64(codeEditor.getValue() || ''), 'base64', function (err, data) {
+            if (err) printe('文件写入失败,请手动粘贴至' + _fileValues[0] + '\n' + err);
+            else {
+                editor_multi.hide();
+                printf(_fileValues[0] + " 写入成功，F5刷新后生效");
+            }
+        });
+    }
+
+    editor_multi.editCommentJs = function (mod) {
+        var dict = {
+            loc: '_server/table/comment.js',
+            enemyitem: '_server/table/comment.js',
+            floor: '_server/table/comment.js',
+            tower: '_server/table/data.comment.js',
+            functions: '_server/table/functions.comment.js',
+            commonevent: '_server/table/events.comment.js',
+            plugins: '_server/table/plugins.comment.js',
+        }
+        editor_multi.lintAutocomplete = true
+        editor_multi.setLint()
+        editor_multi.importFile(dict[mod])
+    }
+
     return editor_multi;
 }
 //editor_multi=editor_multi();

_server/editor_table.js

@@ -0,0 +1,383 @@
+editor_table_wrapper = function (editor) {
+
+    editor_table = function () {
+
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // HTML模板
+
+    editor_table.prototype.select = function (value, values) {
+        let content = editor.table.option(value) +
+            values.map(function (v) {
+                return editor.table.option(v)
+            }).join('')
+        return /* html */`<select>\n${content}</select>\n`
+    }
+    editor_table.prototype.option = function (value) {
+        return /* html */`<option value='${JSON.stringify(value)}'>${JSON.stringify(value)}</option>\n`
+    }
+    editor_table.prototype.text = function (value) {
+        return /* html */`<input type='text' spellcheck='false' value='${JSON.stringify(value)}'/>\n`
+    }
+    editor_table.prototype.checkbox = function (value) {
+        return /* html */`<input type='checkbox' ${(value ? 'checked ' : '')}/>\n`
+    }
+    editor_table.prototype.textarea = function (value, indent) {
+        return /* html */`<textarea spellcheck='false'>${JSON.stringify(value, null, indent || 0)}</textarea>\n`
+    }
+
+    editor_table.prototype.title = function () {
+        return /* html */`\n<tr><td>条目</td><td>注释</td><td>值</td></tr>\n`
+    }
+
+    editor_table.prototype.gap = function (field) {
+        return /* html */`<tr><td>----</td><td>----</td><td>${field}</td></tr>\n`
+    }
+
+    editor_table.prototype.tr = function (guid, field, shortField, commentHTMLescape, cobjstr, shortCommentHTMLescape, tdstr) {
+        return /* html */`<tr id="${guid}">
+        <td title="${field}">${shortField}</td>
+        <td title="${commentHTMLescape}" cobj="${cobjstr}">${shortCommentHTMLescape}</td>
+        <td><div class="etableInputDiv">${tdstr}</div></td>
+        </tr>\n`
+    }
+
+
+    /////////////////////////////////////////////////////////////////////////////
+    // 表格生成的控制
+
+    /**
+     * 注释对象的默认值
+     */
+    editor_table.prototype.defaultcobj = {
+        // 默认是文本域
+        _type: 'textarea',
+        _data: '',
+        _string: function (args) {//object~[field,cfield,vobj,cobj]
+            var thiseval = args.vobj;
+            return (typeof (thiseval) === typeof ('')) && thiseval[0] === '"';
+        },
+        // 默认情况下 非对象和数组的视为叶节点
+        _leaf: function (args) {//object~[field,cfield,vobj,cobj]
+            var thiseval = args.vobj;
+            if (thiseval == null || thiseval == undefined) return true;//null,undefined
+            if (typeof (thiseval) === typeof ('')) return true;//字符串
+            if (Object.keys(thiseval).length === 0) return true;//数字,true,false,空数组,空对象
+            return false;
+        },
+    }
+
+    /**
+     * 把来自数据文件的obj和来自*comment.js的commentObj组装成表格
+     * commentObj在无视['_data']的意义下与obj同形
+     * 即: commentObj['_data']['a']['_data']['b'] 与 obj['a']['b'] 是对应的
+     *     在此意义下, 两者的结构是一致的
+     *     在commentObj没有被定义的obj的分支, 会取defaultcobj作为默认值
+     * 因此在深度优先遍历时,维护 
+     *     field="['a']['b']"
+     *     cfield="['_data']['a']['_data']['b']"
+     *     vobj=obj['a']['b']
+     *     cobj=commentObj['_data']['a']['_data']['b']
+     * cobj
+     *     cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii])
+     *     每一项若未定义,就从defaultcobj中取
+     *     当其是函数不是具体值时,把args = {field: field, cfield: cfield, vobj: vobj, cobj: cobj}代入算出该值
+     * 得到的叶节点的<tr>结构如下
+     *     tr>td[title=field]
+     *       >td[title=comment,cobj=cobj:json]
+     *       >td>div>input[value=thiseval]
+     * 返回结果
+     *     返回一个对象, 假设被命名为tableinfo
+     *     在把一个 table 的 innerHTML 赋值为 tableinfo.HTML 后
+     *     再调 tableinfo.listen(tableinfo.guids) 进行绑定事件
+     * @param {Object} obj 
+     * @param {Object} commentObj 
+     * @returns {{"HTML":String,"guids":String[],"listen":Function}}
+     */
+    editor_table.prototype.objToTable = function (obj, commentObj) {
+        // 表格抬头
+        var outstr = [editor.table.title()];
+        var guids = [];
+        var defaultcobj = this.defaultcobj
+        /**
+         * 深度优先遍历, p*即为父节点的四个属性
+         * @param {String} pfield 
+         * @param {String} pcfield 
+         * @param {Object} pvobj 
+         * @param {Object} pcobj 
+         */
+        var recursionParse = function (pfield, pcfield, pvobj, pcobj) {
+            var keysForTableOrder = {};
+            var voidMark = {};
+            // 1. 按照pcobj排序生成
+            if (pcobj && pcobj['_data']) {
+                for (var ii in pcobj['_data']) keysForTableOrder[ii] = voidMark;
+            }
+            // 2. 对每个pvobj且不在pcobj的，再添加到最后
+            keysForTableOrder = Object.assign(keysForTableOrder, pvobj)
+            for (var ii in keysForTableOrder) {
+                // 3. 对于pcobj有但是pvobj中没有的, 弹出提示, (正常情况下editor_file会补全成null)
+                //    事实上能执行到这一步工程没崩掉打不开,就继续吧..
+                if (keysForTableOrder[ii] === voidMark) {
+                    if (typeof id_815975ad_ee6f_4684_aac7_397b7e392702 === "undefined") {
+                        // alert('comment和data不匹配,请在群 HTML5造塔技术交流群 959329661 内反馈')
+                        console.error('comment和data不匹配,请在群 HTML5造塔技术交流群 959329661 内反馈')
+                        id_815975ad_ee6f_4684_aac7_397b7e392702 = 1;
+                    }
+                    pvobj[ii] = null;
+                }
+                var field = pfield + "['" + ii + "']";
+                var cfield = pcfield + "['_data']['" + ii + "']";
+                var vobj = pvobj[ii];
+                var cobj = null;
+                if (pcobj && pcobj['_data'] && pcobj['_data'][ii]) {
+                    // cobj存在时直接取
+                    cobj = Object.assign({}, defaultcobj, pcobj['_data'][ii]);
+                } else {
+                    // 当其函数时代入参数算出cobj, 不存在时只取defaultcobj
+                    if (pcobj && (pcobj['_data'] instanceof Function)) cobj = Object.assign({}, defaultcobj, pcobj['_data'](ii));
+                    else cobj = Object.assign({}, defaultcobj);
+                }
+                var args = { field: field, cfield: cfield, vobj: vobj, cobj: cobj }
+                // 当cobj的参数为函数时,代入args算出值
+                for (var key in cobj) {
+                    if (key === '_data') continue;
+                    if (cobj[key] instanceof Function) cobj[key] = cobj[key](args);
+                }
+                // 标记为_hide的属性不展示
+                if (cobj._hide) continue;
+                if (!cobj._leaf) {
+                    // 不是叶节点时, 插入展开的标记并继续遍历, 此处可以改成按钮用来添加新项或折叠等
+                    outstr.push(editor.table.gap(field));
+                    recursionParse(field, cfield, vobj, cobj);
+                } else {
+                    // 是叶节点时, 调objToTr_渲染<tr>
+                    var leafnode = editor.table.objToTr(obj, commentObj, field, cfield, vobj, cobj);
+                    outstr.push(leafnode[0]);
+                    guids.push(leafnode[1]);
+                }
+            }
+        }
+        // 开始遍历
+        recursionParse("", "", obj, commentObj);
+
+        var listen = function (guids) {
+            // 每个叶节点的事件绑定
+            guids.forEach(function (guid) {
+                editor.table.guidListen(guid, obj, commentObj)
+            });
+        }
+        return { "HTML": outstr.join(''), "guids": guids, "listen": listen };
+    }
+
+    /**
+     * 返回叶节点<tr>形如
+     * tr>td[title=field]
+     *   >td[title=comment,cobj=cobj:json]
+     *   >td>div>input[value=thiseval]
+     * 参数意义在 objToTable 中已解释
+     * @param {Object} obj 
+     * @param {Object} commentObj 
+     * @param {String} field 
+     * @param {String} cfield 
+     * @param {Object} vobj 
+     * @param {Object} cobj 
+     */
+    editor_table.prototype.objToTr = function (obj, commentObj, field, cfield, vobj, cobj) {
+        var guid = editor.util.guid();
+        var thiseval = vobj;
+        var comment = String(cobj._data);
+
+        var charlength = 10;
+        // "['a']['b']" => "b"
+        var shortField = field.split("']").slice(-2)[0].split("['").slice(-1)[0];
+        // 把长度超过 charlength 的字符改成 固定长度+...的形式
+        shortField = (shortField.length < charlength ? shortField : shortField.slice(0, charlength) + '...');
+
+        // 完整的内容转义后供悬停查看
+        var commentHTMLescape = editor.util.HTMLescape(comment);
+        // 把长度超过 charlength 的字符改成 固定长度+...的形式
+        var shortCommentHTMLescape = (comment.length < charlength ? commentHTMLescape : editor.util.HTMLescape(comment.slice(0, charlength)) + '...');
+
+        var cobjstr = Object.assign({}, cobj);
+        delete cobjstr._data;
+        // 把cobj塞到第二个td的[cobj]中, 方便绑定事件时取
+        cobjstr = editor.util.HTMLescape(JSON.stringify(cobjstr));
+
+        var tdstr = editor.table.objToTd(obj, commentObj, field, cfield, vobj, cobj)
+        var outstr = editor.table.tr(guid, field, shortField, commentHTMLescape, cobjstr, shortCommentHTMLescape, tdstr)
+        return [outstr, guid];
+    }
+
+    editor_table.prototype.objToTd = function (obj, commentObj, field, cfield, vobj, cobj) {
+        var thiseval = vobj;
+        if (cobj._select) {
+            var values = cobj._select.values;
+            return editor.table.select(thiseval, values);
+        } else if (cobj._input) {
+            return editor.table.text(thiseval);
+        } else if (cobj._bool) {
+            return editor.table.checkbox(thiseval);
+        } else {
+            var indent = 0;
+            return editor.table.textarea(thiseval, indent);
+        }
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    // 表格的用户交互
+
+    /**
+     * 检查一个值是否允许被设置为当前输入
+     * @param {Object} cobj 
+     * @param {*} thiseval 
+     */
+    editor_table.prototype.checkRange = function (cobj, thiseval) {
+        if (cobj._range) {
+            return eval(cobj._range);
+        }
+        if (cobj._select) {
+            return cobj._select.values.indexOf(thiseval) !== -1;
+        }
+        if (cobj._bool) {
+            return [true, false].indexOf(thiseval) !== -1;
+        }
+        return true;
+    }
+
+    /**
+     * 监听一个guid对应的表格项
+     * @param {String} guid 
+     */
+    editor_table.prototype.guidListen = function (guid, obj, commentObj) {
+        // tr>td[title=field]
+        //   >td[title=comment,cobj=cobj:json]
+        //   >td>div>input[value=thiseval]
+        var thisTr = document.getElementById(guid);
+        var input = thisTr.children[2].children[0].children[0];
+        var field = thisTr.children[0].getAttribute('title');
+        var cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
+        var modeNode = thisTr.parentNode;
+        while (!editor_mode._ids.hasOwnProperty(modeNode.getAttribute('id'))) {
+            modeNode = modeNode.parentNode;
+        }
+        input.onchange = function () {
+            editor.table.onchange(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        }
+        // 用检测两次单击的方式来实现双击(以支持手机端的双击)
+        var doubleClickCheck = [0];
+        thisTr.onclick = function () {
+            var newClick = new Date().getTime();
+            var lastClick = doubleClickCheck.shift();
+            doubleClickCheck.push(newClick);
+            if (newClick - lastClick < 500) {
+                editor.table.dblclickfunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+            }
+        }
+    }
+
+    /**
+     * 表格的值变化时
+     */
+    editor_table.prototype.onchange = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+        var thiseval = null;
+        if (input.checked != null) input.value = input.checked;
+        try {
+            thiseval = JSON.parse(input.value);
+        } catch (ee) {
+            printe(field + ' : ' + ee);
+            throw ee;
+        }
+        if (editor.table.checkRange(cobj, thiseval)) {
+            editor_mode.addAction(['change', field, thiseval]);
+            editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+        } else {
+            printe(field + ' : 输入的值不合要求,请鼠标放置在注释上查看说明');
+        }
+    }
+
+    /**
+     * 双击表格时
+     *     正常编辑: 尝试用事件编辑器或多行文本编辑器打开
+     *     添加: 在该项的同一级创建一个内容为null新的项, 刷新后生效并可以继续编辑
+     *     删除: 删除该项, 刷新后生效
+     * 在点击按钮 添加/删除 后,下一次双击将被视为 添加/删除
+     */
+    editor_table.prototype.dblclickfunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        if (editor_mode.doubleClickMode === 'change') {
+            if (cobj._type === 'event') editor_blockly.import(guid, { type: cobj._event });
+            if (cobj._type === 'textarea') editor_multi.import(guid, { lint: cobj._lint, string: cobj._string });
+        } else if (editor_mode.doubleClickMode === 'add') {
+            editor_mode.doubleClickMode = 'change';
+            editor.table.addfunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        } else if (editor_mode.doubleClickMode === 'delete') {
+            editor_mode.doubleClickMode = 'change';
+            editor.table.deletefunc(guid, obj, commentObj, thisTr, input, field, cobj, modeNode)
+        }
+    }
+
+    /**
+     * 删除表格项
+     */
+    editor_table.prototype.deletefunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+        if (editor.table.checkRange(cobj, null)) {
+            editor_mode.addAction(['delete', field, undefined]);
+            editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+        } else {
+            printe(field + ' : 该值不允许为null，无法删除');
+        }
+    }
+
+    /**
+     * 添加表格项
+     */
+    editor_table.prototype.addfunc = function (guid, obj, commentObj, thisTr, input, field, cobj, modeNode) {
+        editor_mode.onmode(editor_mode._ids[modeNode.getAttribute('id')]);
+
+        var mode = document.getElementById('editModeSelect').value;
+
+        // 1.输入id
+        var newid = prompt('请输入新项的ID（仅公共事件支持中文ID）');
+        if (newid == null || newid.length == 0) {
+            return;
+        }
+
+        // 检查commentEvents
+        if (mode !== 'commonevent') {
+            // 2.检查id是否符合规范或与已有id重复
+            if (!/^[a-zA-Z0-9_]+$/.test(newid)) {
+                printe('id不符合规范, 请使用大小写字母数字下划线来构成');
+                return;
+            }
+        }
+
+        var conflict = true;
+        var basefield = field.replace(/\[[^\[]*\]$/, '');
+        if (basefield === "['main']") {
+            printe("全塔属性 ~ ['main'] 不允许添加新值");
+            return;
+        }
+        try {
+            var baseobj = eval('obj' + basefield);
+            conflict = newid in baseobj;
+        } catch (ee) {
+            // 理论上这里不会发生错误
+            printe(ee);
+            throw ee;
+        }
+        if (conflict) {
+            printe('id已存在, 请直接修改该项的值');
+            return;
+        }
+        // 3.添加 
+        editor_mode.addAction(['add', basefield + "['" + newid + "']", null]);
+        editor_mode.onmode('save');//自动保存 删掉此行的话点保存按钮才会保存
+    }
+
+    /////////////////////////////////////////////////////////////////////////////
+    editor.constructor.prototype.table = new editor_table();
+}
+//editor_table_wrapper(editor);

_server/editor_unsorted_1.js

@@ -0,0 +1,839 @@
+editor_unsorted_1_wrapper=function(editor){
+
+editor.constructor.prototype.listen=function () {
+    document.body.onmousedown = function (e) {
+        //console.log(e);
+        var clickpath = [];
+        var getpath=function(e) {
+            var path = [];
+            var currentElem = e.target;
+            while (currentElem) {
+                path.push(currentElem);
+                currentElem = currentElem.parentElement;
+            }
+            if (path.indexOf(window) === -1 && path.indexOf(document) === -1)
+                path.push(document);
+            if (path.indexOf(window) === -1)
+                path.push(window);
+            return path;
+        }
+        getpath(e).forEach(function (node) {
+            if (!node.getAttribute) return;
+            var id_ = node.getAttribute('id');
+            if (id_) {
+                if (['left', 'left1', 'left2', 'left3', 'left4', 'left5', 'left8', 'mobileview'].indexOf(id_) !== -1) clickpath.push('edit');
+                clickpath.push(id_);
+            }
+        });
+    
+        var unselect=true;
+        for(var ii=0,thisId;thisId=['edit','tip','brushMod','brushMod2','brushMod3','layerMod','layerMod2','layerMod3','viewportButtons'][ii];ii++){
+            if (clickpath.indexOf(thisId) !== -1){
+                unselect=false;
+                break;
+            }
+        }
+        if (unselect) {
+            if (clickpath.indexOf('eui') === -1) {
+                if (selectBox.isSelected()) {
+                    editor_mode.onmode('');
+                    editor.file.saveFloorFile(function (err) {
+                        if (err) {
+                            printe(err);
+                            throw(err)
+                        }
+                        ;printf('地图保存成功');
+                    });
+                }
+                selectBox.isSelected(false);
+                editor.info = {};
+            }
+        }
+        //editor.mode.onmode('');
+        if (e.button!=2 && !editor.isMobile){
+            editor.hideMidMenu();
+        }
+        if (clickpath.indexOf('down') !== -1 && editor.isMobile && clickpath.indexOf('midMenu') === -1){
+            editor.hideMidMenu();
+        }
+        if(clickpath.length>=2 && clickpath[0].indexOf('id_')===0){editor.lastClickId=clickpath[0]}
+    }
+
+    var eui=document.getElementById('eui');
+    var uc = eui.getContext('2d');
+
+    function fillPos(pos) {
+        uc.fillStyle = '#' + ~~(Math.random() * 8) + ~~(Math.random() * 8) + ~~(Math.random() * 8);
+        uc.fillRect(pos.x * 32 + 12 - core.bigmap.offsetX, pos.y * 32 + 12 - core.bigmap.offsetY, 8, 8);
+    }//在格子内画一个随机色块
+
+    function eToLoc(e) {
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
+        var xx=e.clientX,yy=e.clientY
+        if(editor.isMobile){xx=e.touches[0].clientX,yy=e.touches[0].clientY}
+        editor.loc = {
+            'x': scrollLeft + xx - mid.offsetLeft - mapEdit.offsetLeft,
+            'y': scrollTop + yy - mid.offsetTop - mapEdit.offsetTop,
+            'size': editor.isMobile?(32*innerWidth*0.96/core.__PIXELS__):32
+        };
+        return editor.loc;
+    }//返回可用的组件内坐标
+
+    function locToPos(loc, addViewportOffset) {
+        var offsetX=0, offsetY=0;
+        if (addViewportOffset){
+            offsetX=core.bigmap.offsetX/32;
+            offsetY=core.bigmap.offsetY/32;
+        }
+        editor.pos = {'x': ~~(loc.x / loc.size)+offsetX, 'y': ~~(loc.y / loc.size)+offsetY}
+        return editor.pos;
+    }
+
+    var holdingPath = 0;
+    var stepPostfix = null;//用于存放寻路检测的第一个点之后的后续移动
+
+    var mouseOutCheck = 2;
+
+    function clear1() {
+        if (mouseOutCheck > 1) {
+            mouseOutCheck--;
+            setTimeout(clear1, 1000);
+            return;
+        }
+        holdingPath = 0;
+        stepPostfix = [];
+        uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+    }//用于鼠标移出canvas时的自动清除状态
+
+    eui.oncontextmenu=function(e){e.preventDefault()}
+
+    eui.ondblclick = function(e) {
+        // 双击地图可以选中素材
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        editor.setSelectBoxFromInfo(editor[editor.layerMod][pos.y][pos.x]);
+        return;
+    }
+
+    eui.onmousedown = function (e) {
+        if (e.button==2){
+            var loc = eToLoc(e);
+            var pos = locToPos(loc,true);
+            editor.showMidMenu(e.clientX,e.clientY);
+            return;
+        }
+        if (!selectBox.isSelected()) {
+            var loc = eToLoc(e);
+            var pos = locToPos(loc,true);
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode('loc');
+            //editor_mode.loc();
+            //tip.whichShow(1);
+            if(editor.isMobile)editor.showMidMenu(e.clientX,e.clientY);
+            return;
+        }
+        
+
+        holdingPath = 1;
+        mouseOutCheck = 2;
+        setTimeout(clear1);
+        e.stopPropagation();
+        uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        stepPostfix = [];
+        stepPostfix.push(pos);
+        fillPos(pos);
+    }
+
+    eui.onmousemove = function (e) {
+        if (!selectBox.isSelected()) {
+            //tip.whichShow(1);
+            return;
+        }
+
+        if (holdingPath == 0) {
+            return;
+        }
+        mouseOutCheck = 2;
+        e.stopPropagation();
+        var loc = eToLoc(e);
+        var pos = locToPos(loc,true);
+        var pos0 = stepPostfix[stepPostfix.length - 1]
+        var directionDistance = [pos.y - pos0.y, pos0.x - pos.x, pos0.y - pos.y, pos.x - pos0.x]
+        var max = 0, index = 4;
+        for (var i = 0; i < 4; i++) {
+            if (directionDistance[i] > max) {
+                index = i;
+                max = directionDistance[i];
+            }
+        }
+        var pos = [{'x': 0, 'y': 1}, {'x': -1, 'y': 0}, {'x': 0, 'y': -1}, {'x': 1, 'y': 0}, false][index]
+        if (pos) {
+            pos.x += pos0.x;
+            pos.y += pos0.y;
+            stepPostfix.push(pos);
+            fillPos(pos);
+        }
+    }
+
+    eui.onmouseup = function (e) {
+        if (!selectBox.isSelected()) {
+            //tip.whichShow(1);
+            return;
+        }
+        holdingPath = 0;
+        e.stopPropagation();
+        if (stepPostfix && stepPostfix.length) {
+            editor.preMapData = JSON.parse(JSON.stringify({map:editor.map,fgmap:editor.fgmap,bgmap:editor.bgmap}));
+            if(editor.brushMod!=='line'){
+                var x0=stepPostfix[0].x;
+                var y0=stepPostfix[0].y;
+                var x1=stepPostfix[stepPostfix.length-1].x;
+                var y1=stepPostfix[stepPostfix.length-1].y;
+                if(x0>x1){x0^=x1;x1^=x0;x0^=x1;}//swap
+                if(y0>y1){y0^=y1;y1^=y0;y0^=y1;}//swap
+                stepPostfix=[];
+                for(var jj=y0;jj<=y1;jj++){
+                    for(var ii=x0;ii<=x1;ii++){
+                        stepPostfix.push({x:ii,y:jj})
+                    }
+                }
+            }
+            currDrawData.pos = JSON.parse(JSON.stringify(stepPostfix));
+            currDrawData.info = JSON.parse(JSON.stringify(editor.info));
+            reDo = null;
+            // console.log(stepPostfix);
+            if(editor.brushMod==='tileset' && core.tilesets.indexOf(editor.info.images)!==-1){
+                var imgWidth=~~(core.material.images.tilesets[editor.info.images].width/32);
+                var x0=stepPostfix[0].x;
+                var y0=stepPostfix[0].y;
+                var idnum=editor.info.idnum;
+                for (var ii = 0; ii < stepPostfix.length; ii++){
+                    if(stepPostfix[ii].y!=y0){
+                        y0++;
+                        idnum+=imgWidth;
+                    }
+                    editor[editor.layerMod][stepPostfix[ii].y][stepPostfix[ii].x] = editor.ids[editor.indexs[idnum+stepPostfix[ii].x-x0]];
+                }
+            } else {
+                for (var ii = 0; ii < stepPostfix.length; ii++)
+                editor[editor.layerMod][stepPostfix[ii].y][stepPostfix[ii].x] = editor.info;
+            }
+            // console.log(editor.map);
+            editor.updateMap();
+            holdingPath = 0;
+            stepPostfix = [];
+            uc.clearRect(0, 0, core.__PIXELS__, core.__PIXELS__);
+        }
+    }
+
+    /*
+    document.getElementById('mid').onkeydown = function (e) {
+        console.log(e);
+        if (e.keyCode==37) {
+            editor.moveViewport(-1, 0);
+        }
+        if (e.keyCode==38) {
+            editor.moveViewport(0, -1);
+        }
+        if (e.keyCode==39) {
+            editor.moveViewport(1, 0);
+        }
+        if (e.keyCode==40) {
+            editor.moveViewport(0, 1);
+        }
+    }
+    */
+
+    document.getElementById('mid').onmousewheel = function (e) {
+        e.preventDefault();
+        var wheel = function (direct) {
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            var toId = editor.currentFloorId;
+
+            if (direct>0 && index<editor.core.floorIds.length-1)
+                toId = editor.core.floorIds[index+1];
+            else if (direct<0 && index>0)
+                toId = editor.core.floorIds[index-1];
+            else return;
+
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode('floor');
+            document.getElementById('selectFloor').value = toId;
+            editor.changeFloor(toId);
+        }
+
+        try {
+            if (e.wheelDelta)
+                wheel(Math.sign(e.wheelDelta))
+            else if (e.detail)
+                wheel(Math.sign(e.detail));
+        }
+        catch (ee) {
+            console.log(ee);
+        }
+    }
+
+    editor.preMapData = null;
+    var currDrawData = {
+        pos: [],
+        info: {}
+    };
+    var reDo = null;
+    var shortcut = core.getLocalStorage('shortcut',{48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0});
+    document.body.onkeydown = function (e) {
+
+        // 监听Ctrl+S保存
+        if (e.ctrlKey && e.keyCode == 83) {
+            e.preventDefault();
+            if (editor_multi.id != "") {
+                editor_multi.confirm(); // 保存脚本编辑器
+            }
+            else if (editor_blockly.id != "") {
+                editor_blockly.confirm(); // 保存事件编辑器
+            }
+            else {
+                editor_mode.saveFloor();
+            }
+            return;
+        }
+
+        // 如果是开启事件/脚本编辑器状态，则忽略
+        if (editor_multi.id!="" || editor_blockly.id!="")
+            return;
+
+        // 禁止快捷键的默认行为
+        if (e.ctrlKey && [89, 90, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1)
+            e.preventDefault();
+        if (e.altKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1)
+            e.preventDefault();
+        //Ctrl+z 撤销上一步undo
+        if (e.keyCode == 90 && e.ctrlKey && editor.preMapData && currDrawData.pos.length && selectBox.isSelected()) {
+            editor.map = JSON.parse(JSON.stringify(editor.preMapData.map));
+            editor.fgmap = JSON.parse(JSON.stringify(editor.preMapData.fgmap));
+            editor.bgmap = JSON.parse(JSON.stringify(editor.preMapData.bgmap));
+            editor.updateMap();
+            reDo = JSON.parse(JSON.stringify(currDrawData));
+            currDrawData = {pos: [], info: {}};
+            editor.preMapData = null;
+        }
+        //Ctrl+y 重做一步redo
+        if (e.keyCode == 89 && e.ctrlKey && reDo && reDo.pos.length && selectBox.isSelected()) {
+            editor.preMapData = JSON.parse(JSON.stringify({map:editor.map,fgmap:editor.fgmap,bgmap:editor.bgmap}));
+            for (var j = 0; j < reDo.pos.length; j++)
+                editor.map[reDo.pos[j].y][reDo.pos[j].x] = JSON.parse(JSON.stringify(reDo.info));
+
+            editor.updateMap();
+            currDrawData = JSON.parse(JSON.stringify(reDo));
+            reDo = null;
+        }
+
+        // PGUP和PGDOWN切换楼层
+        if (e.keyCode==33) {
+            e.preventDefault();
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            if (index<editor.core.floorIds.length-1) {
+                var toId = editor.core.floorIds[index+1];
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                document.getElementById('selectFloor').value = toId;
+                editor.changeFloor(toId);
+            }
+        }
+        if (e.keyCode==34) {
+            e.preventDefault();
+            var index=editor.core.floorIds.indexOf(editor.currentFloorId);
+            if (index>0) {
+                var toId = editor.core.floorIds[index-1];
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                document.getElementById('selectFloor').value = toId;
+                editor.changeFloor(toId);
+            }
+        }
+        //ctrl + 0~9 切换到快捷图块
+        if (e.ctrlKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1){
+            editor.setSelectBoxFromInfo(JSON.parse(JSON.stringify(shortcut[e.keyCode]||0)));
+        }
+        //alt + 0~9 改变快捷图块
+        if (e.altKey && [48, 49, 50, 51, 52, 53, 54, 55, 56, 57].indexOf(e.keyCode) !== -1){
+            var infoToSave = JSON.stringify(editor.info||0);
+            if(infoToSave==JSON.stringify({}))return;
+            shortcut[e.keyCode]=JSON.parse(infoToSave);
+            printf('已保存该快捷图块, ctrl + '+(e.keyCode-48)+' 使用.')
+            core.setLocalStorage('shortcut',shortcut);
+        }
+        var focusElement = document.activeElement;
+        if (!focusElement || focusElement.tagName.toLowerCase()=='body') {
+            // wasd平移大地图
+            if (e.keyCode==87)
+                editor.moveViewport(0,-1)
+            else if (e.keyCode==65)
+                editor.moveViewport(-1,0)
+            else if (e.keyCode==83)
+                editor.moveViewport(0,1);
+            else if (e.keyCode==68)
+                editor.moveViewport(1,0);
+        }
+    }
+
+    var getScrollBarHeight = function () {
+        var outer = document.createElement("div");
+        outer.style.visibility = "hidden";
+        outer.style.width = "100px";
+        outer.style.msOverflowStyle = "scrollbar"; // needed for WinJS apps
+
+        document.body.appendChild(outer);
+
+        var widthNoScroll = outer.offsetWidth;
+        // force scrollbars
+        outer.style.overflow = "scroll";
+
+        // add innerdiv
+        var inner = document.createElement("div");
+        inner.style.width = "100%";
+        outer.appendChild(inner);
+
+        var widthWithScroll = inner.offsetWidth;
+
+        // remove divs
+        outer.parentNode.removeChild(outer);
+
+        return widthNoScroll - widthWithScroll;
+    }
+    var scrollBarHeight = getScrollBarHeight();
+
+    var dataSelection = document.getElementById('dataSelection');
+    var iconLib=document.getElementById('iconLib');
+    iconLib.onmousedown = function (e) {
+        e.stopPropagation();
+        if (!editor.isMobile && e.clientY>=((core.__SIZE__==13?630:655) - scrollBarHeight)) return;
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+        var loc = {
+            'x': scrollLeft + e.clientX + iconLib.scrollLeft - right.offsetLeft - iconLib.offsetLeft,
+            'y': scrollTop + e.clientY + iconLib.scrollTop - right.offsetTop - iconLib.offsetTop,
+            'size': 32
+        };
+        editor.loc = loc;
+        var pos = locToPos(loc);
+        for (var spriter in editor.widthsX) {
+            if (pos.x >= editor.widthsX[spriter][1] && pos.x < editor.widthsX[spriter][2]) {
+                var ysize = spriter.indexOf('48') === -1 ? 32 : 48;
+                loc.ysize = ysize;
+                pos.images = editor.widthsX[spriter][0];
+                pos.y = ~~(loc.y / loc.ysize);
+                if(core.tilesets.indexOf(pos.images)==-1)pos.x = editor.widthsX[spriter][1];
+                var autotiles = core.material.images['autotile'];
+                if (pos.images == 'autotile') {
+                    var imNames = Object.keys(autotiles);
+                    if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
+                        pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 4;
+                    else {
+                        for (var i = 0; i < imNames.length; i++) {
+                            if (pos.y >= 4 * i && pos.y < 4 * (i + 1)) {
+                                pos.images = imNames[i];
+                                pos.y = 4 * i;
+                            }
+                        }
+                    }
+                } else if ((pos.y + 1) * ysize > editor.widthsX[spriter][3])
+                    pos.y = ~~(editor.widthsX[spriter][3] / ysize) - 1;
+
+                selectBox.isSelected(true);
+                // console.log(pos,core.material.images[pos.images].height)
+                dataSelection.style.left = pos.x * 32 + 'px';
+                dataSelection.style.top = pos.y * ysize + 'px';
+                dataSelection.style.height = ysize - 6 + 'px';
+
+                if (pos.x == 0 && pos.y == 0) {
+                    // editor.info={idnum:0, id:'empty','images':'清除块', 'y':0};
+                    editor.info = 0;
+                } else if(pos.x == 0 && pos.y == 1){
+                    editor.info = editor.ids[editor.indexs[17]];
+                } else {
+                    if (Object.prototype.hasOwnProperty.call(autotiles, pos.images)) editor.info = {'images': pos.images, 'y': 0};
+                    else if (pos.images == 'terrains') editor.info = {'images': pos.images, 'y': pos.y - 2};
+                    else if (core.tilesets.indexOf(pos.images)!=-1) editor.info = {'images': pos.images, 'y': pos.y, 'x': pos.x-editor.widthsX[spriter][1]};
+                    else editor.info = {'images': pos.images, 'y': pos.y};
+
+                    for (var ii = 0; ii < editor.ids.length; ii++) {
+                        if ((core.tilesets.indexOf(pos.images)!=-1 && editor.info.images == editor.ids[ii].images
+                                && editor.info.y == editor.ids[ii].y && editor.info.x == editor.ids[ii].x)
+                            || (Object.prototype.hasOwnProperty.call(autotiles, pos.images) && editor.info.images == editor.ids[ii].id
+                            && editor.info.y == editor.ids[ii].y)
+                            || (core.tilesets.indexOf(pos.images)==-1 && editor.info.images == editor.ids[ii].images
+                                && editor.info.y == editor.ids[ii].y )
+                            ) {
+
+                            editor.info = editor.ids[ii];
+                            break;
+                        }
+                    }
+                }
+                tip.infos(JSON.parse(JSON.stringify(editor.info)));
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('enemyitem');
+                //editor_mode.enemyitem();
+            }
+        }
+    }
+
+    var midMenu=document.getElementById('midMenu');
+    midMenu.oncontextmenu=function(e){e.preventDefault()}
+    editor.lastRightButtonPos=[{x:0,y:0},{x:0,y:0}];
+    editor.showMidMenu=function(x,y){
+        editor.lastRightButtonPos=JSON.parse(JSON.stringify(
+            [editor.pos,editor.lastRightButtonPos[0]]
+        ));
+        var locStr='('+editor.lastRightButtonPos[1].x+','+editor.lastRightButtonPos[1].y+')';
+        var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
+        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
+
+        // 检测是否是上下楼
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if (thisevent.id=='upFloor') {
+            addFloorEvent.style.display='block';
+            addFloorEvent.children[0].innerHTML='绑定上楼事件';
+        }
+        else if (thisevent.id=='downFloor') {
+            addFloorEvent.style.display='block';
+            addFloorEvent.children[0].innerHTML='绑定下楼事件';
+        }
+        else addFloorEvent.style.display='none';
+
+        chooseThis.children[0].innerHTML='选中此点'+'('+editor.pos.x+','+editor.pos.y+')'
+        copyLoc.children[0].innerHTML='复制事件'+locStr+'到此处';
+        moveLoc.children[0].innerHTML='交换事件'+locStr+'与此事件的位置';
+        midMenu.style='top:'+(y+scrollTop)+'px;left:'+(x+scrollLeft)+'px;';
+    }
+    editor.hideMidMenu=function(){
+        if(editor.isMobile){
+            setTimeout(function(){
+                midMenu.style='display:none';
+            },200)
+        } else {
+            midMenu.style='display:none';
+        }
+    }
+
+    var addFloorEvent = document.getElementById('addFloorEvent');
+    addFloorEvent.onmousedown = function(e) {
+        editor.hideMidMenu();
+        e.stopPropagation();
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if (thisevent.id=='upFloor') {
+            editor.currentFloorData.changeFloor[editor.pos.x+","+editor.pos.y] = {"floorId": ":next", "stair": "downFloor"};
+        }
+        else if (thisevent.id=='downFloor') {
+            editor.currentFloorData.changeFloor[editor.pos.x+","+editor.pos.y] = {"floorId": ":before", "stair": "upFloor"};
+        }
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('添加楼梯事件成功');
+            editor.drawPosSelection();
+            editor_mode.showMode('loc');
+        });
+    }
+
+    var chooseThis = document.getElementById('chooseThis');
+    chooseThis.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        selectBox.isSelected(false);
+
+        editor_mode.onmode('nextChange');
+        editor_mode.onmode('loc');
+        //editor_mode.loc();
+        //tip.whichShow(1);
+        if(editor.isMobile)editor.showdataarea(false);
+    }
+
+    var chooseInRight = document.getElementById('chooseInRight');
+    chooseInRight.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        var thisevent = editor[editor.layerMod][editor.pos.y][editor.pos.x];
+        editor.setSelectBoxFromInfo(thisevent);
+    }
+
+    var fields = Object.keys(editor.file.comment._data.floors._data.loc._data);
+
+    var copyLoc = document.getElementById('copyLoc');
+    copyLoc.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        editor.preMapData = null;
+        reDo = null;
+        editor_mode.onmode('');
+        var now = editor.pos;
+        var last = editor.lastRightButtonPos[1];
+        var lastevent = editor.map[last.y][last.x];
+        var lastinfo = 0;
+        if(lastevent==0){
+            lastinfo = 0;
+        } else {
+            var ids=editor.indexs[lastevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            lastinfo=editor.ids[ids];
+        }
+        editor.map[now.y][now.x]=lastinfo;
+        editor.updateMap();
+        fields.forEach(function(v){
+            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y]
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('复制事件成功');
+            editor.drawPosSelection();
+        });
+    }
+
+    var moveLoc = document.getElementById('moveLoc');
+    moveLoc.onmousedown = function(e){
+        editor.hideMidMenu();
+        e.stopPropagation();
+        editor.preMapData = null;
+        reDo = null;
+        var thisevent = editor.map[editor.pos.y][editor.pos.x];
+        if(thisevent==0){
+            editor.info = 0;
+        } else {
+            var ids=editor.indexs[thisevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            editor.info=editor.ids[ids];
+        }
+        editor_mode.onmode('');
+        var now = editor.pos;
+        var last = editor.lastRightButtonPos[1];
+        
+        var lastevent = editor.map[last.y][last.x];
+        var lastinfo = 0;
+        if(lastevent==0){
+            lastinfo = 0;
+        } else {
+            var ids=editor.indexs[lastevent.idnum];
+            ids=ids[0]?ids[0]:ids;
+            lastinfo=editor.ids[ids];
+        }
+        editor.map[last.y][last.x]=editor.info;
+        editor.map[now.y][now.x]=lastinfo;
+        editor.updateMap();
+
+        fields.forEach(function(v){
+            var temp_atsfcytaf=editor.currentFloorData[v][now.x+','+now.y];
+            editor.currentFloorData[v][now.x+','+now.y]=editor.currentFloorData[v][last.x+','+last.y];
+            editor.currentFloorData[v][last.x+','+last.y]=temp_atsfcytaf;
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf('两位置的事件已互换');
+            editor.drawPosSelection();
+        });
+    }
+
+    var _clearPoint = function (clearPoint) {
+        editor.hideMidMenu();
+        editor.preMapData = null;
+        reDo = null;
+        editor.info = 0;
+        editor_mode.onmode('');
+        var now = editor.pos;
+        if (clearPoint)
+            editor.map[now.y][now.x]=editor.info;
+        editor.updateMap();
+        fields.forEach(function(v){
+            delete editor.currentFloorData[v][now.x+','+now.y];
+        })
+        editor.file.saveFloorFile(function (err) {
+            if (err) {
+                printe(err);
+                throw(err)
+            }
+            ;printf(clearPoint?'清空该点和事件成功':'只清空该点事件成功');
+            editor.drawPosSelection();
+        });
+    }
+
+    var clearEvent = document.getElementById('clearEvent');
+    clearEvent.onmousedown = function (e) {
+        e.stopPropagation();
+        _clearPoint(false);
+    }
+
+    var clearLoc = document.getElementById('clearLoc');
+    clearLoc.onmousedown = function(e){
+        e.stopPropagation();
+        _clearPoint(true);
+    }
+
+    var brushMod=document.getElementById('brushMod');
+    brushMod.onchange=function(){
+        editor.brushMod=brushMod.value;
+    }
+
+    var brushMod2=document.getElementById('brushMod2');
+    if(brushMod2)brushMod2.onchange=function(){
+        editor.brushMod=brushMod2.value;
+    }
+
+    var brushMod3=document.getElementById('brushMod3');
+    if(brushMod3)brushMod3.onchange=function(){
+        editor.brushMod=brushMod3.value;
+    }
+
+    var bgc = document.getElementById('bg'), fgc = document.getElementById('fg'),
+        evc = document.getElementById('event'), ev2c = document.getElementById('event2');
+
+    var layerMod=document.getElementById('layerMod');
+    layerMod.onchange=function(){
+        editor.layerMod=layerMod.value;
+        [bgc,fgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 1;
+        });
+
+        // 手机端....
+        if (editor.isMobile) {
+            if (layerMod.value == 'bgmap') {
+                [fgc,evc,ev2c].forEach(function (x) {
+                    x.style.opacity = 0.3;
+                });
+            }
+            if (layerMod.value == 'fgmap') {
+                [bgc,evc,ev2c].forEach(function (x) {
+                    x.style.opacity = 0.3;
+                });
+            }
+        }
+    }
+
+    var layerMod2=document.getElementById('layerMod2');
+    if(layerMod2)layerMod2.onchange=function(){
+        editor.layerMod=layerMod2.value;
+        [fgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 0.3;
+        });
+        bgc.style.opacity = 1;
+    }
+
+    var layerMod3=document.getElementById('layerMod3');
+    if(layerMod3)layerMod3.onchange=function(){
+        editor.layerMod=layerMod3.value;
+        [bgc,evc,ev2c].forEach(function (x) {
+            x.style.opacity = 0.3;
+        });
+        fgc.style.opacity = 1;
+    }
+
+    var viewportButtons=document.getElementById('viewportButtons');
+    for(var ii=0,node;node=viewportButtons.children[ii];ii++){
+        (function(x,y){
+            node.onclick=function(){
+                editor.moveViewport(x,y);
+            }
+        })([-1,0,0,1][ii],[0,-1,1,0][ii]);
+    }
+}
+
+editor.constructor.prototype.mobile_listen=function () {
+    if(!editor.isMobile)return;
+
+    var mobileview=document.getElementById('mobileview');
+    var editModeSelect=document.getElementById('editModeSelect');
+    var mid=document.getElementById('mid');
+    var right=document.getElementById('right');
+    var mobileeditdata=document.getElementById('mobileeditdata');
+
+    
+    editor.showdataarea=function(callShowMode){
+        mid.style='z-index:-1;opacity: 0;';
+        right.style='z-index:-1;opacity: 0;';
+        mobileeditdata.style='';
+        if(callShowMode)editor.mode.showMode(editModeSelect.value);
+        editor.hideMidMenu();
+    }
+    mobileview.children[0].onclick=function(){
+        editor.showdataarea(true)
+    }
+    mobileview.children[1].onclick=function(){
+        mid.style='';
+        right.style='z-index:-1;opacity: 0;';
+        mobileeditdata.style='z-index:-1;opacity: 0;';
+        editor.lastClickId='';
+    }
+    mobileview.children[3].onclick=function(){
+        mid.style='z-index:-1;opacity: 0;';
+        right.style='';
+        mobileeditdata.style='z-index:-1;opacity: 0;';
+        editor.lastClickId='';
+    }
+
+
+    var gettrbyid=function(){
+        if(!editor.lastClickId)return false;
+        thisTr = document.getElementById(editor.lastClickId);
+        input = thisTr.children[2].children[0].children[0];
+        field = thisTr.children[0].getAttribute('title');
+        cobj = JSON.parse(thisTr.children[1].getAttribute('cobj'));
+        return [thisTr,input,field,cobj];
+    }
+    mobileeditdata.children[0].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        info[1].ondblclick()
+    }
+    mobileeditdata.children[1].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        printf(info[2])
+    }
+    mobileeditdata.children[2].onclick=function(){
+        var info = gettrbyid()
+        if(!info)return;
+        printf(info[0].children[1].getAttribute('title'))
+    }
+
+    //=====
+
+    document.body.ontouchstart=document.body.onmousedown;
+    document.body.onmousedown=null;
+
+
+    var eui=document.getElementById('eui');
+    eui.ontouchstart=eui.onmousedown
+    eui.onmousedown=null
+    eui.ontouchmove=eui.onmousemove
+    eui.onmousemove=null
+    eui.ontouchend=eui.onmouseup
+    eui.onmouseup=null
+
+
+    var chooseThis = document.getElementById('chooseThis');
+    chooseThis.ontouchstart=chooseThis.onmousedown
+    chooseThis.onmousedown=null
+    var chooseInRight = document.getElementById('chooseInRight');
+    chooseInRight.ontouchstart=chooseInRight.onmousedown
+    chooseInRight.onmousedown=null
+    var copyLoc = document.getElementById('copyLoc');
+    copyLoc.ontouchstart=copyLoc.onmousedown
+    copyLoc.onmousedown=null
+    var moveLoc = document.getElementById('moveLoc');
+    moveLoc.ontouchstart=moveLoc.onmousedown
+    moveLoc.onmousedown=null
+    var clearLoc = document.getElementById('clearLoc');
+    clearLoc.ontouchstart=clearLoc.onmousedown
+    clearLoc.onmousedown=null
+}
+
+}

_server/editor_unsorted_2.js

@@ -0,0 +1,636 @@
+editor_unsorted_2_wrapper=function(editor_mode){
+
+    editor_mode.constructor.prototype.listen=function (callback) {
+        var newIdIdnum = document.getElementById('newIdIdnum');
+        newIdIdnum.children[2].onclick = function () {
+            if (newIdIdnum.children[0].value && newIdIdnum.children[1].value) {
+                var id = newIdIdnum.children[0].value;
+                var idnum = parseInt(newIdIdnum.children[1].value);
+                if (!core.isset(idnum)) {
+                    printe('不合法的idnum');
+                    return;
+                }
+                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
+                    printe('不合法的id，请使用字母、数字或下划线')
+                    return;
+                }
+                editor.file.changeIdAndIdnum(id, idnum, editor_mode.info, function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err)
+                    }
+                    printe('添加id和idnum成功,请F5刷新编辑器');
+                });
+            } else {
+                printe('请输入id和idnum');
+            }
+        }
+
+        newIdIdnum.children[4].onclick = function () {
+            editor.file.autoRegister(editor_mode.info, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                printe('该列所有剩余项全部自动注册成功,请F5刷新编辑器');
+            })
+        }
+
+        var changeId = document.getElementById('changeId');
+        changeId.children[1].onclick = function () {
+            var id = changeId.children[0].value;
+            if (id) {
+                if (!/^[0-9a-zA-Z_]+$/.test(id)) {
+                    printe('不合法的id，请使用字母、数字或下划线')
+                    return;
+                }
+                editor.file.changeIdAndIdnum(id, null, editor_mode.info, function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+                    printe('修改id成功,请F5刷新编辑器');
+                });
+            } else {
+                printe('请输入要修改到的ID');
+            }
+        }
+
+        var selectFloor = document.getElementById('selectFloor');
+        editor.game.getFloorFileList(function (floors) {
+            var outstr = [];
+            floors[0].forEach(function (floor) {
+                outstr.push(["<option value='", floor, "'>", floor, '</option>\n'].join(''));
+            });
+            selectFloor.innerHTML = outstr.join('');
+            selectFloor.value = core.status.floorId;
+            selectFloor.onchange = function () {
+                editor_mode.onmode('nextChange');
+                editor_mode.onmode('floor');
+                editor.changeFloor(selectFloor.value);
+            }
+        });
+
+        var saveFloor = document.getElementById('saveFloor');
+        editor_mode.saveFloor = function () {
+            editor_mode.onmode('');
+            editor.file.saveFloorFile(function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                ;printf('保存成功');
+            });
+        }
+        saveFloor.onclick = editor_mode.saveFloor;
+
+        var newMap = document.getElementById('newMap');
+        var newFileName = document.getElementById('newFileName');
+        newMap.onclick = function () {
+            if (!newFileName.value) return;
+            if (core.floorIds.indexOf(newFileName.value)>=0) {
+                printe("该楼层已存在！");
+                return;
+            }
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newFileName.value)) {
+                printe("楼层名不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                return;
+            }
+            var width = parseInt(document.getElementById('newMapWidth').value);
+            var height = parseInt(document.getElementById('newMapHeight').value);
+            if (!core.isset(width) || !core.isset(height) || width<core.__SIZE__ || height<core.__SIZE__ || width*height>1000) {
+                printe("新建地图的宽高都不得小于"+core.__SIZE__+"，且宽高之积不能超过1000");
+                return;
+            }
+
+            editor_mode.onmode('');
+            editor.file.saveNewFile(newFileName.value, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                core.floorIds.push(newFileName.value);
+                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                    if (objs_.slice(-1)[0] != null) {
+                        printe(objs_.slice(-1)[0]);
+                        throw(objs_.slice(-1)[0])
+                    }
+                    ;printe('新建成功,请F5刷新编辑器生效');
+                });
+            });
+        }
+
+        var newMaps = document.getElementById('newMaps');
+        var newFloors = document.getElementById('newFloors');
+        newMaps.onclick = function () {
+            if (newFloors.style.display == 'none') newFloors.style.display = 'block';
+            else newFloors.style.display = 'none';
+        }
+
+        var createNewMaps = document.getElementById('createNewMaps');
+        createNewMaps.onclick = function () {
+            var floorIds = document.getElementById('newFloorIds').value;
+            if (!floorIds) return;
+            var from = parseInt(document.getElementById('newMapsFrom').value),
+                to = parseInt(document.getElementById('newMapsTo').value);
+            if (!core.isset(from) || !core.isset(to) || from>to || from<0 || to<0) {
+                printe("请输入有效的起始和终止楼层");
+                return;
+            }
+            if (to-from >= 100) {
+                printe("一次最多创建99个楼层");
+                return;
+            }
+            var floorIdList = [];
+            for (var i = from; i<=to; i++) {
+                var floorId = floorIds.replace(/\${(.*?)}/g, function (word, value) {
+                    return eval(value);
+                });
+                if (core.floorIds.indexOf(floorId)>=0) {
+                    printe("要创建的楼层 "+floorId+" 已存在！");
+                    return;
+                }
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(floorId)) {
+                    printe("楼层名 "+floorId+" 不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                    return;
+                }
+                if (floorIdList.indexOf(floorId)>=0) {
+                    printe("尝试重复创建楼层 "+floorId+" ！");
+                    return;
+                }
+                floorIdList.push(floorId);
+            }
+
+            var width = parseInt(document.getElementById('newMapsWidth').value);
+            var height = parseInt(document.getElementById('newMapsHeight').value);
+            if (!core.isset(width) || !core.isset(height) || width<core.__SIZE__ || height<core.__SIZE__ || width*height>1000) {
+                printe("新建地图的宽高都不得小于"+core.__SIZE__+"，且宽高之积不能超过1000");
+                return;
+            }
+            editor_mode.onmode('');
+            
+            editor.file.saveNewFiles(floorIdList, from, to, function (err) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                core.floorIds = core.floorIds.concat(floorIdList);
+                editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                    if (objs_.slice(-1)[0] != null) {
+                        printe(objs_.slice(-1)[0]);
+                        throw(objs_.slice(-1)[0])
+                    }
+                    ;printe('批量创建 '+floorIdList[0]+'~'+floorIdList[floorIdList.length-1]+' 成功,请F5刷新编辑器生效');
+                });
+            });
+        }
+
+        var changeFloorId = document.getElementById('changeFloorId');
+        changeFloorId.children[1].onclick = function () {
+            var floorId = changeFloorId.children[0].value;
+            if (floorId) {
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(floorId)) {
+                    printe("楼层名 "+floorId+" 不合法！请使用字母、数字、下划线，且不能以数字开头！");
+                    return;
+                }
+                if (main.floorIds.indexOf(floorId)>=0) {
+                    printe("楼层名 "+floorId+" 已存在！");
+                    return;
+                }
+                var currentFloorId = editor.currentFloorId;
+                editor.currentFloorId = floorId;
+                editor.currentFloorData.floorId = floorId;
+                editor.file.saveFloorFile(function (err) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+                    core.floorIds[core.floorIds.indexOf(currentFloorId)] = floorId;
+                    editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+                        if (objs_.slice(-1)[0] != null) {
+                            printe(objs_.slice(-1)[0]);
+                            throw(objs_.slice(-1)[0])
+                        }
+                        alert("修改floorId成功，需要刷新编辑器生效。\n请注意，原始的楼层文件没有删除，请根据需要手动删除。");
+                        window.location.reload();
+                    });
+                });
+            } else {
+                printe('请输入要修改到的floorId');
+            }
+        }
+
+        var ratio = 1;
+        var appendPicCanvas = document.getElementById('appendPicCanvas');
+        var bg = appendPicCanvas.children[0];
+        var source = appendPicCanvas.children[1];
+        var source_ctx=source.getContext('2d');
+        var picClick = appendPicCanvas.children[2];
+        var sprite = appendPicCanvas.children[3];
+        var sprite_ctx=sprite.getContext('2d');
+        var appendPicSelection = document.getElementById('appendPicSelection');
+        
+        [source_ctx,sprite_ctx].forEach(function(ctx){
+            ctx.mozImageSmoothingEnabled = false;
+            ctx.webkitImageSmoothingEnabled = false;
+            ctx.msImageSmoothingEnabled = false;
+            ctx.imageSmoothingEnabled = false;
+        })
+
+        var selectAppend = document.getElementById('selectAppend');
+        var selectAppend_str = [];
+        ["terrains", "animates", "enemys", "enemy48", "items", "npcs", "npc48", "autotile"].forEach(function (image) {
+            selectAppend_str.push(["<option value='", image, "'>", image, '</option>\n'].join(''));
+        });
+        selectAppend.innerHTML = selectAppend_str.join('');
+        selectAppend.onchange = function () {
+
+            var value = selectAppend.value;
+
+            if (value == 'autotile') {
+                editor_mode.appendPic.imageName = 'autotile';
+                for (var jj=0;jj<4;jj++) appendPicSelection.children[jj].style = 'display:none';
+                if (editor_mode.appendPic.img) {
+                    sprite.style.width = (sprite.width = editor_mode.appendPic.img.width) / ratio + 'px';
+                    sprite.style.height = (sprite.height = editor_mode.appendPic.img.height) / ratio + 'px';
+                    sprite_ctx.clearRect(0, 0, sprite.width, sprite.height);
+                    sprite_ctx.drawImage(editor_mode.appendPic.img, 0, 0);
+                }
+                return;
+            }
+
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            editor_mode.appendPic.imageName = value;
+            var img = core.material.images[value];
+            editor_mode.appendPic.toImg = img;
+            var num = ~~img.width / 32;
+            editor_mode.appendPic.num = num;
+            editor_mode.appendPic.index = 0;
+            var selectStr = '';
+            for (var ii = 0; ii < num; ii++) {
+                appendPicSelection.children[ii].style = 'left:0;top:0;height:' + (ysize - 6) + 'px';
+                selectStr += '{"x":0,"y":0},'
+            }
+            editor_mode.appendPic.selectPos = eval('[' + selectStr + ']');
+            for (var jj = num; jj < 4; jj++) {
+                appendPicSelection.children[jj].style = 'display:none';
+            }
+            sprite.style.width = (sprite.width = img.width) / ratio + 'px';
+            sprite.style.height = (sprite.height = img.height + ysize) / ratio + 'px';
+            sprite_ctx.drawImage(img, 0, 0);
+        }
+        selectAppend.onchange();
+
+        var getPixel=editor.util.getPixel
+        var setPixel=editor.util.setPixel
+
+        var autoAdjust = function (image, callback) {
+            var changed = false;
+
+            // Step 1: 检测白底
+            var tempCanvas = document.createElement('canvas').getContext('2d');
+            tempCanvas.canvas.width = image.width;
+            tempCanvas.canvas.height = image.height;
+            tempCanvas.mozImageSmoothingEnabled = false;
+            tempCanvas.webkitImageSmoothingEnabled = false;
+            tempCanvas.msImageSmoothingEnabled = false;
+            tempCanvas.imageSmoothingEnabled = false;
+            tempCanvas.drawImage(image, 0, 0);
+            var imgData = tempCanvas.getImageData(0, 0, image.width, image.height);
+            var trans = 0, white = 0, black=0;
+            for (var i=0;i<image.width;i++) {
+                for (var j=0;j<image.height;j++) {
+                    var pixel = getPixel(imgData, i, j);
+                    if (pixel[3]==0) trans++;
+                    if (pixel[0]==255 && pixel[1]==255 && pixel[2]==255 && pixel[3]==255) white++;
+                    // if (pixel[0]==0 && pixel[1]==0 && pixel[2]==0 && pixel[3]==255) black++;
+                }
+            }
+            if (white>black && white>trans*10 && confirm("看起来这张图片是以纯白为底色，是否自动调整为透明底色？")) {
+                for (var i=0;i<image.width;i++) {
+                    for (var j=0;j<image.height;j++) {
+                        var pixel = getPixel(imgData, i, j);
+                        if (pixel[0]==255 && pixel[1]==255 && pixel[2]==255 && pixel[3]==255) {
+                            setPixel(imgData, i, j, [0,0,0,0]);
+                        }
+                    }
+                }
+                tempCanvas.clearRect(0, 0, image.width, image.height);
+                tempCanvas.putImageData(imgData, 0, 0);
+                changed = true;
+            }
+            /*
+            if (black>white && black>trans*10 && confirm("看起来这张图片是以纯黑为底色，是否自动调整为透明底色？")) {
+                for (var i=0;i<image.width;i++) {
+                    for (var j=0;j<image.height;j++) {
+                        var pixel = getPixel(imgData, i, j);
+                        if (pixel[0]==0 && pixel[1]==0 && pixel[2]==0 && pixel[3]==255) {
+                            setPixel(imgData, i, j, [0,0,0,0]);
+                        }
+                    }
+                }
+                tempCanvas.clearRect(0, 0, image.width, image.height);
+                tempCanvas.putImageData(imgData, 0, 0);
+                changed = true;
+            }
+            */
+
+            // Step 2: 检测长宽比
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            if ((image.width%32!=0 || image.height%ysize!=0) && (image.width<=128 && image.height<=ysize*4)
+                && confirm("目标长宽不符合条件，是否自动进行调整？")) {
+                var ncanvas = document.createElement('canvas').getContext('2d');
+                ncanvas.canvas.width = 128;
+                ncanvas.canvas.height = 4*ysize;
+                ncanvas.mozImageSmoothingEnabled = false;
+                ncanvas.webkitImageSmoothingEnabled = false;
+                ncanvas.msImageSmoothingEnabled = false;
+                ncanvas.imageSmoothingEnabled = false;
+                var w = image.width / 4, h = image.height / 4;
+                for (var i=0;i<4;i++) {
+                    for (var j=0;j<4;j++) {
+                        ncanvas.drawImage(tempCanvas.canvas, i*w, j*h, w, h, i*32 + (32-w)/2, j*ysize + (ysize-h)/2, w, h);
+                    }
+                }
+                tempCanvas = ncanvas;
+                changed = true;
+            }
+
+            if (!changed) {
+                callback(image);
+            }
+            else {
+                var nimg = new Image();
+                nimg.onload = function () {
+                    callback(nimg);
+                };
+                nimg.src = tempCanvas.canvas.toDataURL();
+            }
+        }
+
+        var selectFileBtn = document.getElementById('selectFileBtn');
+        selectFileBtn.onclick = function () {
+            var loadImage = function (content, callback) {
+                var image = new Image();
+                try {
+                    image.onload = function () {
+                        callback(image);
+                    }
+                    image.src = content;
+                }
+                catch (e) {
+                    printe(e);
+                }
+            }
+            core.readFile(function (content) {
+                loadImage(content, function (image) {
+                    autoAdjust(image, function (image) {
+                        editor_mode.appendPic.img = image;
+                        editor_mode.appendPic.width = image.width;
+                        editor_mode.appendPic.height = image.height;
+
+                        if (selectAppend.value == 'autotile') {
+                            for (var ii = 0; ii < 3; ii++) {
+                                var newsprite = appendPicCanvas.children[ii];
+                                newsprite.style.width = (newsprite.width = image.width) / ratio + 'px';
+                                newsprite.style.height = (newsprite.height = image.height) / ratio + 'px';
+                            }
+                            sprite_ctx.clearRect(0, 0, sprite.width, sprite.height);
+                            sprite_ctx.drawImage(image, 0, 0);
+                        }
+                        else {
+                            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+                            for (var ii = 0; ii < 3; ii++) {
+                                var newsprite = appendPicCanvas.children[ii];
+                                newsprite.style.width = (newsprite.width = Math.floor(image.width / 32) * 32) / ratio + 'px';
+                                newsprite.style.height = (newsprite.height = Math.floor(image.height / ysize) * ysize) / ratio + 'px';
+                            }
+                        }
+
+                        //画灰白相间的格子
+                        var bgc = bg.getContext('2d');
+                        var colorA = ["#f8f8f8", "#cccccc"];
+                        var colorIndex;
+                        var sratio = 4;
+                        for (var ii = 0; ii < image.width / 32 * sratio; ii++) {
+                            colorIndex = 1 - ii % 2;
+                            for (var jj = 0; jj < image.height / 32 * sratio; jj++) {
+                                bgc.fillStyle = colorA[colorIndex];
+                                colorIndex = 1 - colorIndex;
+                                bgc.fillRect(ii * 32 / sratio, jj * 32 / sratio, 32 / sratio, 32 / sratio);
+                            }
+                        }
+
+                        //把导入的图片画出
+                        source_ctx.drawImage(image, 0, 0);
+                        editor_mode.appendPic.sourceImageData=source_ctx.getImageData(0,0,image.width,image.height);
+
+                        //重置临时变量
+                        selectAppend.onchange();
+                    });
+                });
+            }, null, 'img');
+
+            return;
+        }
+
+        var changeColorInput=document.getElementById('changeColorInput')
+        changeColorInput.oninput=function(){
+            var delta=(~~changeColorInput.value)*30;
+            var imgData=editor_mode.appendPic.sourceImageData;
+            var nimgData=new ImageData(imgData.width,imgData.height);
+            // ImageData .data 形如一维数组,依次排着每个点的 R(0~255) G(0~255) B(0~255) A(0~255)
+            var convert=function(rgba,delta){
+                var rgbToHsl = editor.util.rgbToHsl
+                var hue2rgb = editor.util.hue2rgb
+                var hslToRgb = editor.util.hslToRgb
+                //
+                var hsl=rgbToHsl(rgba)
+                hsl[0]=(hsl[0]+delta)%360
+                var nrgb=hslToRgb(hsl)
+                nrgb.push(rgba[3])
+                return nrgb
+            }
+            for(var x=0; x<imgData.width; x++){
+                for(var y=0 ; y<imgData.height; y++){
+                    setPixel(nimgData,x,y,convert(getPixel(imgData,x,y),delta))
+                }
+            }
+            source_ctx.clearRect(0, 0, imgData.width, imgData.height);
+            source_ctx.putImageData(nimgData, 0, 0);
+        }
+
+        var left1 = document.getElementById('left1');
+        var eToLoc = function (e) {
+            var scrollLeft = document.documentElement.scrollLeft || document.body.scrollLeft
+            var scrollTop = document.documentElement.scrollTop || document.body.scrollTop
+            var loc = {
+                'x': scrollLeft + e.clientX + appendPicCanvas.scrollLeft - left1.offsetLeft - appendPicCanvas.offsetLeft,
+                'y': scrollTop + e.clientY + appendPicCanvas.scrollTop - left1.offsetTop - appendPicCanvas.offsetTop,
+                'size': 32,
+                'ysize': selectAppend.value.endsWith('48') ? 48 : 32
+            };
+            return loc;
+        }//返回可用的组件内坐标
+
+        var locToPos = function (loc) {
+            var pos = {'x': ~~(loc.x / loc.size), 'y': ~~(loc.y / loc.ysize), 'ysize': loc.ysize}
+            return pos;
+        }
+
+        picClick.onclick = function (e) {
+            var loc = eToLoc(e);
+            var pos = locToPos(loc);
+            //console.log(e,loc,pos);
+            var num = editor_mode.appendPic.num;
+            var ii = editor_mode.appendPic.index;
+            if (ii + 1 >= num) editor_mode.appendPic.index = ii + 1 - num;
+            else editor_mode.appendPic.index++;
+            editor_mode.appendPic.selectPos[ii] = pos;
+            appendPicSelection.children[ii].style = [
+                'left:', pos.x * 32, 'px;',
+                'top:', pos.y * pos.ysize, 'px;',
+                'height:', pos.ysize - 6, 'px;'
+            ].join('');
+        }
+
+        var appendConfirm = document.getElementById('appendConfirm');
+        appendConfirm.onclick = function () {
+
+            var confirmAutotile = function () {
+                var image = editor_mode.appendPic.img;
+                if (image.width % 96 !=0 || image.height != 128) {
+                    printe("不合法的Autotile图片！");
+                    return;
+                }
+                var imgData = source_ctx.getImageData(0,0,image.width,image.height);
+                sprite_ctx.putImageData(imgData, 0, 0);
+                var imgbase64 = sprite.toDataURL().split(',')[1];
+
+                // Step 1: List文件名
+                fs.readdir('./project/images', function (err, data) {
+                    if (err) {
+                        printe(err);
+                        throw(err);
+                    }
+
+                    // Step 2: 选择Autotile文件名
+                    var filename;
+                    for (var i=1;;++i) {
+                        filename = 'autotile'+i;
+                        if (data.indexOf(filename+".png")==-1) break;
+                    }
+
+                    // Step 3: 写入文件
+                    fs.writeFile('./project/images/'+filename+".png", imgbase64, 'base64', function (err, data) {
+                        if (err) {
+                            printe(err);
+                            throw(err);
+                        }
+                        // Step 4: 自动注册
+                        editor.file.registerAutotile(filename, function (err) {
+                            if (err) {
+                                printe(err);
+                                throw(err);
+                            }
+                            printe('自动元件'+filename+'注册成功,请F5刷新编辑器');
+                        })
+
+                    })
+
+                })
+
+            }
+
+            if (selectAppend.value == 'autotile') {
+                confirmAutotile();
+                return;
+            }
+
+            var ysize = selectAppend.value.endsWith('48') ? 48 : 32;
+            for (var ii = 0, v; v = editor_mode.appendPic.selectPos[ii]; ii++) {
+                // var imgData = source_ctx.getImageData(v.x * 32, v.y * ysize, 32, ysize);
+                // sprite_ctx.putImageData(imgData, ii * 32, sprite.height - ysize);
+                // sprite_ctx.drawImage(editor_mode.appendPic.img, v.x * 32, v.y * ysize, 32, ysize,  ii * 32, height,  32, ysize)
+
+                sprite_ctx.drawImage(source_ctx.canvas, v.x*32, v.y*ysize, 32, ysize, 32*ii, sprite.height - ysize, 32, ysize);
+            }
+            var dt = sprite_ctx.getImageData(0, 0, sprite.width, sprite.height);
+            var imgbase64 = sprite.toDataURL().split(',')[1];
+            fs.writeFile('./project/images/' + editor_mode.appendPic.imageName + '.png', imgbase64, 'base64', function (err, data) {
+                if (err) {
+                    printe(err);
+                    throw(err)
+                }
+                printe('追加素材成功，请F5刷新编辑器，或继续追加当前素材');
+                sprite.style.height = (sprite.height = (sprite.height+ysize)) + "px";
+                sprite_ctx.putImageData(dt, 0, 0);
+            });
+        }
+
+        var editModeSelect = document.getElementById('editModeSelect');
+        editModeSelect.onchange = function () {
+            editor_mode.onmode('nextChange');
+            editor_mode.onmode(editModeSelect.value);
+            if(editor.isMobile)editor.showdataarea(false);
+        }
+
+        editor_mode.checkUnique = function (thiseval) {
+            if (!(thiseval instanceof Array)) return false;
+            var map = {};
+            for (var i = 0; i<thiseval.length; ++i) {
+                if (map[thiseval[i]]) {
+                    alert("警告：存在重复定义！");
+                    return false;
+                }
+                map[thiseval[i]] = true;
+            }
+            return true;
+        }
+
+        editor_mode.checkFloorIds = function(thiseval){
+            if (!editor_mode.checkUnique(thiseval)) return false;
+            var oldvalue = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d.main.floorIds;
+            fs.readdir('project/floors',function(err, data){
+                if(err){
+                    printe(err);
+                    throw Error(err);
+                }
+                var newfiles=thiseval.map(function(v){return v+'.js'});
+                var notExist='';
+                for(var name,ii=0;name=newfiles[ii];ii++){
+                    if(data.indexOf(name)===-1)notExist=name;
+                }
+                if(notExist){
+                    var discard=confirm('文件'+notExist+'不存在, 保存会导致工程无法打开, 是否放弃更改');
+                    if(discard){
+                        editor.file.editTower([['change', "['main']['floorIds']", oldvalue]], function (objs_) {//console.log(objs_);
+                            if (objs_.slice(-1)[0] != null) {
+                                printe(objs_.slice(-1)[0]);
+                                throw(objs_.slice(-1)[0])
+                            }
+                            ;printe('已放弃floorIds的修改，请F5进行刷新');
+                        });
+                    }
+                }
+            });
+            return true
+        }
+
+        editor_mode.changeDoubleClickModeByButton=function(mode){
+            ({
+                delete:function(){
+                    printf('下一次双击表格的项删除，切换下拉菜单可取消；编辑后需刷新浏览器生效。');
+                    editor_mode.doubleClickMode=mode;
+                },
+                add:function(){
+                    printf('下一次双击表格的项则在同级添加新项，切换下拉菜单可取消；编辑后需刷新浏览器生效。');
+                    editor_mode.doubleClickMode=mode;
+                }
+            }[mode])();
+        }
+
+        if (Boolean(callback)) callback();
+    }
+
+}

_server/editor_unsorted_3.js

@@ -0,0 +1,369 @@
+
+exportMap = document.getElementById('exportMap')
+exportMap.isExport=false
+exportMap.onclick=function(){
+    editor.updateMap();
+    var sx=editor.map.length-1,sy=editor.map[0].length-1;
+
+    var filestr = '';
+    for (var yy = 0; yy <= sy; yy++) {
+        filestr += '['
+        for (var xx = 0; xx <= sx; xx++) {
+            var mapxy = editor.map[yy][xx];
+            if (typeof(mapxy) == typeof({})) {
+                if ('idnum' in mapxy) mapxy = mapxy.idnum;
+                else {
+                    // mapxy='!!?';
+                    tip.whichShow(3);
+                    return;
+                }
+            } else if (typeof(mapxy) == 'undefined') {
+                tip.whichShow(3);
+                return;
+            }
+            mapxy = String(mapxy);
+            mapxy = Array(Math.max(4 - mapxy.length, 0)).join(' ') + mapxy;
+            filestr += mapxy + (xx == sx ? '' : ',')
+        }
+
+        filestr += ']' + (yy == sy ? '' : ',\n');
+    }
+    pout.value = filestr;
+    mapEditArea.mapArr(filestr);
+    exportMap.isExport = true;
+    mapEditArea.error(0);
+    tip.whichShow(2);
+}
+mapEditArea = document.getElementById('mapEditArea')
+mapEditArea.errors=[ // 编号1,2
+    "格式错误！请使用正确格式(请使用地图生成器进行生成，且需要和本地图宽高完全一致)",
+    "当前有未定义ID（在地图区域显示红块），请修改ID或者到icons.js和maps.js中进行定义！"
+]
+mapEditArea.formatTimer=null
+mapEditArea._mapArr=''
+mapEditArea.mapArr=function(value){
+    if(value!=null){
+        var val=value
+        var oldval=mapEditArea._mapArr
+        if (val==oldval) return;
+
+        if (exportMap.isExport) {
+            exportMap.isExport = false;
+            return;
+        }
+        if (mapEditArea.formatArr()) {
+            mapEditArea.error(0);
+
+            setTimeout(function () {
+                if (mapEditArea.formatArr())mapEditArea.mapArr(mapEditArea.formatArr());
+                mapEditArea.drawMap();
+                tip.whichShow(8)
+            }, 1000);
+            clearTimeout(mapEditArea.formatTimer);
+            mapEditArea.formatTimer = setTimeout(function () {
+                pout.value = mapEditArea.formatArr();
+            }, 5000); //5s后再格式化，不然光标跳到最后很烦
+        } else {
+            mapEditArea.error(1);
+        }
+
+        mapEditArea._mapArr=value
+    }
+    return mapEditArea._mapArr
+}
+pout.oninput=function(){
+    mapEditArea.mapArr(pout.value)
+}
+mapEditArea._error=0
+mapEditArea.error=function(value){
+    if(value!=null){
+        mapEditArea._error=value
+        if (value>0)
+        printe(mapEditArea.errors[value-1])
+    }
+    return mapEditArea._error
+}
+mapEditArea.drawMap= function () {
+    // var mapArray = mapEditArea.mapArr().split(/\D+/).join(' ').trim().split(' ');
+    var mapArray = JSON.parse('[' + mapEditArea.mapArr() + ']');
+    var sy=editor.map.length,sx=editor.map[0].length;
+    for (var y = 0; y < sy; y++)
+        for (var x = 0; x < sx; x++) {
+            var num = mapArray[y][x];
+            if (num == 0)
+                editor.map[y][x] = 0;
+            else if (typeof(editor.indexs[num][0]) == 'undefined') {
+                mapEditArea.error(2);
+                editor.map[y][x] = undefined;
+            } else editor.map[y][x] = editor.ids[[editor.indexs[num][0]]];
+        }
+
+    editor.updateMap();
+
+}
+mapEditArea.formatArr= function () {
+    var formatArrStr = '';
+    console.log(1)
+    
+    var si=editor.map.length,sk=editor.map[0].length;
+    if (mapEditArea.mapArr().split(/\D+/).join(' ').trim().split(' ').length != si*sk) return false;
+    var arr = mapEditArea.mapArr().replace(/\s+/g, '').split('],[');
+
+    if (arr.length != si) return;
+    for (var i = 0; i < si; i++) {
+        var a = [];
+        formatArrStr += '[';
+        if (i == 0 || i == si-1) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
+        else a = arr[i].split(/\D+/);
+        if (a.length != sk) {
+            formatArrStr = '';
+            return;
+        }
+
+        for (var k = 0; k < sk; k++) {
+            var num = parseInt(a[k]);
+            formatArrStr += Array(Math.max(4 - String(num).length, 0)).join(' ') + num + (k == sk-1 ? '' : ',');
+        }
+        formatArrStr += ']' + (i == si-1 ? '' : ',\n');
+    }
+    return formatArrStr;
+}
+copyMap=document.getElementById('copyMap')
+copyMap.err=''
+copyMap.onclick=function(){
+    tip.whichShow(0);
+    if (pout.value.trim() != '') {
+        if (mapEditArea.error()) {
+            copyMap.err = mapEditArea.errors[mapEditArea.error() - 1];
+            tip.whichShow(5)
+            return;
+        }
+        try {
+            pout.focus();
+            pout.setSelectionRange(0, pout.value.length);
+            document.execCommand("Copy");
+            tip.whichShow(6);
+        } catch (e) {
+            copyMap.err = e;
+            tip.whichShow(5);
+        }
+    } else {
+        tip.whichShow(7);
+    }
+}
+clearMapButton=document.getElementById('clearMapButton')
+clearMapButton.onclick=function () {
+    editor.mapInit();
+    editor_mode.onmode('');
+    editor.file.saveFloorFile(function (err) {
+        if (err) {
+            printe(err);
+            throw(err)
+        }
+        ;printf('地图清除成功');
+    });
+    editor.updateMap();
+    clearTimeout(mapEditArea.formatTimer);
+    clearTimeout(tip.timer);
+    pout.value = '';
+    mapEditArea.mapArr('');
+    tip.whichShow(4);
+    mapEditArea.error(0);
+}
+deleteMap=document.getElementById('deleteMap')
+deleteMap.onclick=function () {
+    editor_mode.onmode('');
+    var index = core.floorIds.indexOf(editor.currentFloorId);
+    if (index>=0) {
+        core.floorIds.splice(index,1);
+        editor.file.editTower([['change', "['main']['floorIds']", core.floorIds]], function (objs_) {//console.log(objs_);
+            if (objs_.slice(-1)[0] != null) {
+                printe(objs_.slice(-1)[0]);
+                throw(objs_.slice(-1)[0])
+            }
+            ;printe('删除成功,请F5刷新编辑器生效');
+        });
+    }
+    else printe('删除成功,请F5刷新编辑器生效');
+}
+printf = function (str_, type) {
+    selectBox.isSelected(false);
+    if (!type) {
+        tip.whichShow(11);
+    } else {
+        tip.whichShow(12);
+    }
+    setTimeout(function () {
+        if (!type) {
+            tip.msgs[11] = String(str_);
+            tip.whichShow(12);
+        } else {
+            tip.msgs[10] = String(str_);
+            tip.whichShow(11);
+        }
+    }, 1);
+}
+printe = function (str_) {
+    printf(str_, 'error')
+}
+tip_in_showMode = [
+    '涉及图片的更改需要F5刷新浏览器来生效',
+    '文本域可以通过双击,在文本编辑器或事件编辑器中编辑',
+    '事件编辑器中的显示文本和自定义脚本的方块也可以双击',
+    "画出的地图要点击\"保存地图\"才会写入到文件中",
+];
+tip=document.getElementById('tip')
+tip._infos= {}
+tip.infos=function(value){
+    if(value!=null){
+        var val=value
+        var oldval=tip._infos
+
+        tip.isClearBlock(false);
+        tip.isAirwall(false);
+        if (typeof(val) != 'undefined') {
+            if (val == 0) {
+                tip.isClearBlock(true);
+                return;
+            }
+            if ('id' in val) {
+                if (val.idnum == 17) {
+                    tip.isAirwall(true);
+                    return;
+                }
+                tip.hasId = true;
+            } else {
+                tip.hasId = false;
+            }
+            tip.isAutotile = false;
+            if (val.images == "autotile" && tip.hasId) tip.isAutotile = true;
+            document.getElementById('isAirwall-else').innerHTML=(tip.hasId?`<p>图块编号：<span class="infoText">${ value['idnum'] }</span></p>
+            <p>图块ID：<span class="infoText">${ value['id'] }</span></p>`:`
+            <p class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>`)+`
+            <p>图块所在素材：<span class="infoText">${ value['images'] + (tip.isAutotile ? '( '+value['id']+' )' : '') }</span>
+            </p>
+            <p>图块索引：<span class="infoText">${ value['y'] }</span></p>`
+        }
+
+        tip._infos=value
+    }
+    return tip._infos
+}
+tip.hasId= true
+tip.isAutotile= false
+tip._isSelectedBlock= false
+tip.isSelectedBlock=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isSelectedBlock-if')
+        var dhide=document.getElementById('isSelectedBlock-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isSelectedBlock=value
+    }
+    return tip._isSelectedBlock
+}
+tip._isClearBlock= false
+tip.isClearBlock=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isClearBlock-if')
+        var dhide=document.getElementById('isClearBlock-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isClearBlock=value
+    }
+    return tip._isClearBlock
+}
+tip._isAirwall= false
+tip.isAirwall=function(value){
+    if(value!=null){
+        var dshow=document.getElementById('isAirwall-if')
+        var dhide=document.getElementById('isAirwall-else')
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        dshow.style.display=''
+        dhide.style.display='none'
+        tip._isAirwall=value
+    }
+    return tip._isAirwall
+}
+tip.geneMapSuccess= false
+tip.timer= null
+tip.msgs= [ //分别编号1,2,3,4,5,6,7,8,9,10；奇数警告，偶数成功
+    "当前未选择任何图块，请先在右边选择要画的图块!",
+    "生成地图成功！可点击复制按钮复制地图数组到剪切板",
+    "生成失败! 地图中有未定义的图块，建议先用其他有效图块覆盖或点击清除地图！",
+    "地图清除成功!",
+    "复制失败！",
+    "复制成功！可直接粘贴到楼层文件的地图数组中。",
+    "复制失败！当前还没有数据",
+    "修改成功！可点击复制按钮复制地图数组到剪切板",
+    "选择背景图片失败！文件名格式错误或图片不存在！",
+    "更新背景图片成功！",
+    "11:警告",
+    "12:成功"
+]
+tip._mapMsg= ''
+tip.mapMsg=function(value){
+    if(value!=null){
+        document.getElementById('whichShow-if').innerText=value
+        tip._mapMsg=value
+    }
+    return tip._mapMsg
+}
+tip._whichShow= 0
+tip.whichShow=function(value){
+    if(value!=null){
+
+        var dshow=document.getElementById('whichShow-if')
+        var dhide=null
+        if(!value){
+            var dtemp=dshow
+            dshow=dhide
+            dhide=dtemp
+        }
+        if(dshow)dshow.style.display=''
+        if(dhide)dhide.style.display='none'
+
+        if(dshow)dshow.setAttribute('class',(value%2) ? 'warnText' : 'successText')
+
+        tip.mapMsg('');
+        tip.msgs[4] = "复制失败！" + editTip.err;
+        clearTimeout(tip.timer);
+        if (value) {
+            tip.mapMsg(tip.msgs[value - 1]);
+            tip.timer = setTimeout(function () {
+                if (!(value % 2))
+                value = 0;
+            }, 5000); //5秒后自动清除success，warn不清除
+        }
+        tip._whichShow=value
+    }
+    return tip._whichShow
+}
+selectBox=document.getElementById('selectBox')
+dataSelection=document.getElementById('dataSelection')
+selectBox._isSelected=false
+selectBox.isSelected=function(value){
+    if(value!=null){
+        selectBox._isSelected=value;
+        tip.isSelectedBlock(value);
+        tip.whichShow(0);
+        clearTimeout(tip.timer);
+        dataSelection.style.display=value?'':'none'
+    }
+    return selectBox._isSelected
+}
+

_server/editor_util.js

@@ -0,0 +1,173 @@
+editor_util_wrapper = function (editor) {
+
+    editor_util = function () {
+
+    }
+
+    editor_util.prototype.guid = function () {
+        return 'id_' + 'xxxxxxxx_xxxx_4xxx_yxxx_xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    editor_util.prototype.HTMLescape = function (str_) {
+        return String(str_).split('').map(function (v) {
+            return '&#' + v.charCodeAt(0) + ';'
+        }).join('');
+    }
+
+    editor_util.prototype.getPixel = function (imgData, x, y) {
+        var offset = (x + y * imgData.width) * 4;
+        var r = imgData.data[offset + 0];
+        var g = imgData.data[offset + 1];
+        var b = imgData.data[offset + 2];
+        var a = imgData.data[offset + 3];
+        return [r, g, b, a];
+    }
+
+    editor_util.prototype.setPixel = function (imgData, x, y, rgba) {
+        var offset = (x + y * imgData.width) * 4;
+        imgData.data[offset + 0] = rgba[0];
+        imgData.data[offset + 1] = rgba[1];
+        imgData.data[offset + 2] = rgba[2];
+        imgData.data[offset + 3] = rgba[3];
+    }
+
+    // rgbToHsl hue2rgb hslToRgb from https://github.com/carloscabo/colz.git
+    //--------------------------------------------
+    // The MIT License (MIT)
+    //
+    // Copyright (c) 2014 Carlos Cabo
+    //
+    // Permission is hereby granted, free of charge, to any person obtaining a copy
+    // of this software and associated documentation files (the "Software"), to deal
+    // in the Software without restriction, including without limitation the rights
+    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    // copies of the Software, and to permit persons to whom the Software is
+    // furnished to do so, subject to the following conditions:
+    //
+    // The above copyright notice and this permission notice shall be included in all
+    // copies or substantial portions of the Software.
+    //
+    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    // SOFTWARE.
+    //--------------------------------------------
+    // https://github.com/carloscabo/colz/blob/master/public/js/colz.class.js
+    var round = Math.round;
+    var rgbToHsl = function (rgba) {
+        var arg, r, g, b, h, s, l, d, max, min;
+
+        arg = rgba;
+
+        if (typeof arg[0] === 'number') {
+            r = arg[0];
+            g = arg[1];
+            b = arg[2];
+        } else {
+            r = arg[0][0];
+            g = arg[0][1];
+            b = arg[0][2];
+        }
+
+        r /= 255;
+        g /= 255;
+        b /= 255;
+
+        max = Math.max(r, g, b);
+        min = Math.min(r, g, b);
+        l = (max + min) / 2;
+
+        if (max === min) {
+            h = s = 0; // achromatic
+        } else {
+            d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+
+            switch (max) {
+                case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+                case g: h = (b - r) / d + 2; break;
+                case b: h = (r - g) / d + 4; break;
+            }
+
+            h /= 6;
+        }
+
+        //CARLOS
+        h = round(h * 360);
+        s = round(s * 100);
+        l = round(l * 100);
+
+        return [h, s, l];
+    }
+    //
+    var hue2rgb = function (p, q, t) {
+        if (t < 0) { t += 1; }
+        if (t > 1) { t -= 1; }
+        if (t < 1 / 6) { return p + (q - p) * 6 * t; }
+        if (t < 1 / 2) { return q; }
+        if (t < 2 / 3) { return p + (q - p) * (2 / 3 - t) * 6; }
+        return p;
+    }
+    var hslToRgb = function (hsl) {
+        var arg, r, g, b, h, s, l, q, p;
+
+        arg = hsl;
+
+        if (typeof arg[0] === 'number') {
+            h = arg[0] / 360;
+            s = arg[1] / 100;
+            l = arg[2] / 100;
+        } else {
+            h = arg[0][0] / 360;
+            s = arg[0][1] / 100;
+            l = arg[0][2] / 100;
+        }
+
+        if (s === 0) {
+            r = g = b = l; // achromatic
+        } else {
+
+            q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            p = 2 * l - q;
+            r = hue2rgb(p, q, h + 1 / 3);
+            g = hue2rgb(p, q, h);
+            b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return [round(r * 255), round(g * 255), round(b * 255)];
+    }
+    editor_util.prototype.rgbToHsl = rgbToHsl
+    editor_util.prototype.hue2rgb = hue2rgb
+    editor_util.prototype.hslToRgb = hslToRgb
+
+    editor_util.prototype.encode64 = function (str) {
+        return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function (match, p1) {
+            return String.fromCharCode(parseInt(p1, 16))
+        }))
+    }
+
+    editor_util.prototype.decode64 = function (str) {
+        return decodeURIComponent(atob(str.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '')).split('').map(function (c) {
+            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
+        }).join(''))
+    }
+
+    editor_util.prototype.isset = function (val) {
+        return val != null && !(typeof val == 'number' && isNaN(val));
+    }
+
+    editor_util.prototype.checkCallback=function(callback){
+        if (!editor.util.isset(callback)) {
+            editor.printe('未设置callback');
+            throw('未设置callback')
+        }
+    }
+
+    editor.constructor.prototype.util = new editor_util();
+}
+//editor_util_wrapper(editor);

_server/fs.js

@@ -56,7 +56,7 @@
                 callback(null, data);
             }
         }, function (e) {
-            console.log(e);
+            main.log(e);
             callback(e+"：请检查启动服务是否处于正常运行状态。");
         }, "text/plain; charset=x-user-defined");
     }
@@ -119,6 +119,10 @@
         throw 'Type Error in fs.writeFile';
     }
 
+    fs.writeMultiFiles = function (filenames, datastrs, callback) {
+        postsomething('name='+filenames.join(';')+'&value='+datastrs.join(';'), '/writeMultiFiles', callback);
+    }
+
     fs.readdir = function (path, callback) {
         //callback:function(err, data)
         //path:支持"/"做分隔符,不以"/"结尾

_server/fsTest_cs.html

@@ -34,6 +34,12 @@
             console.log(d);
         })
     }, 4000);
+    setTimeout(function () {
+        fs.writeMultiFiles(['_test.txt','_test_multi.txt'], ['abc=','abe='], function (e, d) {
+            console.log(e);
+            console.log(d);
+        })
+    }, 5000);
 
 
 </script>