diff --git a/README.md b/README.md
index bb72521e..68a5c0d2 100644
--- a/README.md
+++ b/README.md
@@ -44,7 +44,20 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 
 ## 更新说明
 
-### 2017.12.21
+### 2017.12.31 V1.3
+
+* [x] 支持全键盘操作。
+* [x] 便捷PS工具支持更改图片色相。
+* [x] 支持经验升级（进阶/境界塔）。
+* [x] 打败怪物可以进行加点（加点塔）。
+* [x] 增加阻击、N连击等属性；在怪物手册有属性显示。
+* [x] 支持九宫格领域和大范围领域。
+* [x] 增加负伤。
+* [x] 支持各种BGM的播放。
+* [x] 支持不同层使用不同的地面素材；支持多个Autotile同时存在。
+* [x] 许多细节进行了优化，一些已知的Bug进行了修复。
+
+### 2017.12.21 V1.2
 
 * [x] 新增：本地HTTP服务器。
 * [x] 新增：可视化地图编辑工具。
@@ -57,7 +70,7 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 * [x] 新增：更多的默认素材，现在对于大多数地图风格无需P图，直接替换即可。
 * [x] 添加部分自定义事件，部分细节优化，一些已知的Bug进行了修复。
 
-### 2017.12.16
+### 2017.12.16 V1.1
 
 * [x] 新增：战斗过程显示，可以在设置中关闭
 * [x] 新增：勇士支持48*32（大图）的行走图
@@ -67,7 +80,7 @@ HTML5 canvas制作的魔塔样板，支持全平台游戏！
 * [x] 增添Web的Markdown文档，移除原本的doc和pdf文档。
 * [x] 修复若干Bug。
 
-### 2017.12.9
+### 2017.12.9 V1.0
 
 * [x] 发布初版HTML5魔塔样板
 
diff --git a/_server/vm.js b/_server/vm.js
new file mode 100644
index 00000000..e198d040
--- /dev/null
+++ b/_server/vm.js
@@ -0,0 +1,266 @@
+// vue 相关处理
+
+document.body.onmousedown = function(e){
+  selectBox.isSelected = false;
+  editor.info = {};
+}
+iconLib.onmousedown = function(e){
+  e.stopPropagation();
+}
+var exportM = new Vue({
+  el: '#exportM',
+
+  methods: {
+    exportMap: function(){
+      editor.updateMap();
+      if(editArea.error) {
+        tip.whichShow = 3;
+        
+        return;
+      }
+      var filestr='';
+      for (var yy = 0; yy < 13; yy++){
+        filestr+='['
+        for (var xx = 0; xx < 13; 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==12?'':',')
+        }
+        
+        filestr += ']'+(yy==12?'':',\n');
+      }
+      pout.value = filestr;
+
+      tip.whichShow = 2;
+    }
+  }
+})
+var editArea = new Vue({
+  el: '#editArea',
+  data: {
+    mapArr: '',
+    errors: [ // 编号1,2,3,4
+      "格式错误！请使用正确格式(13*13数组，如不清楚，可先点击生成地图查看正确格式)",
+      "当前有未定义ID（在地图区域显示红块），请修改ID或者到icons.js和maps.js中进行定义！",
+      "ID越界（在地图区域显示红块），当前编辑器暂时支持编号小于400，请修改编号！",
+      // "发生错误！",
+    ],
+    error: 0,
+    formatTimer: null,
+  },
+  watch: {
+    mapArr: function (val, oldval) {
+      var that = this;
+      if(val=='') return;
+      if(that.formatArr()){
+        that.error = 0;
+        clearTimeout(that.formatTimer);
+        setTimeout(function(){
+          that.drawMap();
+          tip.whichShow = 8
+        }, 1000);
+        that.formatTimer = setTimeout(function(){
+          pout.value = that.formatArr();
+        }, 5000); //5s后再格式化，不然光标跳到最后很烦
+      }else{
+        that.error = 1;
+      }
+    },
+    error: function(){
+      // console.log(editArea.mapArr);
+    }
+  },
+  methods: {
+    drawMap: function(){
+      var that = this;
+
+      // var mapArray = that.mapArr.split(/\D+/).join(' ').trim().split(' ');
+      var mapArray = JSON.parse('['+that.mapArr+']');
+      for(var y=0; y<13; y++)
+        for(var x=0; x<13; x++){
+          var num = mapArray[y][x];
+          if(num == 0 )
+            editor.map[y][x] = 0;
+          else if(num >= 400){
+            that.error = 3;
+            editor.map[y][x] = undefined;
+          }else if(typeof(editor.indexs[num][0]) == 'undefined'){
+            that.error = 2;
+            editor.map[y][x] = undefined;
+          }else editor.map[y][x] = editor.ids[[editor.indexs[num][0]]];
+        }
+
+      editor.updateMap();
+      
+    },
+    formatArr: function(){
+      var formatArrStr = '';
+
+      if(this.mapArr.split(/\D+/).join(' ').trim().split(' ').length != 169) return false;
+      var arr = this.mapArr.replace(/\s+/g, '').split('],[');
+      
+      if(arr.length != 13) return ;
+      for(var i =0; i<13; i++){
+        var a = [];
+        formatArrStr +='[';
+        if(i==0||i==12) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
+        else a = arr[i].split(/\D+/);
+        if(a.length != 13){
+          formatArrStr = '';
+          return ;
+        } 
+
+        for(var k=0; k<13; k++){
+          var num = parseInt(a[k]);
+          formatArrStr += Array(Math.max(4-String(num).length,0)).join(' ')+num+(k==12?'':',');
+        }
+        formatArrStr += ']'+(i==12?'':',\n');
+      }
+      
+      return formatArrStr;
+    }
+  }
+});
+var editTip = new Vue({
+  el: '#editTip',
+  data: {
+    err: ''
+  },
+  methods: {
+    copyMap: function(){
+
+      tip.whichShow = 0;
+      if(pout.value.trim() != ''){
+        if(editArea.error) {
+          this.err = editArea.errors[editArea.error-1];
+          tip.whichShow = 5
+          return;
+        }
+        try{
+          pout.select();
+          document.execCommand("Copy");
+          tip.whichShow = 6;
+        }catch(e){
+          this.err= e;
+          tip.whichShow = 5;
+        }
+      }else{
+        tip.whichShow = 7;
+      }
+    }
+  },
+})
+var clear = new Vue({
+  el: '#clear',
+
+  methods: {
+    clearMap: function(){
+      editor.mapInit();
+      clearTimeout(editArea.formatTimer);
+      clearTimeout(tip.timer);
+      pout.value = '';
+      editArea.mapArr = '';
+      tip.whichShow = 4;
+      editArea.error = 0;
+    }
+  }
+})
+var tip = new Vue({
+  el: '#tip',
+  data: {
+    infos: {},
+    hasId: true,
+    isAutotile: false,
+    isSelectedBlock: false,
+    isClearBlock: false,
+    geneMapSuccess: false,
+    timer: null,
+    msgs: [ //分别编号1,2,3,4,5,6,7,8；奇数警告，偶数成功
+      "当前未选择任何图块，请先在右边选择要画的图块!",
+      "生成地图成功！可点击复制按钮复制地图数组到剪切板",
+      "生成失败! 地图中有未定义的图块，建议先用其他有效图块覆盖或点击清除地图！",
+      "地图清除成功!",
+      "复制失败！",
+      "复制成功！可直接粘贴到楼层文件的地图数组中。",
+      "复制失败！当前还没有数据",
+      "修改成功！可点击复制按钮复制地图数组到剪切板"
+    ],
+    mapMsg: '',
+    whichShow: 0,
+  },
+  watch: {
+    infos: {
+      handler: function(val, oldval){
+        this.isClearBlock = false;
+        if(typeof(val) != 'undefined'){
+          if(val==0) {
+            this.isClearBlock = true;
+            return;
+          }
+          if('id' in val){
+            this.hasId = true;
+          }else{
+            this.hasId = false;
+          }
+          this.isAutotile = false;
+          if(val.images == "autotile" && this.hasId) this.isAutotile = true;
+        }
+      },
+      deep: true
+    },
+
+    whichShow: function(){
+      var that = this;
+      that.mapMsg = '';
+      that.msgs[4] = "复制失败！"+editTip.err;
+      clearTimeout(that.timer);
+      if(that.whichShow){
+        that.mapMsg = that.msgs[that.whichShow-1];
+        that.timer = setTimeout(function() {
+          if(!(that.whichShow%2))
+            that.whichShow = 0;
+        }, 5000); //5秒后自动清除success，warn不清除
+      }
+    }
+  }
+})
+
+var selectBox = new Vue({
+  el: '#selectBox',
+  data: {
+    isSelected: false
+  },
+  watch: {
+    isSelected: function(){
+      tip.isSelectedBlock = this.isSelected;
+      tip.whichShow = 0;
+      clearTimeout(tip.timer);
+    }
+  }
+})
+
+var bgSelect = new Vue({
+  el: '#bgSelect',
+  data: {
+    bgs: {},
+    selectedBg: 'ground'
+  },
+  watch:{
+    selectedBg: function(){
+      editor.bgY = this.bgs.indexOf(this.selectedBg);
+      editor.drawMapBg();
+    }
+  }
+})
\ No newline at end of file
diff --git a/docs/api.md b/docs/api.md
index 51973cda..d1b609f4 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -4,32 +4,39 @@
 
 可以在chrome浏览器的控制台中（`ctrl+shift+I`，找到Console）中直接进行调用，以查看效果。
 
+!> **`main.js`：游戏入口。所有其他JS文件都是被此文件加载。**
+
+``` js
+
+```
+
 !> **`core.js`：系统核心文件。所有核心逻辑处理都在此文件完成。**
 
 ``` js
 * core.status.floorId // 获得当前层floorId
 * core.status.thisMap // 获得当前层的地图信息
+* core.status.maps // 获得所有楼层的地图信息
+* core.floors // 获得所有楼层的剧本
 
 // ------ 初始化部分 ------
 core.init // 初始化
-core.showStartAnimate // 显示开始界面
-core.hideStartAnimate // 隐藏开始界面
+core.showStartAnimate // 显示游戏开始界面
+core.hideStartAnimate // 隐藏游戏开始界面
 core.setStartProgressVal // 设置加载进度条进度
 core.setStartLoadTipText // 设置加载进度条提示文字
 core.loader // 加载图片和音频
 core.loadImage // 加载图片
-core.loadSound // 加载音频
-core.loadSoundItem // 加载某一个音频
+core.loadMusic // 加载音频
 core.isPlaying // 游戏是否已经开始
 core.clearStatus // 清除游戏状态和数据
 core.resetStatus // 重置游戏状态和初始数据
-core.startGame // 具体开始游戏
+core.startGame // 开始游戏
 * core.restart // 重新开始游戏；此函数将回到标题页面
 
 // ------ 键盘、鼠标事件 ------
 core.onKeyDown // 按下某个键时
 core.onKeyUp // 放开某个键时
-core.pressKey // 按住某个键不动时
+core.pressKey // 按住某个键时
 core.keyDown // 根据按下键的code来执行一系列操作
 core.keyUp // 根据放开键的code来执行一系列操作
 core.ondown // 点击（触摸）事件按下时
@@ -37,14 +44,14 @@ core.onmove // 当在触摸屏上滑动时
 core.onup // 当点击（触摸）事件放开时
 core.getClickLoc // 获得点击事件相对左上角的坐标（0到12之间）
 core.onclick // 具体点击屏幕上(x,y)点时，执行的操作
-core.onmousewheel // 滑动鼠标滚轮时的操作（楼层传送时可用滚轮切换楼层）
+core.onmousewheel // 滑动鼠标滚轮时的操作
 
 // ------ 自动寻路代码相关 ------
 core.clearAutomaticRouteNode // 清除自动寻路路线
 core.stopAutomaticRoute // 停止自动寻路操作
 core.continueAutomaticRoute // 继续剩下的自动寻路操作
-core.clearContinueAutomaticRoute // 清除剩下的自动寻路列表
-core.setAutomaticRoute // 设置一个自动寻路
+core.clearContinueAutomaticRoute // 清空剩下的自动寻路列表
+core.setAutomaticRoute // 设置自动寻路路线
 core.automaticRoute // 自动寻路算法，找寻最优路径
 core.fillPosWithPoint // 显示离散的寻路点
 core.clearStepPostfix // 清除已经寻路过的部分
@@ -54,13 +61,15 @@ core.stopAutoHeroMove // 停止勇士的自动行走
 core.setAutoHeroMove // 设置勇士的自动行走路线
 core.autoHeroMove // 让勇士开始自动行走
 core.setHeroMoveInterval // 设置行走的效果动画
-core.setHeroMoveTriggerInterval // 设置勇士行走过程中对途经事件的触发检测
-* core.turnHero(direction) // 设置勇士的方向（转向）；如果指定了direction则会面向该方向，否则执行一个转向操作。
+core.setHeroMoveTriggerInterval // 设置勇士行走过程中对事件的触发检测
+* core.turnHero(direction) // 设置勇士的方向（转向）
+core.canMoveHero // 勇士能否前往某方向
 core.moveHero // 让勇士开始移动
+core.eventMoveHero // 使用事件让勇士移动。这个函数将不会触发任何事件。
 core.moveOneStep // 每移动一格后执行的事件。中毒时在这里进行扣血判断。
 core.waitHeroToStop(callback) // 停止勇士的一切行动，等待勇士行动结束后，再执行callback回调函数。
 core.stopHero // 停止勇士的移动状态。
-core.drawHero // 在hero层绘制勇士。
+core.drawHero // 绘制勇士。
 * core.setHeroLoc(name, value) // 设置勇士的位置。name为”direction”,”x”,”y”
 * core.getHeroLoc(name) // 获得勇士的位置。
 * core.nextX // 获得勇士面对位置的x坐标
@@ -71,42 +80,49 @@ core.drawHero // 在hero层绘制勇士。
 * core.battle(id, x, y, force, callback) // 进行战斗；force表示是否强制战斗
 core.afterBattle // 战斗完毕
 core.trigger(x,y) // 触发x,y点的事件
-* core.changeFloor(floorId, stair, heroLoc, time, callback) // 楼层切换floorId为目标楼层Id，stair可指定为上/下楼梯，time动画时间
-core.mapChangeAnimate // 实际切换的动画效果
-core.clearMap // 清除地图显示
+* core.changeFloor(floorId, stair, heroLoc, time, callback) // 楼层切换。floorId为目标楼层Id，stair可指定为上/下楼梯，time动画时间
+core.mapChangeAnimate // 地图切换动画效果
+core.clearMap // 清除地图
 core.fillText // 在某个canvas上绘制一段文字
 core.fillRect // 在某个canvas上绘制一个矩形
 core.strokeRect // 在某个canvas上绘制一个矩形的边框
+core.drawLine // 在某个canvas上绘制一条线
 core.setFont // 设置某个canvas的文字字体
 core.setLineWidth // 设置某个canvas的线宽度
 core.saveCanvas // 保存某个canvas状态
-core.loadCanvas // 读取某个canvas状态
+core.loadCanvas // 加载某个canvas状态
 core.setStrokeStyle // 设置某个canvas边框属性
 core.setAlpha // 设置某个canvas的alpha值
 core.setOpacity // 设置某个canvas的透明度
 core.setFillStyle // 设置某个canvas的绘制属性（如颜色等）
 * core.drawMap(mapId, callback) // 绘制某张地图。mapId为地图Id，绘制完毕将执行callback回调函数。
+core.drawAutotile // 绘制Autotile
+core.drawAutotileBlock // 绘制Autotile的某一块
 * core.noPassExists(x,y) // 某个点是否不可通行
 core.noPass // 某个点是否在区域内且不可通行
 * core.npcExists(x,y) // 某个点是否存在NPC
-* core.terrainExists(x,y) // 某个点是否存在指定的地形
+* core.terrainExists(x,y) // 某个点是否存在（指定的）地形
 * core.stairExists(x,y) // 某个点是否存在楼梯
 * core.nearStair // 当前位置是否在楼梯边
-* core.enemyExists(x,y) // 某个点是否存在怪物
+* core.enemyExists(x,y) // 某个点是否存在（指定的）怪物
 * core.getBlock(x, y, floorId, needEnable) // 获得某个点的block。floorId指定目标楼层，needEnable如果为false则即使该点的事件处于禁用状态也将被返回（否则只有事件启用的点才被返回）
 core.moveBlock // 显示移动某块的动画，达到{“type”:”move”}的效果
 core.animateBlock // 显示/隐藏某个块时的动画效果
-core.addBlock // 将某个块从禁用变成启用状态
+core.showBlock // 将某个块从禁用变成启用状态
 core.removeBlock // 将某个块从启用变成禁用状态
 core.removeBlockById // 根据block的索引删除该块
 core.removeBlockByIds // 一次性删除多个block
 core.addGlobalAnimate // 添加一个全局动画
 core.removeGlobalAnimate // 删除一个或所有全局动画
 core.setGlobalAnimate // 设置全局动画的显示效果
+core.syncGlobalAnimate // 同步所有的全局动画效果
 core.setBoxAnimate // 显示UI层某个box的动画（如怪物手册中怪物的动画）
 core.drawBoxAnimate // 绘制UI层的box动画
-core.setFg // 色调渐变
-* core.updateFg // 更新全地图的显伤
+core.updateCheckBlock // 更新领域、夹击、阻击的伤害地图
+core.checkBlock // 检查并执行领域、夹击、阻击事件
+core.snipe // 阻击事件（动画效果）
+core.setFg // 更改画面色调
+* core.updateFg // 更新全地图显伤
 * core.itemCount // 获得某个物品的个数
 * core.hasItem // 是否存在某个物品
 * core.setItem // 设置某个物品的个数
@@ -114,23 +130,23 @@ core.setFg // 色调渐变
 * core.useItem // 使用某个物品；直接调用items.js中的useItem函数。
 * core.canUseItem // 能否使用某个物品。直接调用items.js中的canUseItem函数。
 * core.addItem // 增加某个物品的个数
-* core.getItem // 获得某个物品时的事件
+core.getNextItem // 获得面前的物品（轻按）
+* core.getItem // 获得某个物品
 * core.drawTip // 左上角绘制一段提示
 * core.drawText // 地图中间绘制一段文字
 
 // ------ 系统机制 ------
 core.replaceText // 将文字中的${和}（表达式）进行替换
 core.calValue // 计算表达式的值
-core.splitText // 字符串自动换行的分割
+core.doEffect // 执行一个表达式的effect操作
+core.splitLines // 字符串自动换行的分割
 core.unshift // 向某个数组前插入另一个数组或元素
 core.setLocalStorage // 设置本地存储
 core.getLocalStorage // 获得本地存储
 core.removeLocalStorage // 移除本地存储
-core.clone // 复制一个对象
+core.clone // 深拷贝一个对象
 core.formatDate // 格式化时间为字符串
 core.setTwoDigits // 两位数显示
-core.win // 获胜；将直接调用events.js中的win函数
-core.lose // 失败；将直接调用events.js中的lose函数
 core.debug // 进入Debug模式，攻防血和钥匙都调成很高的数值
 core.checkStatus // 判断当前能否进入某个事件
 core.openBook // 点击怪物手册时的打开操作
@@ -144,6 +160,7 @@ core.saveData // 存档到本地
 core.loadData // 从本地读档
 * core.setStatus // 设置勇士属性
 * core.getStatus // 获得勇士属性
+core.getLvName // 获得某个等级的名称
 * core.setFlag // 设置某个自定义变量或flag
 * core.getFlag // 获得某个自定义变量或flag
 * core.hasFlag // 是否存在某个自定义变量或flag，且值为true
@@ -151,17 +168,16 @@ core.insertAction // 往当前事件列表之前插入一系列事件
 * core.lockControl // 锁定状态栏，常常用于事件处理
 * core.unlockControl // 解锁状态栏
 * core.isset // 判断某对象是否不为undefined也不会null
-* core.playSound // 播放音频
 * core.playBgm // 播放背景音乐
-core.changeSoundStatus // 切换声音状态
-core.enableSound // 启用音效
-core.disableSound // 禁用音效
+* core.pauseBgm // 暂停背景音乐的播放
+* core.resumeBgm // 恢复背景音乐的播放
+* core.playSound // 播放音频
 core.show // 动画显示某对象
 core.hide // 动画使某对象消失
 core.clearStatusBar // 清空状态栏
 core.updateStatusBar // 更新状态栏
 core.resize // 屏幕分辨率改变后重新自适应
-core.resetSize // 屏幕分辨率改变后重新自适应
+core.domRenderer // 渲染DOM
 
 // ------ core.js 结束 ------
 ```
@@ -171,53 +187,105 @@ core.resetSize // 屏幕分辨率改变后重新自适应
 !> **`enemys.js` 定义了怪物信息。**
 
 ``` js
-* core.enemys.getSpecialText // 获得特殊属性的文字
+core.enemys.init // 初始化
+* core.enemys.getEnemys // 获得一个或所有怪物数据
+* core.enemys.hasSpecial // 判断是否含有某特殊属性
+* core.enemys.getSpecialText // 获得所有特殊属性的名称
+* core.enemys.getSpecialHint // 获得每个特殊属性的说明
 * core.enemys.getDamage // 获得某个怪物的伤害
-* core.enemys.getExtraDamage // 获得某个怪物的额外伤害（吸血）
-* core.enemys.getCritical // 计算某个怪物的临界值
-* core.enemys.getCriticalDamage // 计算某个怪物的临界减伤
-* core.enemys.getDefDamage // 计算某个怪物的1防减伤
-* core.enemys.calDamage // 实际的伤害计算公式
-core.enemys.getCurrentEnemys // 获得当前层剩下的的怪物列表
+* core.enemys.getExtraDamage // 获得某个怪物的额外伤害
+* core.enemys.getCritical // 临界值计算
+* core.enemys.getCriticalDamage // 临界减伤计算
+* core.enemys.getDefDamage // 1防减伤计算
+* core.enemys.calDamage // 具体的伤害计算公式
+core.enemys.getCurrentEnemys // 获得当前楼层的怪物列表
 ```
 
 !> **`events.js` 定义了各个事件的处理流程。**
 
 ``` js
-* core.events.startGame // 开始游戏
-* core.events.win // 获胜
-* core.events.lose // 失败
-core.events.checkBlock // 检查领域、夹击事件
-core.events.afterChangeFloor // 楼层切换结束时的事件
+core.events.init // 初始化
+core.events.getEvents // 获得一个或所有系统事件类型
+core.events.startGame // 游戏开始事件
+* core.events.setInitData // 不同难度分别设置初始属性
+* core.events.win // 游戏获胜事件
+* core.events.lose // 游戏失败事件
+core.events.afterChangeFloor // 转换楼层结束的事件
 core.events.doEvents // 开始执行一系列自定义事件
 core.events.doAction // 执行当前自定义事件列表中的下一个事件
-core.events.insertAction // 往当前自定义事件列表前插入若干个事件
+core.events.insertAction // 往当前事件列表之前添加一个或多个事件
 core.events.openShop // 打开一个全局商店
-core.events.disableQuickShop // 禁用一个快捷商店
+core.events.disableQuickShop // 禁用一个全局商店
 * core.events.canUseQuickShop // 当前能否使用快捷商店
+* core.events.checkLvUp // 检查升级事件
 * core.events.useItem // 尝试使用道具
+core.events.addPoint // 加点事件
 core.events.afterBattle // 战斗结束后触发的事件
 core.events.afterOpenDoor // 开一个门后触发的事件
 core.events.passNet // 经过一个路障
-core.events.beforeSaveData // 即将存档前可以执行的操作
-core.events.afterLoadData // 读档后，载入事件前可以执行的操作
+core.events.changeLight // 改变亮灯（感叹号）的事件
+* core.events.afterChangeLight // 改变亮灯之后，可以触发的事件
+* core.events.afterUseBomb // 使用炸弹/圣锤后的事件
+* core.events.beforeSaveData // 即将存档前可以执行的操作
+* core.events.afterLoadData // 读档事件后，载入事件前，可以执行的操作
 
-// ------ 界面上的点击事件 ------
-core.events.clickAction // 自定义事件处理时，对用户点击的处理
-core.events.clickBook // 怪物手册打开时，对用户点击的处理
-core.events.clickFly // 楼层传送器打开时，对用户点击的处理
-core.events.clickShop // 全局商店打开时，对用户点击的处理
-core.events.clickQuickShop // 快捷商店选项打开时
-core.events.clickToolbox // 工具栏打开时
-core.events.clickSL // 存/读档界面打开时
-core.events.clickSettings // 设置页面打开时
+// ------ 点击事件和键盘事件的处理 ------
+core.events.keyDownCtrl // 按下Ctrl键时（快捷跳过对话）
+core.events.clickConfirmBox // 确认框界面时的点击操作
+core.events.keyUpConfirmBox // 确认框界面时，放开某个键的操作
+core.events.clickAction // 自定义事件时的点击操作
+core.events.keyDownAction // 自定义事件时，按下某个键的操作
+core.events.keyUpAction // 自定义事件时，放开某个键的操作
+core.events.clickBook // 怪物手册界面的点击操作
+core.events.keyDownBook // 怪物手册界面时，按下某个键的操作
+core.events.keyUpBook // 怪物手册界面时，放开某个键的操作
+core.events.clickBookDetail // 怪物手册属性显示界面时的点击操作
+core.events.clickFly // 楼层传送器界面时的点击操作
+core.events.keyDownFly // 楼层传送器界面时，按下某个键的操作
+core.events.keyUpFly // 楼层传送器界面时，放开某个键的操作
+core.events.clickShop // 商店界面时的点击操作
+core.events.keyDownShop // 商店界面时，按下某个键的操作
+core.events.keyUpShop // 商店界面时，放开某个键的操作
+core.events.clickQuickShop // 快捷商店界面时的点击操作
+core.events.keyDownQuickShop // 快捷商店界面时，按下某个键的操作
+core.events.keyUpQuickShop // 快捷商店界面时，放开某个键的操作
+core.events.clickToolbox // 工具栏界面时的点击操作
+core.events.clickToolboxIndex // 选择工具栏界面中某个Index后的操作
+core.events.keyDownToolbox // 工具栏界面时，按下某个键的操作
+core.events.keyUpToolbox // 工具栏界面时，放开某个键的操作
+core.events.clickSL // 存读档界面时的点击操作
+core.events.keyDownSL // 存读档界面时，按下某个键的操作
+core.events.keyUpSL // 存读档界面时，放开某个键的操作
+core.events.clickSwitchs // 系统设置界面时的点击操作
+core.events.keyDownSwitchs // 系统设置界面时，按下某个键的操作
+core.events.keyUpSwitchs // 系统设置界面时，放开某个键的操作
+core.events.clickSettings // 系统菜单栏界面时的点击事件
+core.events.keyDownSettings // 系统菜单栏界面时，按下某个键的操作
+core.events.keyUpSettings // 系统菜单栏界面时，放开某个键的操作
+core.events.clickSyncSave // 同步存档界面时的点击操作
+core.events.keyDownSyncSave // 同步存档界面时，按下某个键的操作
+core.events.keyUpSyncSave // 同步存档界面时，放开某个键的操作
+core.events.clickAbout // “关于”界面时的点击操作
 ```
 
-!> `maps.js` 定义了地图，以及每个数字所代表的意义。
+!> `icons.js` 定义了素材ID和它在图片上的索引的对应关系。
+
+!> `items.js` 定义了每个道具的名称，以及使用效果。
+
+``` js
+core.items.init // 初始化
+core.items.getItems // 获得所有道具
+core.items.getItemEffect // “即捡即用类”道具的使用效果
+core.items.getItemEffectTip // “即捡即用类”道具的文字提示
+* core.items.useItem // 使用道具
+* core.items.cauUseItem // 当前能否使用道具
+```
+
+!> `maps.js` 定义了数字-ID的对应关系。
 
 ``` js
 core.maps.loadFloor // 加载某个楼层（从剧本或存档中）
-core.maps.getBlock // 将数字替换成实际的内容
+core.maps.getBlock // 数字和ID的对应关系
 core.maps.addEvent // 向该楼层添加剧本的自定义事件
 core.maps.addChangeFloor // 向该楼层添加剧本的楼层转换事件
 core.maps.initMaps // 初始化所有地图
@@ -232,16 +300,19 @@ core.ui.closePanel // 结束一切事件和绘制，关闭UI窗口，返回游
 core.ui.drawTextBox // 绘制一个对话框
 core.ui.drawChoices // 绘制一个选项界面
 core.ui.drawConfirmBox // 绘制一个确认/取消的警告页面
+core.ui.drawSwitchs // 绘制系统设置界面
 core.ui.drawSettings // 绘制系统菜单栏
 core.ui.drawQuickShop // 绘制快捷商店选择栏
-core.ui.drawBattleAnimate // 绘制战斗过程
-core.ui.drawWaiting // 绘制一个“请稍后”页面
-core.ui.drawSyncSave // 绘制存档同步选项
+core.ui.drawBattleAnimate // 绘制战斗动画
+core.ui.drawWaiting // 绘制等待界面
+core.ui.drawSyncSave // 绘制存档同步界面
 core.ui.drawPagination // 绘制分页
 core.ui.drawEnemyBook // 绘制怪物手册
+core.ui.drawBookDetail // 绘制怪物属性的详细信息
 core.ui.drawFly // 绘制楼层传送器
 core.ui.drawToolbox // 绘制道具栏
 core.ui.drawSLPanel // 绘制存档/读档界面
 core.ui.drawThumbnail // 绘制一个缩略图
 core.ui.drawAbout // 绘制“关于”界面
+core.ui.drawHelp // 绘制帮助界面
 ```
diff --git a/docs/element.md b/docs/element.md
index 668c0c2d..50459e42 100644
--- a/docs/element.md
+++ b/docs/element.md
@@ -40,14 +40,15 @@
 ``` js
 enemys.prototype.getSpecialText = function (enemyId) {
     if (enemyId == undefined) return "";
-    var special = this.enemys[enemyId].special;
+    var enemy = this.enemys[enemyId];
+    var special = enemy.special;
     var text = [];
     if (this.hasSpecial(special, 1)) text.push("先攻");
     if (this.hasSpecial(special, 2)) text.push("魔攻");
     if (this.hasSpecial(special, 3)) text.push("坚固");
     if (this.hasSpecial(special, 4)) text.push("2连击");
     if (this.hasSpecial(special, 5)) text.push("3连击");
-    if (this.hasSpecial(special, 6)) text.push("4连击");
+    if (this.hasSpecial(special, 6)) text.push((enemy.n||4)+"连击");
     if (this.hasSpecial(special, 7)) text.push("破甲");
     if (this.hasSpecial(special, 8)) text.push("反击");
     if (this.hasSpecial(special, 9)) text.push("净化");
@@ -59,22 +60,35 @@ enemys.prototype.getSpecialText = function (enemyId) {
     if (this.hasSpecial(special, 15)) text.push("领域");
     if (this.hasSpecial(special, 16)) text.push("夹击");
     if (this.hasSpecial(special, 17)) text.push("仇恨");
+    if (this.hasSpecial(special, 18)) text.push("阻击");
+    if (this.hasSpecial(special, 19)) text.push("自爆");
+    if (this.hasSpecial(special, 20)) text.push("无敌");
     return text.join("  ");
 }
 ```
 
-如果需要双属性，则采用100x+y的写法。例如 103 则视为同时拥有1和3的属性，即先攻且坚固。同理1314为衰弱诅咒双属性。
+多属性可采用数组的写法，比如`'special': [1,3]`视为同时拥有先攻和坚固属性；`'special': [5,10,14,18]`视为拥有3连击、魔防、诅咒、阻击四个属性。
 
-如果需要三属性，则采用10000x+100y+z的写法。例如71116视为同时拥有7,11和16的属性，即破甲、吸血、夹击。
+本塔支持战斗动画，在`data.js`中存在三个全局选项：`canOpenBattleAnimate`, `showBattleAnimateConfirm`, `battleAnimate`。
+- `canOpenBattleAnimate`代表是否允许用户开启战斗动画。如果你添加了一些自定义属性，且不想修改战斗界面的UI，则可以将其关闭。
+- `showBattleAnimateConfirm`代表是否在游戏开始时给用户提供开启动画的选项。对于一些偏向于萌新的塔，可以开启此项。
+- `battleAnimate`代表是否默认开启战斗动画。此项会被用户存储的设置给覆盖。
+- 如果`canOpenBattleAnimate`为false，则后面两个也强制为false。
 
-四个乃至更多的属性以此类推。
+怪物可以负伤，在`data.js`的全局变量`enableNegativeDamage`中指定。
 
-怪物的伤害计算在下面的`calDamage`函数中，如有自己需求的伤害计算公式请修改该函数的代码。
+下面的`getSpecialHint`函数则给定了每个特殊属性的详细描述。这个描述将在怪物手册中看到。
+
+**打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](event#加点事件)。**
 
 如果`data.js`中的enableExperience为false，即不启用经验的话，怪物手册里将不显示怪物的经验值，打败怪物也不获得任何经验。
 
 拿到幸运金币后，打怪获得的金币将翻倍。
 
+N连击怪物的special是6，且我们可以为它定义n代表实际连击数。参见样板中剑王的写法。
+
+![N连击](./img/nattack.png)
+
 吸血怪需要在怪物后添加value，代表吸血的比例。
 
 ![怪物吸血](./img/blood.png)
@@ -89,15 +103,21 @@ enemys.prototype.getSpecialText = function (enemyId) {
 
 领域怪需要在怪物后添加value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
 
-![怪物领域](./img/domainenemy.png)
+领域是十字伤害还是九宫格伤害由data.js中的全局变量`zoneSquare`设定。你也可以对该怪物自行进行设定。
 
-请注意如果吸血和领域同时存在，则value会冲突。**因此请勿将吸血和领域放置在同一个怪物身上。**
+`range`选项可选，代表该领域怪的范围，不写则默认为1。
 
-本塔暂不支持阻击、激光、自爆、退化等属性。
+![怪物领域](./img/zone.png)
+
+阻击怪同样需要在怪物后添加value，代表领域伤害的数值。如果勇士生命值扣减到0，则直接死亡触发lose事件。
+
+!> 阻击怪后退的地点不能有任何事件存在，即使是已经被禁用的自定义事件！
+
+请注意如果吸血、领域、阻击中任何两个同时存在，则value会冲突。**因此请勿将吸血、领域或阻击放置在同一个怪物身上。**
 
 如有额外需求，可参见[自定义怪物属性](personalization#自定义自定义怪物属性)，里面讲了如何设置一个新的怪物属性。
 
-### 路障、楼梯、传送门
+### 路障，楼梯，传送门
 
 血网的伤害数值、中毒后每步伤害数值、衰弱时暂时攻防下降的数值，都在 `data.js` 的values内定义。
 
@@ -123,6 +143,65 @@ floorId指定的是目标楼层的唯一标识符（ID）。
 
 ![楼层转换穿透](./img/floorset.png)
 
+### 背景音乐
+
+本塔支持BGM和SE的播放。
+
+要播放音乐和音效，你需要将对应的文件放在sounds目录下，然后在main.js中进行定义
+
+``` js
+this.bgms = [ // 在此存放所有的bgm，和文件名一致。第一项为默认播放项
+    // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+    '058-Slow01.mid', 'bgm.mp3', 'qianjin.mid', 'star.mid'
+];
+this.sounds = [ // 在此存放所有的SE，和文件名一致
+    // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+    'floor.mp3', 'attack.ogg', 'door.ogg', 'item.ogg'
+]
+```
+
+!> 音频名不能使用中文，不能带空格或特殊字符。
+
+目前BGM支持主流的音乐格式，如mp3, ogg, mid格式等。SE则不支持mid格式的播放。
+
+!> mid格式是通过数学方法模拟出来的音乐效果，质量可能会和实际效果差距较大。
+
+定义完毕后，我们可以调用`playBgm`/`playSound`事件来播放对应的音乐/音效，有关事件的详细介绍请参见[事件](event)。
+
+**另外，考虑到用户的流量问题，将遵循如下规则：**
+- **如果用户当前使用的电脑，则默认开启音乐效果，并播放默认BGM**
+- **如果用户当前使用的手机，且处于Wifi状态，则默认开启音乐效果，并播放默认BGM**
+- **其他情况，将默认关闭音乐效果，只有在用户在菜单栏中点击“音乐开关”后才会播放音乐**
+
+!> iOS平台以及部分浏览器不支持获得当前网络状态，此时即使在使用Wifi也必须要用户点击“音乐开关”才能播放音乐。
+
+### 操作说明
+
+本塔主要支持鼠标（触摸屏）操作和键盘操作。
+
+鼠标（触摸屏）操作说明如下：
+- **点状态栏中图标：** 进行对应的操作
+- **点任意块：** 寻路并移动
+- **点任意块并拖动：** 指定寻路路线
+- **单击勇士：** 转向
+- **双击勇士：** 轻按（仅在轻按开关打开时有效）
+
+键盘操作快捷键如下：
+- **[CTRL]** 跳过对话
+- **[X]** 打开/关闭怪物手册
+- **[G]** 打开/关闭楼层传送器
+- **[S/D]** 打开/关闭存/读档页面
+- **[K]** 打开/关闭快捷商店选择列表
+- **[T]** 打开/关闭工具栏
+- **[ESC]** 打开/关闭系统菜单
+- **[H]** 打开帮助页面
+- **[SPACE]** 轻按（仅在轻按开关打开时有效）
+- **[1]** 快捷使用破墙镐
+- **[2]** 快捷使用炸弹/圣锤
+- **[3]** 快捷使用中心对称飞行器
+
+以上快捷键也能在游戏菜单中的操作说明中看到。
+
 &nbsp;
 
 &nbsp;
diff --git a/docs/event.md b/docs/event.md
index f9cab896..a1525c3c 100644
--- a/docs/event.md
+++ b/docs/event.md
@@ -397,7 +397,9 @@ revisit常常使用在一些商人之类的地方，当用户购买物品后不
 
 如果强制战斗失败，则会立刻生命归0并死亡，调用lose函数，接下来的事件不会再被执行。
 
-强制战斗没有指定loc的选项，因此战斗后需要调用hide使怪物消失（如果有必要）。强制战斗不会触发任何afterBattle里的事件。
+打败怪物后可以进行加点操作。有关加点塔的制作可参见[加点事件](#加点事件)。
+
+强制战斗没有指定loc的选项，因此战斗后需要调用hide使怪物消失（如果有必要）。
 
 ### openDoor: 开门
 
@@ -416,8 +418,6 @@ loc指定门的坐标，floorId指定门所在的楼层ID。如果是当前层
 
 如果loc所在的点既不是门也不是墙壁，则忽略本事件。
 
-openDoor不会触发任何afterOpenDoor里的事件。
-
 ### changeFloor: 楼层切换
 
 在事件中也可以对楼层进行切换。一个比较典型的例子就是TSW中，勇士在三楼的陷阱被扔到了二楼，就是一个楼层切换事件。
@@ -553,6 +553,26 @@ move完毕后移动的NPC/怪物一定会消失，只不过可以通过immediate
 
 不过值得注意的是，用这种方式移动勇士的过程中将无视一切地形，无视一切事件，中毒状态也不会扣血。
 
+### playBgm: 播放背景音乐
+
+使用playBgm可以播放一个背景音乐。
+
+使用方法：`{"type": "playBgm", "name": "bgm.mp3"}`
+
+值得注意的是，额外添加进文件的背景音乐，需在main.js中this.bgms里加载它。
+
+目前支持mp3/ogg/wav/mid等多种格式的音乐播放。
+
+有关BGM播放的详细说明参见[背景音乐](element#背景音乐)
+
+### pauseBgm: 暂停背景音乐
+
+使用`{"type": "pauseBgm"}`可以暂停背景音乐的播放。
+
+### resumeBgm: 恢复背景音乐
+
+使用`{"type": "resumeBgm"}`可以恢复背景音乐的播放。
+
 ### playSound: 播放音效
 
 使用playSound可以立刻播放一个音效。
@@ -561,10 +581,6 @@ move完毕后移动的NPC/怪物一定会消失，只不过可以通过immediate
 
 值得注意的是，如果是额外添加进文件的音效，则需在main.js中this.sounds里加载它。
 
-!> 自定义添加的音效名请勿包含`-`，否则将无法正常使用！
-
-由于考虑到用户流量问题，每个额外音效最好不超过20KB。
-
 ### win: 获得胜利
 
 `{"type": "win", "reason": "xxx"}` 将会直接调用events.js中的win函数，并将reason作为参数传入。
@@ -756,6 +772,43 @@ core.insertAction(list) //往当前事件列表中插入一系列事件。使用
 // ……
 ```
 
+## 加点事件
+
+打败怪物后可以进行加点。
+
+如果要对某个怪物进行加点操作，则首先需要修改该怪物的点数值，即在怪物定义的后面添加`point`，代表怪物本身的加点数值。
+
+``` js
+... 'def': 0, 'money': 1, 'experience': 1, 'special': 0, 'point': 1}, // 在怪物后面添加point代表怪物的加点数
+```
+
+然后在`events.js`文件中找到`addPoint`函数。它将返回一个choices事件。修改此函数为我们需要的加点项即可。
+
+``` js
+////// 加点 //////
+events.prototype.addPoint = function (enemy) {
+    var point = enemy.point; // 获得该怪物的point
+    if (!core.isset(point) || point<=0) return [];
+
+    // 加点，返回一个choices事件
+    return [
+        {"type": "choices",
+            "choices": [ // 提供三个选项：对于每一点，攻击+1/防御+2/生命+200
+                {"text": "攻击+"+(1*point), "action": [
+                    {"type": "setValue", "name": "status:atk", "value": "status:atk+"+(1*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)}
+                ]},
+            ]
+        }
+    ];
+}
+```
+
 ## 全局商店
 
 我们可以采用上面的choices方式来给出一个商店。这样的商店确实可以有效地进行操作，但是却是"非全局"的，换句话说，只有在碰到NPC的时候才能触发商店事件。
@@ -776,7 +829,6 @@ core.insertAction(list) //往当前事件列表中插入一系列事件。使用
         // 上面的例子是50层商店的计算公式。你也可以写任意其他的计算公式，只要以times作为参数即可。
         // 例如： "need": "25" 就是恒定需要25金币的商店； "need": "20+2*times" 就是第一次访问要20金币，以后每次递增2金币的商店。
         // 如果是对于每个选项有不同的计算公式，写 "need": "-1" 即可。可参见下面的经验商店。
-    
         "text": "勇敢的武士啊，给我${need}金币就可以：", // 显示的文字，需手动加换行符。可以使用${need}表示上面的need值。
         "choices": [ // 商店的选项
             {"text": "生命+800", "effect": "status:hp+=800"},
@@ -784,10 +836,12 @@ core.insertAction(list) //往当前事件列表中插入一系列事件。使用
             {"text": "攻击+4", "effect": "status:atk+=4"},
             {"text": "防御+4", "effect": "status:def+=4"},
             {"text": "魔防+10", "effect": "status:mdef+=10"}
-            // effect只能对status和item进行操作，不能修改flag值。且其中间只能用+=符号（也就是只能增加某个属性或道具）
+            // effect只能对status和item进行操作，不能修改flag值。
+            // 必须是X+=Y的形式，其中Y可以是一个表达式，以status:xxx或item:xxx为参数
             // 其他effect样例：
             // "item:yellowKey+=1" 黄钥匙+1
             // "item:pickaxe+=3" 破墙镐+3
+            // "status:hp+=2*(status:atk+status:def)" 将生命提升攻防和的数值的两倍
         ]
     },
     "expShop1": { // 商店唯一ID
@@ -800,13 +854,13 @@ core.insertAction(list) //往当前事件列表中插入一系列事件。使用
         "choices": [
             // 在choices中写need，可以针对每个选项都有不同的需求。
             // 这里的need同样可以以times作为参数，比如 "need": "100+20*times"
-            {"text": "等级+1", "need": "100", "effect": "status:hp+=1000;status:atk+=7;status:def+=7"},
+            {"text": "等级+1", "need": "100", "effect": "status:lv+=1;status:hp+=1000;status:atk+=7;status:def+=7"},
             // 多个effect直接以分号分开即可。如上面的意思是生命+1000，攻击+7，防御+7。
             {"text": "攻击+5", "need": "30", "effect": "status:atk+=5"},
             {"text": "防御+5", "need": "30", "effect": "status:def+=5"},
         ]
-    }
-}
+    },
+},
 ```
 
 全局商店全部定义在`data.js`中的shops一项里。
@@ -887,37 +941,70 @@ core.insertAction(list) //往当前事件列表中插入一系列事件。使用
 
 当且仅当勇士第一次到达某层时，将会触发此事件。可以利用此事件来显示一些剧情，或再让它调用 `{"type": "trigger"}` 来继续调用其他的事件。
 
+## 经验升级（进阶/境界塔）
+
+本塔也支持经验升级，即用户杀怪获得经验后，可以到达某些数值自动进阶，全面提升属性。
+
+要经验升级，你需要先在`data.js`中的全局变量中启用。你需要将`enableExperience`启用经验，且`enableLevelUp`启用进阶。同时你也可以将`enableLv`置为true以在状态栏中显示当前等级（境界）。
+
+同时，你还需要在`data.js`中的`levelUp`来定义每一个进阶所需要的生命值，以及进阶时的效果。
+
+``` js
+"levelUp": [ // 经验升级所需要的数值，是一个数组
+    {}, // 第一项为初始等级，可以简单留空，也可以写name
+
+    // 每一个里面可以含有三个参数 need, name, effect
+    // need为所需要的经验数值，是一个正整数。请确保need所需的依次递增
+    // name为该等级的名称，也可以省略代表使用系统默认值；本项将显示在状态栏中
+    // effect为本次升级所执行的操作，可由若干项组成，由分号分开
+    // 其中每一项写法和上面的商店完全相同，同样必须是X+=Y的形式，Y是一个表达式，同样可以使用status:xxx或item:xxx代表勇士的某项数值/道具个数
+    {"need": 20, "name": "第二级", "effect": "status:hp+=2*(status:atk+status:def);status:atk+=10;status:def+=10"}, // 先将生命提升攻防和的2倍；再将攻击+10，防御+10
+
+    // effect也允许写一个function，代表本次升级将会执行的操作，比如可以显示一段提示文字，或者触发一个事件
+    {"need": 40, "effect": function () {
+        core.drawText("恭喜升级！");
+        core.status.hero.hp *= 2;
+        core.status.hero.atk += 100;
+        core.status.hero.def += 100;
+    }},
+
+    // 依次往下写需要的数值即可
+]
+```
+
+`levelUp`是一个数组，里面分别定义了每个等级的信息。里面每一项是一个object，主要有三个参数`need`, `name`, `effect`
+- `need` 该等级所需要的经验值，是一个正整数。请确保数组中的need依次递增。
+- `name` 该等级的名称，比如“佣兵下级”等。该项可以忽略，以使用系统默认的等级。该项将显示在状态栏中。
+- `effect` 为本次等级执行的操作。它有两种写法：字符串，或函数。
+  - 如果`effect`为字符串，则和上面的全局商店的写法完全相同。可由分号分开，每一项为X+=Y的形式，X为你要修改的勇士属性/道具个数，Y为一个表达式。
+  - 如果`effect`为函数，则也允许写一个`function`，来代表本次升级将会执行的操作。
+
 ## 开始，难度分歧，获胜与失败
 
-游戏开始时将调用`events.js`中的startGame函数。
+游戏开始时将调用`events.js`中的`startGame`函数。
 
-它将显示`data.js`中的startText内容（可以修改成自己的），并正式开始游戏。
+它将显示`data.js`中的startText内容（可以修改成自己的），提供战斗动画开启选择，设置初始福利，并正式开始游戏。
+
+我们可以修改`setInitData`函数来对于不同难度分别设置初始属性。
 
 其参数hard为以下三个字符串之一：`"Easy"`, `"Normal"`, `"Hard"`，分别对应三个难度。针对不同的难度，我们可以设置一些难度分歧。
 
 ``` js
-////// 游戏开始事件 //////
-events.prototype.startGame = function (hard) {
-
-    if (core.status.isStarting) return;
-    core.status.isStarting = true;
-
-    core.hideStartAnimate(function() {
-        core.drawText(core.clone(core.firstData.startText), function() {
-            core.startGame(hard);
-            if (hard=='Easy') { // 简单难度
-                core.setFlag('hard', 1); // 可以用flag:hard来获得当前难度
-                // 可以在此设置一些初始福利，比如设置初始生命值可以调用：
-                // core.setStatus("hp", 10000);
-            }
-            if (hard=='Normal') { // 普通难度
-                core.setFlag('hard', 2); // 可以用flag:hard来获得当前难度
-            }
-            if (hard=='Hard') { // 困难难度
-                core.setFlag('hard', 3); // 可以用flag:hard来获得当前难度
-            }
-        });
-    })
+////// 不同难度分别设置初始属性 //////
+events.prototype.setInitData = function (hard) {
+    if (hard=='Easy') { // 简单难度
+        core.setFlag('hard', 1); // 可以用flag:hard来获得当前难度
+        // 可以在此设置一些初始福利，比如设置初始生命值可以调用：
+        // core.setStatus("hp", 10000);
+        // 赠送一把黄钥匙可以调用
+        // core.setItem("yellowKey", 1);
+    }
+    if (hard=='Normal') { // 普通难度
+        core.setFlag('hard', 2); // 可以用flag:hard来获得当前难度
+    }
+    if (hard=='Hard') { // 困难难度
+        core.setFlag('hard', 3); // 可以用flag:hard来获得当前难度
+    }
 }
 ```
 
diff --git a/docs/img/domainenemy.png b/docs/img/domainenemy.png
deleted file mode 100644
index b74eabcb..00000000
Binary files a/docs/img/domainenemy.png and /dev/null differ
diff --git a/docs/img/nattack.png b/docs/img/nattack.png
new file mode 100644
index 00000000..011b0c55
Binary files /dev/null and b/docs/img/nattack.png differ
diff --git a/docs/img/ps.png b/docs/img/ps.png
index 9e0837e3..9e28c864 100644
Binary files a/docs/img/ps.png and b/docs/img/ps.png differ
diff --git a/docs/img/zone.png b/docs/img/zone.png
new file mode 100644
index 00000000..e5577a9f
Binary files /dev/null and b/docs/img/zone.png differ
diff --git a/docs/index.html b/docs/index.html
index e445274a..8065a5e4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
   <meta charset="UTF-8">
-  <title></title>
+  <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">
@@ -15,7 +15,7 @@
     window.$docsify = {
       homepage: 'index.md',
       loadSidebar: true,
-      name: 'H5魔塔样板',
+      name: 'HTML5魔塔样板',
       repo: 'https://github.com/ckcz123/mota-js',
       // basepath: '../docs/',
       
diff --git a/docs/personalization.md b/docs/personalization.md
index 08328a78..d63c4883 100644
--- a/docs/personalization.md
+++ b/docs/personalization.md
@@ -6,7 +6,7 @@
 
 所有素材的图片都在`images`目录下。
 - `animates.png` 为所有动画效果。主要是星空熔岩，开门，毒网，传送门之类的效果。为四帧。
-- `autotile.png` 为Autotile块。全塔只支持一种Autotile，其ID为20。
+- `autotile.png` 为Autotile块。
 - `enemys.png` 为所有怪物的图片。其对应的数字，从上至下依次是会从201开始计算（即，绿色史莱姆为201，小蝙蝠为205，依次类推）。请注意，动画效果为两帧，一般是原始四帧中的1和3。（四帧中12相同，34相同，因此只取1和3即可）
 - `heros.png` 为勇士行走图。
 - `items.png` 为所有道具的图标。
@@ -17,7 +17,7 @@
 
 ### 使用预定义的素材
 
-在images目录的“默认素材”下给定了若干预定义的自定义素材。包括野外（草地），星空，木板等等都已经被预先给定。
+在images目录的“默认素材”下给定了若干预定义的自定义素材。
 
 如果你需要某个素材已经存在，则可以直接将其覆盖images目录下的同名文件，就能看到效果。
 
@@ -29,6 +29,8 @@
 
 我们可以打开有需求改变的素材，和我们需要被替换的素材，然后简单的Ctrl+C和Ctrl+V操作即可。
 
+便捷PS工具同样支持图片色相的修改，和RMXP几乎完全相同。
+
 用这种方式，我们能极快地替换或素材，包括需要新增的怪物。
 
 ### 添加素材到游戏
@@ -37,63 +39,74 @@
 
 这是因为，该素材没有被定义，无法被游戏所识别。
 
+#### 素材的机制
+
+本塔所有的素材都拥有三个属性：**ID**，**索引**，**数字**。
+- **ID** 为该素材的唯一标识符，任何两个素材的ID都不能相同。
+- **索引** 为该素材的在对应图片上的图标索引，即该素材是图片上的第几个。
+- **数字** 为该素材的对应数字，以方便地图的生成和存储。
+
+**`ID-索引` 对应关系定义在icons.js文件中。该文件将唯一确定一个ID在图片上所在的位置。**
+
+**`ID-数字` 对应关系定义在maps.js文件的getBlock函数中。该函数将唯一确定一个ID对应的数字是多少。**
+
+如果需要添加一个素材到游戏，则必须为其分配一个唯一标识符，并同时修改`icons.js`和`maps.js`两个文件。
+
+
 #### 新添加自定义地形（路面、墙壁等）
 
 如果你在terrains.png中新增了一行：
 
-1. 指定一个唯一的英文ID，不能和terrains中现有的重复。
-2. 进入icons.js，在terrains分类下进行添加（对应图标在图片上的位置，即index）
-3. 指定一个数字，在maps.js的getBlock下类似进行添加。
-``` js
-if (id == 13) tmp.event = {'cls': 'animates', 'id': 'weakNet', 'noPass': false, 'trigger': 'passNet'}; // 衰网
-if (id == 14) tmp.event = {'cls': 'animates', 'id': 'curseNet', 'noPass': false, 'trigger': 'passNet'}; // 咒网
-if (id == 15) tmp.event = {'cls': 'animates', 'id': 'water', 'noPass': true}; // 水
-// 可以在此处类似添加数字-ID对应关系，但不能和任何已有的数字重复
-// autotile: 20
-if (id == 20) tmp.event = {'cls': 'autotile', 'id': 'autotile', 'noPass': true}; // autotile
-``` 
+1. 指定一个唯一的英文ID，不能和现有的重复。
+2. 进入icons.js，在terrains分类下进行添加索引（对应图标在图片上的位置，即index）
+
+**如果你无须在游戏内使用本地形，而仅仅是将其作为“背景图”使用，则操作如下：**
+3. 修改对应楼层的剧本文件的`defaultGround`项，改成新的ID。
+
+**如果你要在游戏内使用本地形，则操作如下：**
+3. 指定一个数字，在maps.js的getBlock函数下类似进行添加。
+
+#### 新添加Autotile
+
+如果你需要新增一个Autotile：
+
+1. 将新的Autotile图片复制到images目录下。
+2. 进入icons.js，在autotile分类下进行添加该文件的名称，索引简单的写0。
+3. 指定一个数字，在maps.js的getBlock函数下类似进行添加。
+
+!> Autotile的ID和文件名完全相同！且其ID/文件名不能含有中文、空格或特殊字符。
 
 #### 新添加道具
 
 如果你需要新增一个未被定义的道具：
 
-1. 指定一个唯一的英文ID，不能和items中现有的重复。
-2. 进入icons.js，在items分类下进行添加（对应图标在图片上的位置，即index）
+1. 指定一个唯一的英文ID，不能和现有的重复。
+2. 进入icons.js，在items分类下进行添加索引（对应图标在图片上的位置，即index）
 3. 指定一个数字，在maps.js的getBlock下类似进行添加。
 4. 在items.js中仿照其他道具，来添加道具的信息。
 
-``` js
-if (id == 63) tmp.event = {'cls': 'items', 'id': 'moneyPocket'} // 金钱袋
-if (id == 64) tmp.event = {'cls': 'items', 'id': 'shoes'} // 绿鞋
-if (id == 65) tmp.event = {'cls': 'items', 'id': 'hammer'} // 圣锤
-// 可以在这里添加自己的数字-ID对应关系，但不能和任何已有的数字重复
-``` 
-
 有关如何自行实现一个道具的效果，参见[自定义道具效果](#自定义道具效果)。
 
 #### 新添加怪物
 
 如果我们需要新添加怪物，请在enemys.png中新增一行，然后复制粘贴上四帧怪物图的**1和3帧**。
 
+你可以通过便捷PS工具的“更改色相”来将红头怪变成橙头怪等。
+
 然后执行如下操作：
 
 1. 指定一个唯一的英文ID，不能和enemys中现有的重复。
-2. 进入icons.js，在enemys分类下进行添加（对应图标在图片上的位置，即index）
+2. 进入icons.js，在enemys分类下进行添加索引（对应图标在图片上的位置，即index）
 3. 在maps.js的getBlock下继续进行添加。请注意其ID为200开始的顺序，即如果新增一行为261，依次类推
 4. 在enemys.js中仿照其他怪物，来添加怪物的信息。
 
-``` js
-if (id == 258) tmp.event = {'cls': 'enemys', 'id': 'octopus'};
-if (id == 259) tmp.event = {'cls': 'enemys', 'id': 'fairy'};
-if (id == 260) tmp.event = {'cls': 'enemys', 'id': 'greenKnight'};
-// 在此依次添加，数字要求是递增的
-```
-
 有关如何自行实现一个怪物的特殊属性或伤害计算公式，参见[怪物的特殊属性](#怪物的特殊属性)。
 
 #### 新添加NPC
 
-类似同上，给NPC指定ID，在icons.js中指定ID-index关系，在maps.js中指定ID-数字的关系，即可。
+1. 指定一个唯一的英文ID，不能和现有的重复。
+2. 进入icons.js，在npcs分类下进行添加索引（对应图标在图片上的位置，即index）
+3. 指定一个数字，在maps.js的getBlock下类似进行添加。
 
 ### 地图生成器使用自定义素材
 
@@ -176,18 +189,24 @@ enemys.prototype.getExtraDamage = function (monster) {
     }
 // ... 下略
 ```
-3. 免疫领域、夹击效果：在`core.js`中，找到updateCheckBlock函数，并编辑成如果有神圣盾标记，则直接返回。
+3. 免疫领域、夹击、阻击效果：在`core.js`中，找到checkBlock函数，并编辑成如果有神圣盾标记，则将伤害变成0。
 ``` js
-// 更新领域、显伤点
-core.prototype.updateCheckBlock = function() {
-    if (!core.isset(core.status.thisMap)) return;
-    if (!core.isset(core.status.checkBlockMap)) core.updateCheckBlockMap();
-    core.status.checkBlock = [];
-    if (core.hasItem('shield5')) return; // 如拥有神圣盾则直接返回
-    for (var x=0;x<13;x++) {
-        for (var y=0;y<13;y++) {
-            // 计算(x,y)点伤害
-            var damage = 0;
+// 检查领域、夹击、阻击事件
+core.prototype.checkBlock = function () {
+    var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
+    var damage = core.status.checkBlock.damage[13*x+y];
+    if (damage>0) {
+        if (core.hasFlag("shield5")) damage = 0; // 如果存在神圣盾，则将伤害变成0
+        core.status.hero.hp -= damage;
+
+        // 检查阻击事件
+        var snipe = [];
+        var scan = {
+            'up': {'x': 0, 'y': -1},
+            'left': {'x': -1, 'y': 0},
+            'down': {'x': 0, 'y': 1},
+            'right': {'x': 1, 'y': 0}
+        }
 // ... 下略
 ```
 4. 如果有更高的需求，例如想让吸血效果变成一半（如异空间），则还是在上面这些地方进行对应的修改即可。
@@ -196,42 +215,15 @@ core.prototype.updateCheckBlock = function() {
 
 如果你对现有的怪物不满意，想自行添加怪物属性（例如让怪物拥有双属性乃至更多属性），也是可以的。具体参见`enemys.js`文件。
 
-你需自己指定一个special数字，修改getSpecialText函数。
+你需自己指定一个special数字，修改getSpecialText函数（属性名）和getSpecialHint函数（属性提示文字）。
 
 如果要修改伤害计算公式，请修改下面的calDamage函数。请注意，如果无法战斗，该函数必须返回`999999999`。
 
-因此无敌属性可以这样设置：
-
-先给无敌属性指定一个数字，例如18，在getSpecialText中定义
-
-``` js
-// ... 上略
-    if (this.hasSpecial(special, 15)) text.push("领域");
-    if (this.hasSpecial(special, 16)) text.push("夹击");
-    if (this.hasSpecial(special, 17)) text.push("仇恨");
-    if (this.hasSpecial(special, 18)) text.push("无敌"); // 添加无敌的显示
-    return text.join("  ");
-}
-
-```
-
-然后修改calDamage，如果无敌属性且勇士没有拥有十字架，则立刻返回无穷大。
-
-``` js
-enemys.prototype.calDamage = function (hero_atk, hero_def, hero_mdef, mon_hp, mon_atk, mon_def, mon_special) {
-    if (this.hasSpecial(mon_special, 18) && !core.hasItem("cross")) // 如果是无敌属性，且勇士未持有十字架
-        return 999999999; // 返回无限大
-
-    // 魔攻
-    if (this.hasSpecial(mon_special, 2)) hero_def = 0;
-// ... 下略
-```
-
 对于吸血怪的额外伤害计算在getExtraDamage中。
 
 对于毒衰弱怪物的战斗后结算在`events.js`中的afterBattle函数中。
 
-对于领域、夹击怪物的检查在`events.js`中的checkBlock函数中。
+对于领域、夹击、阻击怪物的检查在`events.js`中的checkBlock函数中。
 
 `getCritical`, `getCriticalDamage`和`getDefDamage`三个函数依次计算的是该怪物的临界值、临界减伤和1防减伤。也可以适当进行修改。
 
diff --git a/docs/start.md b/docs/start.md
index 127fd819..10300b46 100644
--- a/docs/start.md
+++ b/docs/start.md
@@ -36,7 +36,23 @@
 
 然后将楼层名改为MT1，floorId改名为MT1；title可以改成任意内容，将在切换楼层时进行显示（比如可以改成“1层小塔”）。
 
-具体样板文件的每个要素都有详细的注释。我们最终的任务其实是，将每个楼层的剧本（地图&事件）给写完即可。
+具体样板文件的每个要素如下：
+- **`floorId`** 楼层唯一标识符；必须和文件名，以及 `main.floors.xxx` 完全一致
+- **`title`** 楼层中文名，将在切换楼层时进行显示
+- **`canFlyTo`** 当前楼层可否被楼传器飞到。如果该层不能飞到，则也在该层也不允许使用楼传器。
+- **`canUseQuickShop`** 当前楼层可否使用快捷商店。
+- **`defaultGround`** 该层的背景（地面）素材。需要是在`icon.js`里`terrains`中定义的一个ID，如`ground`, `grass2`等等。
+- **`color`** 该层的画面色调。本项可选，如果不写则色调为默认值（无色调），否则是一个RGBA数组，比如`[255,0,0,0.3]`等。
+- **`bgm`** 到达该层后默认播放的BGM。本项可忽略。
+- **`map`** 本层地图，需要是13x13数组，建议使用地图生成器或者可视化地图编辑器制作。
+- **`firstArrive`** 第一次到该楼层触发的事件
+- **`events`** 该楼的所有可能事件列表
+- **`changeFloor`** 楼层转换事件；该事件不能和上面的events有冲突（同位置点），否则会被覆盖
+- **`afterBattle`** 战斗后可能触发的事件列表
+- **`afterGetItem`** 获得道具后可能触发的事件列表
+- **`afterOpenDoor`** 开完门后可能触发的事件列表
+
+我们最终的任务其实是，将每个楼层的剧本（地图&事件）给写完即可。
 
 换句话说，只需要简单的复制操作，我们就可以新建一个剧本了。
 
diff --git a/drawMapGUI.html b/drawMapGUI.html
index be032623..78373784 100644
--- a/drawMapGUI.html
+++ b/drawMapGUI.html
@@ -8,9 +8,9 @@
         font-family: Roboto,"Helvetica Neue",Helvetica,"PingFang SC","Hiragino Sans GB","Microsoft YaHei","微软雅黑",Arial,sans-serif;;
         background-color: #F5F5F5;
       }
-      ::-webkit-scrollbar {
+      /* ::-webkit-scrollbar {
           width: 5px;
-      }
+      } */
       .main {
         max-width: 100%;
         min-height: 500px;
@@ -26,7 +26,7 @@
         left: 5px;
         top: 10px;
         width: 435px;
-        height: 400px;
+        height: 630px;
       }
 
       #editArea{
@@ -108,7 +108,7 @@
         border: 1px solid #ccc;
         border-radius: 2px;
         font-size: 15px;
-        line-height: 16px;
+        line-height: 14px;
       }
       .files {
         width: 50%;
@@ -129,6 +129,16 @@
         border-radius: 3px;
         box-shadow: inset 0 1px 1px rgba(0,0,0,.075);
       }
+      #bgSelect{
+        width: 50%;
+        height: 100px;
+        margin-top: 10px;
+      }
+      #bgSelect span{
+        display: block;
+        font-size: 14px;
+        line-height: 30px;
+      }
       #printOut{
         margin-top: 10px;
         height: 20px;
@@ -176,7 +186,7 @@
         height: 620px;
         left: 5px;
         top: 5px;
-        overflow:auto;
+        overflow: auto;
       }
       .gameCanvas {
         position: absolute;
@@ -186,15 +196,16 @@
         /* top:0;
         left:320px; */
         z-index:75;
-        width:32px;height:32px;
-
-        margin:-2px 0 0 -2px;
+        width:26px;
+        height:26px;
+        margin: 3px 0 0 3px;
         padding:0;
         /* display: none; */
-
+        box-sizing: border-box;
         background-color:rgba(255, 255, 255, 0.0);
-        border: 2px solid #30DFF3;
-        box-shadow: 0px 0px 2px #30DFF3;
+        border: 1px solid #000;
+        box-shadow: 0 0 0 2px #fff,
+                    0 0 0 3px #000;
       }
       .warnText{
         color: #D50000;
@@ -293,14 +304,22 @@
 <body>
   <div class="main">
     <div id="left">
-      <table class="col" id='arrColMark'></table>
-      <table class="row" id='arrRowMark'></table>
-      <div id="editArea" v-cloak>
-        <textarea cols="10" rows="10" id="pout" v-model="mapArr"></textarea>
-        <p class="warnText" v-if="error">{{ errors[error-1] }}</p>
+      <div id="arrEditor">
+        <table class="col" id='arrColMark'></table>
+        <table class="row" id='arrRowMark'></table>
+        <div id="editArea" v-cloak>
+          <textarea cols="10" rows="10" id="pout" v-model="mapArr"></textarea>
+          <p class="warnText" v-if="error">{{ errors[error-1] }}</p>
+        </div>
+        <div id="editTip" v-cloak>
+          <input class='btn' type="button" value="复制地图" v-on:click="copyMap"/>
+        </div>
       </div>
-      <div id="editTip" v-cloak>
-        <input class='btn' type="button" value="复制地图" v-on:click="copyMap"/>
+      <div id="objDataEditor">
+
+      </div>
+      <div id="eventEditor">
+
       </div>
       
     </div>
@@ -315,11 +334,14 @@
       <div class="tools">
         <div id="tip" v-cloak >
           <div v-if="isSelectedBlock" >
-            <p v-if="hasId">图块编号：<span class="infoText">{{ infos['idnum'] }}</span></p>
-            <p v-if="hasId">图块ID：<span class="infoText">{{ infos['id'] }}</span></p>
-            <p v-else class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>
-            <p>图块所在素材：<span class="infoText">{{ infos['images'] }}</span></p>
-            <p>图块索引：<span class="infoText">{{ infos['y'] }}</span></p>
+            <p v-if="isClearBlock" class="infoText">当前选择为清除块，可擦除地图上块</p>
+            <div v-else>
+              <p v-if="hasId">图块编号：<span class="infoText">{{ infos['idnum'] }}</span></p>
+              <p v-if="hasId">图块ID：<span class="infoText">{{ infos['id'] }}</span></p>
+              <p v-else class="warnText">该图块无对应的数字或ID存在，请先前往icons.js和maps.js中进行定义！</p>
+              <p>图块所在素材：<span class="infoText">{{ infos['images'] + (isAutotile ? '( '+infos['id']+' )' : '') }}</span></p>
+              <p>图块索引：<span class="infoText">{{ infos['y'] }}</span></p>
+            </div>
           </div>
           <div v-else>
               <p v-if="whichShow" v-bind:class="[ (whichShow%2) ? 'warnText' : 'successText']">{{ mapMsg }}</p>
@@ -327,13 +349,14 @@
         </div>
         <input class='btn' id='clear' type="button" value="清除地图" v-on:click="clearMap"/>
         <input class='btn' type="button" value="导出地图" id="exportM" v-on:click="exportMap"/>
-        
-        <div class="files">
-          <input class='btn' type="button" value="read" onclick="readUTF8file(pin.value)" />
-          <input class='btn' type="button" value="write" onclick="writeUTF8file(pin.value,pout.innerText)" />
-          
-          <input class='input' id='pin' placeholder="请输入文件名"/>
-          <div id="printOut"></div>
+        <div id="bgSelect" v-cloak>
+          <select v-model="selectedBg">
+            <option disabled value="">请选择地板</option>
+            <option v-for="bg in bgs" v-bind:value="bg">
+              {{ bg }}
+            </option>
+          </select>
+          <span>当前地板: {{ selectedBg }}</span>
         </div>
       </div>
     </div>
@@ -346,8 +369,6 @@
       </div>
     </div>
   </div>
-
-
 <script>
 // 生成定位编号
 (function(){
@@ -371,9 +392,10 @@
 <!-- =========================================================== -->
 
 <script src='_server/vendor/vue.min.js'></script>
-<!-- <script src="https://unpkg.com/vue"></script> -->
+<!-- <script src="https://cdn.bootcss.com/vue/2.5.13/vue.js"></script> -->
 <script src='_server/fs.js'></script>
 <script src='_server/editor_file.js'></script>
+<script src='_server/vm.js'></script>
 <script>
 printf = function(str,weak) {
   var prefix='<span class="result">',postfix='</span>';
@@ -386,80 +408,136 @@ __all__=['Vue','fs','printf','editor','main','core','fullX','fullY'];
 __id__=['printOut','arrRowMark','mapRowMark','data','bg','dataSelection'];
 __Vue__=['exportM','editArea','editTip','clear','tip','selectBox'];
 
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwnProp (obj, key) {
+  return hasOwnProperty.call(obj, key)
+}
+
 var main={'instance':{}};
 var core={};
 
 function editor() {
-  this.version = "0.1";
+  this.version = "1.2";
+  this.material = {};
 }
-editor.prototype.init = function() {
-  var loadedNum=0;
-  var tmp_callback = function () {
-    loadedNum++;
-    if (loadedNum==2)
-      editor.drawInitData(function(){
-        editor.listen();
-      });
-  }
+// 重构这一堆回调
+editor.prototype.init = function(){
+  var mapsdatajsUrl = 'libs/project/maps.js';
+  var iconsdatajsUrl = 'libs/project/icons.js';
+  var mapsjsUrl = 'libs/maps.js';
+  var iconsjsUrl = 'libs/icons.js';
 
-  editor.loadMod(function(){
-    editor.afterLoadMod(function(){
-      tmp_callback();
-    });
+  var p1_data = editor.loadjs(mapsdatajsUrl).then(function(){ // 加载maps.js的数据
+    return 'complete'; 
+  }); 
+  var p2_data = editor.loadjs(iconsdatajsUrl).then(function(){ // 加载icons.js的数据
+    return 'complete'; 
   });
 
-  editor.loadImage(function(){
-    editor.importGrass(function(){
-      editor.afterImportGrass(function(){
-        tmp_callback();
-      });
+  Promise.all([p1_data, p2_data]).then(function([p1_data, p2_data]){
+    
+    var p1 = editor.loadjs(mapsjsUrl).then(function(){ // 加载maps.js
+      var maps_ = new maps(); //实例化maps
+      maps.init();
+      return maps
+    }); 
+    var p2 = editor.loadjs(iconsjsUrl)  // 加载icons.js
+    .then(function(){  // 实例化并获取icons
+      var ic = new icons();
+      ic.init();
+      return ic.getIcons();
+    });
+    var p3 = p2.then(function(icons){ // 加载所有图片
+      return editor.loadAllImgs(icons);
+    })
+    .catch(function(err){
+      console.log('发生错误！', err);
     });
-  });
 
+    Promise.all([p1, p2, p3])
+    .then(function([maps, icons, img]){
+      editor.idsInit(maps, icons); // 初始化图片素材信息
+      editor.drawInitData(icons); // 初始化绘图
+      editor.listen(); // 开始监听事件
+    })
+
+  });
 }
 
-editor.prototype.loadMod = function (callback) {
-  main={'instance':{}};
-  var loadedNum=0;
-  ['libs/project/icons.js','libs/project/maps.js','libs/icons.js','libs/maps.js'].forEach( function (value,ii,aa) {
+editor.prototype.loadjs = function(url){
+  return new Promise(function(resolve, reject){
     var script = document.createElement('script');
-    script.src = value + '?' + editor.version;
+    script.src = url + '?' + editor.version;
     document.body.appendChild(script);
     script.onload = function () {
-      loadedNum++;
-      if (loadedNum==aa.length)
-        callback();
+      resolve( console.log(url+"加载完成"));
+    }
+    script.onerror = function(){
+      reject(new Error('Load js error at '+url))
+    }
+  });
+}
+editor.prototype.loadImg = function(url){
+  return new Promise(function(resolve, reject){
+    var img = new Image();
+    img.src = url;
+    img.onload = function(){
+      resolve(img);
+    }
+    img.onerror = function(){
+      reject(new Error('Load image error at '+url));
     }
   })
-}//main       加载['libs/icons.js','libs/maps.js']
+}
 
-editor.prototype.afterLoadMod = function (callback) {
-  
-  main.instance.icons.init();
-  main.instance.maps.init();
-  var icons=main.instance.icons.getIcons();
+editor.prototype.loadAllImgs = function(icons){
+  editor.material.images = {};
+  var imgs = Object.keys(icons);
+  var autotiles = null;
+  if(hasOwnProp(icons, 'hero')){ // hero 图片不加载
+    var index = imgs.indexOf('hero');
+    imgs.splice(index, 1);
+  }
+  if(hasOwnProp(icons, 'autotile')){
+    editor.material.images['autotile'] = {};
+    var index = imgs.indexOf('autotile');
+    imgs.splice(index, 1);
+    autotiles = Object.keys(icons.autotile);
+    imgs = imgs.concat(autotiles);
+  }
+  var p = imgs.map(function(im){
+    var url = 'images/'+im+'.png'
+    return editor.loadImg(url).then(function(image){
+      if(autotiles.indexOf(im) >= 0){
+        editor.material.images['autotile'][im] = image;
+      }else editor.material.images[im] = image;
+    }).catch(function(err){
+      console.log('发生错误！', err);
+    });
+  });
 
+  return Promise.all(p);
+}
+editor.prototype.idsInit = function(maps, icons){
   editor.ids = [];
   editor.indexs = [];
-  editor.ids.push({'idnum':0,'id':'ground','images':'terrains','y':0});
-
-  var point = 0
-  for(var i=0; i<400; i++){
-    var indexBlock = main.instance.maps.getBlock(0,0,i);
+  var MAX_NUM = 400;
+  var getInfoById = function(id){
+    var block = maps.getBlock(0, 0, id);
+    if(hasOwnProp(block, 'event')){
+      return block;
+    }
+  }
+  var point = 0;
+  for(var i=0; i<MAX_NUM; i++){
+    var indexBlock = getInfoById(i);
     editor.indexs[i] = [];
-    if('event' in indexBlock){
+    if(indexBlock){
       var id = indexBlock.event.id;
       var indexId = indexBlock.id;
-      if(id=='autotile'){
-        editor.ids.push({'idnum':indexId,'id':'autotile','images':'autotile','y':0});
-        point++;
-        editor.indexs[i].push(point);
-        continue;
-      }
       var allCls = Object.keys(icons);
       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);
@@ -467,277 +545,210 @@ editor.prototype.afterLoadMod = function (callback) {
       }
     }
   }
-
-  callback();
-}//editor.ids,editor.indexs
-
-editor.prototype.loadImage = function (callback) {
-  core={};
-  core.material={};
-  core.material.images = {};
-  core.images=['terrains','animates', 'enemys', 'items', 'npcs', ];
-  var loadedImageNum=0;
-  core.loadImage = function (imgName, callback) {
-      try {
-          var image = new Image();
-          image.src = 'images/' + imgName + '.png';
-          if (image.complete) {
-              callback(imgName, image);
-              return;
-          }
-          image.onload = function () {
-              callback(imgName, image);
-          }
-      }
-      catch (e) {
-          alert(e);
-      }
-  }
-  for (var i = 0; i < core.images.length; i++) {
-    core.loadImage(core.images[i], function (imgName, image) {
-      imgName = imgName.split('-');
-      imgName = imgName[0];
-      core.material.images[imgName] = image;
-      loadedImageNum++;
-      if (loadedImageNum == core.images.length) {callback();}
-    });
-  }
-}//core       加载['terrains','animates', 'enemys', 'items', 'npcs']
-
-editor.prototype.importGrass = function (callback) {
-  var autotile = new Image();
-
-  autotile.src = "images/autotile.png";
-
-  if (autotile.complete) {
-    editor.autotile = autotile;
-    callback();
-    return;
-  }
-  autotile.onload = function () {
-    editor.autotile = autotile;
-    callback();
-  };
-
-}//           加载 'autotile'
-
-editor.prototype.afterImportGrass = function (callback) {
-  var drawAutotile = function (canvas, x, y, size, autotile, index) {
-    switch (index) {
-      case 0:
-        canvas.drawImage(autotile, 0, 0, 32, 32, x, y, size, size);
-        break;
-      case 1:
-        canvas.drawImage(autotile, 0, 3 * 32, 16, 32, x, y, size / 2, size);
-        canvas.drawImage(autotile, 2 * 32 + 16, 3 * 32, 16, 32, x + size / 2, y, size / 2, size);
-        break;
-      case 2:
-        canvas.drawImage(autotile, 2 * 32, 32, 32, 16, x, y, size, size / 2);
-        canvas.drawImage(autotile, 2 * 32, 3 * 32 + 16, 32, 16, x, y + size / 2, size, size / 2);
-        break;
-      case 3:
-        canvas.drawImage(autotile, 2 * 32, 3 * 32, 32, 32, x, y, size, size);
-        break;
-      case 4:
-        canvas.drawImage(autotile, 0, 1 * 32, 16, 32, x, y, size / 2, size);
-        canvas.drawImage(autotile, 2 * 32 + 16, 1 * 32, 16, 32, x + size / 2, y, size / 2, size);
-        break;
-      case 5:
-        canvas.drawImage(autotile, 0, 2 * 32, 16, 32, x, y, size / 2, size);
-        canvas.drawImage(autotile, 2 * 32 + 16, 2 * 32, 16, 32, x + size / 2, y, size / 2, size);
-        break;
-      case 6:
-        canvas.drawImage(autotile, 2 * 32, 1 * 32, 32, 32, x, y, size, size);
-        break;
-      case 7:
-        canvas.drawImage(autotile, 2 * 32, 2 * 32, 32, 32, x, y, size, size);
-        break;
-      case 8:
-        canvas.drawImage(autotile, 0, 32, 32, 16, x, y, size, size / 2);
-        canvas.drawImage(autotile, 0, 3 * 32 + 16, 32, 16, x, y + size / 2, size, size / 2);
-        break;
-      case 9:
-        canvas.drawImage(autotile, 0, 3 * 32, 32, 32, x, y, size, size);
-        break;
-      case 10:
-        canvas.drawImage(autotile, 32, 32, 32, 16, x, y, size, size / 2);
-        canvas.drawImage(autotile, 32, 3 * 32 + 16, 32, 16, x, y + size / 2, size, size / 2);
-        break;
-      case 11:
-        canvas.drawImage(autotile, 32, 3 * 32, 32, 32, x, y, size, size);
-        break;
-      case 12:
-        canvas.drawImage(autotile, 0, 32, 32, 32, x, y, size, size);
-        break;
-      case 13:
-        canvas.drawImage(autotile, 0, 2 * 32, 32, 32, x, y, size, size);
-        break;
-      case 14:
-        canvas.drawImage(autotile, 32, 32, 32, 32, x, y, size, size);
-        break;
-      case 15:
-        canvas.drawImage(autotile, 32, 2 * 32, 32, 32, x, y, size, size);
-        break;
-      case 16:
-        canvas.clearRect(x, y, size / 2, size / 2);
-        canvas.drawImage(autotile, 2 * 32, 0, 16, 16, x, y, size / 2, size / 2);
-        break;
-      case 17:
-        canvas.clearRect(x, y, size / 2, size / 2);
-        canvas.drawImage(autotile, 2 * 32 + 16, 0, 16, 16, x, y, size / 2, size / 2);
-        break;
-      case 18:
-        canvas.clearRect(x, y, size / 2, size / 2);
-        canvas.drawImage(autotile, 2 * 32 + 16, 16, 16, 16, x, y, size / 2, size / 2);
-        break;
-      case 19:
-        canvas.clearRect(x, y, size / 2, size / 2);
-        canvas.drawImage(autotile, 2 * 32, 16, 16, 16, x, y, size / 2, size / 2);
-        break;
-    }
-  }
-
-  //根据状态画图
-  var cxt = eventLayer.getContext("2d");
-
-  var grass = function (ii, x, y) {
-    cxt.clearRect(x * 32, y * 32, 32, 32);
-    // cxt.putImageData(grassImageData[ii], x * 32, y * 32);
-    drawAutotile(cxt, x * 32, y * 32, 32, editor.autotile, ii);
-  }
-
-  var isGrass = function (xx, yy) { 
-    var mapxy=editor.map[editor.m(xx,yy)];
-    if (typeof(mapxy) == typeof(-1) || typeof(mapxy) == typeof([][0]))return 0;
-    if (mapxy.images=='autotile')return 1;
-    return 0;
-  }
-
-  fullX = 12;
-  fullY = 12;
-
-  editor.map = [];//-2表示边界,0表示空地,其他对象对应实体
-  editor.map[fullX + 1 + fullY * (fullX + 1)] = -2;
-  for(var ii=0;ii<fullX + 1 + fullY * (fullX + 1);ii++)editor.map[ii]=0;
-
-  editor.m = function (x, y) {
-    if (x < 0 || x > fullX || y < 0 || y > fullY) return fullX + 1 + fullY * (fullX + 1);
-    return x + y * (fullX + 1);
-  }
-
-  editor.updateMap = function (error) {
-    //clearGrass();
-    // console.log(editor.map)
-    for (var xx = 0; xx <= fullX; xx++) {
-      for (var yy = 0; yy <= fullY; yy++) {
-        if (!isGrass(xx, yy)) continue;
-        var _id = 0;
-        _id += isGrass(xx, yy - 1) + 2 * isGrass(xx - 1, yy) + 4 * isGrass(xx, yy + 1) + 8 * isGrass(xx + 1, yy);
-        //1上2左4下8右
-        grass(_id, xx, yy);
-      }
-    }
-    for (var xx = 0; xx < fullX; xx++) {
-      for (var yy = 0; yy < fullY; yy++) {
-        if (isGrass(xx, yy) + isGrass(xx + 1, yy) + isGrass(xx + 1, yy + 1) + isGrass(xx, yy + 1) != 3) continue;
-        var autotile = editor.autotile;
-        if (!isGrass(xx, yy)) {
-          // cxt.clearRect(xx * 32 + 32, yy * 32 + 32, 16, 16);
-          // cxt.putImageData(grassImageData[16], xx * 32 + 32, yy * 32 + 32);
-          drawAutotile(cxt, xx * 32 + 32, yy * 32 + 32, 32, autotile, 16);
-        }
-        if (!isGrass(xx + 1, yy)) {
-          // cxt.clearRect(xx * 32 + 16, yy * 32 + 32, 16, 16);
-          //cxt.putImageData(grassImageData[17], xx * 32 + 16, yy * 32 + 32);
-          drawAutotile(cxt, xx * 32 + 16, yy * 32 + 32, 32, autotile, 17);
-        }
-        if (!isGrass(xx + 1, yy + 1)) {
-          // cxt.clearRect(xx * 32 + 16, yy * 32 + 16, 16, 16);
-          // cxt.putImageData(grassImageData[18], xx * 32 + 16, yy * 32 + 16);
-          drawAutotile(cxt, xx * 32 + 16, yy * 32 + 16, 32, autotile, 18);
-        }
-        if (!isGrass(xx, yy + 1)) {
-          // cxt.clearRect(xx * 32 + 32, yy * 32 + 16, 16, 16);
-          // cxt.putImageData(grassImageData[19], xx * 32 + 32, yy * 32 + 16);
-          drawAutotile(cxt, xx * 32 + 32, yy * 32 + 16, 32, autotile, 19);
-        }
-      }
-    }
-    for (var xx = 0; xx <= fullX; xx++) {
-      for (var yy = 0; yy <= fullY; yy++) {
-        if (isGrass(xx, yy)) continue;
-        var mapxy=editor.map[editor.m(xx,yy)];
-        if (typeof(mapxy) == typeof(-1)){
-          if(mapxy == 0) cxt.clearRect(xx*32, yy*32, 32, 32);
-          continue;
-        }
-        
-        //context.drawImage(img,sx,sy,swidth,sheight,x,y,width,height)
-        cxt.clearRect(xx*32, yy*32, 32, 32);
-        cxt.drawImage(core.material.images[mapxy.images], 0, mapxy.y*32, 32, 32, xx*32, yy*32, 32, 32);
-
-        if(typeof(mapxy) != typeof({}) || !('idnum' in mapxy) ) {//未定义块画红块
-          if (error=='clearError'){
-            editor.map[editor.m(xx,yy)]=0;
-            cxt.clearRect(xx*32, yy*32, 32, 32);
-            continue;
-          }
-          if (error=='showError'){
-            cxt.fillStyle = 'rgba(255,0,0,0.8)';
-            var tmpNum =6;
-            cxt.fillRect(xx*32+tmpNum, yy*32+tmpNum, 32-tmpNum*2, 32-tmpNum*2);
-          }
-        } 
-      }
-    }
-  }
-
-  callback();
-}//fullX,fullY,editor.map,editor.m,editor.updateMap
-
-editor.prototype.drawInitData = function (callback) {
+}
+editor.prototype.drawInitData = function (icons) {
   var ratio=1;
-  var images=core.material.images;
+  var images=editor.material.images;
   var maxHeight=700;
   var sumWidth=0;
   editor.widthsX={};
-  for(var ii=0;ii<core.images.length;ii++){
-    var img=core.images[ii];
-    editor.widthsX[img]=[img,sumWidth/32,(sumWidth+images[img].width)/32];
-    sumWidth+=images[img].width;
-    maxHeight=Math.max(maxHeight,images[img].height);
-  }
-  editor.widthsX['autotile']=['autotile',sumWidth/32,(sumWidth+3*32)/32];
-  sumWidth+=3*32;
+  // var imgNames = Object.keys(images);  //还是固定顺序吧；
+  var imgNames = ["terrains", "animates", "enemys", "items", "npcs", "autotile"];
   
+  for(var ii=0; ii<imgNames.length; ii++){
+    var img=imgNames[ii], tempy = 0;
+    if(img == 'autotile'){
+      var autotiles = images[img];
+      for(var im in autotiles){
+        tempy += autotiles[im].height;
+      }
+      editor.widthsX[img]=[img, sumWidth/32, (sumWidth+3*32)/32, tempy];
+      sumWidth += 3*32;
+      maxHeight = Math.max(maxHeight, tempy);
+      continue;
+    }
+    if(img == 'terrains'){
+      editor.widthsX[img]=[img, sumWidth/32, (sumWidth+images[img].width)/32, images[img].height+32]
+      sumWidth += images[img].width;
+      maxHeight = Math.max(maxHeight, images[img].height+32);
+      continue;
+    }
+    editor.widthsX[img]=[img, sumWidth/32, (sumWidth+images[img].width)/32, images[img].height];
+    sumWidth += images[img].width;
+    maxHeight = Math.max(maxHeight, images[img].height);
+  }
   var fullWidth=~~(sumWidth*ratio);
   var fullHeight=~~(maxHeight*ratio);
 
   if (fullWidth > data.width) data.style.width = (data.width = fullWidth)/ratio + 'px';
   data.style.height = (data.height = fullHeight)/ratio + 'px';
-
   var dc = data.getContext('2d');
+  var nowx = 0;
+  var nowy = 0;
+  for(var ii=0; ii<imgNames.length; ii++){
+    var img=imgNames[ii];
+    if(img == 'terrains'){
+      dc.drawImage(images[img], nowx, 32);
+      nowx += images[img].width;
+      continue;
+    }
+    if(img == 'autotile'){
+      var autotiles = images[img];
+      for(var im in autotiles){
+        dc.drawImage(autotiles[im], nowx, nowy);
+        nowy += autotiles[im].height;
+      }
+      continue;
+    }
+    dc.drawImage(images[img], nowx, 0)
+    nowx += images[img].width;
+  }
+  bgSelect.bgs = Object.keys(icons.terrains);
+  editor.drawMapBg();
+  editor.mapInit();
+}
+editor.prototype.mapInit = function(){
+  var ec = eventLayer.getContext('2d');
+  ec.clearRect(0, 0, 416, 416);
+  editor.map = [];
+  for(var y=0; y<13; y++){
+    editor.map[y] = [];
+    for(var x = 0; x<13; x++){
+      editor.map[y][x] = 0;
+    }
+  }
+}
+editor.prototype.drawMapBg = function(){
   var bgc = bg.getContext('2d');
-  //var colorA = ["#f8f8f8", "#cccccc"];
-  //var colorIndex = 1;
-  //在data内画一个13*13的灰白相间的格子
+
   for (var ii = 0; ii < 13; ii++)
     for (var jj = 0; jj < 13; jj++) {
-      //dc.fillStyle = colorA[colorIndex];
-      //colorIndex = 1 - colorIndex;
-      //dc.fillRect(ii * 32, jj * 32, 32, 32);
-      bgc.drawImage(core.material.images['terrains'], 0, 0, 32, 32, ii*32, jj*32, 32, 32);
+      bgc.clearRect(ii*32, jj*32, 32, 32);
+      bgc.drawImage(editor.material.images['terrains'], 0, 32*(editor.bgY||0), 32, 32, ii*32, jj*32, 32, 32);
     }
-  var nowx=0;
-  for(var ii=0;ii<core.images.length;ii++){
-    var img=core.images[ii];
-    dc.drawImage(images[img], nowx, 0)
-    nowx+=images[img].width;
-  }
-  dc.drawImage(editor.autotile, nowx, 0)
+}
 
-  callback();
-}//editor.widthsX
+editor.prototype.updateMap = function(){
+
+  var drawTile = function(ctx, x, y, tileInfo){ // 绘制一个普通块
+
+    ctx.clearRect(x*32, y*32, 32, 32);
+    if(tileInfo == 0) return;
+
+    if(typeof(tileInfo) == typeof([][0]) || !hasOwnProp(tileInfo, 'idnum')) {//未定义块画红块
+      if(typeof(tileInfo) != typeof([][0]) && hasOwnProp(tileInfo, 'images')){
+        ctx.drawImage(editor.material.images[tileInfo.images], 0, tileInfo.y*32, 32, 32, x*32, y*32, 32, 32);
+      }
+      ctx.strokeStyle = 'red';
+      var OFFSET = 2;
+      ctx.lineWidth = OFFSET;
+      ctx.strokeRect(x*32+OFFSET, y*32+OFFSET, 32-OFFSET*2, 32-OFFSET*2);
+      ctx.font = "30px Verdana";
+      ctx.textAlign = 'center'
+      ctx.fillStyle = 'red';
+      ctx.fillText("?", x*32+16, y*32+27);
+      return;
+    } 
+    ctx.drawImage(editor.material.images[tileInfo.images], 0, tileInfo.y*32, 32, 32, x*32, y*32, 32, 32); 
+  }
+
+  // autotile的相关处理
+  var indexArrs = [ //16种组合的图块索引数组; // 将autotile分割成48块16*16的小块; 数组索引即对应各个小块
+  //                                       +----+----+----+----+----+----+
+    [10,  9,  4, 3 ],  //0   bin:0000      | 1  | 2  | 3  | 4  | 5  | 6  |
+    [10,  9,  4, 13],  //1   bin:0001      +----+----+----+----+----+----+
+    [10,  9, 18, 3 ],  //2   bin:0010      | 7  | 8  | 9  | 10 | 11 | 12 |
+    [10,  9, 16, 15],  //3   bin:0011      +----+----+----+----+----+----+
+    [10, 43,  4, 3 ],  //4   bin:0100      | 13 | 14 | 15 | 16 | 17 | 18 |
+    [10, 31,  4, 25],  //5   bin:0101      +----+----+----+----+----+----+
+    [10,  7,  2, 3 ],  //6   bin:0110      | 19 | 20 | 21 | 22 | 23 | 24 |
+    [10, 31, 16, 5 ],  //7   bin:0111      +----+----+----+----+----+----+
+    [48,  9,  4, 3 ],  //8   bin:1000      | 25 | 26 | 27 | 28 | 29 | 30 |
+    [ 8,  9,  4, 1 ],  //9   bin:1001      +----+----+----+----+----+----+
+    [36,  9, 30, 3 ],  //10  bin:1010      | 31 | 32 | 33 | 34 | 35 | 36 |
+    [36,  9,  6, 15],  //11  bin:1011      +----+----+----+----+----+----+
+    [46, 45,  4, 3 ],  //12  bin:1100      | 37 | 38 | 39 | 40 | 41 | 42 |
+    [46, 11,  4, 25],  //13  bin:1101      +----+----+----+----+----+----+
+    [12, 45, 30, 3 ],  //14  bin:1110      | 43 | 44 | 45 | 46 | 47 | 48 |
+    [34, 33, 28, 27]   //15  bin:1111      +----+----+----+----+----+----+
+  ];
+  var drawBlockByIndex = function(ctx, dx, dy, autotileImg, index){ //index为autotile的图块索引1-48
+    var sx = 16*((index-1)%6), sy = 16*(~~((index-1)/6));
+    ctx.drawImage(autotileImg, sx, sy, 16, 16, dx, dy, 16, 16);
+  }
+  var isAutotile = function(info){
+    if(typeof(info)=='object' && hasOwnProp(info, 'images') && info.images=='autotile') return true;
+    return false;
+  }
+  var getAutotileAroundId = function(currId, x, y){ //与autotile当前idnum一致返回1，否则返回0
+    if(x>=0 && y >=0 && x<13 && y<13 && isAutotile(editor.map[y][x]) && editor.map[y][x].idnum == currId)
+      return 1;
+    else if(x<0 || y<0 || x>12 || y>12) return 1; //边界外视为通用autotile，这样好看些
+    else
+      return 0;
+  }
+  var checkAround = function(x, y){ // 得到周围四个32*32块（周围每块都包含当前块的1/4，不清楚的话画下图你就明白）的数组索引
+    var currId = editor.map[y][x].idnum;
+    var pointBlock = [];
+    for(var i=0; i<4; i++){
+      var bsum = 0;
+      var offsetx = i%2, offsety = ~~(i/2);
+      for(var j=0; j<4; j++){
+        var mx = j%2, my = ~~(j/2);
+        var b = getAutotileAroundId(currId, x+offsetx+mx-1, y+offsety+my-1);
+        bsum += b*(Math.pow(2, 3-j));
+      }
+      pointBlock.push(bsum);
+    }
+    return pointBlock;
+  }
+  var addIndexToAutotileInfo = function(x, y){
+    var indexArr = [];
+    var pointBlocks = checkAround(x, y);
+    for(var i=0; i<4; i++){
+      var arr = indexArrs[pointBlocks[i]]
+      indexArr.push(arr[3-i]);
+    }
+    editor.map[y][x].blockIndex = indexArr;
+  }
+  var drawAutotile = function(ctx, x, y, info){ // 绘制一个autotile
+    ctx.clearRect(x*32, y*32, 32, 32);
+    //修正四个边角的固定搭配
+    if(info.blockIndex[0] == 13){
+      if(info.blockIndex[1] == 16) info.blockIndex[1] = 14;
+      if(info.blockIndex[2] == 31) info.blockIndex[2] = 19;
+    }
+    if(info.blockIndex[1] == 18){
+      if(info.blockIndex[0] == 15) info.blockIndex[0] = 17;
+      if(info.blockIndex[3] == 36) info.blockIndex[3] = 24;
+    }
+    if(info.blockIndex[2] == 43){
+      if(info.blockIndex[0] == 25) info.blockIndex[0] = 37;
+      if(info.blockIndex[3] == 46) info.blockIndex[3] = 44;
+    }
+    if(info.blockIndex[3] == 48){
+      if(info.blockIndex[1] == 30) info.blockIndex[1] = 42;
+      if(info.blockIndex[2] == 45) info.blockIndex[2] = 47;
+    }
+    for(var i=0; i<4; i++){
+      var index = info.blockIndex[i];
+      var dx = x*32 + 16*(i%2), dy = y*32 + 16*(~~(i/2));
+      drawBlockByIndex(ctx, dx, dy, editor.material.images[info.images][info.id], index);
+    }
+  }
+
+  // 绘制地图 start
+  var eventCtx = eventLayer.getContext("2d");
+  for(var y=0; y<13; y++)
+    for(var x=0; x<13; x++){
+      var tileInfo = editor.map[y][x];
+      if(isAutotile(tileInfo)){
+        addIndexToAutotileInfo(x, y);
+        drawAutotile(eventCtx, x, y, tileInfo);
+      }else drawTile(eventCtx, x, y, tileInfo);
+    }
+  // 绘制地图 end
+}
 
 editor.prototype.listen = function() {
 
@@ -838,8 +849,7 @@ editor.prototype.listen = function() {
       reDo = null;
       // console.log(stepPostfix);
       for (var ii = 0; ii < stepPostfix.length; ii++)
-        editor.map[editor.m(stepPostfix[ii].x, stepPostfix[ii].y)] = editor.info;
-      editor.map[fullX + 1 + fullY * (fullX + 1)] = -2;
+        editor.map[stepPostfix[ii].y][stepPostfix[ii].x] = editor.info;
       // console.log(editor.map);
       editor.updateMap();
       holdingPath = 0;
@@ -870,55 +880,76 @@ editor.prototype.listen = function() {
     if(e.keyCode == 89 && e.ctrlKey && reDo && reDo.pos.length){
       preMapData = JSON.parse(JSON.stringify(editor.map));
       for(var j=0; j<reDo.pos.length;j++)
-        editor.map[editor.m(reDo.pos[j].x, reDo.pos[j].y)] = JSON.parse(JSON.stringify(reDo.info));
+        editor.map[reDo.pos[j].y][reDo.pos[j].x] = JSON.parse(JSON.stringify(reDo.info));
 
-      editor.map[fullX + 1 + fullY * (fullX + 1)] = -2;
       editor.updateMap();
       currDrawData = JSON.parse(JSON.stringify(reDo));
       reDo = null;
     }
   }
-  
-  // info=editor.ids[editor.indexs[20][0]];//autotile
+
   data.onmousedown = function (e) {
     e.stopPropagation();
     var loc = { 
-      'x': document.documentElement.scrollLeft + e.clientX + (iconLib.scrollLeft||0) - right.offsetLeft-iconLib.offsetLeft, 
-      'y': document.documentElement.scrollTop + e.clientY + (iconLib.scrollTop||0) - right.offsetTop-iconLib.offsetTop, 
+      'x': document.documentElement.scrollLeft + e.clientX + iconLib.scrollLeft - right.offsetLeft-iconLib.offsetLeft, 
+      'y': document.documentElement.scrollTop + e.clientY + iconLib.scrollTop - right.offsetTop-iconLib.offsetTop, 
       'size': 32 
     };
-    editor.loc =loc;
+    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]){
-          pos.x=editor.widthsX[spriter][1];
-          pos.images=editor.widthsX[spriter][0];
+        pos.x=editor.widthsX[spriter][1];
+        pos.images = editor.widthsX[spriter][0];
+        var autotiles = editor.material.images['autotile'];
         if(pos.images=='autotile'){
-          pos.y=0;
-        }else if((pos.y+1)*32>core.material.images[pos.images].height)
-          pos.y=~~(core.material.images[pos.images].height/32)-1;
+          var imNames = Object.keys(autotiles);
+          if((pos.y+1)*32 > editor.widthsX[spriter][3])
+            pos.y = ~~(editor.widthsX[spriter][3]/32)-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)*32 > editor.widthsX[spriter][3])
+          pos.y = ~~(editor.widthsX[spriter][3]/32)-1;
         
         selectBox.isSelected = true;
-        // console.log(pos,core.material.images[pos.images].height)
+        // console.log(pos,editor.material.images[pos.images].height)
         dataSelection.style.left = pos.x*32 +'px';
         dataSelection.style.top = pos.y*32 +'px';
-        editor.info={'images':pos.images,'y':pos.y};
-        for (var ii=0;ii<editor.ids.length;ii++){
-          if(pos.images==editor.ids[ii].images && pos.y==editor.ids[ii].y)
-            editor.info = editor.ids[ii];
+        
+        if(pos.x==0&&pos.y==0){
+          // editor.info={idnum:0, id:'empty','images':'清除块', 'y':0};
+          editor.info=0;
+        }else{
+          if(hasOwnProp(autotiles, pos.images)) editor.info={'images':pos.images, 'y':0};
+          else if(pos.images == 'terrains') editor.info={'images':pos.images, 'y':pos.y-1};
+          else editor.info={'images':pos.images, 'y':pos.y};
+
+          for (var ii=0;ii<editor.ids.length;ii++){
+            if( ( editor.info.images==editor.ids[ii].images 
+                && editor.info.y==editor.ids[ii].y )
+                || (hasOwnProp(autotiles, pos.images) && editor.info.images==editor.ids[ii].id 
+                && editor.info.y==editor.ids[ii].y)){
+
+              editor.info = editor.ids[ii];
+              break;
+            }
+          }
         }
         tip.infos = JSON.parse(JSON.stringify(editor.info));
       }
     }
   }
 
-
 }//绑定事件
 
 /* 
 editor.updateMap
-现在可以通过editor.updateMap('clearError')把所有错误id置零并绘图
-以及editor.updateMap('showError')显示所有错误
 
 editor.loc
 editor.pos
@@ -932,260 +963,14 @@ editor.main=main;
 editor.core=core;
 editor.fs=fs;
 editor.file=editor_file;
+
 </script>
 <script type="text/javascript">
-//Vue
-//var listenByVue = function() {
-  document.body.onmousedown = function(e){
-    selectBox.isSelected = false;
-    editor.info = {};
-  }
-  iconLib.onmousedown = function(e){
-    e.stopPropagation();
-  }
-  var exportM = new Vue({
-    el: '#exportM',
-
-    methods: {
-      exportMap: function(){
-        setTimeout(function(){editor.updateMap();},5000);
-        if(editArea.error) {
-          tip.whichShow = 3;
-          editor.updateMap('showError');
-          return;
-        }
-        var filestr='';
-        for (var yy = 0; yy < 13; yy++){
-          filestr+='['
-          for (var xx = 0; xx < 13; xx++) {
-            var mapxy=editor.map[editor.m(xx,yy)];
-            if(typeof(mapxy)==typeof({})){
-              if ('idnum' in mapxy)mapxy=mapxy.idnum;
-              else {
-                // mapxy='!!?';
-                tip.whichShow = 3;
-                editor.updateMap('showError');
-                return;
-              }
-            }else if(typeof(mapxy)=='undefined'){
-              tip.whichShow = 3;
-              editor.updateMap('showError');
-              return;
-            }
-            mapxy=String(mapxy);
-            mapxy=Array(Math.max(4-mapxy.length,0)).join(' ')+mapxy;
-            filestr+=mapxy+(xx==12?'':',')
-          }
-          
-          filestr += ']'+(yy==12?'':',\n');
-        }
-        pout.value = filestr;
-
-        tip.whichShow = 2;
-      }
-    }
-  })
-  var editArea = new Vue({
-    el: '#editArea',
-    data: {
-      mapArr: '',
-      errors: [ // 编号1,2,3,4
-        "格式错误！请使用正确格式(13*13数组，如不清楚，可先点击生成地图查看正确格式)",
-        "当前有未定义ID（在地图区域显示红块），请修改ID或者到icons.js和maps.js中进行定义！",
-        "ID越界（在地图区域显示红块），当前编辑器暂时支持编号小于400，请修改编号！",
-        // "发生错误！",
-      ],
-      error: 0,
-      formatTimer: null,
-    },
-    watch: {
-      mapArr: function (val, oldval) {
-        var that = this;
-        if(val=='') return;
-        if(that.formatArr()){
-          that.error = 0;
-          clearTimeout(that.formatTimer);
-          setTimeout(function(){
-            that.drawMap();
-            tip.whichShow = 8
-          }, 1000);
-          that.formatTimer = setTimeout(function(){
-            pout.value = that.formatArr();
-          }, 5000); //5s后再格式化，不然光标跳到最后很烦
-        }else{
-          that.error = 1;
-        }
-      },
-      error: function(){
-        console.log(editArea.mapArr);
-      }
-    },
-    methods: {
-      drawMap: function(){
-        var that = this;
-
-        var mapArray = that.mapArr.split(/\D+/).join(' ').trim().split(' ')
-        for(var i=0; i<mapArray.length; i++){
-          var num = parseInt(mapArray[i]);
-          if(num == 0 ) 
-            editor.map[i] = 0;
-          else if(num >= 400){
-            that.error = 3;
-            editor.map[i] = undefined;
-          }else if(editor.indexs[num][0] == undefined){
-            that.error = 2;
-            editor.map[i] = undefined;
-          }else editor.map[i] = editor.ids[[editor.indexs[num][0]]];
-        }
-
-        editor.updateMap();
-        
-      },
-      formatArr: function(){
-        var formatArrStr = '';
-
-        if(this.mapArr.split(/\D+/).join(' ').trim().split(' ').length != 169) return false;
-        var arr = this.mapArr.replace(/\s+/g, '').split('],[');
-        
-        if(arr.length != 13) return ;
-        for(var i =0; i<13; i++){
-          var a = [];
-          formatArrStr +='[';
-          if(i==0||i==12) a = arr[i].split(/\D+/).join(' ').trim().split(' ');
-          else a = arr[i].split(/\D+/);
-          if(a.length != 13){
-            formatArrStr = '';
-            return ;
-          } 
-
-          for(var k=0; k<13; k++){
-            var num = parseInt(a[k]);
-            formatArrStr += Array(Math.max(4-String(num).length,0)).join(' ')+num+(k==12?'':',');
-          }
-          formatArrStr += ']'+(i==12?'':',\n');
-        }
-        
-        return formatArrStr;
-      }
-    }
-  });
-  var editTip = new Vue({
-    el: '#editTip',
-    data: {
-      err: ''
-    },
-    methods: {
-      copyMap: function(){
-
-        tip.whichShow = 0;
-        if(pout.value.trim() != ''){
-          if(editArea.error) {
-            this.err = editArea.errors[editArea.error-1];
-            tip.whichShow = 5
-            return;
-          }
-          try{
-            pout.select();
-            document.execCommand("Copy");
-            tip.whichShow = 6;
-          }catch(e){
-            this.err= e;
-            tip.whichShow = 5;
-          }
-        }else{
-          tip.whichShow = 7;
-        }
-      }
-    },
-  })
-  var clear = new Vue({
-    el: '#clear',
-
-    methods: {
-      clearMap: function(){
-        editor.map[fullX + 1 + fullY * (fullX + 1)] = -2;
-        for(var ii=0;ii<fullX + 1 + fullY * (fullX + 1);ii++)editor.map[ii]=0;
-        ec = eventLayer.getContext('2d');
-        ec.clearRect(0, 0, 416, 416);
-        clearTimeout(editArea.formatTimer);
-        clearTimeout(tip.timer);
-        pout.value = '';
-        editArea.mapArr = '';
-        tip.whichShow = 4;
-        editArea.error = 0;
-      }
-    }
-  })
-  var tip = new Vue({
-    el: '#tip',
-    data: {
-      infos: {idnum: 20, id: "autotile", images: "autotile", y: 0},//editor.ids[editor.indexs[20][0]],
-      hasId: true,
-      isSelectedBlock: false,
-      geneMapSuccess: false,
-      timer: null,
-      msgs: [ //分别编号1,2,3,4,5,6,7,8；奇数警告，偶数成功
-        "当前未选择任何图块，请先在右边选择要画的图块!",
-        "生成地图成功！可点击复制按钮复制地图数组到剪切板",
-        "生成失败! 地图中有未定义的图块，建议先用其他有效图块覆盖或点击清除地图！",
-        "地图清除成功!",
-        "复制失败！",
-        "复制成功！可直接粘贴到楼层文件的地图数组中。",
-        "复制失败！当前还没有数据",
-        "修改成功！可点击复制按钮复制地图数组到剪切板"
-      ],
-      mapMsg: '',
-      whichShow: 0,
-    },
-    watch: {
-      infos: {
-        handler: function(val, oldval){
-          if(typeof(val) != 'undefined'){
-            this.infos = val;
-            if('id' in val){
-              this.hasId = true;
-            }else{
-              this.hasId = false;
-            }
-          }
-        },
-        deep: true
-      },
-
-      whichShow: function(){
-        var that = this;
-        that.mapMsg = '';
-        that.msgs[4] = "复制失败！"+editTip.err;
-        clearTimeout(that.timer);
-        if(that.whichShow){
-          that.mapMsg = that.msgs[that.whichShow-1];
-          that.timer = setTimeout(function() {
-            if(!(that.whichShow%2))
-              that.whichShow = 0;
-          }, 5000); //5秒后自动清除success，warn不清除
-        }
-      }
-    }
-  })
-
-  var selectBox = new Vue({
-    el: '#selectBox',
-    data: {
-      isSelected: false
-    },
-    watch: {
-      isSelected: function(){
-        tip.isSelectedBlock = this.isSelected;
-        tip.whichShow = 0;
-        clearTimeout(tip.timer);
-      }
-    }
-  })
+  //Vue
+  //var listenByVue = function() {
+  
 //}
 //listenByVue()
 </script>
-
-
-
 </body>
 </html>
diff --git a/index.html b/index.html
index fa25ac90..d59b0e43 100644
--- a/index.html
+++ b/index.html
@@ -114,5 +114,6 @@
 </div>
 <script id='mainScript' src='main.js'></script>
 <script>main.init();main.listen();</script>
+<script src='libs/thirdparty/mid.js'></script>
 </body>
 </html>
\ No newline at end of file
diff --git a/libs/core.js b/libs/core.js
index 8200765e..74ef79ec 100644
--- a/libs/core.js
+++ b/libs/core.js
@@ -7,12 +7,14 @@ function core() {
     this.statusBar = {};
     this.canvas = {};
     this.images = [];
-    this.sounds = {};
+    this.bgms = [];
+    this.sounds = [];
     this.floorIds = [];
     this.floors = {};
     this.firstData = {};
     this.material = {
         'images': {},
+        'bgms': {},
         'sounds': {},
         'ground': null,
         'items': {},
@@ -35,12 +37,12 @@ function core() {
         'openDoorAnimate': null
     }
     this.musicStatus = {
-        'isIOS': false,
-        'loaded': false,
-        'bgmStatus': false,
-        'soundStatus': true,
-        'playedSound': null,
-        'playedBgm': null,
+        'audioContext': null, // WebAudioContext
+        'startDirectly': false, // 是否直接播放（加载）音乐
+        'bgmStatus': false, // 是否播放BGM
+        'soundStatus': true, // 是否播放SE
+        'playingBgm': null, // 正在播放的BGM
+        'isPlaying': false,
     }
     // 样式
     this.domStyle = {
@@ -57,7 +59,7 @@ function core() {
         'floorId': null,
         'thisMap': null,
         'maps': null,
-        'checkBlock': [], // 显伤伤害
+        'checkBlock': {}, // 显伤伤害
 
         // 勇士状态；自动寻路相关
         'heroMoving': false,
@@ -102,11 +104,13 @@ function core() {
 
 /////////// 系统事件相关 ///////////
 
-core.prototype.init = function (dom, statusBar, canvas, images, sounds, floorIds, floors, coreData) {
+////// 初始化 //////
+core.prototype.init = function (dom, statusBar, canvas, images, bgms, sounds, floorIds, floors, coreData) {
     core.dom = dom;
     core.statusBar = statusBar;
     core.canvas = canvas;
     core.images = images;
+    core.bgms = bgms;
     core.sounds = sounds;
     core.floorIds = floorIds;
     core.floors = floors;
@@ -134,16 +138,43 @@ core.prototype.init = function (dom, statusBar, canvas, images, sounds, floorIds
     core.material.icons = core.icons.getIcons();
     core.material.events = core.events.getEvents();
 
-    // test if iOS
-    core.musicStatus.soundStatus = core.getLocalStorage('soundStatus', true);
-    var userAgent = navigator.userAgent;
 
-    if (userAgent.indexOf('iPhone') > -1 || userAgent.indexOf('iPad') > -1) {
-        console.log("你的设备为iphone，不自动播放音乐！");
-        core.musicStatus.isIOS = true;
-        core.musicStatus.soundStatus = false;
+
+    if (location.protocol.indexOf("http")==0) {
+        window.AudioContext = window.AudioContext || window.webkitAudioContext || window.mozAudioContext || window.msAudioContext;
+        try {
+            core.musicStatus.audioContext = new window.AudioContext();
+        } catch (e) {
+            console.log("该浏览器不支持AudioContext");
+            core.musicStatus.audioContext = null;
+        }
     }
 
+    // 音效设置部分
+    var isPC = true;
+    ["Android", "iPhone", "SymbianOS", "Windows Phone", "iPad", "iPod"].forEach(function (t) {
+        if (navigator.userAgent.indexOf(t)>=0) isPC=false;
+    });
+    if (isPC) {
+        // 如果是PC端直接加载
+        core.musicStatus.startDirectly = true;
+    }
+    else {
+        var connection = navigator.connection;
+        if (core.isset(connection) && connection.type=='wifi')
+            core.musicStatus.startDirectly = true;
+    }
+
+    // 先从存储中读取BGM状态
+    core.musicStatus.bgmStatus = core.getLocalStorage('bgmStatus', true);
+    if (!core.musicStatus.startDirectly) // 如果当前网络环境不允许
+        core.musicStatus.bgmStatus = false;
+    core.setLocalStorage('bgmStatus', core.musicStatus.bgmStatus);
+
+    core.musicStatus.soundStatus = core.getLocalStorage('soundStatus', true);
+    core.setLocalStorage('soundStatus', core.musicStatus.soundStatus);
+
+
     // switchs
     core.flags.battleAnimate = core.getLocalStorage('battleAnimate', core.flags.battleAnimate);
     core.flags.displayEnemyDamage = core.getLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
@@ -162,6 +193,7 @@ core.prototype.init = function (dom, statusBar, canvas, images, sounds, floorIds
     });
 }
 
+////// 显示游戏开始界面 //////
 core.prototype.showStartAnimate = function (callback) {
     core.dom.startPanel.style.opacity=1;
     core.dom.startPanel.style.display="block";
@@ -188,6 +220,7 @@ core.prototype.showStartAnimate = function (callback) {
     }, 20);
 }
 
+////// 隐藏游戏开始界面 //////
 core.prototype.hideStartAnimate = function (callback) {
     var opacityVal = 1;
     var startAnimate = window.setInterval(function () {
@@ -201,14 +234,17 @@ core.prototype.hideStartAnimate = function (callback) {
     }, 20);
 }
 
+////// 设置加载进度条进度 //////
 core.prototype.setStartProgressVal = function (val) {
     core.dom.startTopProgress.style.width = val + '%';
 }
 
+////// 设置加载进度条提示文字 //////
 core.prototype.setStartLoadTipText = function (text) {
     core.dom.startTopLoadTips.innerHTML = text;
 }
 
+////// 加载图片和音频 //////
 core.prototype.loader = function (callback) {
     var loadedImageNum = 0, allImageNum = 0, allSoundNum = 0;
     allImageNum = core.images.length;
@@ -232,7 +268,7 @@ core.prototype.loader = function (callback) {
                         core.material.images.autotile[autotileId]=image;
                         if (Object.keys(core.material.images.autotile).length==autotileIds.length) {
                             // 音频
-                            core.loadSounds(callback);
+                            core.loadMusic(callback);
                         }
                     })
                 }
@@ -241,6 +277,7 @@ core.prototype.loader = function (callback) {
     }
 }
 
+////// 加载图片 //////
 core.prototype.loadImage = function (imgName, callback) {
     try {
         core.setStartLoadTipText('加载图片 ' + imgName + ' 中...');
@@ -259,65 +296,114 @@ core.prototype.loadImage = function (imgName, callback) {
     }
 }
 
-core.prototype.loadSounds = function (callback) {
-    for (var key in core.sounds) {
-        for (var i = 0; i < core.sounds[key].length; i++) {
-            var soundName=core.sounds[key][i];
-            soundName = soundName.split('-');
-            var sound = new Audio();
-            sound.preload = 'none';
-            sound.src = 'sounds/' + soundName[0] + '.' + key;
-            if (soundName[1] == 'loop') {
-                sound.loop = 'loop';
-            }
+////// 加载音频 //////
+core.prototype.loadMusic = function (callback) {
 
-            if (!core.isset(core.material.sounds[key]))
-                core.material.sounds[key] = {};
-            core.material.sounds[key][soundName[0]] = sound;
+    core.bgms.forEach(function (t) {
+
+        // 判断是不是mid
+        if (/^.*\.mid$/.test(t)) {
+
+            if (core.musicStatus.audioContext!=null) {
+                core.material.bgms[t] = 'loading';
+                var xhr = new XMLHttpRequest();
+                xhr.open('GET', 'sounds/'+t, true);
+                xhr.overrideMimeType("text/plain; charset=x-user-defined");
+                xhr.onload = function(e) { //下载完成
+                    try {
+                        var ff = [];
+                        var mx = this.responseText.length;
+                        for (var z = 0; z < mx; z++)
+                            ff[z] = String.fromCharCode(this.responseText.charCodeAt(z) & 255);
+                        var shouldStart = core.material.bgms[t] == 'starting';
+                        core.material.bgms[t] = AudioPlayer(core.musicStatus.audioContext, Replayer(MidiFile(ff.join("")), Synth(44100)), true);
+
+                        if (shouldStart)
+                            core.playBgm(t);
+                    }
+                    catch (ee) {
+                        console.log(ee);
+                        core.material.bgms[t] = null;
+                    }
+
+                };
+                xhr.ontimeout = function(e) {
+                    console.log(e);
+                    core.material.bgms[t] = null;
+                }
+                xhr.onerror = function(e) {
+                    console.log(e);
+                    core.material.bgms[t] = null;
+                }
+                xhr.send();
+            }
+            else {
+                core.material.bgms[t] = null;
+            }
         }
-    }
+        else {
+            var music = new Audio();
+            music.preload = core.musicStatus.startDirectly?'auto':'none';
+            music.src = 'sounds/'+t;
+            music.loop = 'loop';
+            core.material.bgms[t] = music;
+        }
+    });
+
+    core.sounds.forEach(function (t) {
+
+        if (core.musicStatus.audioContext != null) {
+            var xhr = new XMLHttpRequest();
+            xhr.open('GET', 'sounds/'+t, true);
+            xhr.responseType = 'arraybuffer';
+            xhr.onload = function(e) { //下载完成
+                try {
+                    core.musicStatus.audioContext.decodeAudioData(this.response, function (buffer) {
+                        core.material.sounds[t] = buffer;
+                    }, function (e) {
+                        console.log(e);
+                        core.material.sounds[t] = null;
+                    })
+                }
+                catch (ee) {
+                    console.log(ee);
+                    core.material.sounds[t] = null;
+                }
+            };
+
+            xhr.ontimeout = function(e) {
+                console.log(e);
+                core.material.sounds[t] = null;
+            }
+            xhr.onerror = function(e) {
+                console.log(e);
+                core.material.sounds[t] = null;
+            }
+            xhr.send();
+        }
+        else {
+            var music = new Audio();
+            music.src = 'sounds/'+t;
+            core.material.sounds[t] = music;
+        }
+
+    });
+
+    // 直接开始播放
+    if (core.musicStatus.startDirectly && core.bgms.length>0)
+        core.playBgm(core.bgms[0]);
+
     callback();
 }
 
-core.prototype.loadSound = function() {
-    if (!core.isset(core.material.sounds.mp3)) return;
-    if (core.musicStatus.isIOS) return;
-    if (core.musicStatus.loaded) return;
-    core.musicStatus.loaded=true;
-    console.log("加载音乐");
-
-    var toLoadList = [];
-
-    for (var key in core.material.sounds) {
-        for (var name in core.material.sounds[key]) {
-            toLoadList.push(core.material.sounds[key][name]);
-        }
-    }
-    core.loadSoundItem(toLoadList);
-}
-
-core.prototype.loadSoundItem = function (toLoadList) {
-    if (toLoadList.length==0) {
-        if (core.musicStatus.bgmStatus>0) return;
-        core.musicStatus.bgmStatus=1;
-        if (core.musicStatus.soundStatus)
-            core.playBgm('bgm', 'mp3');
-        return;
-    }
-    var item = toLoadList.shift();
-    item.oncanplay = function() {
-        core.loadSoundItem(toLoadList);
-    }
-    item.load();
-}
-
+////// 游戏是否已经开始 //////
 core.prototype.isPlaying = function() {
     if (core.isset(core.status.played) && core.status.played)
         return true;
     return false;
 }
 
-
+////// 清除游戏状态和数据 //////
 core.prototype.clearStatus = function() {
     // 停止各个Timeout和Interval
     for (var i in core.interval) {
@@ -328,6 +414,7 @@ core.prototype.clearStatus = function() {
     core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
 }
 
+////// 重置游戏状态和初始数据 //////
 core.prototype.resetStatus = function(hero, hard, floorId, maps) {
 
     // 停止各个Timeout和Interval
@@ -352,6 +439,7 @@ core.prototype.resetStatus = function(hero, hard, floorId, maps) {
     core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
 }
 
+////// 开始游戏 //////
 core.prototype.startGame = function (hard, callback) {
     console.log('开始游戏');
 
@@ -363,7 +451,7 @@ core.prototype.startGame = function (hard, callback) {
     });
 }
 
-
+////// 重新开始游戏；此函数将回到标题页面 //////
 core.prototype.restart = function() {
     core.showStartAnimate();
 }
@@ -375,6 +463,7 @@ core.prototype.restart = function() {
 
 /////////// 键盘、鼠标事件相关 ///////////
 
+////// 按下某个键时 //////
 core.prototype.onkeyDown = function(e) {
     if (!core.isset(core.status.holdingKeys))core.status.holdingKeys=[];
     var isArrow={37:true,38:true,39:true,40:true}[e.keyCode]
@@ -391,6 +480,7 @@ core.prototype.onkeyDown = function(e) {
     }
 }
 
+////// 放开某个键时 //////
 core.prototype.onkeyUp = function(e) {
     var isArrow={37:true,38:true,39:true,40:true}[e.keyCode]
     if(isArrow && !core.status.lockControl){
@@ -408,6 +498,7 @@ core.prototype.onkeyUp = function(e) {
     }
 }
 
+////// 按住某个键时 //////
 core.prototype.pressKey = function (keyCode) {
     if (keyCode === core.status.holdingKeys.slice(-1)[0]) {
         core.keyDown(keyCode);
@@ -415,6 +506,7 @@ core.prototype.pressKey = function (keyCode) {
     }
 }
 
+////// 根据按下键的code来执行一系列操作 //////
 core.prototype.keyDown = function(keyCode) {
     if(core.status.automaticRouting || core.status.automaticRouted) {
         core.stopAutomaticRoute();
@@ -513,6 +605,7 @@ core.prototype.keyDown = function(keyCode) {
     }
 }
 
+////// 根据放开键的code来执行一系列操作 //////
 core.prototype.keyUp = function(keyCode) {
 
     if (core.status.lockControl) {
@@ -538,6 +631,10 @@ core.prototype.keyUp = function(keyCode) {
             core.events.keyUpBook(keyCode);
             return;
         }
+        if (core.status.event.id=='book-detail' && (keyCode==13 || keyCode==32 || keyCode==67)) {
+            core.events.clickBookDetail();
+            return;
+        }
         if (core.status.event.id=='fly') {
             core.events.keyUpFly(keyCode);
             return;
@@ -662,6 +759,7 @@ core.prototype.keyUp = function(keyCode) {
     core.stopHero();
 }
 
+////// 点击（触摸）事件按下时 //////
 core.prototype.ondown = function (x ,y) {
     if (!core.status.played || core.status.lockControl) {
         core.onclick(x, y, []);
@@ -678,6 +776,7 @@ core.prototype.ondown = function (x ,y) {
     core.fillPosWithPoint(pos);
 }
 
+////// 当在触摸屏上滑动时 //////
 core.prototype.onmove = function (x ,y) {
     if (core.status.holdingPath==0){return;}
     core.status.mouseOutCheck =1;
@@ -700,6 +799,7 @@ core.prototype.onmove = function (x ,y) {
     }
 }
 
+////// 当点击（触摸）事件放开时 //////
 core.prototype.onup = function () {
     core.status.holdingPath=0;
     if(core.status.stepPostfix.length>0){
@@ -720,6 +820,7 @@ core.prototype.onup = function () {
     }
 }
 
+////// 获得点击事件相对左上角的坐标（0到12之间） //////
 core.prototype.getClickLoc = function (x, y) {
     
     var statusBar = {'x': 0, 'y': 0};
@@ -744,6 +845,7 @@ core.prototype.getClickLoc = function (x, y) {
     return loc;
 }
 
+////// 具体点击屏幕上(x,y)点时，执行的操作 //////
 core.prototype.onclick = function (x, y, stepPostfix) {
     // console.log("Click: (" + x + "," + y + ")");
 
@@ -780,6 +882,12 @@ core.prototype.onclick = function (x, y, stepPostfix) {
         return;
     }
 
+    // 怪物详细信息
+    if (core.status.event.id == 'book-detail') {
+        core.events.clickBookDetail(x,y);
+        return;
+    }
+
     // 楼层飞行器
     if (core.status.event.id == 'fly') {
         core.events.clickFly(x,y);
@@ -853,6 +961,7 @@ core.prototype.onclick = function (x, y, stepPostfix) {
 
 }
 
+////// 滑动鼠标滚轮时的操作 //////
 core.prototype.onmousewheel = function (direct) {
     // 向下滚动是 -1 ,向上是 1
 
@@ -865,8 +974,8 @@ core.prototype.onmousewheel = function (direct) {
 
     // 怪物手册
     if (core.status.lockControl && core.status.event.id == 'book') {
-        if (direct==1) core.ui.drawEnemyBook(core.status.event.data - 1);
-        if (direct==-1) core.ui.drawEnemyBook(core.status.event.data + 1);
+        if (direct==1) core.ui.drawBook(core.status.event.data - 1);
+        if (direct==-1) core.ui.drawBook(core.status.event.data + 1);
         return;
     }
 
@@ -885,10 +994,13 @@ core.prototype.onmousewheel = function (direct) {
 
 /////////// 寻路代码相关 ///////////
 
+////// 清除自动寻路路线 //////
 core.prototype.clearAutomaticRouteNode = function (x, y) {
-    core.canvas.ui.clearRect(x * 32 + 5, y * 32 + 5, 27, 27);
+    if (core.status.event.id==null)
+        core.canvas.ui.clearRect(x * 32 + 5, y * 32 + 5, 27, 27);
 }
 
+////// 停止自动寻路操作 //////
 core.prototype.stopAutomaticRoute = function () {
     if (!core.status.played) {
         return;
@@ -902,6 +1014,7 @@ core.prototype.stopAutomaticRoute = function () {
         core.canvas.ui.clearRect(0, 0, 416, 416);
 }
 
+////// 继续剩下的自动寻路操作 //////
 core.prototype.continueAutomaticRoute = function () {
     // 此函数只应由events.afterOpenDoor和events.afterBattle调用
     var moveStep = core.status.moveStepBeforeStop;
@@ -912,11 +1025,13 @@ core.prototype.continueAutomaticRoute = function () {
     core.setAutoHeroMove(moveStep);
 }
 
+////// 清空剩下的自动寻路列表 //////
 core.prototype.clearContinueAutomaticRoute = function () {
     core.canvas.ui.clearRect(0, 0, 416, 416);
     core.status.moveStepBeforeStop=[];
 }
 
+////// 设置自动寻路路线 //////
 core.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
     if (!core.status.played || core.status.lockControl) {
         return;
@@ -1031,7 +1146,8 @@ core.prototype.setAutomaticRoute = function (destX, destY, stepPostfix) {
     core.status.automaticRoutingTemp = {'destX': 0, 'destY': 0, 'moveStep': []};
 
 }
-// BFS
+
+////// 自动寻路算法，找寻最优路径 //////
 core.prototype.automaticRoute = function (destX, destY) {
     var startX = core.getHeroLoc('x');
     var startY = core.getHeroLoc('y');
@@ -1098,8 +1214,8 @@ core.prototype.automaticRoute = function (destX, destY) {
                 // 绕过可能的夹击点
                 // if (nextBlock.block.event.trigger == 'checkBlock') deepAdd=200;
             }
-            if (core.status.checkBlock[nid]>0)
-                deepAdd = core.status.checkBlock[nid];
+            if (core.status.checkBlock.damage[nid]>0)
+                deepAdd = core.status.checkBlock.damage[nid];
 
             if (nx == destX && ny == destY) {
                 route[nid] = direction;
@@ -1130,10 +1246,12 @@ core.prototype.automaticRoute = function (destX, destY) {
     return ans;
 }
 
+////// 显示离散的寻路点 //////
 core.prototype.fillPosWithPoint = function (pos) {
     core.fillRect('ui', pos.x*32+12,pos.y*32+12,8,8, '#bfbfbf');
 }
 
+////// 清除已经寻路过的部分 //////
 core.prototype.clearStepPostfix = function () {
     if(core.status.mouseOutCheck >0){
         core.status.mouseOutCheck--;
@@ -1154,6 +1272,7 @@ core.prototype.clearStepPostfix = function () {
 
 /////////// 自动行走 & 行走控制 ///////////
 
+////// 停止勇士的自动行走 //////
 core.prototype.stopAutoHeroMove = function () {
     core.status.autoHeroMove = false;
     core.status.automaticRouting = false;
@@ -1166,6 +1285,7 @@ core.prototype.stopAutoHeroMove = function () {
     clearInterval(core.interval.heroAutoMoveScan);
 }
 
+////// 设置勇士的自动行走路线 //////
 core.prototype.setAutoHeroMove = function (steps, start) {
     if (steps.length == 0) {
         return;
@@ -1185,12 +1305,14 @@ core.prototype.setAutoHeroMove = function (steps, start) {
     }, 80);
 }
 
+////// 让勇士开始自动行走 //////
 core.prototype.autoHeroMove = function (direction, step) {
     core.status.autoHeroMove = true;
     core.status.destStep = step;
     core.moveHero(direction);
 }
 
+////// 设置行走的效果动画 //////
 core.prototype.setHeroMoveInterval = function (direction, x, y, callback) {
     if (core.status.heroMoving) {
         return;
@@ -1222,6 +1344,7 @@ core.prototype.setHeroMoveInterval = function (direction, x, y, callback) {
     }, 12.5);
 }
 
+////// 设置勇士行走过程中对事件的触发检测 //////
 core.prototype.setHeroMoveTriggerInterval = function () {
     var direction, x, y;
     var scan = {
@@ -1235,7 +1358,7 @@ core.prototype.setHeroMoveTriggerInterval = function () {
             direction = core.getHeroLoc('direction');
             x = core.getHeroLoc('x');
             y = core.getHeroLoc('y');
-            var noPass = core.noPass(x + scan[direction].x, y + scan[direction].y), canMove = core.canMove();
+            var noPass = core.noPass(x + scan[direction].x, y + scan[direction].y), canMove = core.canMoveHero();
             if (noPass || !canMove) {
                 if (canMove) // 非箭头：触发
                     core.trigger(x + scan[direction].x, y + scan[direction].y);
@@ -1270,14 +1393,15 @@ core.prototype.setHeroMoveTriggerInterval = function () {
                     core.drawHero(core.getHeroLoc('direction'), core.getHeroLoc('x'), core.getHeroLoc('y'), 'stop');
                 }
                 core.trigger(core.getHeroLoc('x'), core.getHeroLoc('y'));
-                core.checkBlock();
                 clearInterval(core.interval.heroMoveInterval);
                 core.status.heroMoving = false;
+                core.checkBlock();
             });
         }
     }, 50);
 }
 
+////// 设置勇士的方向（转向） //////
 core.prototype.turnHero = function(direction) {
     if (core.isset(direction)) {
         core.status.hero.loc.direction = direction;
@@ -1291,7 +1415,8 @@ core.prototype.turnHero = function(direction) {
     core.canvas.ui.clearRect(0, 0, 416, 416);
 }
 
-core.prototype.canMove = function() {
+////// 勇士能否前往某方向 //////
+core.prototype.canMoveHero = function() {
     var direction = core.getHeroLoc('direction');
     var nowBlock = core.getBlock(core.getHeroLoc('x'),core.getHeroLoc('y'));
     if (nowBlock!=null){
@@ -1329,11 +1454,13 @@ core.prototype.canMove = function() {
     return true;
 }
 
+////// 让勇士开始移动 //////
 core.prototype.moveHero = function (direction) {
     core.setHeroLoc('direction', direction);
     core.status.heroStop = false;
 }
 
+/////// 使用事件让勇士移动。这个函数将不会触发任何事件 //////
 core.prototype.eventMoveHero = function(steps, time, callback) {
 
     time = time || 100;
@@ -1394,6 +1521,7 @@ core.prototype.eventMoveHero = function(steps, time, callback) {
     }, time/8);
 }
 
+////// 每移动一格后执行的事件 //////
 core.prototype.moveOneStep = function() {
     // 中毒状态
     if (core.hasFlag('poison')) {
@@ -1408,6 +1536,7 @@ core.prototype.moveOneStep = function() {
     }
 }
 
+////// 停止勇士的一切行动，等待勇士行动结束后，再执行callback //////
 core.prototype.waitHeroToStop = function(callback) {
     core.stopAutomaticRoute();
     core.clearContinueAutomaticRoute();
@@ -1420,10 +1549,12 @@ core.prototype.waitHeroToStop = function(callback) {
     }
 }
 
+////// 停止勇士的移动状态 //////
 core.prototype.stopHero = function () {
     core.status.heroStop = true;
 }
 
+////// 绘制勇士 //////
 core.prototype.drawHero = function (direction, x, y, status, offsetX, offsetY) {
     offsetX = offsetX || 0;
     offsetY = offsetY || 0;
@@ -1436,13 +1567,54 @@ core.prototype.drawHero = function (direction, x, y, status, offsetX, offsetY) {
     core.canvas.hero.drawImage(core.material.images.hero, heroIcon[status] * 32, heroIcon.loc * height, 32, height, x + offsetX, y + offsetY + 32-height, 32, height);
 }
 
+////// 设置勇士的位置 //////
+core.prototype.setHeroLoc = function (itemName, itemVal) {
+    if (itemVal == '++') {
+        core.status.hero.loc[itemName]++;
+        return;
+    }
+    else if (itemVal == '--') {
+        core.status.hero.loc[itemName]--;
+        return;
+    }
+    core.status.hero.loc[itemName] = itemVal;
+}
+
+////// 获得勇士的位置 //////
+core.prototype.getHeroLoc = function (itemName) {
+    if (!core.isset(itemName)) return core.status.hero.loc;
+    return core.status.hero.loc[itemName];
+}
+
+////// 获得勇士面对位置的x坐标 //////
+core.prototype.nextX = function() {
+    var scan = {
+        'up': {'x': 0, 'y': -1},
+        'left': {'x': -1, 'y': 0},
+        'down': {'x': 0, 'y': 1},
+        'right': {'x': 1, 'y': 0}
+    };
+    return core.getHeroLoc('x')+scan[core.getHeroLoc('direction')].x;
+}
+
+////// 获得勇士面对位置的y坐标 //////
+core.prototype.nextY = function () {
+    var scan = {
+        'up': {'x': 0, 'y': -1},
+        'left': {'x': -1, 'y': 0},
+        'down': {'x': 0, 'y': 1},
+        'right': {'x': 1, 'y': 0}
+    };
+    return core.getHeroLoc('y')+scan[core.getHeroLoc('direction')].y;
+}
+
 /////////// 自动行走 & 行走控制 END ///////////
 
 
 
 /////////// 地图处理 ///////////
 
-// 开门
+////// 开门 //////
 core.prototype.openDoor = function (id, x, y, needKey, callback) {
 
     if (core.interval.openDoorAnimate!=null) return;
@@ -1471,7 +1643,7 @@ core.prototype.openDoor = function (id, x, y, needKey, callback) {
         }
     }
     // open
-    core.playSound("door", "ogg");
+    core.playSound("door.ogg");
     var state = 0;
     var doorId = id;
     if (!(doorId.substring(doorId.length-4)=="Door")) {
@@ -1493,7 +1665,7 @@ core.prototype.openDoor = function (id, x, y, needKey, callback) {
     }, speed)
 }
 
-// 战斗
+////// 战斗 //////
 core.prototype.battle = function (id, x, y, force, callback) {
     if (core.status.moveStepBeforeStop.length==0) {
         core.status.moveStepBeforeStop=core.status.autoStepRoutes.slice(core.status.autoStep-1,core.status.autoStepRoutes.length);
@@ -1517,11 +1689,12 @@ core.prototype.battle = function (id, x, y, force, callback) {
         });
     }
     else {
-        core.playSound('attack', 'ogg');
+        core.playSound('attack.ogg');
         core.afterBattle(id, x, y, callback);
     }
 }
 
+////// 战斗完毕 //////
 core.prototype.afterBattle = function(id, x, y, callback) {
     core.status.hero.hp -= core.enemys.getDamage(id);
     if (core.status.hero.hp<=0) {
@@ -1549,12 +1722,12 @@ core.prototype.afterBattle = function(id, x, y, callback) {
         hint += "，经验+" + core.material.enemys[id].experience;
     core.drawTip(hint);
 
-    core.updateCheckBlockMap();
     // 打完怪物，触发事件
     core.events.afterBattle(id,x,y,callback);
 
 }
 
+////// 触发(x,y)点的事件 //////
 core.prototype.trigger = function (x, y) {
     var mapBlocks = core.status.thisMap.blocks;
     var noPass;
@@ -1581,7 +1754,7 @@ core.prototype.trigger = function (x, y) {
     }
 }
 
-// 楼层切换
+////// 楼层切换 //////
 core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback) {
     time = time || 800;
     time /= 20;
@@ -1590,6 +1763,8 @@ core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback)
     core.stopAutomaticRoute();
     core.clearContinueAutomaticRoute();
     core.dom.floorNameLabel.innerHTML = core.status.maps[floorId].title;
+    if (!core.isset(stair) && !core.isset(heroLoc))
+        heroLoc = core.status.hero.loc;
     if (core.isset(stair)) {
         if (!core.isset(heroLoc)) heroLoc={};
         var blocks = core.status.maps[floorId].blocks;
@@ -1613,7 +1788,7 @@ core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback)
     }
 
     window.setTimeout(function () {
-        core.playSound('floor', 'mp3');
+        core.playSound('floor.mp3');
         core.mapChangeAnimate('show', time/2, function () {
 
             // 根据文字判断是否斜体
@@ -1624,6 +1799,32 @@ core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback)
                 core.statusBar.floor.style.fontStyle = 'italic';
             else core.statusBar.floor.style.fontStyle = 'normal';
 
+            // 更改BGM
+            if (core.isset(core.floors[floorId].bgm)) {
+                core.playBgm(core.floors[floorId].bgm);
+            }
+
+            // 不存在事件时，更改画面色调
+            if (core.status.event.id == null) {
+                // 默认画面色调
+                if (core.isset(core.floors[floorId].color)) {
+                    var color = core.floors[floorId].color;
+
+                    // 直接变色
+                    var nowR = parseInt(color[0]), nowG = parseInt(color[1]), nowB = parseInt(color[2]);
+                    var toRGB = "#"+((1<<24)+(nowR<<16)+(nowG<<8)+nowB).toString(16).slice(1);
+                    core.dom.curtain.style.background = toRGB;
+                    if (core.isset(color[3]))
+                        core.dom.curtain.style.opacity = color[3];
+                    else core.dom.curtain.style.opacity=1;
+                    core.status.curtainColor = color;
+                }
+                else {
+                    core.dom.curtain.style.background = "#000000";
+                    core.dom.curtain.style.opacity = 0;
+                }
+            }
+
             core.drawMap(floorId, function () {
                 setTimeout(function() {
                     core.mapChangeAnimate('hide', time/4, function () {
@@ -1637,16 +1838,13 @@ core.prototype.changeFloor = function (floorId, stair, heroLoc, time, callback)
                     core.setHeroLoc('y', heroLoc.y);
                     core.drawHero(core.getHeroLoc('direction'), core.getHeroLoc('x'), core.getHeroLoc('y'), 'stop');
                     core.updateStatusBar();
-                    // core.updateCheckBlockMap();
-                    // core.updateCheckBlock();
-                    // core.updateFg();
                 }, 15)
             });
         });
     }, 50);
 }
 
-// 地图切换
+////// 地图切换动画效果 //////
 core.prototype.mapChangeAnimate = function (mode, time, callback) {
     if (mode == 'show') {
         core.show(core.dom.floorMsgGroup, time, function () {
@@ -1660,6 +1858,7 @@ core.prototype.mapChangeAnimate = function (mode, time, callback) {
     }
 }
 
+////// 清除地图 //////
 core.prototype.clearMap = function (map, x, y, width, height) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1671,6 +1870,7 @@ core.prototype.clearMap = function (map, x, y, width, height) {
     }
 }
 
+////// 在某个canvas上绘制一段文字 //////
 core.prototype.fillText = function (map, text, x, y, style, font) {
     if (core.isset(style)) {
         core.setFillStyle(map, style);
@@ -1681,6 +1881,7 @@ core.prototype.fillText = function (map, text, x, y, style, font) {
     core.canvas[map].fillText(text, x, y);
 }
 
+////// 在某个canvas上绘制一个矩形 //////
 core.prototype.fillRect = function (map, x, y, width, height, style) {
     if (core.isset(style)) {
         core.setFillStyle(map, style);
@@ -1688,6 +1889,7 @@ core.prototype.fillRect = function (map, x, y, width, height, style) {
     core.canvas[map].fillRect(x, y, width, height);
 }
 
+////// 在某个canvas上绘制一个矩形的边框 //////
 core.prototype.strokeRect = function (map, x, y, width, height, style, lineWidth) {
     if (core.isset(style)) {
         core.setStrokeStyle(map, style);
@@ -1698,6 +1900,7 @@ core.prototype.strokeRect = function (map, x, y, width, height, style, lineWidth
     core.canvas[map].strokeRect(x, y, width, height);
 }
 
+////// 在某个canvas上绘制一条线 //////
 core.prototype.drawLine = function (map, x1, y1, x2, y2, style, lineWidth) {
     if (core.isset(style)) {
         core.setStrokeStyle(map, style);
@@ -1711,10 +1914,12 @@ core.prototype.drawLine = function (map, x1, y1, x2, y2, style, lineWidth) {
     core.canvas[map].stroke();
 }
 
+////// 设置某个canvas的文字字体 //////
 core.prototype.setFont = function (map, font) {
     core.canvas[map].font = font;
 }
 
+////// 设置某个canvas的线宽度 //////
 core.prototype.setLineWidth = function (map, lineWidth) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1724,14 +1929,17 @@ core.prototype.setLineWidth = function (map, lineWidth) {
     core.canvas[map].lineWidth = lineWidth;
 }
 
+////// 保存某个canvas状态 //////
 core.prototype.saveCanvas = function (map) {
     core.canvas[map].save();
 }
 
+////// 加载某个canvas状态 //////
 core.prototype.loadCanvas = function (map) {
     core.canvas[map].restore();
 }
 
+////// 设置某个canvas边框属性 //////
 core.prototype.setStrokeStyle = function (map, style) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1743,6 +1951,7 @@ core.prototype.setStrokeStyle = function (map, style) {
     }
 }
 
+////// 设置某个canvas的alpha值 //////
 core.prototype.setAlpha = function (map, alpha) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1752,6 +1961,7 @@ core.prototype.setAlpha = function (map, alpha) {
     else core.canvas[map].globalAlpha = alpha;
 }
 
+////// 设置某个canvas的透明度 //////
 core.prototype.setOpacity = function (map, opacity) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1761,6 +1971,7 @@ core.prototype.setOpacity = function (map, opacity) {
     else core.canvas[map].canvas.style.opacity = opacity;
 }
 
+////// 设置某个canvas的绘制属性（如颜色等） //////
 core.prototype.setFillStyle = function (map, style) {
     if (map == 'all') {
         for (var m in core.canvas) {
@@ -1772,11 +1983,7 @@ core.prototype.setFillStyle = function (map, style) {
     }
 }
 
-/**
- * 地图绘制
- * @param mapName 地图ID
- * @param callback 绘制完毕后的回调函数
- */
+////// 绘制某张地图 //////
 core.prototype.drawMap = function (mapName, callback) {
     core.clearMap('all');
     core.removeGlobalAnimate(null, null, true);
@@ -1840,6 +2047,7 @@ core.prototype.drawMap = function (mapName, callback) {
         callback();
 }
 
+////// 绘制Autotile //////
 core.prototype.drawAutotile = function (floorId, canvas, autotileMaps, left, top, size, autotileId) {
 
     if (!core.isset(autotileId)) {
@@ -1854,7 +2062,7 @@ core.prototype.drawAutotile = function (floorId, canvas, autotileMaps, left, top
     }
 
     var isAutotile = function(x, y) {
-        if (x<0 || x>12 || y<0 || y>12) return 0;
+        if (x<0 || x>12 || y<0 || y>12) return 1;
         return autotileMaps[13*x+y]==autotileId?1:0;
     }
     for (var xx=0;xx<13;xx++) {
@@ -1885,6 +2093,7 @@ core.prototype.drawAutotile = function (floorId, canvas, autotileMaps, left, top
     }
 }
 
+////// 绘制Autotile的某一块 //////
 core.prototype.drawAutotileBlock = function (floorId, map, x, y, size, autotile, index) {
     var canvas = core.canvas[map];
     var groundId = core.floors[floorId].defaultGround || "ground";
@@ -1968,51 +2177,53 @@ core.prototype.drawAutotileBlock = function (floorId, map, x, y, size, autotile,
     }
 }
 
-core.prototype.autotileExists = function (x, y, floorId) {
-    var block = core.getBlock(x,y,floorId);
-    if (block==null) return false;
-    return block.block.event.cls == 'autotile';
-}
-
+////// 某个点是否不可通行 //////
 core.prototype.noPassExists = function (x, y, floorId) {
     var block = core.getBlock(x,y,floorId);
     if (block==null) return false;
     return core.isset(block.block.event.noPass) && block.block.event.noPass;
 }
 
+////// 某个点是否在区域内且不可通行 //////
 core.prototype.noPass = function (x, y) {
     return x<0 || x>12 || y<0 || y>12 || core.noPassExists(x,y);
 }
 
+////// 某个点是否存在NPC //////
 core.prototype.npcExists = function (x, y, floorId) {
     var block = core.getBlock(x,y,floorId);
     if (block==null) return false;
     return block.block.event.cls == 'npcs';
 }
 
+////// 某个点是否存在（指定的）地形 //////
 core.prototype.terrainExists = function (x, y, id, floorId) {
     var block = core.getBlock(x,y,floorId);
     if (block==null) return false;
-    return block.block.event.cls=='terrains' && block.block.event.id==id;
+    return block.block.event.cls=='terrains' && (core.isset(id)?block.block.event.id==id:true);
 }
 
+////// 某个点是否存在楼梯 //////
 core.prototype.stairExists = function (x, y, floorId) {
     var block = core.getBlock(x,y,floorId);
     if (block==null) return false;
     return block.block.event.cls=='terrains' && (block.block.event.id=='upFloor' || block.block.event.id=='downFloor');
 }
 
+////// 当前位置是否在楼梯边 //////
 core.prototype.nearStair = function() {
     var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
     return core.stairExists(x,y) || core.stairExists(x-1,y) || core.stairExists(x,y-1) || core.stairExists(x+1,y) || core.stairExists(x,y+1);
 }
 
+////// 某个点是否存在（指定的）怪物 //////
 core.prototype.enemyExists = function (x, y, id,floorId) {
     var block = core.getBlock(x,y,floorId);
     if (block==null) return false;
-    return block.block.event.cls=='enemys' && block.block.event.id==id;
+    return block.block.event.cls=='enemys' && (core.isset(id)?block.block.event.id==id:true);
 }
 
+////// 获得某个点的block //////
 core.prototype.getBlock = function (x, y, floorId, needEnable) {
     if (!core.isset(floorId)) floorId=core.status.floorId;
     if (!core.isset(needEnable)) needEnable=true;
@@ -2026,6 +2237,7 @@ core.prototype.getBlock = function (x, y, floorId, needEnable) {
     return null;
 }
 
+////// 显示移动某块的动画，达到{“type”:”move”}的效果 //////
 core.prototype.moveBlock = function(x,y,steps,time,immediateHide,callback) {
     time = time || 500;
 
@@ -2125,6 +2337,7 @@ core.prototype.moveBlock = function(x,y,steps,time,immediateHide,callback) {
     }, time/16);
 }
 
+////// 显示/隐藏某个块时的动画效果 //////
 core.prototype.animateBlock = function (x,y,type,time,callback) {
     if (type!='hide') type='show';
 
@@ -2167,8 +2380,8 @@ core.prototype.animateBlock = function (x,y,type,time,callback) {
     }, time/10);
 }
 
-// 显示一个事件
-core.prototype.addBlock = function(x,y,floodId) {
+////// 将某个块从禁用变成启用状态 //////
+core.prototype.showBlock = function(x, y, floodId) {
     floodId = floodId || core.status.floorId;
     var block = core.getBlock(x,y,floodId,false);
     if (block==null) return; // 不存在
@@ -2176,7 +2389,6 @@ core.prototype.addBlock = function(x,y,floodId) {
     // 本身是禁用事件，启用之
     if (core.isset(block.enable) && !block.enable) {
         block.enable = true;
-        core.updateCheckBlockMap();
         // 在本层，添加动画
         if (floodId == core.status.floorId && core.isset(block.event)) {
             blockIcon = core.material.icons[block.event.cls][block.event.id];
@@ -2188,6 +2400,7 @@ core.prototype.addBlock = function(x,y,floodId) {
     }
 }
 
+////// 将某个块从启用变成禁用状态 //////
 core.prototype.removeBlock = function (x, y, floorId) {
     floorId = floorId || core.status.floorId;
 
@@ -2207,7 +2420,7 @@ core.prototype.removeBlock = function (x, y, floorId) {
     core.updateFg();
 }
 
-
+////// 根据block的索引删除该块 //////
 core.prototype.removeBlockById = function (index, floorId) {
 
     var blocks = core.status.maps[floorId].blocks;
@@ -2218,25 +2431,22 @@ core.prototype.removeBlockById = function (index, floorId) {
     if (!core.isset(event))
         event = core.floors[floorId].changeFloor[x+","+y];
 
-    var shouldUpdateBlockMap = blocks[index].event.cls == 'enemys';
     // 不存在事件，直接删除
     if (!core.isset(event)) {
         blocks.splice(index,1);
-        if (shouldUpdateBlockMap)
-            core.updateCheckBlockMap();
         return;
     }
     blocks[index].enable = false;
-    if (shouldUpdateBlockMap)
-        core.updateCheckBlockMap();
 }
 
+////// 一次性删除多个block //////
 core.prototype.removeBlockByIds = function (floorId, ids) {
     ids.sort(function (a,b) {return b-a}).forEach(function (id) {
         core.removeBlockById(id, floorId);
     });
 }
 
+////// 添加一个全局动画 //////
 core.prototype.addGlobalAnimate = function (animateMore, x, y, loc, image) {
     if (main.mode=='editor') return;
     if (animateMore == 2) {
@@ -2259,6 +2469,7 @@ core.prototype.addGlobalAnimate = function (animateMore, x, y, loc, image) {
     }
 }
 
+////// 删除一个或所有全局动画 //////
 core.prototype.removeGlobalAnimate = function (x, y, all) {
     if (main.mode=='editor') return;
     if (all == true) {
@@ -2279,6 +2490,7 @@ core.prototype.removeGlobalAnimate = function (x, y, all) {
     }
 }
 
+////// 设置全局动画的显示效果 //////
 core.prototype.setGlobalAnimate = function (speed) {
     if (main.mode=='editor') return;
     clearInterval(core.interval.twoAnimate);
@@ -2308,6 +2520,17 @@ core.prototype.setGlobalAnimate = function (speed) {
     }, speed / 2);
 }
 
+////// 同步所有的全局动画效果 //////
+core.prototype.syncGlobalAnimate = function () {
+    core.status.twoAnimateObjs.forEach(function (t) {
+        t.status=0;
+    })
+    core.status.fourAnimateObjs.forEach(function (t) {
+        t.status=0;
+    })
+}
+
+////// 显示UI层某个box的动画 //////
 core.prototype.setBoxAnimate = function () {
     clearInterval(core.interval.boxAnimate);
     if (core.status.boxAnimateObjs.length > 0) {
@@ -2319,6 +2542,7 @@ core.prototype.setBoxAnimate = function () {
     }
 }
 
+////// 绘制UI层的box动画 //////
 core.prototype.drawBoxAnimate = function (background) {
     for (var a = 0; a < core.status.boxAnimateObjs.length; a++) {
         var obj = core.status.boxAnimateObjs[a];
@@ -2330,84 +2554,136 @@ core.prototype.drawBoxAnimate = function (background) {
     }
 }
 
-core.prototype.updateCheckBlockMap = function() {
-    // 更新领域、夹击地图
-    core.status.checkBlockMap = [];
+////// 更新领域、夹击、阻击的伤害地图 //////
+core.prototype.updateCheckBlock = function() {
+    core.status.checkBlock = {};
+    if (!core.isset(core.status.thisMap)) return;
     var blocks = core.status.thisMap.blocks;
+
+    // Step1: 更新怪物地图
+    core.status.checkBlock.map = []; // 记录怪物地图
     for (var n=0;n<blocks.length;n++) {
         var block = blocks[n];
-        if (core.isset(block.event) && !(core.isset(block.enable) && !block.enable)) {
-            if (block.event.cls=='enemys') {
-                var enemy = core.enemys.getEnemys(block.event.id);
-                if (core.isset(enemy)) {
-                    var value=0;
-                    if (core.enemys.hasSpecial(enemy.special, 15)) // 领域
-                        value += enemy.value;
-                    if (core.enemys.hasSpecial(enemy.special, 16)) // 夹击
-                        value += 1000000 * block.id;
-                    core.status.checkBlockMap[13*block.x+block.y] = value;
-                }
+        if (core.isset(block.event) && !(core.isset(block.enable) && !block.enable) && block.event.cls=='enemys') {
+            var id = block.event.id, enemy = core.enemys.getEnemys(id);
+            if (core.isset(enemy)) {
+                core.status.checkBlock.map[13*block.x+block.y]=id;
             }
         }
     }
-}
 
-// 更新领域、显伤点
-core.prototype.updateCheckBlock = function() {
-    if (!core.isset(core.status.thisMap)) return;
-    if (!core.isset(core.status.checkBlockMap)) core.updateCheckBlockMap();
-    core.status.checkBlock = [];
+    // Step2: 更新领域、阻击伤害
+    core.status.checkBlock.damage = []; // 记录(x,y)点的伤害
+    for (var x=0;x<13*13;x++) core.status.checkBlock.damage[x]=0;
+
     for (var x=0;x<13;x++) {
         for (var y=0;y<13;y++) {
-            // 计算(x,y)点伤害
-            var damage = 0;
-            if (!core.enemyExists(x,y)) { // 如果该点本身不存在怪物（打死怪物会调用更新）
-
-                // 领域
-                [[-1,0],[0,-1],[1,0],[0,1]].forEach(function (dir) {
-                    var nx = x+dir[0], ny = y+dir[1];
-                    if (nx<0 || nx>12 || ny<0 || ny>12) return;
-                    if (core.status.checkBlockMap[13*nx+ny]%1000000>0) {
-                        damage += core.status.checkBlockMap[13*nx+ny] % 1000000;
+            var id = core.status.checkBlock.map[13*x+y];
+            if (core.isset(id)) {
+                var enemy = core.enemys.getEnemys(id);
+                // 存在领域
+                if (core.enemys.hasSpecial(enemy.special, 15)) {
+                    var range = enemy.range || 1;
+                    var zoneSquare = core.flags.zoneSquare;
+                    if (core.isset(enemy.zoneSquare)) zoneSquare=enemy.zoneSquare;
+                    for (var dx=-range;dx<=range;dx++) {
+                        for (var dy=-range;dy<=range;dy++) {
+                            if (dx==0 && dy==0) continue;
+                            var nx=x+dx, ny=y+dy;
+                            if (nx<0 || nx>12 || ny<0 || ny>12) continue;
+                            if (!zoneSquare && Math.abs(dx)+Math.abs(dy)>range) continue;
+                            core.status.checkBlock.damage[13*nx+ny]+=enemy.value;
+                        }
                     }
-                })
-
-                var leftValue = core.status.hero.hp - damage;
-                if (leftValue>1) {
-                    var has = false;
-                    // 夹击
-                    if (x>0 && x<12) {
-                        var id1=parseInt(core.status.checkBlockMap[13*(x-1)+y]/1000000),
-                            id2=parseInt(core.status.checkBlockMap[13*(x+1)+y]/1000000);
-                        if (id1>0 && id1==id2)
-                            has = true;
-                    }
-                    if (y>0 && y<12) {
-                        var id1=parseInt(core.status.checkBlockMap[13*x+y-1]/1000000),
-                            id2=parseInt(core.status.checkBlockMap[13*x+y+1]/1000000);
-                        if (id1>0 && id1==id2)
-                            has = true;
-                    }
-                    if (has) {
-                        damage += parseInt((leftValue+1) / 2);
+                }
+                // 存在阻击
+                if (core.enemys.hasSpecial(enemy.special, 18)) {
+                    for (var dx=-1;dx<=1;dx++) {
+                        for (var dy=-1;dy<=1;dy++) {
+                            if (dx==0 && dy==0) continue;
+                            var nx=x+dx, ny=y+dy;
+                            if (nx<0 || nx>12 || ny<0 || ny>12 || Math.abs(dx)+Math.abs(dy)>1) continue;
+                            core.status.checkBlock.damage[13*nx+ny]+=enemy.value;
+                        }
                     }
                 }
             }
-            core.status.checkBlock[13*x+y] = damage;
+        }
+    }
+
+
+    // Step3: 更新夹击点坐标，并将夹击伤害加入到damage中
+    core.status.checkBlock.betweenAttack = []; // 记录(x,y)点是否有夹击
+    for (var x=0;x<13;x++) {
+        for (var y=0;y<13;y++) {
+            var has=false;
+            if (x>0 && x<12) {
+                var id1=core.status.checkBlock.map[13*(x-1)+y],
+                    id2=core.status.checkBlock.map[13*(x+1)+y];
+                if (core.isset(id1) && core.isset(id2) && id1==id2) {
+                    var enemy = core.enemys.getEnemys(id1);
+                    if (core.enemys.hasSpecial(enemy.special, 16)) {
+                        has = true;
+                    }
+                }
+            }
+            if (y>0 && y<12) {
+                var id1=core.status.checkBlock.map[13*x+y-1],
+                    id2=core.status.checkBlock.map[13*x+y+1];
+                if (core.isset(id1) && core.isset(id2) && id1==id2) {
+                    var enemy = core.enemys.getEnemys(id1);
+                    if (core.enemys.hasSpecial(enemy.special, 16)) {
+                        has = true;
+                    }
+                }
+            }
+            // 存在夹击
+            if (has) {
+                core.status.checkBlock.betweenAttack[13*x+y]=true;
+                var leftHp = core.status.hero.hp - core.status.checkBlock.damage[13*x+y];
+                if (leftHp>1)
+                    core.status.checkBlock.damage[13*x+y] += parseInt((leftHp+1)/2);
+            }
         }
     }
 }
 
+////// 检查并执行领域、夹击、阻击事件 //////
 core.prototype.checkBlock = function () {
-    // 检查领域、夹击事件
     var x=core.getHeroLoc('x'), y=core.getHeroLoc('y');
-    if (core.status.checkBlock[13*x+y]>0) {
-        core.status.hero.hp -= core.status.checkBlock[13*x+y];
-        if (core.hasBetweenAttack(x,y)) {
+    var damage = core.status.checkBlock.damage[13*x+y];
+    if (damage>0) {
+        core.status.hero.hp -= damage;
+
+        // 检查阻击事件
+        var snipe = [];
+        var scan = {
+            'up': {'x': 0, 'y': -1},
+            'left': {'x': -1, 'y': 0},
+            'down': {'x': 0, 'y': 1},
+            'right': {'x': 1, 'y': 0}
+        }
+        for (var direction in scan) {
+            var nx = x+scan[direction].x, ny=y+scan[direction].y;
+            if (nx<0 || nx>12 || ny<0 || ny>12) continue;
+            var id=core.status.checkBlock.map[13*nx+ny];
+            if (core.isset(id)) {
+                var enemy = core.enemys.getEnemys(id);
+                if (core.isset(enemy) && core.enemys.hasSpecial(enemy.special, 18)) {
+                    snipe.push({'direction': direction, 'x': nx, 'y': ny});
+                }
+            }
+        }
+
+        if (core.status.checkBlock.betweenAttack[13*x+y] && damage>0) {
             core.drawTip('受到夹击，生命变成一半');
         }
-        else if (core.hasZone(x,y)) {
-            core.drawTip('受到领域伤害'+core.status.checkBlock[13*x+y]+'点');
+        // 阻击
+        else if (snipe.length>0 && damage>0) {
+            core.drawTip('受到阻击伤害'+damage+'点');
+        }
+        else if (damage>0) {
+            core.drawTip('受到领域伤害'+damage+'点');
         }
         if (core.status.hero.hp<=0) {
             core.status.hero.hp=0;
@@ -2415,43 +2691,127 @@ core.prototype.checkBlock = function () {
             core.events.lose('zone');
             return;
         }
+        snipe = snipe.filter(function (t) {
+            var x=t.x, y=t.y, direction = t.direction;
+            var nx = x+scan[direction].x, ny=y+scan[direction].y;
+
+            return nx>=0 && nx<=12 && ny>=0 && ny<=12 && core.getBlock(nx, ny, core.status.floorId, false)==null;
+        });
         core.updateStatusBar();
+        if (snipe.length>0)
+            core.snipe(snipe);
     }
 }
 
-core.prototype.hasZone = function (x,y) {
-    if (!core.isset(core.status.checkBlockMap)) core.updateCheckBlockMap();
-    var isZone = false;
-    // 领域
-    [[-1,0],[0,-1],[1,0],[0,1]].forEach(function (dir) {
-        var nx = x+dir[0], ny = y+dir[1];
-        if (nx<0 || nx>12 || ny<0 || ny>12) return;
-        if (core.status.checkBlockMap[13*nx+ny]%1000000>0) {
-            isZone = true;
-        }
-    })
-    return isZone;
-}
-
-core.prototype.hasBetweenAttack = function(x,y) {
-    if (!core.isset(core.status.checkBlockMap)) core.updateCheckBlockMap();
-    // 夹击
-    if (x>0 && x<12) {
-        var id1=parseInt(core.status.checkBlockMap[13*(x-1)+y]/1000000),
-            id2=parseInt(core.status.checkBlockMap[13*(x+1)+y]/1000000);
-        if (id1>0 && id1==id2)
-            return true;
-    }
-    if (y>0 && y<12) {
-        var id1=parseInt(core.status.checkBlockMap[13*x+y-1]/1000000),
-            id2=parseInt(core.status.checkBlockMap[13*x+y+1]/1000000);
-        if (id1>0 && id1==id2)
-            return true;
-    }
+////// 阻击事件（动画效果） //////
+core.prototype.snipe = function (snipes) {
+    core.waitHeroToStop(function() {
+        core.lockControl();
+
+        var scan = {
+            'up': {'x': 0, 'y': -1},
+            'left': {'x': -1, 'y': 0},
+            'down': {'x': 0, 'y': 1},
+            'right': {'x': 1, 'y': 0}
+        };
+
+        snipes.forEach(function (snipe) {
+            var x=snipe.x, y=snipe.y, direction = snipe.direction;
+            snipe.nx = x+scan[snipe.direction].x;
+            snipe.ny = y+scan[snipe.direction].y;
+
+            core.removeGlobalAnimate(x, y);
+
+            var block = core.getBlock(x,y).block;
+
+            snipe.blockIcon = core.material.icons[block.event.cls][block.event.id];
+            snipe.blockImage = core.material.images[block.event.cls];
+            var damage = core.enemys.getDamage(block.event.id);
+
+            var color = "#000000";
+            if (damage <= 0) color = '#00FF00';
+            else if (damage < core.status.hero.hp / 3) color = '#FFFFFF';
+            else if (damage < core.status.hero.hp * 2 / 3) color = '#FFFF00';
+            else if (damage < core.status.hero.hp) color = '#FF7F00';
+            else color = '#FF0000';
+
+            if (damage >= 999999999) damage = "???";
+            else if (damage > 100000) damage = (damage / 10000).toFixed(1) + "w";
+
+            snipe.damage = damage;
+            snipe.color = color;
+            snipe.block = core.clone(block);
+        })
+
+        var time = 500, step = 0;
+
+        var animateValue = 2;
+        var animateCurrent = 0;
+        var animateTime = 0;
+
+        core.canvas.fg.textAlign = 'left';
+
+        var animate=window.setInterval(function() {
+
+            step++;
+            animateTime += time / 16;
+            if (animateTime >= core.values.animateSpeed * 2 / animateValue) {
+                animateCurrent++;
+                animateTime = 0;
+                if (animateCurrent>=animateValue) animateCurrent=0;
+            }
+
+            snipes.forEach(function (snipe) {
+                var x=snipe.x, y=snipe.y, direction = snipe.direction;
+
+                var nowX=32*x+scan[direction].x*2*step, nowY=32*y+scan[direction].y*2*step;
+
+                // 清空上一次
+                core.clearMap('event', nowX-2*scan[direction].x, nowY-2*scan[direction].y, 32, 32);
+                core.clearMap('fg', nowX-2*scan[direction].x, nowY-2*scan[direction].y, 32, 32);
+
+                core.canvas.event.drawImage(snipe.blockImage, animateCurrent*32, snipe.blockIcon*32, 32, 32, nowX, nowY, 32, 32);
+
+                if (core.hasItem('book')) {
+                    // drawFG
+                    core.setFillStyle('fg', '#000000');
+                    core.canvas.fg.fillText(snipe.damage, nowX + 2, nowY + 30);
+                    core.canvas.fg.fillText(snipe.damage, nowX, nowY + 30);
+                    core.canvas.fg.fillText(snipe.damage, nowX + 2, nowY + 32);
+                    core.canvas.fg.fillText(snipe.damage, nowX, nowY + 32);
+
+                    core.setFillStyle('fg', snipe.color);
+                    core.canvas.fg.fillText(snipe.damage, nowX + 1, nowY + 31);
+                }
+
+            })
+
+            if (step==16) { // 移动完毕
+                clearInterval(animate);
+                snipes.forEach(function (t) {
+                    core.removeBlock(t.x, t.y);
+                    var nBlock = core.clone(t.block);
+                    nBlock.x = t.nx; nBlock.y = t.ny;
+                    core.status.thisMap.blocks.push(nBlock);
+                    core.addGlobalAnimate(animateValue, 32*t.nx, 32*t.ny, t.blockIcon, t.blockImage);
+                });
+                core.syncGlobalAnimate();
+                core.updateStatusBar();
+                // 不存在自定义事件
+                if (core.status.event.id==null)
+                    core.unLockControl();
+            }
+        }, time/16);
+
+
+
+    });
 }
 
+////// 更改画面色调 //////
 core.prototype.setFg = function(color, time, callback) {
-    time = time || 750;
+    if (!core.isset(time)) time=750;
+    if (time<=0) time=0;
 
     if (!core.isset(core.status.curtainColor)) {
         core.status.curtainColor = [0,0,0,0];
@@ -2466,6 +2826,18 @@ core.prototype.setFg = function(color, time, callback) {
     if (color[3]<0) color[3]=0;
     if (color[3]>1) color[3]=1;
 
+
+    if (time==0) {
+        // 直接变色
+        var nowR = parseInt(color[0]), nowG = parseInt(color[1]), nowB = parseInt(color[2]);
+        var toRGB = "#"+((1<<24)+(nowR<<16)+(nowG<<8)+nowB).toString(16).slice(1);
+        core.dom.curtain.style.background = toRGB;
+        core.dom.curtain.style.opacity = color[3];
+        core.status.curtainColor = color;
+        if (core.isset(callback)) callback();
+        return;
+    }
+
     var step=0;
     var changeAnimate = setInterval(function() {
         step++;
@@ -2491,59 +2863,9 @@ core.prototype.setFg = function(color, time, callback) {
 
 }
 
-
-core.prototype.setHeroLoc = function (itemName, itemVal) {
-    if (itemVal == '++') {
-        core.status.hero.loc[itemName]++;
-        return;
-    }
-    else if (itemVal == '--') {
-        core.status.hero.loc[itemName]--;
-        return;
-    }
-    core.status.hero.loc[itemName] = itemVal;
-}
-
-core.prototype.getHeroLoc = function (itemName) {
-    if (!core.isset(itemName)) return core.status.hero.loc;
-    return core.status.hero.loc[itemName];
-}
-
-core.prototype.nextX = function() {
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    return core.getHeroLoc('x')+scan[core.getHeroLoc('direction')].x;
-}
-
-core.prototype.nextY = function () {
-    var scan = {
-        'up': {'x': 0, 'y': -1},
-        'left': {'x': -1, 'y': 0},
-        'down': {'x': 0, 'y': 1},
-        'right': {'x': 1, 'y': 0}
-    };
-    return core.getHeroLoc('y')+scan[core.getHeroLoc('direction')].y;
-}
-
-/**
- * 更新显伤
- */
+////// 更新全地图显伤 //////
 core.prototype.updateFg = function () {
 
-    /*
-    // 如果存在颜色
-    if (core.isset(core.status.event.data) && core.isset(core.status.event.data.currentColor)) {
-        var color=core.status.event.data.currentColor;
-        core.setAlpha('fg', color[3]);
-        core.fillRect("fg",0,0,416,416,"#"+((1<<24)+(color[0]<<16)+(color[1]<<8)+color[2]).toString(16).slice(1));
-        return;
-    }
-    */
-
     if (!core.isset(core.status.thisMap) || !core.isset(core.status.thisMap.blocks)) return;
     // 更新显伤
     var mapBlocks = core.status.thisMap.blocks;
@@ -2588,7 +2910,7 @@ core.prototype.updateFg = function () {
         core.canvas.fg.textAlign = 'center';
         for (var x=0;x<13;x++) {
             for (var y=0;y<13;y++) {
-                var damage = core.status.checkBlock[13*x+y];
+                var damage = core.status.checkBlock.damage[13*x+y];
                 if (damage>0) {
                     core.setFillStyle('fg', '#000000');
                     core.canvas.fg.fillText(damage, 32 * x + 17, 32 * (y + 1) - 13);
@@ -2604,9 +2926,7 @@ core.prototype.updateFg = function () {
     }
 }
 
-/**
- * 物品处理 start
- */
+////// 获得某个物品的个数 //////
 core.prototype.itemCount = function (itemId) {
     if (!core.isset(itemId) || !core.isset(core.material.items[itemId])) return 0;
     var itemCls = core.material.items[itemId].cls;
@@ -2614,10 +2934,12 @@ core.prototype.itemCount = function (itemId) {
     return core.isset(core.status.hero.items[itemCls][itemId]) ? core.status.hero.items[itemCls][itemId] : 0;
 }
 
+////// 是否存在某个物品 //////
 core.prototype.hasItem = function (itemId) {
     return core.itemCount(itemId) > 0;
 }
 
+////// 设置某个物品的个数 //////
 core.prototype.setItem = function (itemId, itemNum) {
     var itemCls = core.material.items[itemId].cls;
     if (itemCls == 'items') return;
@@ -2627,6 +2949,7 @@ core.prototype.setItem = function (itemId, itemNum) {
     core.status.hero.items[itemCls][itemId] = itemNum;
 }
 
+////// 删除某个物品 //////
 core.prototype.removeItem = function (itemId) {
     if (!core.hasItem(itemId)) return false;
     var itemCls = core.material.items[itemId].cls;
@@ -2638,15 +2961,18 @@ core.prototype.removeItem = function (itemId) {
     return true;
 }
 
+////// 使用某个物品 //////
 core.prototype.useItem = function (itemId) {
     core.items.useItem(itemId);
     return;
 }
 
+////// 能否使用某个物品 //////
 core.prototype.canUseItem = function (itemId) {
     return core.items.canUseItem(itemId);
 }
 
+////// 增加某个物品的个数 //////
 core.prototype.addItem = function (itemId, itemNum) {
     var itemData = core.material.items[itemId];
     var itemCls = itemData.cls;
@@ -2661,6 +2987,7 @@ core.prototype.addItem = function (itemId, itemNum) {
     core.status.hero.items[itemCls][itemId] += itemNum;
 }
 
+////// 获得面前的物品（轻按） //////
 core.prototype.getNextItem = function() {
     if (!core.status.heroStop || !core.flags.enableGentleClick) return;
     var nextX = core.nextX(), nextY = core.nextY();
@@ -2671,9 +2998,10 @@ core.prototype.getNextItem = function() {
     }
 }
 
+////// 获得某个物品 //////
 core.prototype.getItem = function (itemId, itemNum, itemX, itemY, callback) {
     // core.getItemAnimate(itemId, itemNum, itemX, itemY);
-    core.playSound('item', 'ogg');
+    core.playSound('item.ogg');
     var itemCls = core.material.items[itemId].cls;
     core.items.getItemEffect(itemId, itemNum);
     core.removeBlock(itemX, itemY);
@@ -2692,6 +3020,7 @@ core.prototype.getItem = function (itemId, itemNum, itemX, itemY, callback) {
     else if (core.isset(callback)) callback();
 }
 
+////// 左上角绘制一段提示 //////
 core.prototype.drawTip = function (text, itemIcon) {
     var textX, textY, width, height, hide = false, opacityVal = 0;
     clearInterval(core.interval.tipAnimate);
@@ -2747,6 +3076,7 @@ core.prototype.drawTip = function (text, itemIcon) {
     }, 30);
 }
 
+////// 地图中间绘制一段文字 //////
 core.prototype.drawText = function (contents, callback) {
     if (core.isset(contents)) {
         if (typeof contents == 'string') {
@@ -2789,18 +3119,19 @@ core.prototype.drawText = function (contents, callback) {
 
 /////////// 地图相关 END ///////////
 
-/**
- * 系统机制 start
- */
 
-// 替换文本中的数为实际值
+
+
+/////////// 系统机制 ///////////
+
+////// 将文字中的${和}（表达式）进行替换 //////
 core.prototype.replaceText = function (text) {
     return text.replace(/\${([^}]+)}/g, function (word, value) {
         return core.calValue(value);
     });
 }
 
-
+////// 计算表达式的值 //////
 core.prototype.calValue = function (value) {
     value=value.replace(/status:([\w\d_]+)/g, "core.getStatus('$1')");
     value=value.replace(/item:([\w\d_]+)/g, "core.itemCount('$1')");
@@ -2808,6 +3139,7 @@ core.prototype.calValue = function (value) {
     return eval(value);
 }
 
+////// 执行一个表达式的effect操作 //////
 core.prototype.doEffect = function (expression) {
     // 必须使用"+="
     var arr = expression.split("+=");
@@ -2823,6 +3155,7 @@ core.prototype.doEffect = function (expression) {
     }
 }
 
+////// 字符串自动换行的分割 //////
 core.prototype.splitLines = function(canvas, text, maxLength, font) {
     if (core.isset(font)) core.setFont(canvas, font);
 
@@ -2847,6 +3180,7 @@ core.prototype.splitLines = function(canvas, text, maxLength, font) {
     return contents;
 }
 
+////// 向某个数组前插入另一个数组或元素 //////
 core.prototype.unshift = function (a,b) {
     if (!(a instanceof Array) || !core.isset(b)) return;
     if (b instanceof Array) {
@@ -2858,6 +3192,7 @@ core.prototype.unshift = function (a,b) {
     return a;
 }
 
+////// 设置本地存储 //////
 core.prototype.setLocalStorage = function(key, value) {
     try {
         localStorage.setItem(core.firstData.name + "_" + key, JSON.stringify(value));
@@ -2868,16 +3203,20 @@ core.prototype.setLocalStorage = function(key, value) {
         return false;
     }
 }
+
+////// 获得本地存储 //////
 core.prototype.getLocalStorage = function(key, defaultValue) {
     var value = localStorage.getItem(core.firstData.name+"_"+key);
     if (core.isset(value)) return JSON.parse(value);
     return defaultValue;
 }
 
+////// 移除本地存储 //////
 core.prototype.removeLocalStorage = function (key) {
     localStorage.removeItem(core.firstData.name+"_"+key);
 }
 
+////// 深拷贝一个对象 //////
 core.prototype.clone = function (data) {
     if (!core.isset(data)) return data;
     // date
@@ -2912,25 +3251,19 @@ core.prototype.clone = function (data) {
     return data;
 }
 
+////// 格式化时间为字符串 //////
 core.prototype.formatDate = function(date) {
     if (!core.isset(date)) return "";
     return date.getFullYear()+"-"+core.setTwoDigits(date.getMonth()+1)+"-"+core.setTwoDigits(date.getDate())+" "
         +core.setTwoDigits(date.getHours())+":"+core.setTwoDigits(date.getMinutes())+":"+core.setTwoDigits(date.getSeconds());
 }
 
+////// 两位数显示 //////
 core.prototype.setTwoDigits = function (x) {
     return parseInt(x)<10?"0"+x:x;
 }
 
-core.prototype.win = function(reason) {
-    core.events.win(reason);
-}
-
-core.prototype.lose = function(reason) {
-    core.events.lose(reason);
-}
-
-// 作弊
+////// 作弊 //////
 core.prototype.debug = function() {
     core.setStatus('hp', 999999);
     core.setStatus('atk', 10000);
@@ -2950,9 +3283,10 @@ core.prototype.debug = function() {
     core.drawTip("作弊成功");
 }
 
-core.prototype.checkStatus = function (name, need, item, clearData) {
+////// 判断当前能否进入某个事件 //////
+core.prototype.checkStatus = function (name, need, item) {
     if (need && core.status.event.id == name) {
-        core.ui.closePanel(clearData);
+        core.ui.closePanel();
         return false;
     }
 
@@ -2972,12 +3306,14 @@ core.prototype.checkStatus = function (name, need, item, clearData) {
     return true;
 }
 
+////// 点击怪物手册时的打开操作 //////
 core.prototype.openBook = function (need) {
-    if (!core.checkStatus('book', need, true, true))
+    if (!core.checkStatus('book', need, true))
         return;
     core.useItem('book');
 }
 
+////// 点击楼层传送器时的打开操作 //////
 core.prototype.useFly = function (need) {
     if (!core.checkStatus('fly', need, true))
         return;
@@ -2999,18 +3335,21 @@ core.prototype.useFly = function (need) {
     return;
 }
 
+////// 点击工具栏时的打开操作 //////
 core.prototype.openToolbox = function (need) {
     if (!core.checkStatus('toolbox', need))
         return;
     core.ui.drawToolbox();
 }
 
+////// 点击保存按钮时的打开操作 //////
 core.prototype.save = function(need) {
     if (!core.checkStatus('save', need))
         return;
     core.ui.drawSLPanel(core.status.saveIndex);
 }
 
+////// 点击读取按钮时的打开操作 //////
 core.prototype.load = function (need) {
 
     // 游戏开始前读档
@@ -3027,6 +3366,7 @@ core.prototype.load = function (need) {
     core.ui.drawSLPanel(core.status.saveIndex);
 }
 
+////// 实际进行存读档事件 //////
 core.prototype.doSL = function (id, type) {
     core.status.saveIndex=id;
     if (type=='save') {
@@ -3060,6 +3400,7 @@ core.prototype.doSL = function (id, type) {
     }
 }
 
+////// 存档同步操作 //////
 core.prototype.syncSave = function(type) {
     if (type=='save') {
         core.status.event.selection=1;
@@ -3188,6 +3529,7 @@ core.prototype.syncSave = function(type) {
 
 }
 
+////// 存档到本地 //////
 core.prototype.saveData = function(dataId) {
     var data = {
         'floorId': core.status.floorId,
@@ -3210,6 +3552,7 @@ core.prototype.saveData = function(dataId) {
     return core.setLocalStorage(dataId, data);
 }
 
+////// 从本地读档 //////
 core.prototype.loadData = function (data, callback) {
 
     core.resetStatus(data.hero, data.hard, data.floorId, core.maps.load(data.maps));
@@ -3228,24 +3571,29 @@ core.prototype.loadData = function (data, callback) {
     });
 }
 
+////// 设置勇士属性 //////
 core.prototype.setStatus = function (statusName, statusVal) {
     core.status.hero[statusName] = statusVal;
 }
 
+////// 获得勇士属性 //////
 core.prototype.getStatus = function (statusName) {
     return core.status.hero[statusName];
 }
 
+////// 获得某个等级的名称 //////
 core.prototype.getLvName = function () {
     if (core.status.hero.lv>core.firstData.levelUp.length) return core.status.hero.lv;
     return core.firstData.levelUp[core.status.hero.lv-1].name || core.status.hero.lv;
 }
 
+////// 设置某个自定义变量或flag //////
 core.prototype.setFlag = function(flag, value) {
     if (!core.isset(core.status.hero)) return;
     core.status.hero.flags[flag]=value;
 }
 
+////// 获得某个自定义变量或flag //////
 core.prototype.getFlag = function(flag, defaultValue) {
     if (!core.isset(core.status.hero)) return defaultValue;
     var value = core.status.hero.flags[flag];
@@ -3253,24 +3601,28 @@ core.prototype.getFlag = function(flag, defaultValue) {
     return defaultValue;
 }
 
-// 只有不为0或false时才会返回true
+////// 是否存在某个自定义变量或flag，且值为true //////
 core.prototype.hasFlag = function(flag) {
     if (core.getFlag(flag)) return true;
     return false;
 }
 
+////// 往当前事件列表之前插入一系列事件 //////
 core.prototype.insertAction = function (list) {
     core.events.insertAction(list);
 }
 
+////// 锁定状态栏，常常用于事件处理 //////
 core.prototype.lockControl = function () {
     core.status.lockControl = true;
 }
 
+////// 解锁状态栏 //////
 core.prototype.unLockControl = function () {
     core.status.lockControl = false;
 }
 
+////// 判断某对象是否不为undefined也不会null //////
 core.prototype.isset = function (val) {
     if (val == undefined || val == null) {
         return false;
@@ -3278,46 +3630,117 @@ core.prototype.isset = function (val) {
     return true
 }
 
-core.prototype.playSound = function (soundName, soundType) {
-    if (!core.musicStatus.soundStatus || !core.musicStatus.loaded) {
+////// 播放背景音乐 //////
+core.prototype.playBgm = function (bgm) {
+
+    // 如果不允许播放
+    if (!core.musicStatus.bgmStatus) return;
+    // 音频不存在
+    if (!core.isset(core.material.bgms[bgm])) return;
+
+    // 延迟播放
+    if (core.material.bgms[bgm] == 'loading') {
+        core.material.bgms[bgm] = 'starting';
         return;
     }
-    if (!core.isset(core.material.sounds[soundType][soundName])) return;
-    core.musicStatus.playedSound = core.material.sounds[soundType][soundName];
-    core.musicStatus.playedSound.play();
-}
 
-core.prototype.playBgm = function (bgmName, bgmType) {
-    if (core.musicStatus.isIOS || !core.musicStatus.loaded) return;
-    if (core.isset(core.musicStatus.playedBgm)) {
-        core.musicStatus.playedBgm.pause();
-    }
-    core.musicStatus.playedBgm = core.material.sounds[bgmType][bgmName];
-    if (core.musicStatus.soundStatus)
-        core.musicStatus.playedBgm.play();
-}
+    try {
+        // 如果当前正在播放，且和本BGM相同，直接忽略
+        if (core.musicStatus.playingBgm == bgm && core.musicStatus.isPlaying) {
+            return;
+        }
+        // 如果正在播放中，暂停
+        if (core.isset(core.musicStatus.playingBgm) && core.musicStatus.isPlaying) {
+            core.material.bgms[core.musicStatus.playingBgm].pause();
+        }
+        // 播放当前BGM
+        core.musicStatus.playingBgm = bgm;
+        core.material.bgms[bgm].play();
+        core.musicStatus.isPlaying = true;
 
-core.prototype.changeSoundStatus = function () {
-    if (core.musicStatus.soundStatus) {
-        main.core.disabledSound();
     }
-    else {
-        main.core.enabledSound();
+    catch (e) {
+        console.log("无法播放BGM "+bgm);
+        console.log(e);
+        core.musicStatus.playingBgm = null;
     }
 }
 
-core.prototype.enabledSound = function () {
-    core.musicStatus.soundStatus = true;
-    core.playBgm('bgm', 'mp3');
-    core.setLocalStorage('soundStatus', true);
+////// 暂停背景音乐的播放 //////
+core.prototype.pauseBgm = function () {
+    // 直接暂停播放
+    try {
+        if (core.isset(core.musicStatus.playingBgm)) {
+            core.material.bgms[core.musicStatus.playingBgm].pause();
+        }
+        core.musicStatus.isPlaying = false;
+    }
+    catch (e) {
+        console.log("无法暂停BGM "+bgm);
+        console.log(e);
+    }
 }
 
-core.prototype.disabledSound = function () {
-    core.musicStatus.playedBgm.pause();
-    core.musicStatus.soundStatus = false;
-    core.setLocalStorage('soundStatus', false);
+////// 恢复背景音乐的播放 //////
+core.prototype.resumeBgm = function () {
+
+    // 如果不允许播放
+    if (!core.musicStatus.bgmStatus) return;
+
+    // 恢复BGM
+    try {
+        if (core.isset(core.musicStatus.playingBgm)) {
+            core.material.bgms[core.musicStatus.playingBgm].play();
+            core.musicStatus.isPlaying = true;
+        }
+        else {
+            if (core.bgms.length>0) {
+                core.playBgm(core.bgms[0]);
+                core.musicStatus.isPlaying = true;
+            }
+        }
+    }
+    catch (e) {
+        console.log("无法恢复BGM "+bgm);
+        console.log(e);
+    }
 }
 
+////// 播放音频 //////
+core.prototype.playSound = function (sound) {
+
+    // 如果不允许播放
+    if (!core.musicStatus.soundStatus) return;
+    // 音频不存在
+    if (!core.isset(core.material.sounds[sound])) return;
+
+    try {
+        if (core.musicStatus.audioContext != null) {
+            var source = core.musicStatus.audioContext.createBufferSource();
+            source.buffer = core.material.sounds[sound];
+            source.connect(core.musicStatus.audioContext.destination);
+            try {
+                source.start(0);
+            }
+            catch (e) {
+                try {
+                    source.noteOn(0);
+                }
+                catch (ee) {
+                }
+            }
+        }
+        else {
+            core.material.sounds[sound].play();
+        }
+    }
+    catch (eee) {
+        console.log("无法播放SE "+bgm);
+        console.log(eee);
+    }
+}
+
+////// 动画显示某对象 //////
 core.prototype.show = function (obj, speed, callback) {
     if (!core.isset(speed)) {
         obj.style.display = 'block';
@@ -3338,6 +3761,7 @@ core.prototype.show = function (obj, speed, callback) {
     }, speed);
 }
 
+////// 动画使某对象消失 //////
 core.prototype.hide = function (obj, speed, callback) {
     if (!core.isset(speed)) {
         obj.style.display = 'none';
@@ -3358,8 +3782,7 @@ core.prototype.hide = function (obj, speed, callback) {
 }
 
 
-////// 状态栏相关 //////
-
+////// 清空状态栏 //////
 core.prototype.clearStatusBar = function() {
     var statusList = ['floor', 'lv', 'hp', 'atk', 'def', 'mdef', 'money', 'experience', 'up', 'yellowKey', 'blueKey', 'redKey', 'poison', 'weak', 'curse', 'hard'];
     statusList.forEach(function (e) {
@@ -3369,19 +3792,20 @@ core.prototype.clearStatusBar = function() {
     core.statusBar.image.fly.style.opacity = 0.3;
 }
 
-/**
- * 更新状态栏
- */
+////// 更新状态栏 //////
 core.prototype.updateStatusBar = function () {
 
-    // 检查登记
-    core.checkLvUp();
+    // 检查等级
+    core.events.checkLvUp();
 
-    // 上限999999
+    // 检查HP上限
     if (core.values.HPMAX>0) {
         core.setStatus('hp', Math.min(core.values.HPMAX, core.getStatus('hp')));
     }
 
+    // 更新领域、阻击、显伤
+    core.updateCheckBlock();
+
     var lvName = core.getLvName();
     core.statusBar.lv.innerHTML = lvName;
     if (/^[+-]?\d+$/.test(lvName))
@@ -3419,31 +3843,10 @@ core.prototype.updateStatusBar = function () {
     } else {
         core.statusBar.image.fly.style.opacity = 0.3;
     }
-    core.updateCheckBlock();
     core.updateFg();
 }
 
-core.prototype.checkLvUp = function () {
-    if (!core.flags.enableLevelUp || core.status.hero.lv>=core.firstData.levelUp.length) return;
-    // 计算下一个所需要的数值
-    var need=core.firstData.levelUp[core.status.hero.lv].need;
-    if (!core.isset(need)) return;
-    if (core.status.hero.experience>=need) {
-        // 升级
-        core.status.hero.lv++;
-        var effect = core.firstData.levelUp[core.status.hero.lv-1].effect;
-        if (typeof effect == "string") {
-            effect.split(";").forEach(function (t) {
-                core.doEffect(t);
-            });
-        }
-        else if (effect instanceof Function) {
-            effect();
-        }
-        core.checkLvUp();
-    }
-}
-
+////// 屏幕分辨率改变后重新自适应 //////
 core.prototype.resize = function(clientWidth, clientHeight) {
     if (main.mode=='editor')return;
 
@@ -3632,8 +4035,8 @@ core.prototype.resize = function(clientWidth, clientHeight) {
             id: 'floorMsgGroup',
             rules:{
                 width: (canvasWidth - SPACE*2) + unit,
-                height:(canvasWidth - SPACE*2) + unit,
-                top: (canvasTop + SPACE) + unit,
+                height: (gameGroupHeight - SPACE*2) + unit,
+                top: SPACE + unit,
                 right: SPACE + unit,
             }
         },
@@ -3749,6 +4152,7 @@ core.prototype.resize = function(clientWidth, clientHeight) {
     core.domRenderer();
 }
 
+////// 渲染DOM //////
 core.prototype.domRenderer = function(){
 
     core.dom.statusBar.style.display = 'block';
diff --git a/libs/enemys.js b/libs/enemys.js
index 56b4de1c..f98e73c7 100644
--- a/libs/enemys.js
+++ b/libs/enemys.js
@@ -2,33 +2,38 @@ function enemys() {
 
 }
 
+////// 初始化 //////
 enemys.prototype.init = function () {
     // 怪物属性初始化定义：
     this.enemys = enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80;
     delete(enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80);
 }
 
+////// 获得一个或所有怪物数据 //////
 enemys.prototype.getEnemys = function (enemyId) {
-    if (enemyId == undefined) {
+    if (!core.isset(enemyId)) {
         return this.enemys;
     }
     return this.enemys[enemyId];
 }
 
+////// 判断是否含有某特殊属性 //////
 enemys.prototype.hasSpecial = function (special, test) {
     return (special instanceof Array)?special.indexOf(test)>=0:(special!=0&&(special%100==test||this.hasSpecial(parseInt(special/100), test)));
 }
 
+////// 获得所有特殊属性的名称 //////
 enemys.prototype.getSpecialText = function (enemyId) {
     if (enemyId == undefined) return "";
-    var special = this.enemys[enemyId].special;
+    var enemy = this.enemys[enemyId];
+    var special = enemy.special;
     var text = [];
     if (this.hasSpecial(special, 1)) text.push("先攻");
     if (this.hasSpecial(special, 2)) text.push("魔攻");
     if (this.hasSpecial(special, 3)) text.push("坚固");
     if (this.hasSpecial(special, 4)) text.push("2连击");
     if (this.hasSpecial(special, 5)) text.push("3连击");
-    if (this.hasSpecial(special, 6)) text.push("4连击");
+    if (this.hasSpecial(special, 6)) text.push((enemy.n||4)+"连击");
     if (this.hasSpecial(special, 7)) text.push("破甲");
     if (this.hasSpecial(special, 8)) text.push("反击");
     if (this.hasSpecial(special, 9)) text.push("净化");
@@ -40,18 +45,63 @@ enemys.prototype.getSpecialText = function (enemyId) {
     if (this.hasSpecial(special, 15)) text.push("领域");
     if (this.hasSpecial(special, 16)) text.push("夹击");
     if (this.hasSpecial(special, 17)) text.push("仇恨");
-    return text.join("  ");
+    if (this.hasSpecial(special, 18)) text.push("阻击");
+    if (this.hasSpecial(special, 19)) text.push("自爆");
+    if (this.hasSpecial(special, 20)) text.push("无敌");
+    return text;
 }
 
+////// 获得每个特殊属性的说明 //////
+enemys.prototype.getSpecialHint = function (enemy, special) {
+    if (!core.isset(special)) {
+        var hints = [];
+        for (var i=1;i<100;i++) {
+            if (this.hasSpecial(enemy.special, i)) {
+                var hint=this.getSpecialHint(enemy, i);
+                if (hint!='')
+                    hints.push(hint);
+            }
+        }
+        return hints;
+    }
+
+    switch (special) {
+        case 1: return "先攻：怪物首先攻击";
+        case 2: return "魔攻：怪物无视勇士的魔防";
+        case 3: return "坚固：勇士每回合最多只能对怪物造成1点伤害";
+        case 4: return "2连击：怪物每回合攻击2次";
+        case 5: return "3连击：怪物每回合攻击3次";
+        case 6: return (enemy.n||4)+"连击： 怪物每回合攻击"+(enemy.n||4)+"次";
+        case 7: return "破甲：战斗前，怪物附加角色防御的"+parseInt(100*core.values.breakArmor)+"%作为伤害";
+        case 8: return "反击：战斗时，怪物每回合附加角色攻击的"+parseInt(100*core.values.counterAttack)+"%作为伤害，无视角色防御";
+        case 9: return "净化：战斗前，怪物附加勇士魔防的"+core.values.purify+"倍作为伤害";
+        case 10: return "模仿：怪物的攻防和勇士攻防相等";
+        case 11: return "吸血：战斗前，怪物首先吸取角色的"+parseInt(100*enemy.value)+"%生命作为伤害";
+        case 12: return "中毒：战斗后，勇士陷入中毒状态，每一步损失生命"+core.values.poisonDamage+"点";
+        case 13: return "衰弱：战斗后，勇士陷入衰弱状态，攻防暂时下降"+core.values.weakValue+"点";
+        case 14: return "诅咒：战斗后，勇士陷入诅咒状态，战斗无法获得金币和经验";
+        case 15: return "领域：经过怪物周围"+(enemy.range||1)+"格时自动减生命"+enemy.value+"点";
+        case 16: return "夹击：经过两只相同的怪物中间，勇士生命值变成一半";
+        case 17: return "仇恨：战斗前，怪物附加之前积累的仇恨值作为伤害；战斗后，释放一半的仇恨值。（每杀死一个怪物获得"+core.values.hatred+"点仇恨值）";
+        case 18: return "阻击：经过怪物的十字领域时自动减生命"+enemy.value+"点，同时怪物后退一格";
+        case 19: return "自爆：战斗后勇士的生命值变成1";
+        case 20: return "无敌：勇士无法打败怪物，除非拥有十字架";
+        default: break;
+    }
+    return ""
+}
+
+////// 获得某个怪物的伤害 //////
 enemys.prototype.getDamage = function (monsterId) {
     var monster = core.material.enemys[monsterId];
     var hero_atk = core.status.hero.atk, hero_def = core.status.hero.def, hero_mdef = core.status.hero.mdef;
     var mon_hp = monster.hp, mon_atk = monster.atk, mon_def = monster.def, mon_special = monster.special;
-    var damage = this.calDamage(hero_atk, hero_def, hero_mdef, mon_hp, mon_atk, mon_def, mon_special);
+    var damage = this.calDamage(hero_atk, hero_def, hero_mdef, mon_hp, mon_atk, mon_def, mon_special, monster.n);
     if (damage == 999999999) return damage;
     return damage + this.getExtraDamage(monster);
 }
 
+////// 获得某个怪物的额外伤害 //////
 enemys.prototype.getExtraDamage = function (monster) {
     var extra_damage = 0;
     if (this.hasSpecial(monster.special, 11)) { // 吸血
@@ -65,17 +115,17 @@ enemys.prototype.getExtraDamage = function (monster) {
     return extra_damage;
 }
 
-// 临界值计算
+////// 临界值计算 //////
 enemys.prototype.getCritical = function (monsterId) {
     var monster = core.material.enemys[monsterId];
     if (this.hasSpecial(monster.special, 3) || this.hasSpecial(monster.special, 10)) return "???";
     var last = this.calDamage(core.status.hero.atk, core.status.hero.def, core.status.hero.mdef,
-        monster.hp, monster.atk, monster.def, monster.special);
+        monster.hp, monster.atk, monster.def, monster.special, monster.n);
     if (last <= 0) return 0;
 
     for (var i = core.status.hero.atk + 1; i <= monster.hp + monster.def; i++) {
         var damage = this.calDamage(i, core.status.hero.def, core.status.hero.mdef,
-            monster.hp, monster.atk, monster.def, monster.special);
+            monster.hp, monster.atk, monster.def, monster.special, monster.n);
         if (damage < last)
             return i - core.status.hero.atk;
         last = damage;
@@ -83,39 +133,46 @@ enemys.prototype.getCritical = function (monsterId) {
     return 0;
 }
 
-// 临界减伤计算
+////// 临界减伤计算 //////
 enemys.prototype.getCriticalDamage = function (monsterId) {
     var c = this.getCritical(monsterId);
     if (c == '???') return '???';
     if (c <= 0) return 0;
     var monster = core.material.enemys[monsterId];
     var last = this.calDamage(core.status.hero.atk, core.status.hero.def, core.status.hero.mdef,
-        monster.hp, monster.atk, monster.def, monster.special);
+        monster.hp, monster.atk, monster.def, monster.special, monster.n);
     if (last == 999999999) return '???';
 
     return last - this.calDamage(core.status.hero.atk + c, core.status.hero.def, core.status.hero.mdef,
-        monster.hp, monster.atk, monster.def, monster.special);
+        monster.hp, monster.atk, monster.def, monster.special, monster.n);
 }
 
-// 1防减伤计算
+////// 1防减伤计算 //////
 enemys.prototype.getDefDamage = function (monsterId) {
     var monster = core.material.enemys[monsterId];
-    return this.calDamage(core.status.hero.atk, core.status.hero.def, core.status.hero.mdef,
-        monster.hp, monster.atk, monster.def, monster.special) -
-        this.calDamage(core.status.hero.atk, core.status.hero.def + 1, core.status.hero.mdef,
-            monster.hp, monster.atk, monster.def, monster.special)
+    var nowDamage = this.calDamage(core.status.hero.atk, core.status.hero.def, core.status.hero.mdef,
+        monster.hp, monster.atk, monster.def, monster.special, monster.n);
+    var nextDamage = this.calDamage(core.status.hero.atk, core.status.hero.def + 1, core.status.hero.mdef,
+        monster.hp, monster.atk, monster.def, monster.special, monster.n);
+    if (nowDamage == 999999999 || nextDamage == 999999999) return "???";
+    return nowDamage - nextDamage;
 }
 
-enemys.prototype.calDamage = function (hero_atk, hero_def, hero_mdef, mon_hp, mon_atk, mon_def, mon_special) {
-    // 魔攻
-    if (this.hasSpecial(mon_special,2)) hero_def = 0;
-    // 坚固
-    if (this.hasSpecial(mon_special,3) && mon_def < hero_atk - 1) mon_def = hero_atk - 1;
+////// 具体的伤害计算公式 //////
+enemys.prototype.calDamage = function (hero_atk, hero_def, hero_mdef, mon_hp, mon_atk, mon_def, mon_special, n) {
+
+    if (this.hasSpecial(mon_special, 20) && !core.hasItem("cross")) // 如果是无敌属性，且勇士未持有十字架
+        return 999999999; // 返回无限大
+
     // 模仿
     if (this.hasSpecial(mon_special,10)) {
         mon_atk = hero_atk;
         mon_def = hero_def;
     }
+    // 魔攻
+    if (this.hasSpecial(mon_special,2)) hero_def = 0;
+    // 坚固
+    if (this.hasSpecial(mon_special,3) && mon_def < hero_atk - 1) mon_def = hero_atk - 1;
     if (hero_atk <= mon_def) return 999999999; // 不可战斗时请直接返回999999999
 
     var per_damage = mon_atk - hero_def;
@@ -124,7 +181,7 @@ enemys.prototype.calDamage = function (hero_atk, hero_def, hero_mdef, mon_hp, mo
 
     if (this.hasSpecial(mon_special, 4)) per_damage *= 2;
     if (this.hasSpecial(mon_special, 5)) per_damage *= 3;
-    if (this.hasSpecial(mon_special, 6)) per_damage *= 4;
+    if (this.hasSpecial(mon_special, 6)) per_damage *= (n||4);
 
     var counterDamage = 0;
     // 反击
@@ -144,7 +201,7 @@ enemys.prototype.calDamage = function (hero_atk, hero_def, hero_mdef, mon_hp, mo
     return core.flags.enableNegativeDamage?ans:Math.max(0, ans);
 }
 
-// 获得当前楼层的怪物列表
+////// 获得当前楼层的怪物列表 //////
 enemys.prototype.getCurrentEnemys = function () {
     var enemys = [];
     var used = {};
@@ -164,6 +221,10 @@ enemys.prototype.getCurrentEnemys = function () {
                 mon_def=core.status.hero.def;
             }
 
+            var specialText = core.enemys.getSpecialText(monsterId);
+            if (specialText.length>=3) specialText = "多属性...";
+            else specialText = specialText.join("  ");
+
             enemys.push({
                 'id': monsterId,
                 'name': monster.name,
@@ -172,7 +233,7 @@ enemys.prototype.getCurrentEnemys = function () {
                 'def': mon_def,
                 'money': monster.money,
                 'experience': monster.experience,
-                'special': core.enemys.getSpecialText(monsterId),
+                'special': specialText,
                 'damage': this.getDamage(monsterId),
                 'critical': this.getCritical(monsterId),
                 'criticalDamage': this.getCriticalDamage(monsterId),
diff --git a/libs/events.js b/libs/events.js
index 26d62ac6..cf66d51e 100644
--- a/libs/events.js
+++ b/libs/events.js
@@ -2,6 +2,7 @@ function events() {
 
 }
 
+////// 初始化 //////
 events.prototype.init = function () {
     this.events = {
         'battle': function (data, core, callback) {
@@ -45,9 +46,9 @@ events.prototype.init = function () {
     }
 }
 
-// 初始化
+////// 获得一个或所有系统事件类型 //////
 events.prototype.getEvents = function (eventName) {
-    if (eventName == undefined) {
+    if (!core.isset(eventName)) {
         return this.events;
     }
     return this.events[eventName];
@@ -87,12 +88,14 @@ events.prototype.startGame = function (hard) {
     })
 }
 
-////// 简单难度设置初始福利 //////
+////// 不同难度分别设置初始属性 //////
 events.prototype.setInitData = function (hard) {
     if (hard=='Easy') { // 简单难度
         core.setFlag('hard', 1); // 可以用flag:hard来获得当前难度
         // 可以在此设置一些初始福利，比如设置初始生命值可以调用：
         // core.setStatus("hp", 10000);
+        // 赠送一把黄钥匙可以调用
+        // core.setItem("yellowKey", 1);
     }
     if (hard=='Normal') { // 普通难度
         core.setFlag('hard', 2); // 可以用flag:hard来获得当前难度
@@ -102,9 +105,8 @@ events.prototype.setInitData = function (hard) {
     }
 }
 
-////// 游戏结束事件 //////
+////// 游戏获胜事件 //////
 events.prototype.win = function(reason) {
-    // 获胜
     core.waitHeroToStop(function() {
         core.removeGlobalAnimate(0,0,true);
         core.clearMap('all'); // 清空全地图
@@ -116,8 +118,8 @@ events.prototype.win = function(reason) {
     });
 }
 
+////// 游戏失败事件 //////
 events.prototype.lose = function(reason) {
-    // 失败
     core.waitHeroToStop(function() {
         core.drawText([
             "\t[结局1]你死了。\n如题。"
@@ -135,7 +137,7 @@ events.prototype.afterChangeFloor = function (floorId) {
     }
 }
 
-////// 实际事件的处理 //////
+////// 开始执行一系列自定义事件 //////
 events.prototype.doEvents = function (list, x, y, callback) {
     // 停止勇士
     core.waitHeroToStop(function() {
@@ -151,6 +153,7 @@ events.prototype.doEvents = function (list, x, y, callback) {
     });
 }
 
+////// 执行当前自定义事件列表中的下一个事件 //////
 events.prototype.doAction = function() {
     // 清空boxAnimate和UI层
     clearInterval(core.interval.boxAnimate);
@@ -161,7 +164,7 @@ events.prototype.doAction = function() {
     if (core.status.event.data.list.length==0) {
         if (core.isset(core.status.event.data.callback))
             core.status.event.data.callback();
-        core.ui.closePanel(false);
+        core.ui.closePanel();
         return;
     }
 
@@ -190,12 +193,12 @@ events.prototype.doAction = function() {
         case "show": // 显示
             if (core.isset(data.time) && data.time>0 && (!core.isset(data.floorId) || data.floorId==core.status.floorId)) {
                 core.animateBlock(data.loc[0],data.loc[1],'show', data.time, function () {
-                    core.addBlock(data.loc[0],data.loc[1],data.floorId);
+                    core.showBlock(data.loc[0],data.loc[1],data.floorId);
                     core.events.doAction();
                 });
             }
             else {
-                core.addBlock(data.loc[0],data.loc[1],data.floorId)
+                core.showBlock(data.loc[0],data.loc[1],data.floorId)
                 this.doAction();
             }
             break;
@@ -285,11 +288,6 @@ events.prototype.doAction = function() {
                 block = block.block;
                 if (core.isset(block.event) && block.event.trigger=='action') {
                     // 触发
-                    /*
-                    core.status.event = {'id': 'action', 'data': {
-                        'list': core.clone(block.event.data), 'x': block.x, 'y': block.y, 'callback': core.status.event.data.callback
-                    }}
-                    */
                     core.status.event.data.list = core.clone(block.event.data);
                     core.status.event.data.x=block.x;
                     core.status.event.data.y=block.y;
@@ -298,11 +296,21 @@ events.prototype.doAction = function() {
             this.doAction();
             break;
         case "playSound":
-            var name=data.name.split(".");
-            if (name.length==2)
-                core.playSound(name[0],name[1]);
+            core.playSound(data.name);
             this.doAction();
             break;
+        case "playBgm":
+            core.playBgm(data.name);
+            this.doAction();
+            break
+        case "pauseBgm":
+            core.pauseBgm();
+            this.doAction();
+            break
+        case "resumeBgm":
+            core.resumeBgm();
+            this.doAction();
+            break
         case "setValue":
             try {
                 var value=core.calValue(data.value);
@@ -352,8 +360,14 @@ events.prototype.doAction = function() {
             core.events.lose(data.reason);
             break;
         case "function":
-            if (core.isset(data["function"]))
-                data["function"]();
+            var func = data["function"];
+            if (core.isset(func)) {
+                if ((typeof func == "string") && func.indexOf("function")==0) {
+                    eval('('+func+')()');
+                }
+                else if (func instanceof Function)
+                    func();
+            }
             this.doAction();
             break;
         case "update":
@@ -388,10 +402,15 @@ events.prototype.doAction = function() {
 
 ////// 往当前事件列表之前添加一个或多个事件 //////
 events.prototype.insertAction = function (action) {
-    core.unshift(core.status.event.data.list, action)
+    if (core.status.event.id == null) {
+        this.doEvents(action);
+    }
+    else {
+        core.unshift(core.status.event.data.list, action)
+    }
 }
 
-////// 打开商店 //////
+////// 打开一个全局商店 //////
 events.prototype.openShop = function(shopId, needVisited) {
     var shop = core.status.shops[shopId];
     shop.times = shop.times || 0;
@@ -433,35 +452,11 @@ events.prototype.openShop = function(shopId, needVisited) {
     core.ui.drawChoices(content, choices);
 }
 
+////// 禁用一个全局商店 //////
 events.prototype.disableQuickShop = function (shopId) {
     core.status.shops[shopId].visited = false;
 }
 
-////// 降低难度 //////
-
-events.prototype.decreaseHard = function() {
-    core.drawTip("本塔不支持降低难度！");
-    /*
-    if (core.status.hard == 0) {
-        core.drawTip("当前已是难度0，不能再降低难度了");
-        return;
-    }
-    var add = 100, x=core.status.hard;
-    while (x<10) {
-        x++; add*=2;
-    }
-    core.ui.drawConfirmBox("本次操作可生命+" + add + "，确定吗？", function () {
-        core.status.hero.hp += add;
-        core.status.hard--;
-        core.updateStatusBar();
-        core.ui.closePanel();
-        core.drawTip("降低难度成功，生命+" + add);
-    }, function () {
-        core.ui.drawSettings(false);
-    });
-    */
-}
-
 ////// 能否使用快捷商店 //////
 events.prototype.canUseQuickShop = function(shopIndex) {
     if (core.isset(core.floors[core.status.floorId].canUseQuickShop) && !core.isset(core.floors[core.status.floorId].canUseQuickShop))
@@ -470,9 +465,36 @@ events.prototype.canUseQuickShop = function(shopIndex) {
     return null;
 }
 
+////// 检查升级事件 //////
+events.prototype.checkLvUp = function () {
+    if (!core.flags.enableLevelUp || core.status.hero.lv>=core.firstData.levelUp.length) return;
+    // 计算下一个所需要的数值
+    var need=core.firstData.levelUp[core.status.hero.lv].need;
+    if (!core.isset(need)) return;
+    if (core.status.hero.experience>=need) {
+        // 升级
+        core.status.hero.lv++;
+        var effect = core.firstData.levelUp[core.status.hero.lv-1].effect;
+        if (typeof effect == "string") {
+            if (effect.indexOf("function")==0) {
+                eval("("+effect+")()");
+            }
+            else {
+                effect.split(";").forEach(function (t) {
+                    core.doEffect(t);
+                });
+            }
+        }
+        else if (effect instanceof Function) {
+            effect();
+        }
+        this.checkLvUp();
+    }
+}
+
 ////// 尝试使用道具 //////
 events.prototype.useItem = function(itemId) {
-    core.ui.closePanel(false);
+    core.ui.closePanel();
 
     if (itemId=='book') {
         core.openBook(false);
@@ -495,7 +517,30 @@ events.prototype.useItem = function(itemId) {
     else core.drawTip("当前无法使用"+core.material.items[itemId].name);
 }
 
-/****** 打完怪物 ******/
+////// 加点事件 //////
+events.prototype.addPoint = function (enemy) {
+    var point = enemy.point;
+    if (!core.isset(point) || point<=0) return [];
+
+    // 加点，返回一个choices事件
+    return [
+        {"type": "choices",
+            "choices": [
+                {"text": "攻击+"+(1*point), "action": [
+                    {"type": "setValue", "name": "status:atk", "value": "status:atk+"+(1*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)}
+                ]},
+            ]
+        }
+    ];
+}
+
+////// 战斗结束后触发的事件 //////
 events.prototype.afterBattle = function(enemyId,x,y,callback) {
 
     // 毒衰咒的处理
@@ -518,50 +563,66 @@ events.prototype.afterBattle = function(enemyId,x,y,callback) {
     if (core.enemys.hasSpecial(special, 17)) {
         core.setFlag('hatred', parseInt(core.getFlag('hatred', 0)/2));
     }
+    // 自爆
+    if (core.enemys.hasSpecial(special, 19)) {
+        core.status.hero.hp = 1;
+    }
     // 增加仇恨值
     core.setFlag('hatred', core.getFlag('hatred',0)+core.values.hatred);
     core.updateStatusBar();
 
-    // 如果已有事件正在处理中
-    if (core.status.lockControl) {
-        if (core.isset(callback)) callback();
-        return;
+
+    // 事件的处理
+    var todo = [];
+    // 如果不为阻击，且该点存在，且有事件
+    if (!core.enemys.hasSpecial(special, 18) && core.isset(x) && core.isset(y)) {
+        var event = core.floors[core.status.floorId].afterBattle[x+","+y];
+        if (core.isset(event)) {
+            // 插入事件
+            core.unshift(todo, event);
+        }
+    }
+    // 如果有加点
+    var point = core.material.enemys[enemyId].point;
+    if (core.isset(point) && point>0) {
+        core.unshift(todo, core.events.addPoint(core.material.enemys[enemyId]));
     }
 
-    // 检查处理后的事件。
-    var event = core.floors[core.status.floorId].afterBattle[x+","+y];
-    if (core.isset(event)) {
-        core.events.doEvents(event, x, y, callback);
+    // 如果事件不为空，将其插入
+    if (todo.length>0) {
+        this.insertAction(todo);
     }
-    //继续行走
-    else {
+
+    // 如果已有事件正在处理中
+    if (core.status.event.id == null) {
         core.continueAutomaticRoute();
-        if (core.isset(callback)) callback();
     }
+    if (core.isset(callback)) callback();
+
 }
 
-/****** 开完门 ******/
+////// 开一个门后触发的事件 //////
 events.prototype.afterOpenDoor = function(doorId,x,y,callback) {
 
-    // 如果已有事件正在处理中
-    if (core.status.lockControl) {
-        if (core.isset(callback)) callback();
-        return;
+    var todo = [];
+    if (core.isset(x) && core.isset(y)) {
+        var event = core.floors[core.status.floorId].afterOpenDoor[x+","+y];
+        if (core.isset(event)) {
+            core.unshift(todo, event);
+        }
     }
 
-    // 检查处理后的事件。
-    var event = core.floors[core.status.floorId].afterOpenDoor[x+","+y];
-    if (core.isset(event)) {
-        core.events.doEvents(event, x, y, callback);
+    if (todo.length>0) {
+        this.insertAction(todo);
     }
-    //继续行走
-    else {
+
+    if (core.status.event.id == null) {
         core.continueAutomaticRoute();
-        if (core.isset(callback)) callback();
     }
+    if (core.isset(callback)) callback();
 }
 
-/****** 经过路障 ******/
+////// 经过一个路障 //////
 events.prototype.passNet = function (data) {
     // 有鞋子
     if (core.hasItem('shoes')) return;
@@ -592,6 +653,7 @@ events.prototype.passNet = function (data) {
     core.updateStatusBar();
 }
 
+////// 改变亮灯（感叹号）的事件 //////
 events.prototype.changeLight = function(x, y) {
     var block = core.getBlock(x, y);
     if (block==null) return;
@@ -608,26 +670,33 @@ events.prototype.changeLight = function(x, y) {
     this.afterChangeLight(x,y);
 }
 
-// 改变灯后的事件
+////// 改变亮灯之后，可以触发的事件 //////
 events.prototype.afterChangeLight = function(x,y) {
 
 }
 
-// 存档事件前一刻的处理
+////// 使用炸弹/圣锤后的事件 //////
+events.prototype.afterUseBomb = function () {
+
+
+}
+
+////// 即将存档前可以执行的操作 //////
 events.prototype.beforeSaveData = function(data) {
 
 }
 
-// 读档事件后，载入事件前，对数据的处理
+////// 读档事件后，载入事件前，可以执行的操作 //////
 events.prototype.afterLoadData = function(data) {
 
 }
 
 
-/******************************************/
-/*********** 界面上的点击事件 ***************/
-/******************************************/
+/****************************************/
+/********** 点击事件、键盘事件 ************/
+/****************************************/
 
+////// 按下Ctrl键时（快捷跳过对话） //////
 events.prototype.keyDownCtrl = function () {
     if (core.status.event.id=='text') {
         core.drawText();
@@ -639,6 +708,15 @@ events.prototype.keyDownCtrl = function () {
     }
 }
 
+////// 点击确认框时 //////
+events.prototype.clickConfirmBox = function (x,y) {
+    if ((x == 4 || x == 5) && y == 7 && core.isset(core.status.event.data.yes))
+        core.status.event.data.yes();
+    if ((x == 7 || x == 8) && y == 7 && core.isset(core.status.event.data.no))
+        core.status.event.data.no();
+}
+
+////// 键盘操作确认框时 //////
 events.prototype.keyUpConfirmBox = function (keycode) {
     if (keycode==37) {
         core.status.event.selection=0;
@@ -661,14 +739,8 @@ events.prototype.keyUpConfirmBox = function (keycode) {
         }
     }
 }
-events.prototype.clickConfirmBox = function (x,y) {
-    if ((x == 4 || x == 5) && y == 7 && core.isset(core.status.event.data.yes))
-        core.status.event.data.yes();
-    if ((x == 7 || x == 8) && y == 7 && core.isset(core.status.event.data.no))
-        core.status.event.data.no();
-}
 
-// 正在处理事件时的点击操作...
+////// 自定义事件时的点击操作 //////
 events.prototype.clickAction = function (x,y) {
 
     if (core.status.event.data.type=='text') {
@@ -691,6 +763,7 @@ events.prototype.clickAction = function (x,y) {
     }
 }
 
+////// 自定义事件时，按下某个键的操作 //////
 events.prototype.keyDownAction = function (keycode) {
     if (core.status.event.data.type=='choices') {
         var data = core.status.event.data.current;
@@ -710,6 +783,7 @@ events.prototype.keyDownAction = function (keycode) {
     }
 }
 
+////// 自定义事件时，放开某个键的操作 //////
 events.prototype.keyUpAction = function (keycode) {
     if (core.status.event.data.type=='text' && (keycode==13 || keycode==32 || keycode==67)) {
         this.doAction();
@@ -727,37 +801,67 @@ events.prototype.keyUpAction = function (keycode) {
     }
 }
 
-// 怪物手册
+////// 怪物手册界面的点击操作 //////
 events.prototype.clickBook = function(x,y) {
     // 上一页
     if ((x == 3 || x == 4) && y == 12) {
-        core.ui.drawEnemyBook(core.status.event.data - 1);
+        core.ui.drawBook(core.status.event.data - 6);
+        return;
     }
     // 下一页
     if ((x == 8 || x == 9) && y == 12) {
-        core.ui.drawEnemyBook(core.status.event.data + 1);
+        core.ui.drawBook(core.status.event.data + 6);
+        return;
     }
     // 返回
     if (x>=10 && x<=12 && y==12) {
-        core.ui.closePanel(true);
+        core.ui.closePanel();
+        return;
+    }
+    // 怪物信息
+    var data = core.status.event.data;
+    if (core.isset(data) && y<12) {
+        var page=parseInt(data/6);
+        var index=6*page+parseInt(y/2);
+        core.ui.drawBook(index);
+        core.ui.drawBookDetail(index);
     }
     return;
 }
 
+////// 怪物手册界面时，按下某个键的操作 //////
 events.prototype.keyDownBook = function (keycode) {
-    if (keycode==37 || keycode==38) core.ui.drawEnemyBook(core.status.event.data - 1);
-    else if (keycode==39 || keycode==40) core.ui.drawEnemyBook(core.status.event.data + 1);
+    if (keycode==37) core.ui.drawBook(core.status.event.data-6);
+    if (keycode==38) core.ui.drawBook(core.status.event.data-1);
+    if (keycode==39) core.ui.drawBook(core.status.event.data+6);
+    if (keycode==40) core.ui.drawBook(core.status.event.data+1);
+    if (keycode==33) core.ui.drawBook(core.status.event.data-6);
+    if (keycode==34) core.ui.drawBook(core.status.event.data+6);
     return;
 }
 
+////// 怪物手册界面时，放开某个键的操作 //////
 events.prototype.keyUpBook = function (keycode) {
     if (keycode==27 || keycode==88) {
-        core.ui.closePanel(true);
+        core.ui.closePanel();
+        return;
+    }
+    if (keycode==13 || keycode==32 || keycode==67) {
+        var data=core.status.event.data;
+        if (core.isset(data)) {
+            this.clickBook(6, 2*(data%6));
+        }
         return;
     }
 }
 
-// 飞行器
+////// 怪物手册属性显示界面时的点击操作 //////
+events.prototype.clickBookDetail = function () {
+    core.clearMap('data', 0, 0, 416, 416);
+    core.status.event.id = 'book';
+}
+
+////// 楼层传送器界面时的点击操作 //////
 events.prototype.clickFly = function(x,y) {
     if ((x==10 || x==11) && y==9) core.ui.drawFly(core.status.event.data-1);
     if ((x==10 || x==11) && y==5) core.ui.drawFly(core.status.event.data+1);
@@ -772,12 +876,14 @@ events.prototype.clickFly = function(x,y) {
     return;
 }
 
+////// 楼层传送器界面时，按下某个键的操作 //////
 events.prototype.keyDownFly = function (keycode) {
     if (keycode==37 || keycode==38) core.ui.drawFly(core.status.event.data+1);
     else if (keycode==39 || keycode==40) core.ui.drawFly(core.status.event.data-1);
     return;
 }
 
+////// 楼层传送器界面时，放开某个键的操作 //////
 events.prototype.keyUpFly = function (keycode) {
     if (keycode==71 || keycode==27 || keycode==88)
         core.ui.closePanel();
@@ -786,7 +892,7 @@ events.prototype.keyUpFly = function (keycode) {
     return;
 }
 
-// 商店
+////// 商店界面时的点击操作 //////
 events.prototype.clickShop = function(x,y) {
     var shop = core.status.event.data.shop;
     var choices = shop.choices;
@@ -833,6 +939,7 @@ events.prototype.clickShop = function(x,y) {
     }
 }
 
+////// 商店界面时，按下某个键的操作 //////
 events.prototype.keyDownShop = function (keycode) {
     var shop = core.status.event.data.shop;
     var choices = shop.choices;
@@ -848,6 +955,7 @@ events.prototype.keyDownShop = function (keycode) {
     }
 }
 
+////// 商店界面时，放开某个键的操作 //////
 events.prototype.keyUpShop = function (keycode) {
     if (keycode==27 || keycode==88) {
         if (core.status.event.data.fromList) {
@@ -868,7 +976,7 @@ events.prototype.keyUpShop = function (keycode) {
     return;
 }
 
-// 快捷商店
+////// 快捷商店界面时的点击操作 //////
 events.prototype.clickQuickShop = function(x, y) {
     var shopList = core.status.shops, keys = Object.keys(shopList);
     if (x >= 5 && x <= 7) {
@@ -889,6 +997,7 @@ events.prototype.clickQuickShop = function(x, y) {
     }
 }
 
+////// 快捷商店界面时，按下某个键的操作 //////
 events.prototype.keyDownQuickShop = function (keycode) {
     var shopList = core.status.shops, keys = Object.keys(shopList);
     if (keycode==38) {
@@ -903,6 +1012,7 @@ events.prototype.keyDownQuickShop = function (keycode) {
     }
 }
 
+////// 快捷商店界面时，放开某个键的操作 //////
 events.prototype.keyUpQuickShop = function (keycode) {
     if (keycode==27 || keycode==75 || keycode==88) {
         core.ui.closePanel();
@@ -916,11 +1026,11 @@ events.prototype.keyUpQuickShop = function (keycode) {
     return;
 }
 
-// 工具栏
+////// 工具栏界面时的点击操作 //////
 events.prototype.clickToolbox = function(x,y) {
     // 返回
     if (x>=10 && x<=12 && y==12) {
-        core.ui.closePanel(false);
+        core.ui.closePanel();
         return;
     }
     var index=0;
@@ -930,6 +1040,7 @@ events.prototype.clickToolbox = function(x,y) {
     this.clickToolboxIndex(index);
 }
 
+////// 选择工具栏界面中某个Index后的操作 //////
 events.prototype.clickToolboxIndex = function(index) {
     var items = null;
     var ii=index;
@@ -950,6 +1061,7 @@ events.prototype.clickToolboxIndex = function(index) {
     }
 }
 
+////// 工具栏界面时，按下某个键的操作 //////
 events.prototype.keyDownToolbox = function (keycode) {
     if (!core.isset(core.status.event.data)) return;
 
@@ -1013,6 +1125,7 @@ events.prototype.keyDownToolbox = function (keycode) {
     }
 }
 
+////// 工具栏界面时，放开某个键的操作 //////
 events.prototype.keyUpToolbox = function (keycode) {
     if (keycode==84 || keycode==27 || keycode==88) {
         core.ui.closePanel();
@@ -1026,7 +1139,7 @@ events.prototype.keyUpToolbox = function (keycode) {
     }
 }
 
-// 存读档
+////// 存读档界面时的点击操作 //////
 events.prototype.clickSL = function(x,y) {
     // 上一页
     if ((x == 3 || x == 4) && y == 12) {
@@ -1038,7 +1151,7 @@ events.prototype.clickSL = function(x,y) {
     }
     // 返回
     if (x>=10 && x<=12 && y==12) {
-        core.ui.closePanel(false);
+        core.ui.closePanel();
         if (!core.isPlaying()) {
             core.showStartAnimate();
         }
@@ -1059,6 +1172,7 @@ events.prototype.clickSL = function(x,y) {
     }
 }
 
+////// 存读档界面时，按下某个键的操作 //////
 events.prototype.keyDownSL = function(keycode) {
     if (keycode==37) { // left
         core.ui.drawSLPanel(core.status.event.data - 1);
@@ -1086,6 +1200,7 @@ events.prototype.keyDownSL = function(keycode) {
     }
 }
 
+////// 存读档界面时，放开某个键的操作 //////
 events.prototype.keyUpSL = function (keycode) {
     if (keycode==27 || keycode==88 || (core.status.event.id == 'save' && keycode==83) || (core.status.event.id == 'load' && keycode==68)) {
         core.ui.closePanel();
@@ -1100,24 +1215,31 @@ events.prototype.keyUpSL = function (keycode) {
     }
 }
 
+////// 系统设置界面时的点击操作 //////
 events.prototype.clickSwitchs = function (x,y) {
     if (x<5 || x>7) return;
     var choices = [
-        "背景音乐", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
+        "背景音乐", "背景音效", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
     ];
     var topIndex = 6 - parseInt((choices.length - 1) / 2);
     if (y>=topIndex && y<topIndex+choices.length) {
         var selection = y-topIndex;
         switch (selection) {
             case 0:
-                if (core.musicStatus.isIOS) {
-                    core.drawTip("iOS设备不支持播放音乐");
-                    return;
-                }
-                core.changeSoundStatus();
+                core.musicStatus.bgmStatus = !core.musicStatus.bgmStatus;
+                if (core.musicStatus.bgmStatus)
+                    core.resumeBgm();
+                else
+                    core.pauseBgm();
+                core.setLocalStorage('bgmStatus', core.musicStatus.bgmStatus);
                 core.ui.drawSwitchs();
                 break;
             case 1:
+                core.musicStatus.soundStatus = !core.musicStatus.soundStatus;
+                core.setLocalStorage('soundStatus', core.musicStatus.soundStatus);
+                core.ui.drawSwitchs();
+                break;
+            case 2:
                 if (!core.flags.canOpenBattleAnimate) {
                     core.drawTip("本塔不能开启战斗动画！");
                 }
@@ -1127,19 +1249,19 @@ events.prototype.clickSwitchs = function (x,y) {
                     core.ui.drawSwitchs();
                 }
                 break;
-            case 2:
+            case 3:
                 core.flags.displayEnemyDamage=!core.flags.displayEnemyDamage;
                 core.updateFg();
                 core.setLocalStorage('enemyDamage', core.flags.displayEnemyDamage);
                 core.ui.drawSwitchs();
                 break;
-            case 3:
+            case 4:
                 core.flags.displayExtraDamage=!core.flags.displayExtraDamage;
                 core.updateFg();
                 core.setLocalStorage('extraDamage', core.flags.displayExtraDamage);
                 core.ui.drawSwitchs();
                 break;
-            case 4:
+            case 5:
                 core.status.event.selection=0;
                 core.ui.drawSettings(false);
                 break;
@@ -1147,9 +1269,10 @@ events.prototype.clickSwitchs = function (x,y) {
     }
 }
 
+////// 系统设置界面时，按下某个键的操作 //////
 events.prototype.keyDownSwitchs = function (keycode) {
     var choices = [
-        "背景音乐", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
+        "背景音乐", "背景音效", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
     ];
     if (keycode==38) {
         core.status.event.selection--;
@@ -1163,6 +1286,7 @@ events.prototype.keyDownSwitchs = function (keycode) {
     }
 }
 
+////// 系统设置界面时，放开某个键的操作 //////
 events.prototype.keyUpSwitchs = function (keycode) {
     if (keycode==27 || keycode==88) {
         core.status.event.selection=0;
@@ -1170,7 +1294,7 @@ events.prototype.keyUpSwitchs = function (keycode) {
         return;
     }
     var choices = [
-        "背景音乐", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
+        "背景音乐", "背景音效", "战斗动画", "怪物显伤", "领域显伤", "返回主菜单"
     ];
     if (keycode==13 || keycode==32 || keycode==67) {
         var topIndex = 6 - parseInt((choices.length - 1) / 2);
@@ -1179,7 +1303,7 @@ events.prototype.keyUpSwitchs = function (keycode) {
 }
 
 
-// 菜单栏
+////// 系统菜单栏界面时的点击事件 //////
 events.prototype.clickSettings = function (x,y) {
     if (x<5 || x>7) return;
     var choices = [
@@ -1226,6 +1350,7 @@ events.prototype.clickSettings = function (x,y) {
     return;
 }
 
+////// 系统菜单栏界面时，按下某个键的操作 //////
 events.prototype.keyDownSettings = function (keycode) {
     var choices = [
         "系统设置", "快捷商店", "同步存档", "重新开始", "操作帮助", "关于本塔", "返回游戏"
@@ -1242,6 +1367,7 @@ events.prototype.keyDownSettings = function (keycode) {
     }
 }
 
+////// 系统菜单栏界面时，放开某个键的操作 //////
 events.prototype.keyUpSettings = function (keycode) {
     if (keycode==27 || keycode==88) {
         core.ui.closePanel();
@@ -1256,6 +1382,7 @@ events.prototype.keyUpSettings = function (keycode) {
     }
 }
 
+////// 同步存档界面时的点击操作 //////
 events.prototype.clickSyncSave = function (x,y) {
     if (x<5 || x>7) return;
     var choices = [
@@ -1291,6 +1418,7 @@ events.prototype.clickSyncSave = function (x,y) {
     return;
 }
 
+////// 同步存档界面时，按下某个键的操作 //////
 events.prototype.keyDownSyncSave = function (keycode) {
     var choices = [
         "同步存档到服务器", "从服务器加载存档", "清空本地存档", "返回主菜单"
@@ -1307,6 +1435,7 @@ events.prototype.keyDownSyncSave = function (keycode) {
     }
 }
 
+////// 同步存档界面时，放开某个键的操作 //////
 events.prototype.keyUpSyncSave = function (keycode) {
     if (keycode==27 || keycode==88) {
         core.status.event.selection=2;
@@ -1322,11 +1451,11 @@ events.prototype.keyUpSyncSave = function (keycode) {
     }
 }
 
+////// “关于”界面时的点击操作 //////
 events.prototype.clickAbout = function () {
     if (core.isPlaying())
-        core.ui.closePanel(false);
+        core.ui.closePanel();
     else
         core.showStartAnimate();
 }
 
-/*********** 点击事件 END ***************/
diff --git a/libs/items.js b/libs/items.js
index 1d6a0201..a210a68b 100644
--- a/libs/items.js
+++ b/libs/items.js
@@ -2,6 +2,7 @@ function items() {
 
 }
 
+////// 初始化 //////
 items.prototype.init = function () {
     this.items = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.items;
     this.itemEffect = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a.itemEffect;
@@ -9,7 +10,7 @@ items.prototype.init = function () {
     delete(items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a);
 }
 
-// 初始化道具
+////// 获得所有道具 //////
 items.prototype.getItems = function () {
     // 大黄门钥匙？钥匙盒？
     if (core.flags.bigKeyIsBox)
@@ -24,7 +25,7 @@ items.prototype.getItems = function () {
 
 main.instance.items = new items();
 
-
+////// “即捡即用类”道具的使用效果 //////
 items.prototype.getItemEffect = function(itemId, itemNum) {
     var itemCls = core.material.items[itemId].cls;
     // 消耗品
@@ -36,19 +37,18 @@ items.prototype.getItemEffect = function(itemId, itemNum) {
     }
 }
 
+////// “即捡即用类”道具的文字提示 //////
 items.prototype.getItemEffectTip = function(itemId) {
     if (itemId in this.itemEffectTip)return eval(this.itemEffectTip[itemId]);
     return "";
 }
 
-
-
+////// 使用道具 //////
 items.prototype.useItem = function (itemId) {
-    // 使用道具
     if (!this.canUseItem(itemId)) return;
     var itemCls = core.material.items[itemId].cls;
 
-    if (itemId=='book') core.ui.drawEnemyBook(1);
+    if (itemId=='book') core.ui.drawBook(0);
     if (itemId=='fly') core.ui.drawFly(core.status.hero.flyRange.indexOf(core.status.floorId));
     if (itemId == 'earthquake' || itemId == 'bomb' || itemId == 'pickaxe' || itemId=='icePickaxe'
         || itemId == 'snow' || itemId == 'hammer' || itemId=='bigKey') {
@@ -58,6 +58,9 @@ items.prototype.useItem = function (itemId) {
             core.drawHero(core.getHeroLoc('direction'), core.getHeroLoc('x'), core.getHeroLoc('y'), 'stop');
             core.updateFg();
             core.drawTip(core.material.items[itemId].name + "使用成功");
+
+            if (itemId == 'bomb' || itemId == 'hammer')
+                core.events.afterUseBomb();
         });
     }
     if (itemId == 'centerFly') {
@@ -96,12 +99,11 @@ items.prototype.useItem = function (itemId) {
         delete core.status.hero.items[itemCls][itemId];
 }
 
+////// 当前能否使用道具 //////
 items.prototype.canUseItem = function (itemId) {
     // 没有道具
     if (!core.hasItem(itemId)) return false;
 
-    var itemCls = core.material.items[itemId].cls;
-
     if (itemId == 'book') return true;
     if (itemId == 'fly') return core.status.hero.flyRange.indexOf(core.status.floorId)>=0;
     if (itemId == 'pickaxe') {
diff --git a/libs/maps.js b/libs/maps.js
index 7704e7a3..79a3e07e 100644
--- a/libs/maps.js
+++ b/libs/maps.js
@@ -4,6 +4,7 @@ maps.prototype.init = function() {
     delete(maps_90f36752_8815_4be8_b32b_d7fad1d0542e);
 }
 
+////// 加载某个楼层（从剧本或存档中） //////
 maps.prototype.loadFloor = function (floorId, map) {
     var floor = core.floors[floorId];
     var content = {};
@@ -47,6 +48,7 @@ maps.prototype.loadFloor = function (floorId, map) {
     return content;
 }
 
+////// 数字和ID的对应关系 //////
 maps.prototype.getBlock = function (x, y, id) {
     var enable=null;
     id = ""+id;
@@ -69,6 +71,7 @@ maps.prototype.getBlock = function (x, y, id) {
     return tmp;
 }
 
+////// 向该楼层添加剧本的自定义事件 //////
 maps.prototype.addEvent = function (block, x, y, event, ground) {
     if (!core.isset(event)) return;
     if (!core.isset(block.event)) { // 本身是空地？
@@ -104,11 +107,13 @@ maps.prototype.addEvent = function (block, x, y, event, ground) {
     }
 }
 
+////// 向该楼层添加剧本的楼层转换事件 //////
 maps.prototype.addChangeFloor = function (block, x, y, event, ground) {
     if (!core.isset(event)) return;
     this.addEvent(block, x, y, {"trigger": "changeFloor", "data": event}, ground);
 }
 
+////// 初始化所有地图 //////
 maps.prototype.initMaps = function (floorIds) {
     var maps = {};
     for (var i=0;i<floorIds.length;i++) {
@@ -118,6 +123,7 @@ maps.prototype.initMaps = function (floorIds) {
     return maps;
 }
 
+////// 将当前地图重新变成数字，以便于存档 //////
 maps.prototype.save = function(maps, floorId) {
     if (!core.isset(floorId)) {
         var map = {};
@@ -147,6 +153,7 @@ maps.prototype.save = function(maps, floorId) {
     return blocks;
 }
 
+////// 将存档中的地图信息重新读取出来 //////
 maps.prototype.load = function (data, floorId) {
     if (floorId == undefined) {
         var map = {};
diff --git a/libs/project/data.js b/libs/project/data.js
index 5a943f27..1bbe4e26 100644
--- a/libs/project/data.js
+++ b/libs/project/data.js
@@ -7,7 +7,7 @@ data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d =
         // 如果要进行剧本的修改请务必将其改成false。
     
         "floorIds" : [ // 在这里按顺序放所有的楼层；其顺序直接影响到楼层传送器的顺序和上楼器/下楼器的顺序
-            "sample0", "sample1", "sample2", "test"
+            "sample0", "sample1", "sample2"
         ]
     },
     "firstData" : {
diff --git a/libs/project/floors/MT0.js b/libs/project/floors/MT0.js
index c8d90ad4..fad21c7d 100644
--- a/libs/project/floors/MT0.js
+++ b/libs/project/floors/MT0.js
@@ -8,6 +8,8 @@ main.floors.MT0 = {
     "canFlyTo": true, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
     "canUseQuickShop": true, // 该层是否允许使用快捷商店
     "defaultGround": "ground", // 默认地面的图块ID（terrains中）
+    // "color": [0,0,0,0.3], // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
+    // "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
     "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
 
     ],
diff --git a/libs/project/floors/sample0.js b/libs/project/floors/sample0.js
index 4535039c..d90875b8 100644
--- a/libs/project/floors/sample0.js
+++ b/libs/project/floors/sample0.js
@@ -8,6 +8,8 @@ main.floors.sample0 = {
     "canFlyTo": true, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
     "canUseQuickShop": true, // 该层是否允许使用快捷商店
     "defaultGround": "ground", // 默认地面的图块ID（terrains中）
+    // "color": [0,0,0,0.3] // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
+    "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
     "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
         [0,    0,    220,  0,    0,    20,   87,   3,    65,   64,   44,   43,   42],
         [0,    246,  0,    246,  0,    20,   0,    3,    58,   59,   60,   61,   41],
@@ -16,8 +18,8 @@ main.floors.sample0 = {
         [216,  247,  256,  235,  248,  6,    0,    3,    49,   50,   51,   52,   38],
         [6,    6,    125,  6,    6,    6,    0,    1,    45,   46,   47,   48,   37],
         [224,  254,  212,  232,  204,  5,    0,    1,    31,   32,   34,   33,   36],
-        [201,  205,  217,  215,  207,  5,   50,    1,    27,   28,   29,   30,   35],
-        [5,    5,    125,  5,    5,    5,   50,    1,    21,   22,   23,   24,   25],
+        [201,  205,  217,  215,  207,  5,    0,    1,    27,   28,   29,   30,   35],
+        [5,    5,    125,  5,    5,    5,    0,    1,    21,   22,   23,   24,   25],
         [0,    0,    0,    0,    0,    0,    45,   1,    1,    1,    121,  1,    1],
         [4,    4,    126,  4,    4,    4,    0,    0,    0,    0,    0,    85,   124],
         [87,   11,   12,   13,   14,   4,    4,    2,    2,    2,    122,  2,    2],
@@ -102,7 +104,6 @@ main.floors.sample0 = {
             "炸弹是只能炸面前的怪物还是四个方向的怪物，由data.js中的系统Flag所决定。\n如只能炸前方怪物则和上面的圣锤等价。\n不能被炸的怪物在enemys中可以定义，可参见样板里黑衣魔王和黑暗大法师的写法。",
         ],
         "10,4": ["“上楼”和“下楼”的目标层由 main.js 的 floorIds顺序所决定。"],
-        "10,3": ["十字架目前未被定义，可能需要自行实现功能。\n有关如何实现一个道具功能参见doc文档。"],
         "9,2": ["该道具默认是大黄门钥匙，如需改为钥匙盒直接修改 data.js 中的系统Flag即可。"],
         "10,2": ["屠龙匕首目前未被定义，可能需要自行实现功能。\n有关如何实现一个道具功能参见doc文档。"],
     },
diff --git a/libs/project/floors/sample1.js b/libs/project/floors/sample1.js
index c9d53d4b..996abf44 100644
--- a/libs/project/floors/sample1.js
+++ b/libs/project/floors/sample1.js
@@ -8,6 +8,8 @@ main.floors.sample1 = {
     "canFlyTo": true, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
     "canUseQuickShop": true, // 该层是否允许使用快捷商店
     "defaultGround": "grass", // 默认地面的图块ID（terrains中）
+    // "color": [0,0,0,0.3] // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
+    // "bgm": "bgm.mp3", // 到达该层后默认播放的BGM。本项可忽略。
     "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
         [7,    131,  8,    152,  9,    130,  10,   152,  166,  165,  132,  165,  166],
         [0,    0,    0,    0,    0,    0,    0,    152,  165,  164,  0,    162,  165],
@@ -31,8 +33,9 @@ main.floors.sample1 = {
         "4,10": [ // 走到中间时的提示
             "\t[样板提示]本层楼将会对各类事件进行介绍。",
             "左边是一个仿50层的陷阱做法，上方是商店、快捷商店的使用方法，右上是一个典型的杀怪开门的例子，右下是各类可能的NPC事件。",
-            "本样板目前支持的事件列表大致有：\ntext: 显示一段文字（比如你现在正在看到的）\ntip: 左上角显示提示\nshow: 使一个事件有效（可见、可被交互）\nhide: 使一个事件失效（不可见、不可被交互）\ntrigger: 触发另一个地点的事件\nbattle: 强制和某怪物战斗\nopenDoor: 无需钥匙开门（例如机关门、暗墙）\nopenShop: 打开一个全局商店\ndisableShop: 禁用一个全局商店\nchangeFloor: 传送勇士到某层某位置\nchangePos: 传送勇士到当层某位置；转向\nsetFg: 更改画面色调",
-            "move: 移动事件效果\nmoveHero: 移动勇士效果\nplaySound: 播放某个音频\nif: 条件判断\nchoices: 提供选项\nsetValue: 设置勇士属性道具，或某个变量/flag\nupdate: 更新状态栏和地图显伤\nwin: 获得胜利（游戏通关）\nlose: 游戏失败\nsleep: 等待多少毫秒\nexit: 立刻结束当前事件\nrevisit: 立刻结束事件并重新触发\nfunction: 自定义JS脚本\n更多支持的事件还在编写中，欢迎您宝贵的意见。",
+            "本样板目前支持的事件列表大致有：\ntext: 显示一段文字（比如你现在正在看到的）\ntip: 左上角显示提示\nshow: 使一个事件有效（可见、可被交互）\nhide: 使一个事件失效（不可见、不可被交互）\ntrigger: 触发另一个地点的事件\nbattle: 强制和某怪物战斗\nopenDoor: 无需钥匙开门（例如机关门、暗墙）",
+            "openShop: 打开一个全局商店\ndisableShop: 禁用一个全局商店\nchangeFloor: 传送勇士到某层某位置\nchangePos: 传送勇士到当层某位置；转向\nsetFg: 更改画面色调\nmove: 移动事件效果\nmoveHero: 移动勇士效果\nplayBgm: 播放某个背景音乐\npauseBgm: 暂停背景音乐\nresumeBgm: 恢复背景音乐的播放\nplaySound: 播放某个音频",
+            "if: 条件判断\nchoices: 提供选项\nsetValue: 设置勇士属性道具，或某个变量/flag\nupdate: 更新状态栏和地图显伤\nwin: 获得胜利（游戏通关）\nlose: 游戏失败\nsleep: 等待多少毫秒\nexit: 立刻结束当前事件\nrevisit: 立刻结束事件并重新触发\nfunction: 自定义JS脚本\n\n更多支持的事件还在编写中，欢迎您宝贵的意见。",
             "有关各事件的样例，可参见本层一些NPC的写法。\n所有事件样例本层都有介绍。\n\n一个自定义事件处理完后，需要调用{\"type\": \"hide\"}该事件才不会再次出现。",
             {"type": "hide"}
         ],
diff --git a/libs/project/floors/sample2.js b/libs/project/floors/sample2.js
index 32d227ff..a312ec93 100644
--- a/libs/project/floors/sample2.js
+++ b/libs/project/floors/sample2.js
@@ -8,6 +8,8 @@ main.floors.sample2 = {
     "canFlyTo": false, // 该楼能否被楼传器飞到（不能的话在该楼也不允许使用楼传器）
     "canUseQuickShop": true, // 该层是否允许使用快捷商店
     "defaultGround": "snowGround", // 默认地面的图块ID（terrains中）
+    "color": [255,0,0,0.3], // 该层的默认画面色调。本项可不写（代表无色调），如果写需要是一个RGBA数组。
+    "bgm": "qianjin.mid", // 到达该层后默认播放的BGM。本项可忽略。
     "map": [ // 地图数据，需要是13x13，建议使用地图生成器来生成
         [5,    5,    5,    5,    5,    5,    87,   5,    5,    5,    5,    5,    5],
         [5,    4,    4,    4,    4,    1,    0,    1,    4,    4,    4,    4,    5],
diff --git a/libs/thirdparty/mid.js b/libs/thirdparty/mid.js
new file mode 100644
index 00000000..45af166d
--- /dev/null
+++ b/libs/thirdparty/mid.js
@@ -0,0 +1,701 @@
+var sampleRate = 44100; /* hard-coded in Flash player */
+
+function AudioPlayer(context, generator, loop) {
+
+		// Uses Webkit Web Audio API if available
+		sampleRate = context.sampleRate;
+		
+		var channelCount = 2;
+		var bufferSize = 4096*4; // Higher for less gitches, lower for less latency
+		
+		var node = context.createScriptProcessor(bufferSize, 0, channelCount);
+		
+		node.onaudioprocess = function(e) { process(e) };
+
+		function process(e) {
+			if (generator.finished) {
+				if (loop) {
+                    generator.reset();
+                    generator.finished = false;
+				}
+				else {
+                    node.disconnect();
+                    return;
+				}
+			}
+			
+			var dataLeft = e.outputBuffer.getChannelData(0);
+			var dataRight = e.outputBuffer.getChannelData(1);
+
+			var generate = generator.generate(bufferSize);
+
+			for (var i = 0; i < bufferSize; ++i) {
+				dataLeft[i] = generate[i*2];
+				dataRight[i] = generate[i*2+1];
+			}
+		}
+		
+		// start
+		// node.connect(context.destination);
+		
+		return {
+			'play': function () {
+                node.connect(context.destination);
+            },
+			'pause': function() {
+				node.disconnect();
+			}
+		}
+}
+/*
+class to parse the .mid file format
+(depends on stream.js)
+*/
+function MidiFile(data) {
+	function readChunk(stream) {
+		var id = stream.read(4);
+		var length = stream.readInt32();
+		return {
+			'id': id,
+			'length': length,
+			'data': stream.read(length)
+		};
+	}
+	
+	var lastEventTypeByte;
+	
+	function readEvent(stream) {
+		var event = {};
+		event.deltaTime = stream.readVarInt();
+		var eventTypeByte = stream.readInt8();
+		if ((eventTypeByte & 0xf0) == 0xf0) {
+			/* system / meta event */
+			if (eventTypeByte == 0xff) {
+				/* meta event */
+				event.type = 'meta';
+				var subtypeByte = stream.readInt8();
+				var length = stream.readVarInt();
+				switch(subtypeByte) {
+					case 0x00:
+						event.subtype = 'sequenceNumber';
+						if (length != 2) throw "Expected length for sequenceNumber event is 2, got " + length;
+						event.number = stream.readInt16();
+						return event;
+					case 0x01:
+						event.subtype = 'text';
+						event.text = stream.read(length);
+						return event;
+					case 0x02:
+						event.subtype = 'copyrightNotice';
+						event.text = stream.read(length);
+						return event;
+					case 0x03:
+						event.subtype = 'trackName';
+						event.text = stream.read(length);
+						return event;
+					case 0x04:
+						event.subtype = 'instrumentName';
+						event.text = stream.read(length);
+						return event;
+					case 0x05:
+						event.subtype = 'lyrics';
+						event.text = stream.read(length);
+						return event;
+					case 0x06:
+						event.subtype = 'marker';
+						event.text = stream.read(length);
+						return event;
+					case 0x07:
+						event.subtype = 'cuePoint';
+						event.text = stream.read(length);
+						return event;
+					case 0x20:
+						event.subtype = 'midiChannelPrefix';
+						if (length != 1) throw "Expected length for midiChannelPrefix event is 1, got " + length;
+						event.channel = stream.readInt8();
+						return event;
+					case 0x2f:
+						event.subtype = 'endOfTrack';
+						if (length != 0) throw "Expected length for endOfTrack event is 0, got " + length;
+						return event;
+					case 0x51:
+						event.subtype = 'setTempo';
+						if (length != 3) throw "Expected length for setTempo event is 3, got " + length;
+						event.microsecondsPerBeat = (
+							(stream.readInt8() << 16)
+							+ (stream.readInt8() << 8)
+							+ stream.readInt8()
+						)
+						return event;
+					case 0x54:
+						event.subtype = 'smpteOffset';
+						if (length != 5) throw "Expected length for smpteOffset event is 5, got " + length;
+						var hourByte = stream.readInt8();
+						event.frameRate = {
+							0x00: 24, 0x20: 25, 0x40: 29, 0x60: 30
+						}[hourByte & 0x60];
+						event.hour = hourByte & 0x1f;
+						event.min = stream.readInt8();
+						event.sec = stream.readInt8();
+						event.frame = stream.readInt8();
+						event.subframe = stream.readInt8();
+						return event;
+					case 0x58:
+						event.subtype = 'timeSignature';
+						if (length != 4) throw "Expected length for timeSignature event is 4, got " + length;
+						event.numerator = stream.readInt8();
+						event.denominator = Math.pow(2, stream.readInt8());
+						event.metronome = stream.readInt8();
+						event.thirtyseconds = stream.readInt8();
+						return event;
+					case 0x59:
+						event.subtype = 'keySignature';
+						if (length != 2) throw "Expected length for keySignature event is 2, got " + length;
+						event.key = stream.readInt8(true);
+						event.scale = stream.readInt8();
+						return event;
+					case 0x7f:
+						event.subtype = 'sequencerSpecific';
+						event.data = stream.read(length);
+						return event;
+					default:
+						// console.log("Unrecognised meta event subtype: " + subtypeByte);
+						event.subtype = 'unknown'
+						event.data = stream.read(length);
+						return event;
+				}
+				event.data = stream.read(length);
+				return event;
+			} else if (eventTypeByte == 0xf0) {
+				event.type = 'sysEx';
+				var length = stream.readVarInt();
+				event.data = stream.read(length);
+				return event;
+			} else if (eventTypeByte == 0xf7) {
+				event.type = 'dividedSysEx';
+				var length = stream.readVarInt();
+				event.data = stream.read(length);
+				return event;
+			} else {
+				throw "Unrecognised MIDI event type byte: " + eventTypeByte;
+			}
+		} else {
+			/* channel event */
+			var param1;
+			if ((eventTypeByte & 0x80) == 0) {
+				/* running status - reuse lastEventTypeByte as the event type.
+					eventTypeByte is actually the first parameter
+				*/
+				param1 = eventTypeByte;
+				eventTypeByte = lastEventTypeByte;
+			} else {
+				param1 = stream.readInt8();
+				lastEventTypeByte = eventTypeByte;
+			}
+			var eventType = eventTypeByte >> 4;
+			event.channel = eventTypeByte & 0x0f;
+			event.type = 'channel';
+			switch (eventType) {
+				case 0x08:
+					event.subtype = 'noteOff';
+					event.noteNumber = param1;
+					event.velocity = stream.readInt8();
+					return event;
+				case 0x09:
+					event.noteNumber = param1;
+					event.velocity = stream.readInt8();
+					if (event.velocity == 0) {
+						event.subtype = 'noteOff';
+					} else {
+						event.subtype = 'noteOn';
+					}
+					return event;
+				case 0x0a:
+					event.subtype = 'noteAftertouch';
+					event.noteNumber = param1;
+					event.amount = stream.readInt8();
+					return event;
+				case 0x0b:
+					event.subtype = 'controller';
+					event.controllerType = param1;
+					event.value = stream.readInt8();
+					return event;
+				case 0x0c:
+					event.subtype = 'programChange';
+					event.programNumber = param1;
+					return event;
+				case 0x0d:
+					event.subtype = 'channelAftertouch';
+					event.amount = param1;
+					return event;
+				case 0x0e:
+					event.subtype = 'pitchBend';
+					event.value = param1 + (stream.readInt8() << 7);
+					return event;
+				default:
+					throw "Unrecognised MIDI event type: " + eventType
+			}
+		}
+	}
+	
+	stream = Stream(data);
+	var headerChunk = readChunk(stream);
+	if (headerChunk.id != 'MThd' || headerChunk.length != 6) {
+		throw "Bad .mid file - header not found";
+	}
+	var headerStream = Stream(headerChunk.data);
+	var formatType = headerStream.readInt16();
+	var trackCount = headerStream.readInt16();
+	var timeDivision = headerStream.readInt16();
+	
+	if (timeDivision & 0x8000) {
+		throw "Expressing time division in SMTPE frames is not supported yet"
+	} else {
+		ticksPerBeat = timeDivision;
+	}
+	
+	var header = {
+		'formatType': formatType,
+		'trackCount': trackCount,
+		'ticksPerBeat': ticksPerBeat
+	}
+	var tracks = [];
+	for (var i = 0; i < header.trackCount; i++) {
+		tracks[i] = [];
+		var trackChunk = readChunk(stream);
+		if (trackChunk.id != 'MTrk') {
+			throw "Unexpected chunk - expected MTrk, got "+ trackChunk.id;
+		}
+		var trackStream = Stream(trackChunk.data);
+		while (!trackStream.eof()) {
+			var event = readEvent(trackStream);
+			tracks[i].push(event);
+			//console.log(event);
+		}
+	}
+	
+	return {
+		'header': header,
+		'tracks': tracks
+	}
+}
+function Replayer(midiFile, synth) {
+	var trackStates = [];
+	var beatsPerMinute = 120;
+	var ticksPerBeat = midiFile.header.ticksPerBeat;
+	var channelCount = 16;
+    var channels = [];
+    var nextEventInfo;
+    var samplesToNextEvent;
+	
+	function Channel() {
+		
+		var generatorsByNote = {};
+		var currentProgram = PianoProgram;
+		
+		function noteOn(note, velocity) {
+			if (generatorsByNote[note] && !generatorsByNote[note].released) {
+				/* playing same note before releasing the last one. BOO */
+				generatorsByNote[note].noteOff(); /* TODO: check whether we ought to be passing a velocity in */
+			}
+			generator = currentProgram.createNote(note, velocity);
+			synth.addGenerator(generator);
+			generatorsByNote[note] = generator;
+		}
+		function noteOff(note, velocity) {
+			if (generatorsByNote[note] && !generatorsByNote[note].released) {
+				generatorsByNote[note].noteOff(velocity);
+			}
+		}
+		function setProgram(programNumber) {
+			currentProgram = PROGRAMS[programNumber] || PianoProgram;
+		}
+		
+		return {
+			'noteOn': noteOn,
+			'noteOff': noteOff,
+			'setProgram': setProgram
+		}
+	}
+
+	function getNextEvent() {
+		var ticksToNextEvent = null;
+		var nextEventTrack = null;
+		var nextEventIndex = null;
+		
+		for (var i = 0; i < trackStates.length; i++) {
+			if (
+				trackStates[i].ticksToNextEvent != null
+				&& (ticksToNextEvent == null || trackStates[i].ticksToNextEvent < ticksToNextEvent)
+			) {
+				ticksToNextEvent = trackStates[i].ticksToNextEvent;
+				nextEventTrack = i;
+				nextEventIndex = trackStates[i].nextEventIndex;
+			}
+		}
+		if (nextEventTrack != null) {
+			/* consume event from that track */
+			var nextEvent = midiFile.tracks[nextEventTrack][nextEventIndex];
+			if (midiFile.tracks[nextEventTrack][nextEventIndex + 1]) {
+				trackStates[nextEventTrack].ticksToNextEvent += midiFile.tracks[nextEventTrack][nextEventIndex + 1].deltaTime;
+			} else {
+				trackStates[nextEventTrack].ticksToNextEvent = null;
+			}
+			trackStates[nextEventTrack].nextEventIndex += 1;
+			/* advance timings on all tracks by ticksToNextEvent */
+			for (var i = 0; i < trackStates.length; i++) {
+				if (trackStates[i].ticksToNextEvent != null) {
+					trackStates[i].ticksToNextEvent -= ticksToNextEvent
+				}
+			}
+			nextEventInfo = {
+				'ticksToEvent': ticksToNextEvent,
+				'event': nextEvent,
+				'track': nextEventTrack
+			}
+			var beatsToNextEvent = ticksToNextEvent / ticksPerBeat;
+			var secondsToNextEvent = beatsToNextEvent / (beatsPerMinute / 60);
+			samplesToNextEvent += secondsToNextEvent * synth.sampleRate;
+		} else {
+			nextEventInfo = null;
+			samplesToNextEvent = null;
+			self.finished = true;
+		}
+	}
+	
+	function generate(samples) {
+		var data = new Array(samples*2);
+		var samplesRemaining = samples;
+		var dataOffset = 0;
+		
+		while (true) {
+			if (samplesToNextEvent != null && samplesToNextEvent <= samplesRemaining) {
+				/* generate samplesToNextEvent samples, process event and repeat */
+				var samplesToGenerate = Math.ceil(samplesToNextEvent);
+				if (samplesToGenerate > 0) {
+					synth.generateIntoBuffer(samplesToGenerate, data, dataOffset);
+					dataOffset += samplesToGenerate * 2;
+					samplesRemaining -= samplesToGenerate;
+					samplesToNextEvent -= samplesToGenerate;
+				}
+				
+				handleEvent();
+				getNextEvent();
+			} else {
+				/* generate samples to end of buffer */
+				if (samplesRemaining > 0) {
+					synth.generateIntoBuffer(samplesRemaining, data, dataOffset);
+					samplesToNextEvent -= samplesRemaining;
+				}
+				break;
+			}
+		}
+		return data;
+	}
+	
+	function handleEvent() {
+		var event = nextEventInfo.event;
+		switch (event.type) {
+			case 'meta':
+				switch (event.subtype) {
+					case 'setTempo':
+						beatsPerMinute = 60000000 / event.microsecondsPerBeat
+				}
+				break;
+			case 'channel':
+				switch (event.subtype) {
+					case 'noteOn':
+						channels[event.channel].noteOn(event.noteNumber, event.velocity);
+						break;
+					case 'noteOff':
+						channels[event.channel].noteOff(event.noteNumber, event.velocity);
+						break;
+					case 'programChange':
+						//console.log('program change to ' + event.programNumber);
+						channels[event.channel].setProgram(event.programNumber);
+						break;
+				}
+				break;
+		}
+	}
+
+    function reset() {
+        for (var i = 0; i < midiFile.tracks.length; i++) {
+            trackStates[i] = {
+                'nextEventIndex': 0,
+                'ticksToNextEvent': (
+                    midiFile.tracks[i].length ?
+                        midiFile.tracks[i][0].deltaTime :
+                        null
+                )
+            };
+        }
+        for (var i = 0; i < channelCount; i++) {
+            channels[i] = Channel();
+        }
+        samplesToNextEvent = 0;
+        getNextEvent();
+    }
+
+    reset();
+
+	var self = {
+		'reset': reset,
+		'generate': generate,
+		'finished': false
+	}
+	return self;
+}
+/* Wrapper for accessing strings through sequential reads */
+function Stream(str) {
+	var position = 0;
+	
+	function read(length) {
+		var result = str.substr(position, length);
+		position += length;
+		return result;
+	}
+	
+	/* read a big-endian 32-bit integer */
+	function readInt32() {
+		var result = (
+			(str.charCodeAt(position) << 24)
+			+ (str.charCodeAt(position + 1) << 16)
+			+ (str.charCodeAt(position + 2) << 8)
+			+ str.charCodeAt(position + 3));
+		position += 4;
+		return result;
+	}
+
+	/* read a big-endian 16-bit integer */
+	function readInt16() {
+		var result = (
+			(str.charCodeAt(position) << 8)
+			+ str.charCodeAt(position + 1));
+		position += 2;
+		return result;
+	}
+	
+	/* read an 8-bit integer */
+	function readInt8(signed) {
+		var result = str.charCodeAt(position);
+		if (signed && result > 127) result -= 256;
+		position += 1;
+		return result;
+	}
+	
+	function eof() {
+		return position >= str.length;
+	}
+	
+	/* read a MIDI-style variable-length integer
+		(big-endian value in groups of 7 bits,
+		with top bit set to signify that another byte follows)
+	*/
+	function readVarInt() {
+		var result = 0;
+		while (true) {
+			var b = readInt8();
+			if (b & 0x80) {
+				result += (b & 0x7f);
+				result <<= 7;
+			} else {
+				/* b is the last byte */
+				return result + b;
+			}
+		}
+	}
+	
+	return {
+		'eof': eof,
+		'read': read,
+		'readInt32': readInt32,
+		'readInt16': readInt16,
+		'readInt8': readInt8,
+		'readVarInt': readVarInt
+	}
+}
+function SineGenerator(freq) {
+	var self = {'alive': true};
+	var period = sampleRate / freq;
+	var t = 0;
+	
+	self.generate = function(buf, offset, count) {
+		for (; count; count--) {
+			var phase = t / period;
+			var result = Math.sin(phase * 2 * Math.PI);
+			buf[offset++] += result;
+			buf[offset++] += result;
+			t++;
+		}
+	}
+	
+	return self;
+}
+
+function SquareGenerator(freq, phase) {
+	var self = {'alive': true};
+	var period = sampleRate / freq;
+	var t = 0;
+	
+	self.generate = function(buf, offset, count) {
+		for (; count; count--) {
+			var result = ( (t / period) % 1 > phase ? 1 : -1);
+			buf[offset++] += result;
+			buf[offset++] += result;
+			t++;
+		}
+	}
+	
+	return self;
+}
+
+function ADSRGenerator(child, attackAmplitude, sustainAmplitude, attackTimeS, decayTimeS, releaseTimeS) {
+	var self = {'alive': true}
+	var attackTime = sampleRate * attackTimeS;
+	var decayTime = sampleRate * (attackTimeS + decayTimeS);
+	var decayRate = (attackAmplitude - sustainAmplitude) / (decayTime - attackTime);
+	var releaseTime = null; /* not known yet */
+	var endTime = null; /* not known yet */
+	var releaseRate = sustainAmplitude / (sampleRate * releaseTimeS);
+	var t = 0;
+	
+	self.noteOff = function() {
+		if (self.released) return;
+		releaseTime = t;
+		self.released = true;
+		endTime = releaseTime + sampleRate * releaseTimeS;
+	}
+	
+	self.generate = function(buf, offset, count) {
+		if (!self.alive) return;
+		var input = new Array(count * 2);
+		for (var i = 0; i < count*2; i++) {
+			input[i] = 0;
+		}
+		child.generate(input, 0, count);
+		
+		childOffset = 0;
+		while(count) {
+			if (releaseTime != null) {
+				if (t < endTime) {
+					/* release */
+					while(count && t < endTime) {
+						var ampl = sustainAmplitude - releaseRate * (t - releaseTime);
+						buf[offset++] += input[childOffset++] * ampl;
+						buf[offset++] += input[childOffset++] * ampl;
+						t++;
+						count--;
+					}
+				} else {
+					/* dead */
+					self.alive = false;
+					return;
+				}
+			} else if (t < attackTime) {
+				/* attack */
+				while(count && t < attackTime) {
+					var ampl = attackAmplitude * t / attackTime;
+					buf[offset++] += input[childOffset++] * ampl;
+					buf[offset++] += input[childOffset++] * ampl;
+					t++;
+					count--;
+				}
+			} else if (t < decayTime) {
+				/* decay */
+				while(count && t < decayTime) {
+					var ampl = attackAmplitude - decayRate * (t - attackTime);
+					buf[offset++] += input[childOffset++] * ampl;
+					buf[offset++] += input[childOffset++] * ampl;
+					t++;
+					count--;
+				}
+			} else {
+				/* sustain */
+				while(count) {
+					buf[offset++] += input[childOffset++] * sustainAmplitude;
+					buf[offset++] += input[childOffset++] * sustainAmplitude;
+					t++;
+					count--;
+				}
+			}
+		}
+	}
+	
+	return self;
+}
+
+function midiToFrequency(note) {
+	return 440 * Math.pow(2, (note-69)/12);
+}
+
+PianoProgram = {
+	'attackAmplitude': 0.2,
+	'sustainAmplitude': 0.1,
+	'attackTime': 0.02,
+	'decayTime': 0.3,
+	'releaseTime': 0.02,
+	'createNote': function(note, velocity) {
+		var frequency = midiToFrequency(note);
+		return ADSRGenerator(
+			SineGenerator(frequency),
+			this.attackAmplitude * (velocity / 128), this.sustainAmplitude * (velocity / 128),
+			this.attackTime, this.decayTime, this.releaseTime
+		);
+	}
+}
+
+StringProgram = {
+	'createNote': function(note, velocity) {
+		var frequency = midiToFrequency(note);
+		return ADSRGenerator(
+			SineGenerator(frequency),
+			0.5 * (velocity / 128), 0.2 * (velocity / 128),
+			0.4, 0.8, 0.4
+		);
+	}
+}
+
+PROGRAMS = {
+	41: StringProgram,
+	42: StringProgram,
+	43: StringProgram,
+	44: StringProgram,
+	45: StringProgram,
+	46: StringProgram,
+	47: StringProgram,
+	49: StringProgram,
+	50: StringProgram
+};
+
+function Synth(sampleRate) {
+	
+	var generators = [];
+	
+	function addGenerator(generator) {
+		generators.push(generator);
+	}
+	
+	function generate(samples) {
+		var data = new Array(samples*2);
+		generateIntoBuffer(samples, data, 0);
+		return data;
+	}
+	
+	function generateIntoBuffer(samplesToGenerate, buffer, offset) {
+		for (var i = offset; i < offset + samplesToGenerate * 2; i++) {
+			buffer[i] = 0;
+		}
+		for (var i = generators.length - 1; i >= 0; i--) {
+			generators[i].generate(buffer, offset, samplesToGenerate);
+			if (!generators[i].alive) generators.splice(i, 1);
+		}
+	}
+	
+	return {
+		'sampleRate': sampleRate,
+		'addGenerator': addGenerator,
+		'generate': generate,
+		'generateIntoBuffer': generateIntoBuffer
+	}
+}
diff --git a/libs/ui.js b/libs/ui.js
index 62ef59e8..4c0b6097 100644
--- a/libs/ui.js
+++ b/libs/ui.js
@@ -12,17 +12,12 @@ ui.prototype.init = function () {
 main.instance.ui = new ui();
 
 
-/**
- * 关闭一切UI窗口
- * @param clearData 是否同时清掉data层
- */
-ui.prototype.closePanel = function (clearData) {
+////// 结束一切事件和绘制，关闭UI窗口，返回游戏进程 //////
+ui.prototype.closePanel = function () {
     core.status.boxAnimateObjs = [];
     core.setBoxAnimate();
     core.clearMap('ui', 0, 0, 416, 416);
     core.setAlpha('ui', 1.0);
-    if (core.isset(clearData) && clearData)
-        core.clearMap('data', 0, 0, 416, 416);
     core.unLockControl();
     core.status.event.data = null;
     core.status.event.id = null;
@@ -30,12 +25,7 @@ ui.prototype.closePanel = function (clearData) {
     core.status.event.ui = null;
 }
 
-
-/**
- * 绘制对话框
- * @param content
- * @param id
- */
+////// 绘制一个对话框 //////
 ui.prototype.drawTextBox = function(content) {
 
     // 获得name, image, icon
@@ -137,7 +127,7 @@ ui.prototype.drawTextBox = function(content) {
     core.fillText('ui', '<点击任意位置继续>', 270, top+height-13, '#CCCCCC', '13px Verdana');
 }
 
-// 绘制选项事件
+////// 绘制一个选项界面 //////
 ui.prototype.drawChoices = function(content, choices) {
 
     var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
@@ -273,12 +263,7 @@ ui.prototype.drawChoices = function(content, choices) {
     return;
 }
 
-/**
- * 绘制确认/取消警告
- * @param text
- * @param yesCallback
- * @param noCallback
- */
+////// 绘制一个确认/取消的警告页面 //////
 ui.prototype.drawConfirmBox = function (text, yesCallback, noCallback) {
     core.lockControl();
 
@@ -327,14 +312,13 @@ ui.prototype.drawConfirmBox = function (text, yesCallback, noCallback) {
 
 }
 
-////// 绘制开关界面 //////
+////// 绘制系统设置界面 //////
 ui.prototype.drawSwitchs = function() {
-    // 背景音乐、背景音效、战斗动画、怪物显伤、领域显伤、返回
-
     core.status.event.id = 'switchs';
 
     var choices = [
-        "背景音乐："+(core.musicStatus.soundStatus ? "[ON]" : "[OFF]"),
+        "背景音乐："+(core.musicStatus.bgmStatus ? "[ON]" : "[OFF]"),
+        "背景音效："+(core.musicStatus.soundStatus ? "[ON]" : "[OFF]"),
         "战斗动画： " + (core.flags.battleAnimate ? "[ON]" : "[OFF]"),
         "怪物显伤： " + (core.flags.displayEnemyDamage ? "[ON]" : "[OFF]"),
         "领域显伤： " + (core.flags.displayExtraDamage ? "[ON]" : "[OFF]"),
@@ -344,10 +328,7 @@ ui.prototype.drawSwitchs = function() {
 
 }
 
-/**
- * 绘制菜单栏
- * @param need
- */
+////// 绘制系统菜单栏 //////
 ui.prototype.drawSettings = function (need) {
     if (!core.checkStatus('settings', need))
         return;
@@ -357,6 +338,7 @@ ui.prototype.drawSettings = function (need) {
     ]);
 }
 
+////// 绘制快捷商店选择栏 //////
 ui.prototype.drawQuickShop = function (need) {
     if (core.isset(need) && !core.checkStatus('selectShop', need))
         return;
@@ -373,7 +355,7 @@ ui.prototype.drawQuickShop = function (need) {
     this.drawChoices(null, choices);
 }
 
-
+////// 绘制战斗动画 //////
 ui.prototype.drawBattleAnimate = function(monsterId, callback) {
 
     // UI层
@@ -389,12 +371,12 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
 
     hero_hp -= core.enemys.getExtraDamage(monster);
 
-    if (core.enemys.hasSpecial(mon_special, 2)) hero_def=0; // 魔攻
-    if (core.enemys.hasSpecial(mon_special, 3) && mon_def<hero_atk) mon_def=hero_atk-1; // 坚固
     if (core.enemys.hasSpecial(mon_special, 10)) { // 模仿
         mon_atk=hero_atk;
         mon_def=hero_def;
     }
+    if (core.enemys.hasSpecial(mon_special, 2)) hero_def=0; // 魔攻
+    if (core.enemys.hasSpecial(mon_special, 3) && mon_def<hero_atk) mon_def=hero_atk-1; // 坚固
 
     // 实际操作
     var turn = 0; // 0为勇士攻击
@@ -404,7 +386,7 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
     var turns = 2;
     if (core.enemys.hasSpecial(mon_special, 4)) turns=3;
     if (core.enemys.hasSpecial(mon_special, 5)) turns=4;
-    if (core.enemys.hasSpecial(mon_special, 6)) turns=5;
+    if (core.enemys.hasSpecial(mon_special, 6)) turns=1+(monster.n||4);
 
 
     // 初始伤害
@@ -422,7 +404,7 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
         hero_mdef=0;
     }
 
-    var specialText = core.enemys.getSpecialText(monsterId);
+    var specialTexts = core.enemys.getSpecialText(monsterId);
 
     var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
 
@@ -465,7 +447,6 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
     core.canvas.ui.textAlign='center';
     core.fillText('ui', core.status.hero.name, left+margin+boxWidth/2, top+margin+heroHeight+40, '#FFD700', 'bold 22px Verdana');
     core.fillText('ui', "怪物", left+right-margin-boxWidth/2, top+margin+32+40);
-    var specialTexts = specialText.split(" ");
     for (var i=0, j=0; i<specialTexts.length;i++) {
         if (specialTexts[i]!='') {
             core.fillText('ui', specialTexts[i], left+right-margin-boxWidth/2, top+margin+32+44+20*(++j), '#FF6A6A', '15px Verdana');
@@ -571,7 +552,7 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
     core.fillText("ui", "S", right_start-8, 208+15, "#FFFFFF", "italic bold 40px Verdana");
 
     var battleInterval = setInterval(function() {
-        core.playSound("attack", "ogg");
+        core.playSound("attack.ogg");
 
         if (turn==0) {
             // 勇士攻击
@@ -662,10 +643,7 @@ ui.prototype.drawBattleAnimate = function(monsterId, callback) {
     }, 500);
 }
 
-/**
- * 绘制“请等候...”
- * @param text
- */
+////// 绘制等待界面 //////
 ui.prototype.drawWaiting = function(text) {
 
     core.lockControl();
@@ -685,9 +663,7 @@ ui.prototype.drawWaiting = function(text) {
 
 }
 
-/**
- * 绘制“存档同步”选项
- */
+////// 绘制存档同步界面 //////
 ui.prototype.drawSyncSave = function () {
 
     core.status.event.id = 'syncSave';
@@ -698,11 +674,7 @@ ui.prototype.drawSyncSave = function () {
 
 }
 
-/**
- * 绘制“分页”
- * @param page
- * @param totalPage
- */
+////// 绘制分页 //////
 ui.prototype.drawPagination = function (page, totalPage) {
 
     core.setFont('ui', 'bold 15px Verdana');
@@ -724,11 +696,8 @@ ui.prototype.drawPagination = function (page, totalPage) {
 
 }
 
-/**
- * 绘制怪物手册
- * @param page 页数
- */
-ui.prototype.drawEnemyBook = function (page) {
+////// 绘制怪物手册 //////
+ui.prototype.drawBook = function (index) {
 
     var enemys = core.enemys.getCurrentEnemys();
     var background = core.canvas.ui.createPattern(core.material.ground, "repeat");
@@ -758,11 +727,12 @@ ui.prototype.drawEnemyBook = function (page) {
         return;
     }
 
+    if (index<0) index=0;
+    if (index>=enemys.length) index=enemys.length-1;
     var perpage = 6;
+    var page=parseInt(index/perpage)+1;
     var totalPage = parseInt((enemys.length - 1) / perpage) + 1;
-    if (page < 1) page = 1;
-    if (page > totalPage) page = totalPage;
-    core.status.event.data = page;
+    core.status.event.data = index;
     var start = (page - 1) * perpage, end = Math.min(page * perpage, enemys.length);
 
     enemys = enemys.slice(start, end);
@@ -834,15 +804,79 @@ ui.prototype.drawEnemyBook = function (page) {
         core.fillText('ui', '1防', 335, 62 * i + 68, '#DDDDDD', '13px Verdana');
         core.fillText('ui', enemy.defDamage, 365, 62 * i + 68, '#DDDDDD', 'bold 13px Verdana');
 
+        if (index == start+i) {
+            core.strokeRect('ui', 10, 62 * i + 13, 416-10*2,  62, '#FFD700');
+        }
+
     }
     core.setBoxAnimate();
     this.drawPagination(page, totalPage);
 }
 
-/**
- * 绘制楼传器
- * @param page
- */
+////// 绘制怪物属性的详细信息 //////
+ui.prototype.drawBookDetail = function (index) {
+    var enemys = core.enemys.getCurrentEnemys();
+    if (enemys.length==0) return;
+    if (index<0) index=0;
+    if (index>=enemys.length) index=enemys.length-1;
+
+    var enemy = enemys[index];
+    var enemyId=enemy.id;
+    var hints=core.enemys.getSpecialHint(core.enemys.getEnemys(enemyId));
+
+    if (hints.length==0) {
+        core.drawTip("该怪物无特殊属性！");
+        return;
+    }
+    var content=hints.join("\n");
+
+    core.status.event.id = 'book-detail';
+    clearInterval(core.interval.tipAnimate);
+
+    core.clearMap('data', 0, 0, 416, 416);
+    core.setOpacity('data', 1);
+
+    var left=10, right=416-2*left;
+    var content_left = left + 25;
+
+    var validWidth = right-(content_left-left)-13;
+    var contents = core.splitLines("data", content, validWidth, '16px Verdana');
+
+    var height = 416 - 10 - Math.min(416-24*(contents.length+1)-65, 250);
+    var top = (416-height)/2, bottom = height;
+
+    // var left = 97, top = 64, right = 416 - 2 * left, bottom = 416 - 2 * top;
+    core.setAlpha('data', 0.9);
+    core.fillRect('data', left, top, right, bottom, '#000000');
+    core.setAlpha('data', 1);
+    core.strokeRect('data', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);
+
+    // 名称
+    core.canvas.data.textAlign = "left";
+
+    core.fillText('data', enemy.name, content_left, top + 30, '#FFD700', 'bold 22px Verdana');
+    var content_top = top + 57;
+
+    for (var i=0;i<contents.length;i++) {
+        // core.fillText('data', contents[i], content_left, content_top, '#FFFFFF', '16px Verdana');
+        var text=contents[i];
+        var index=text.indexOf("：");
+        if (index>=0) {
+            var x1 = text.substring(0, index+1);
+            core.fillText('data', x1, content_left, content_top, '#FF6A6A', 'bold 16px Verdana');
+            var len=core.canvas.data.measureText(x1).width;
+            core.fillText('data', text.substring(index+1), content_left+len, content_top, '#FFFFFF', '16px Verdana');
+        }
+        else {
+            core.fillText('data', contents[i], content_left, content_top, '#FFFFFF', '16px Verdana');
+        }
+        content_top+=24;
+    }
+
+    core.fillText('data', '<点击任意位置继续>', 270, top+height-13, '#CCCCCC', '13px Verdana');
+}
+
+////// 绘制楼层传送器 //////
 ui.prototype.drawFly = function(page) {
 
     if (page<0) page=0;
@@ -868,6 +902,7 @@ ui.prototype.drawFly = function(page) {
     this.drawThumbnail(floorId, 'ui', core.status.maps[floorId].blocks, 20, 100, 273);
 }
 
+////// 绘制道具栏 //////
 ui.prototype.drawToolbox = function(index) {
 
     var tools = Object.keys(core.status.hero.items.tools).sort();
@@ -982,7 +1017,7 @@ ui.prototype.drawToolbox = function(index) {
     core.fillText('ui', '返回游戏', 370, 403,'#DDDDDD', 'bold 15px Verdana');
 }
 
-
+////// 绘制存档/读档界面 //////
 ui.prototype.drawSLPanel = function(index) {
     if (!core.isset(index)) index=1;
     if (index<=0) index=1;
@@ -1036,6 +1071,7 @@ ui.prototype.drawSLPanel = function(index) {
     this.drawPagination(page+1, 30);
 }
 
+////// 绘制一个缩略图 //////
 ui.prototype.drawThumbnail = function(floorId, canvas, blocks, x, y, size, heroLoc) {
     core.clearMap(canvas, x, y, size, size);
     var groundId = core.floors[floorId].defaultGround || "ground";
@@ -1073,9 +1109,7 @@ ui.prototype.drawThumbnail = function(floorId, canvas, blocks, x, y, size, heroL
     }
 }
 
-/**
- * 绘制"关于"
- */
+////// 绘制“关于”界面 //////
 ui.prototype.drawAbout = function() {
 
     if (!core.isPlaying()) {
@@ -1101,18 +1135,9 @@ ui.prototype.drawAbout = function() {
     core.fillText('ui', "作者： 艾之葵", text_start, top + 80, "#FFFFFF", "bold 17px Verdana");
     core.fillText('ui', 'HTML5魔塔交流群：539113091', text_start, top+112);
     // TODO: 写自己的“关于”页面
-    /*
-    core.fillText('ui', "原作： ss433_2", text_start, top + 112, "#FFFFFF", "bold 17px Verdana");
-    core.fillText('ui', "制作工具： WebStorm", text_start, top + 144, "#FFFFFF", "bold 17px Verdana");
-    core.fillText('ui', "测试平台： Chrome/微信/iOS", text_start, top + 176, "#FFFFFF", "bold 17px Verdana");
-    core.fillText('ui', '特别鸣谢： ss433_2', text_start, top+208);
-    var len = core.canvas.ui.measureText('特别鸣谢： ').width;
-    core.fillText('ui', 'iEcho', text_start+len, top+240);
-    core.fillText('ui', '打Dota的喵', text_start+len, top+272);
-    core.fillText('ui', 'HTML5魔塔交流群：539113091', text_start, top+304);
-    */
 }
 
+////// 绘制帮助页面 //////
 ui.prototype.drawHelp = function () {
     core.drawText([
         "\t[键盘快捷键列表]"+
diff --git a/main.js b/main.js
index e0535ce5..4d33ced5 100644
--- a/main.js
+++ b/main.js
@@ -49,12 +49,15 @@ function main() {
     ];
     this.images = [
         'animates', 'enemys', 'hero', 'items', 'npcs', 'terrains'
-        // Autotile 动态添加
     ];
-    this.sounds = {
-        'mp3': ['bgm-loop', 'floor'],
-        'ogg': ['attack', 'door', 'item']
-    }
+    this.bgms = [ // 在此存放所有的bgm，和文件名一致。第一项为默认播放项
+        // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+        '058-Slow01.mid', 'bgm.mp3', 'qianjin.mid', 'star.mid'
+    ];
+    this.sounds = [ // 在此存放所有的SE，和文件名一致
+        // 音频名不能使用中文，不能带空格或特殊字符；可以直接改名拼音就好
+        'floor.mp3', 'attack.ogg', 'door.ogg', 'item.ogg'
+    ]
     this.statusBar = {
         'image': {
             'floor': document.getElementById('img-floor'),
@@ -121,7 +124,7 @@ main.prototype.init = function (mode) {
                 coreData[name] = main[name];
             }
             main.loaderFloors(function() {
-                main.core.init(main.dom, main.statusBar, main.canvas, main.images, main.sounds, main.floorIds, main.floors, coreData);
+                main.core.init(main.dom, main.statusBar, main.canvas, main.images, main.bgms, main.sounds, main.floorIds, main.floors, coreData);
                 main.core.resize(main.dom.body.clientWidth, main.dom.body.clientHeight);
             });
         });
@@ -240,18 +243,6 @@ main.dom.body.onselectstart = function () {
     return false;
 }
 
-document.onmousemove = function() {
-    try {
-        main.core.loadSound();
-    }catch (e) {}
-}
-
-document.ontouchstart = function() {
-    try {
-        main.core.loadSound();
-    }catch (e) {}
-}
-
 main.dom.data.onmousedown = function (e) {
     try {
         e.stopPropagation();
diff --git a/sounds/058-Slow01.mid b/sounds/058-Slow01.mid
new file mode 100644
index 00000000..05ce9228
Binary files /dev/null and b/sounds/058-Slow01.mid differ
diff --git a/sounds/qianjin.mid b/sounds/qianjin.mid
new file mode 100644
index 00000000..b4236a96
Binary files /dev/null and b/sounds/qianjin.mid differ
diff --git a/sounds/star.mid b/sounds/star.mid
new file mode 100644
index 00000000..cc78e590
Binary files /dev/null and b/sounds/star.mid differ
diff --git a/常用工具/便捷PS工具.exe b/常用工具/便捷PS工具.exe
index c27e7010..a85e29fd 100644
Binary files a/常用工具/便捷PS工具.exe and b/常用工具/便捷PS工具.exe differ
diff --git a/更新说明.txt b/更新说明.txt
index 6e9cc527..a1f801b8 100644
--- a/更新说明.txt
+++ b/更新说明.txt
@@ -1,11 +1,39 @@
-全键盘操作  √
-进阶  √
-Ctrl快速跳过对话  √
-增加负伤  √
-支持不同层使用不同的地面素材  √
-支持多个Autotile同时存在  √
-直接内嵌了诸多默认的terrains素材  √
-自动定位到上次存/读档位置  √
-设置储存  √
-修改setFg的实现方法  √
-大范围领域伤害
\ No newline at end of file
+HTML5魔塔样板V1.3：
+
+支持全键盘操作。
+便捷PS工具支持更改图片色相。
+支持经验升级（进阶/境界塔）。
+打败怪物可以进行加点（加点塔）。
+增加阻击、N连击等属性；在怪物手册有属性显示。
+支持九宫格领域和大范围领域。
+增加负伤。
+支持各种BGM的播放。
+支持不同层使用不同的地面素材；支持多个Autotile同时存在。
+许多细节进行了优化，一些已知的Bug进行了修复。
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V1.2：
+
+新增：本地HTTP服务器。
+新增：可视化地图编辑工具。
+新增：便捷PS工具。
+移除了meaning.txt，现在“地图生成器”将直接从js文件中读取数字和图块对应关系。
+新增：对Autotile图块的支持。
+新增：怪物支持多种属性；添加仇恨属性。
+移除了不再支持的checkBlock，现在对于领域和夹击无需再手动指定可能的点了。
+新增：单向箭头、感叹号（单次通行）的支持。
+新增：更多的默认素材，现在对于大多数地图风格无需P图，直接替换即可。
+添加部分自定义事件，部分细节优化，一些已知的Bug进行了修复。
+
+-----------------------------------------------------------------------
+
+HTML5魔塔样板V1.1：
+
+新增：战斗过程显示，可以在设置中关闭
+新增：勇士支持48*32（大图）的行走图
+新增：更改画面色调
+新增：文字显示支持自动换行
+部分修改状态栏UI
+增添Web的Markdown文档，移除原本的doc和pdf文档。
+修复若干Bug。