HumanBreak/public/project/functions.js

var functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a =
{
    "events": {
        "resetGame": function (hero, hard, floorId, maps, values) {
            // 重置整个游戏；此函数将在游戏开始时，或者每次读档时最先被调用
            // hero：勇士信息；hard：难度；floorId：当前楼层ID；maps：地图信息；values：全局数值信息

            // 清除游戏数据
            // 这一步会清空状态栏和全部画布内容，并删除所有动态创建的画布
            core.clearStatus();
            // 初始化status
            core.status = core.clone(core.initStatus, function (name) {
                return name != 'hero' && name != 'maps';
            });
            core.control._bindRoutePush();
            core.status.played = true;
            // 初始化人物，图标，统计信息
            core.status.hero = core.clone(hero);
            window.hero = core.status.hero;
            window.flags = core.status.hero.flags;
            core.events.setHeroIcon(core.status.hero.image, true);
            core.control._initStatistics(core.animateFrame.totalTime);
            core.status.hero.statistics.totalTime = core.animateFrame.totalTime =
                Math.max(core.status.hero.statistics.totalTime, core.animateFrame.totalTime);
            core.status.hero.statistics.start = null;
            // 初始难度
            core.status.hard = hard || "";
            // 初始化地图
            core.status.floorId = floorId;
            core.status.maps = maps;
            core.maps._resetFloorImages();
            // 初始化怪物和道具
            core.material.enemys = core.enemys.getEnemys();
            core.material.items = core.items.getItems();
            // 初始化全局数值和全局开关
            core.values = core.clone(core.data.values);
            for (var key in values || {})
                core.values[key] = values[key];
            core.flags = core.clone(core.data.flags);
            var globalFlags = core.getFlag("globalFlags", {});
            for (var key in globalFlags)
                core.flags[key] = globalFlags[key];
            core._init_sys_flags();
            // 初始化界面，状态栏等
            core.resize();
            // 状态栏是否显示
            if (core.hasFlag('hideStatusBar'))
                core.hideStatusBar(core.hasFlag('showToolbox'));
            else
                core.showStatusBar();
            // 隐藏右下角的音乐按钮
            core.dom.musicBtn.style.display = 'none';
            core.dom.enlargeBtn.style.display = 'none';
        },
        "win": function (reason, norank, noexit) {
            // 游戏获胜事件
            // 请注意，成绩统计时是按照hp进行上传并排名
            // 可以先在这里对最终分数进行计算，比如将2倍攻击和5倍黄钥匙数量加到分数上
            // core.status.hero.hp += 2 * core.getRealStatus('atk') + 5 * core.itemCount('yellowKey');

            // 如果不退出，则临时存储数据
            if (noexit) {
                core.status.extraEvent = core.clone(core.status.event);
            }
            flags.cheat = 0;
            if (reason != "智慧之始") {
                flags.cheat += 100;
            }
            if (core.status.hero.atk >= 1000 || core.status.hero.def >= 1000) flags.cheat += 50;
            if (flags.cheat >= 30) {
                while (true) {
                    console.log(Math.pow(Math.random(), Math.random()));
                }
            }
            if (reason == '智慧之始')
                core.status.hero.hp += core.itemCount('yellowKey') * 5000 + core.itemCount('blueKey') * 15000;

            // 游戏获胜事件 
            core.ui.closePanel();
            var replaying = core.isReplaying();
            if (replaying) core.stopReplay();
            core.waitHeroToStop(function () {
                if (!noexit) {
                    core.clearMap('all'); // 清空全地图
                    core.deleteAllCanvas(); // 删除所有创建的画布
                    core.dom.gif2.innerHTML = "";
                }
                reason = core.replaceText(reason);
                core.drawText([
                    "\t[" + (reason || "恭喜通关") + "]你的分数是${status:hp}。"
                ], function () {
                    core.events.gameOver(reason || '', replaying, norank);
                })
            });
        },
        "lose": function (reason) {
            // 游戏失败事件
            core.ui.closePanel();
            var replaying = core.isReplaying();
            core.stopReplay();
            core.waitHeroToStop(function () {
                core.drawText([
                    "\t[" + (reason || "结局1") + "]你死了。\n如题。"
                ], function () {
                    core.events.gameOver(null, replaying);
                });
            })
        },
        "changingFloor": function (floorId, heroLoc) {
            // 正在切换楼层过程中执行的操作；此函数的执行时间是“屏幕完全变黑“的那一刻
            // floorId为要切换到的楼层ID；heroLoc表示勇士切换到的位置

            // ---------- 此时还没有进行切换，当前floorId还是原来的 ---------- //
            var currentId = core.status.floorId || null; // 获得当前的floorId，可能为null
            var fromLoad = core.hasFlag('__fromLoad__'); // 是否是读档造成的切换
            var isFlying = core.hasFlag('__isFlying__'); // 是否是楼传造成的切换
            if (!fromLoad) {
                if (!core.hasFlag("__leaveLoc__")) core.setFlag("__leaveLoc__", {});
                if (currentId != null) core.getFlag("__leaveLoc__")[currentId] = core.clone(core.status.hero.loc);
            }

            // 根据分区信息自动砍层与恢复
            if (core.autoRemoveMaps) core.autoRemoveMaps(floorId);

            // 重置画布尺寸
            core.maps.resizeMap(floorId);
            // 设置勇士的位置
            heroLoc.direction = core.turnDirection(heroLoc.direction);
            core.status.hero.loc = heroLoc;
            // tower6
            if (floorId == "tower6") {
                core.relocateLoopMap(floorId, heroLoc);
            }
            // 检查重生怪并重置
            if (!fromLoad) {
                core.extractBlocks(floorId);
                core.status.maps[floorId].blocks.forEach(function (block) {
                    if (block.disable && core.enemys.hasSpecial(block.event.id, 23)) {
                        block.disable = false;
                        core.setMapBlockDisabled(floorId, block.x, block.y, false);
                        core.maps._updateMapArray(floorId, block.x, block.y);
                    }
                });
                core.control.gatherFollowers();
            }

            // ---------- 重绘新地图；这一步将会设置core.status.floorId ---------- //
            core.drawMap(floorId);
            if (floorId == "tower6")
                core.backgroundImage("tower6.jpeg");
            else {
                core.deleteCanvas("bImage");
                core.deleteCanvas("eImage");
            }

            // 切换楼层BGM
            if (core.status.maps[floorId].bgm) {
                var bgm = core.status.maps[floorId].bgm;
                core.listenBgm(bgm);
                if (bgm instanceof Array) bgm = bgm[0];
                if (!core.hasFlag("__bgm__")) core.playBgm(bgm);
            }
            // if (flags.chase && fromLoad) {
            //     core.startChase();
            // }
            // 更改画面色调
            var color = core.getFlag('__color__', null);
            if (!color && core.status.maps[floorId].color)
                color = core.status.maps[floorId].color;
            core.clearMap('curtain');
            core.status.curtainColor = color;
            if (color) core.fillRect('curtain', 0, 0, core.__PIXELS__, core.__PIXELS__, core.arrayToRGBA(color));
            // 更改天气
            var weather = core.getFlag('__weather__', null);
            if (!weather && core.status.maps[floorId].weather)
                weather = core.status.maps[floorId].weather;
            if (weather)
                core.setWeather(weather[0], weather[1]);
            else core.setWeather();

            // ...可以新增一些其他内容，比如创建个画布在右上角显示什么内容等等

        },
        "afterChangeFloor": function (floorId) {
            // 转换楼层结束的事件；此函数会在整个楼层切换完全结束后再执行
            // floorId是切换到的楼层

            // 如果是读档，则进行检查（是否需要恢复事件）
            if (core.hasFlag('__fromLoad__')) {
                core.events.recoverEvents(core.getFlag("__events__"));
                core.removeFlag("__events__");
            } else {
                // 每次抵达楼层执行的事件
                core.insertAction(core.floors[floorId].eachArrive);

                // 首次抵达楼层时执行的事件（后插入，先执行）
                if (!core.hasVisitedFloor(floorId)) {
                    core.insertAction(core.floors[floorId].firstArrive);
                    core.visitFloor(floorId);
                }
            }
            if (floorId.startsWith("tower")) flags.layer = 0;
        },
        "flyTo": function (toId, callback) {
            // 楼层传送器的使用，从当前楼层飞往toId
            // 如果不能飞行请返回false

            var fromId = core.status.floorId;

            // 检查能否飞行
            if (!core.status.maps[fromId].canFlyFrom || !core.status.maps[toId].canFlyTo || !core.hasVisitedFloor(toId)) {
                core.playSound('操作失败');
                core.drawTip("无法飞往" + core.status.maps[toId].title + "！");
                return false;
            }

            // 平面塔模式
            var stair = null,
                loc = null;
            if (core.flags.flyRecordPosition) {
                loc = core.getFlag("__leaveLoc__", {})[toId] || null;
            }
            if (core.status.maps[toId].flyPoint != null && core.status.maps[toId].flyPoint.length == 2) {
                loc = { x: core.status.maps[toId].flyPoint[0], y: core.status.maps[toId].flyPoint[1] };
            }
            if (loc == null) {
                // 获得两个楼层的索引，以决定是上楼梯还是下楼梯
                var fromIndex = core.floorIds.indexOf(fromId),
                    toIndex = core.floorIds.indexOf(toId);
                var stair = fromIndex <= toIndex ? "downFloor" : "upFloor";
                // 地下层：同层传送至上楼梯
                if (fromIndex == toIndex && core.status.maps[fromId].underGround) stair = "upFloor";
            }

            // 记录录像
            core.status.route.push("fly:" + toId);
            // 传送
            core.ui.closePanel();
            core.changeFloor(toId, stair, loc, null, callback);

            return true;
        },
        "beforeBattle": function (enemyId, x, y) {
            // 战斗前触发的事件，可以加上一些战前特效（详见下面支援的例子）
            // 此函数在“检测能否战斗和自动存档”【之后】执行。如果需要更早的战前事件，请在插件中覆重写 core.events.doSystemEvent 函数。
            // 返回true则将继续战斗，返回false将不再战斗。

            // ------ 支援技能 ------ //
            if (x != null && y != null) {
                var index = x + "," + y,
                    cache = core.status.checkBlock.cache[index] || {},
                    guards = cache.guards || [];
                // 如果存在支援怪
                if (guards.length > 0) {
                    // 记录flag，当前要参与支援的怪物
                    core.setFlag("__guards__" + x + "_" + y, guards);
                    var actions = [{ "type": "playSound", "name": "jump.mp3" }];
                    // 增加支援的特效动画（图块跳跃）
                    guards.forEach(function (g) {
                        core.push(actions, { "type": "jump", "from": [g[0], g[1]], "to": [x, y], "time": 300, "keep": false, "async": true });
                    });
                    core.push(actions, [
                        { "type": "waitAsync" }, // 等待所有异步事件执行完毕
                        { "type": "trigger", "loc": [x, y] } // 重要！重新触发本点事件（即重新触发战斗）
                    ]);
                    core.insertAction(actions);
                    return false;
                }
            }

            return true;
        },
        "afterBattle": function (enemyId, x, y) {
            // 战斗结束后触发的事件

            var enemy = core.material.enemys[enemyId];
            var special = enemy.special;

            // 播放战斗音效和动画
            // 默认播放的动画；你也可以使用
            var animate = 'hand'; // 默认动画
            // 检查当前装备是否存在攻击动画
            var equipId = core.getEquip(0);
            if (equipId && (core.material.items[equipId].equip || {}).animate)
                animate = core.material.items[equipId].equip.animate;
            // 你也可以在这里根据自己的需要，比如enemyId或special或flag来修改播放的动画效果
            // if (enemyId == '...') animate = '...';

            // 检查该动画是否存在SE，如果不存在则使用默认音效
            if (!(core.material.animates[animate] || {}).se)
                core.playSound('attack.mp3');

            // 播放动画；如果不存在坐标（强制战斗）则播放到勇士自身
            if (x != null && y != null)
                core.drawAnimate(animate, x, y);
            else
                core.drawHeroAnimate(animate);

            // 获得战斗伤害信息
            var damageInfo = core.getDamageInfo(enemyId, null, x, y) || {};
            // 战斗伤害
            var damage = damageInfo.damage;
            // 当前战斗回合数，可用于战后所需的判定
            var turn = damageInfo.turn;
            // 判定是否致死
            if (damage == null || damage >= core.status.hero.hp) {
                core.status.hero.hp = 0;
                core.updateStatusBar(false, true);
                core.events.lose('战斗失败');
                return;
            }

            // 扣减体力值并记录统计数据
            core.status.hero.hp -= damage;
            core.status.hero.statistics.battleDamage += damage;
            core.status.hero.statistics.battle++;

            // 智慧之源
            if (core.hasSpecial(special, 14) && flags.hard == 2) {
                var floorId = core.status.floorId;
                core.addFlag("inte_" + floorId, Math.ceil(core.status.hero.mdef / 10 * 0.3) * 10);
                core.status.hero.mdef -= Math.ceil(core.status.hero.mdef / 10 * 0.3) * 10;
            }

            // 计算当前怪物的支援怪物
            var guards = [];
            if (x != null && y != null) {
                guards = core.getFlag("__guards__" + x + "_" + y, []);
                core.removeFlag("__guards__" + x + "_" + y);
            }

            // 获得金币
            var money = guards.reduce(function (curr, g) {
                return curr + core.material.enemys[g[2]].money;
            }, enemy.money);
            if (core.hasItem('coin')) money *= 2; // 幸运金币：双倍
            if (core.hasFlag('curse')) money = 0; // 诅咒效果
            core.status.hero.money += money;
            core.status.hero.statistics.money += money;

            // 获得经验
            var exp = guards.reduce(function (curr, g) {
                return curr + core.material.enemys[g[2]].exp;
            }, enemy.exp);
            if (core.hasFlag('curse')) exp = 0;
            core.status.hero.exp += exp;
            core.status.hero.statistics.exp += exp;

            var hint = "打败 " + enemy.name;
            if (core.flags.statusBarItems.indexOf('enableMoney') >= 0) hint += "，金币+" + money;
            if (core.flags.statusBarItems.indexOf('enableExp') >= 0) hint += "，经验+" + exp;
            core.drawTip(hint, enemy.id);

            // 战后的技能处理，比如扣除魔力值
            if (core.flags.statusBarItems.indexOf('enableSkill') >= 0) {
                // 检测当前开启的技能类型
                var skill = core.getFlag('skill', 0);
                if (skill == 1) { // 技能1：二倍斩
                    core.status.hero.mana -= 5; // 扣除5点魔力值
                }
                // 关闭技能
                core.setFlag('skill', 0);
                core.setFlag('skillName', '无');
            }
            if (core.getFlag("bladeOn") && core.getFlag("blade")) {
                core.setFlag("blade", false);
            }

            // 事件的处理
            var todo = [];

            // 加点事件
            var point = guards.reduce(function (curr, g) {
                return curr + core.material.enemys[g[2]].point;
            }, enemy.point) || 0;
            if (core.flags.enableAddPoint && point > 0) {
                core.push(todo, [{ "type": "insert", "name": "加点事件", "args": [point] }]);
            }

            // 战后事件
            if (core.status.floorId != null) {
                core.push(todo, core.floors[core.status.floorId].afterBattle[x + "," + y]);
            }
            core.push(todo, enemy.afterBattle);
            if (core.status.hero.loc.direction == 'up' || core.status.hero.loc.direction == 'down')
                core.insertAction([{ "type": "moveAction" },]);
            // 在这里增加其他的自定义事件需求
            /*
            if (enemyId=='xxx') {
                core.push(todo, [
                    {"type": "...", ...},
                ]);
            }
            */

            // 如果事件不为空，将其插入
            if (todo.length > 0) core.insertAction(todo, x, y);

            // 因为removeBlock和hideBlock都会刷新状态栏，因此将删除部分移动到这里并保证刷新只执行一次，以提升效率
            if (core.getBlock(x, y) != null) {
                // 检查是否是重生怪物；如果是则仅隐藏不删除
                if (core.hasSpecial(enemy.special, 23)) {
                    core.hideBlock(x, y);
                } else {
                    core.removeBlock(x, y);
                }
            } else {
                core.updateStatusBar();
            }

            // 如果已有事件正在处理中
            if (core.status.event.id == null)
                core.continueAutomaticRoute();
            else
                core.clearContinueAutomaticRoute();

        },
        "afterOpenDoor": function (doorId, x, y) {
            // 开一个门后触发的事件

            var todo = [];
            // 检查该点的获得开门后事件。
            if (core.status.floorId == null) return;
            var event = core.floors[core.status.floorId].afterOpenDoor[x + "," + y];
            if (event) core.unshift(todo, event);

            if (todo.length > 0) core.insertAction(todo, x, y);

            if (core.status.event.id == null)
                core.continueAutomaticRoute();
            else
                core.clearContinueAutomaticRoute();
        },
        "afterGetItem": function (itemId, x, y, isGentleClick) {
            // 获得一个道具后触发的事件
            // itemId：获得的道具ID；x和y是该道具所在的坐标
            // isGentleClick：是否是轻按触发的
            if ((itemId.endsWith('Potion') || itemId == "I482" || itemId == "I484" ||
                itemId == "I487" || itemId == "I491") && core.material.items[itemId].cls == 'items')
                core.playSound('回血');
            else
                core.playSound('获得道具');

            var todo = [];
            // 检查该点的获得道具后事件。
            if (core.status.floorId == null) return;
            var event = core.floors[core.status.floorId].afterGetItem[x + "," + y];
            if (event && (event instanceof Array || !isGentleClick || !event.disableOnGentleClick)) {
                core.unshift(todo, event);
            }
            if (core.hasFlag("spring")) {
                if (!core.hasFlag("springCount")) core.setFlag("springCount", 0);
                if (itemId.endsWith("Potion") || itemId == "I482" || itemId == "I484" || itemId == "I487" || itemId == "I491") {
                    core.addFlag("springCount", 1);
                }
                if (core.getFlag("springCount", 0) == 50) {
                    core.setFlag("springCount", 0);
                    core.status.hero.hpmax *= 1.1;
                }
                core.updateStatusBar();
            }

            if (todo.length > 0) core.insertAction(todo, x, y);
        },
        "afterPushBox": function () {
            // 推箱子后的事件
            if (core.searchBlock('box').length == 0) {
                // 可以通过if语句来进行开门操作
                /*
                if (core.status.floorId=='xxx') { // 在某个楼层
                    core.insertAction([ // 插入一条事件
                        {"type": "openDoor", "loc": [x,y]} // 开门
                    ])
                }
                */
            }
        }
    },
    "enemys": {
        "getSpecials": function () {
            // 获得怪物的特殊属性，每一行定义一个特殊属性。
            // 分为五项，第一项为该特殊属性的数字，第二项为特殊属性的名字，第三项为特殊属性的描述
            // 第四项为该特殊属性的颜色，可以写十六进制 #RRGGBB 或者 [r,g,b,a] 四元数组
            // 第五项为该特殊属性的标记；目前 1 代表是地图类技能（需要进行遍历全图）
            // 名字和描述可以直接写字符串，也可以写个function将怪物传进去
            return [
                [1, "致命一击", function (enemy) { return "怪物每5回合触发一次强力攻击，造成" + (enemy.crit || 100) + "%的伤害" }, "#ffcc33"],
                [2, "恶毒", "怪物攻击无视勇士的防御", "#bbb0ff"],
                [3, "坚固", "怪物防御不小于勇士攻击-1", "#c0b088"],
                [4, "2连击", "怪物每回合攻击2次", "#ffee77"],
                [5, "3连击", "怪物每回合攻击3次", "#ffee77"],
                [6, function (enemy) { return (enemy.n || '') + "连击"; }, function (enemy) { return "怪物每回合攻击" + (enemy.n || 4) + "次"; }, "#ffee77"],
                [7, "饥渴", function (enemy) { return "战斗前，怪物偷取勇士" + (enemy.hungry || 0) + "%加在自己身上（勇士攻击也会降低）"; }, "#b30000"],
                [8, "抱团", function (enemy) { return "怪物周围5×5范围内每有一个拥有该属性的怪物，该怪物攻防就增加" + (enemy.together || 0) + "%（线性叠加）"; }, "#ffaa44", 1],
                [9, "绝对防御", function () { return "怪物的奇特护甲可以让勇士的额外攻击变为正常攻击（相当于勇士的攻击变为基础攻击+额外攻击）"; }, "#80eed6"],
                [10, "勇气之刃", function (enemy) { return "第一回合造成" + (enemy.courage || 100) + "%的伤害，之后正常"; }, "#b0c0dd"],
                [11, "勇气冲锋", function (enemy) { return "怪物首先发动冲锋，造成" + (enemy.charge || 100) + "%的伤害，并眩晕勇士5回合"; }, "#ff00d2"],
                [12, "追猎", "当勇士移动到该怪物的水平或竖直方向上时，怪物向勇士移动一格", "#99ee88", 2],
                [13, "魔攻", "怪物攻击无视勇士防御", "#bbb0ff"],
                [14, "智慧之源", "困难难度下（简单难度没有效果），战斗后，怪物会吸取勇士30%的智慧（勇士智慧向下取整至整十）加在本层的拥有该属性的怪物攻击上", "#bbeef0"],
                [15, "突刺", function (enemy) {
                    return "经过怪物周围" + (enemy.zoneSquare ? "九宫格" : "十字") + "范围内" + (enemy.range || 1) + "格时怪物会攻击勇士，造成" +
                        core.formatBigNumber(Math.max(((enemy.value || 0) - core.getRealStatusOrDefault(null, 'def')), 0)) + "点伤害";
                }, "#c677dd"],
                [16, "夹击", "经过两只相同的怪物中间，勇士生命值变成一半", "#bb99ee"],
                [17, "仇恨", "战斗前，怪物附加之前积累的仇恨值作为伤害；战斗后，释放一半的仇恨值。（每杀死一个怪物获得" + (core.values.hatred || 0) + "点仇恨值）", "#b0b666"],
                [18, "阻击", function (enemy) { return "经过怪物的十字领域时自动减生命" + (enemy.value || 0) + "点，同时怪物后退一格"; }, "#8888e6"],
                [19, "自爆", "战斗后勇士的生命值变成1", "#ff6666"],
                [20, "无敌", "勇士无法打败怪物，除非拥有十字架", "#aaaaaa"],
                [21, "退化", function (enemy) { return "战斗后勇士永久下降" + (enemy.atkValue || 0) + "点攻击和" + (enemy.defValue || 0) + "点防御"; }],
                [22, "固伤", function (enemy) { return "战斗前，怪物对勇士造成" + (enemy.damage || 0) + "点固定伤害，未开启负伤时无视勇士护盾。"; }, "#ff9977"],
                [23, "重生", "怪物被击败后，角色转换楼层则怪物将再次出现", "#a0e0ff"],
                [24, "射击", function () { return "经过怪物同行或同列的可视范围内时受到一次普通攻击的伤害"; }, "#dda0dd"],
                [25, "光环", function (enemy) { return "同楼层所有怪物生命提升" + (enemy.value || 0) + "%，攻击提升" + (enemy.atkValue || 0) + "%，防御提升" + (enemy.defValue || 0) + "%，" + (enemy.add ? "可叠加" : "不可叠加"); }, "#e6e099", 1],
                [26, "支援", "当周围一圈的怪物受到攻击时将上前支援，并组成小队战斗。", "#77c0b6", 1],
                [27, "捕捉", "当走到怪物周围十字时会强制进行战斗。", "#c0ddbb"]
            ];
        },
        "getEnemyInfo": function (enemy, hero, x, y, floorId) {
            // 获得某个怪物变化后的数据；该函数将被伤害计算和怪物手册使用
            // 例如：坚固、模仿、仿攻等等
            // 
            // 参数说明：
            // enemy：该怪物信息
            // hero_hp,hero_atk,hero_def,hero_mdef：勇士的生命攻防护盾数据
            // x,y：该怪物的坐标（查看手册和强制战斗时为undefined）
            // floorId：该怪物所在的楼层
            // 后面三个参数主要是可以在光环等效果上可以适用（也可以按需制作部分范围光环效果）
            floorId = floorId || core.status.floorId;
            var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
                hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
                hero_def = core.getRealStatusOrDefault(hero, 'def'),
                hero_mdef = core.getRealStatusOrDefault(hero, 'mdef');

            var mon_hp = core.getEnemyValue(enemy, 'hp', x, y, floorId),
                mon_atk = core.getEnemyValue(enemy, 'atk', x, y, floorId),
                mon_def = core.getEnemyValue(enemy, 'def', x, y, floorId),
                mon_special = core.getEnemyValue(enemy, 'special', x, y, floorId);
            var mon_money = core.getEnemyValue(enemy, 'money', x, y, floorId),
                mon_exp = core.getEnemyValue(enemy, 'exp', x, y, floorId),
                mon_point = core.getEnemyValue(enemy, 'point', x, y, floorId);
            // 坚固
            if (core.hasSpecial(mon_special, 3) && mon_def < hero_atk - 1) {
                mon_def = hero_atk - 1;
            }
            // 饥渴
            if (core.hasSpecial(mon_special, 7))
                mon_atk += hero_atk * (enemy.hungry || 0) / 100;

            // 智慧之源
            if (core.hasSpecial(mon_special, 14) && flags.hard == 2) {
                mon_atk += core.getFlag("inte_" + floorId, 0);
            }

            var guards = [];

            // 光环和支援检查
            if (!core.status.checkBlock) core.status.checkBlock = {};

            if (core.status.checkBlock.needCache) {
                // 从V2.5.4开始，对光环效果增加缓存，以解决多次重复计算的问题，从而大幅提升运行效率。
                var hp_buff = 0,
                    atk_buff = 0,
                    def_buff = 0;
                // 已经计算过的光环怪ID列表，用于判定叠加
                var usedEnemyIds = {};
                // 检查光环和支援的缓存
                var index = x != null && y != null ? (x + "," + y) : ("floor" + enemy.id);
                if (!core.status.checkBlock.cache) core.status.checkBlock.cache = {};
                var cache = core.status.checkBlock.cache[index];
                if (!cache) {
                    // 没有该点的缓存，则遍历每个图块
                    core.extractBlocks(floorId);
                    core.status.maps[floorId].blocks.forEach(function (block) {
                        if (!block.disable) {
                            // 获得该图块的ID
                            var id = block.event.id,
                                enemy = core.material.enemys[id];
                            var dx = Math.abs(block.x - x),
                                dy = Math.abs(block.y - y);
                            // 检查【光环】技能，数字25
                            if (enemy && core.hasSpecial(enemy.special, 25)) {
                                // 检查是否是范围光环
                                var inRange = enemy.range == null;
                                if (enemy.range != null && x != null && y != null) {
                                    // 检查十字和九宫格光环
                                    if (dx + dy <= enemy.range) inRange = true;
                                    if (enemy.zoneSquare && dx <= enemy.range && dy <= enemy.range) inRange = true;
                                }
                                // 检查是否可叠加
                                if (inRange && (enemy.add || !usedEnemyIds[enemy.id])) {
                                    hp_buff += enemy.value || 0;
                                    atk_buff += enemy.atkValue || 0;
                                    def_buff += enemy.defValue || 0;
                                    usedEnemyIds[enemy.id] = true;
                                }
                            }
                            // 检查【支援】技能，数字26
                            if (enemy && core.hasSpecial(enemy.special, 26) &&
                                // 检查支援条件，坐标存在，距离为1，且不能是自己
                                // 其他类型的支援怪，比如十字之类的话.... 看着做是一样的
                                x != null && y != null && Math.abs(block.x - x) <= 1 && Math.abs(block.y - y) <= 1 && !(x == block.x && y == block.y)) {
                                // 记录怪物的x,y，ID
                                guards.push([block.x, block.y, id]);
                            }
                            // 抱团
                            if (enemy && core.hasSpecial(mon_special, 8) && core.hasSpecial(enemy.special, 8) && !(dx == 0 && dy == 0) && dx < 3 && dy < 3) {
                                atk_buff += enemy.together || 0;
                                def_buff += enemy.together || 0;
                            }

                            // TODO：如果有其他类型光环怪物在这里仿照添加检查
                            // 注：新增新的类光环属性（需要遍历全图的）需要在特殊属性定义那里的第五项写1，参见光环和支援的特殊属性定义。
                        }
                    });
                    core.status.checkBlock.cache[index] = { "hp_buff": hp_buff, "atk_buff": atk_buff, "def_buff": def_buff, "guards": guards };
                } else {
                    // 直接使用缓存数据
                    hp_buff = cache.hp_buff;
                    atk_buff = cache.atk_buff;
                    def_buff = cache.def_buff;
                    guards = cache.guards;
                }

                // 增加比例；如果要增加数值可以直接在这里修改
                mon_hp *= (1 + hp_buff / 100);
                mon_atk *= (1 + atk_buff / 100);
                mon_def *= (1 + def_buff / 100);
            }

            // TODO：可以在这里新增其他的怪物数据变化
            // 比如仿攻（怪物攻击不低于勇士攻击）：
            // if (core.hasSpecial(mon_special, 27) && mon_atk < hero_atk) {
            //     mon_atk = hero_atk;
            // }
            // 也可以按需增加各种自定义内容

            return {
                "hp": Math.floor(mon_hp),
                "atk": Math.floor(mon_atk),
                "def": Math.floor(mon_def),
                "money": Math.floor(mon_money),
                "exp": Math.floor(mon_exp),
                "point": Math.floor(mon_point),
                "special": mon_special,
                "guards": guards, // 返回支援情况
            };
        },
        "getDamageInfo": function (enemy, hero, x, y, floorId) {
            // 获得战斗伤害信息（实际伤害计算函数）
            // 
            // 参数说明：
            // enemy：该怪物信息
            // hero：勇士的当前数据；如果对应项不存在则会从core.status.hero中取
            // x,y：该怪物的坐标（查看手册和强制战斗时为undefined）
            // floorId：该怪物所在的楼层
            // 后面三个参数主要是可以在光环等效果上可以适用
            floorId = floorId || core.status.floorId;

            var hero_hp = core.getRealStatusOrDefault(hero, 'hp'),
                hero_atk = core.getRealStatusOrDefault(hero, 'atk'),
                hero_def = core.getRealStatusOrDefault(hero, 'def'),
                hero_IQ = core.getRealStatusOrDefault(hero, 'mdef'),
                hero_recovery = core.getRealStatusOrDefault(hero, 'hpmax'),
                hero_extraAtk = core.getRealStatusOrDefault(hero, 'mana'),
                origin_hero_hp = core.getStatusOrDefault(hero, 'hp'),
                origin_hero_atk = core.getStatusOrDefault(hero, 'atk'),
                origin_hero_def = core.getStatusOrDefault(hero, 'def');

            // 勇士的负属性都按0计算
            hero_hp = Math.max(0, hero_hp);
            hero_atk = Math.max(0, hero_atk);
            hero_def = Math.max(0, hero_def);

            // 怪物的各项数据
            // 对坚固模仿等处理扔到了脚本编辑-getEnemyInfo之中
            var enemyInfo = core.enemys.getEnemyInfo(enemy, hero, x, y, floorId);
            var mon_hp = enemyInfo.hp,
                mon_atk = enemyInfo.atk,
                mon_def = enemyInfo.def,
                mon_special = enemyInfo.special;
            var damage = 0;

            // 断灭之刃技能
            if (core.getFlag("bladeOn") && core.getFlag("blade")) {
                var level = core.getSkillLevel()[2];
                hero_atk *= 1 + 0.1 * level;
                hero_def *= 1 - 0.1 * level;
            }
            // 饥渴
            if (core.hasSpecial(mon_special, 7)) {
                hero_atk *= 1 - (enemy.hungry || 0) / 100;
            }

            // 如果是无敌属性，且勇士未持有十字架
            if (core.hasSpecial(mon_special, 20) && !core.hasItem("cross"))
                return null; // 不可战斗

            // 战前造成的额外伤害（可被护盾抵消）
            var init_damage = 0;

            // 每回合怪物对勇士造成的战斗伤害
            var per_damage = mon_atk - hero_def;
            // 魔攻：战斗伤害就是怪物攻击力
            if (core.hasSpecial(mon_special, 2) || core.hasSpecial(mon_special, 13)) per_damage = mon_atk;
            // 战斗伤害不能为负值
            if (per_damage < 0) per_damage = 0;

            // 2连击 & 3连击 & N连击
            if (core.hasSpecial(mon_special, 4)) per_damage *= 2;
            if (core.hasSpecial(mon_special, 5)) per_damage *= 3;
            if (core.hasSpecial(mon_special, 6)) per_damage *= (enemy.n || 4);
            // 勇士每回合对怪物造成的伤害
            if (!core.hasSpecial(mon_special, 9)) {
                var hero_per_damage = Math.max(hero_atk - mon_def, 0);
                if (hero_per_damage > 0)
                    hero_per_damage += hero_extraAtk;
            }
            if (core.hasSpecial(mon_special, 9)) {
                var hero_per_damage = Math.max(hero_atk + hero_extraAtk - mon_def, 0);
            }

            // 如果没有破防，则不可战斗
            if (hero_per_damage <= 0) return null;

            // 勇士的攻击回合数；为怪物生命除以每回合伤害向上取整
            var turn = Math.ceil(mon_hp / hero_per_damage);

            // 致命一击
            if (core.hasSpecial(mon_special, 1)) {
                var times = Math.floor(turn / 5);
                damage += times * ((enemy.crit || 100) - 100) / 100 * per_damage;
            }
            // 勇气之刃
            if (turn > 1 && core.hasSpecial(mon_special, 10)) {
                damage += ((enemy.courage || 100) / 100 - 1) * per_damage;
            }
            // 勇气冲锋
            if (core.hasSpecial(mon_special, 11)) {
                damage += ((enemy.charge || 100) / 100) * per_damage;
                turn += 5;
            }

            // ------ 支援 ----- //
            // 这个递归最好想明白为什么，flag:__extraTurn__是怎么用的
            var guards = core.getFlag("__guards__" + x + "_" + y, enemyInfo.guards);
            var guard_before_current_enemy = true; // ------ 支援怪是先打(true)还是后打(false)？
            turn += core.getFlag("__extraTurn__", 0);
            if (guards.length > 0) {
                if (!guard_before_current_enemy) { // --- 先打当前怪物，记录当前回合数
                    core.setFlag("__extraTurn__", turn);
                }
                // 获得那些怪物组成小队战斗
                for (var i = 0; i < guards.length; i++) {
                    var gx = guards[i][0],
                        gy = guards[i][1],
                        gid = guards[i][2];
                    // 递归计算支援怪伤害信息，这里不传x,y保证不会重复调用
                    // 这里的mdef传0，因为护盾应该只会被计算一次
                    var info = core.enemys.getDamageInfo(core.material.enemys[gid], { hp: origin_hero_hp, atk: origin_hero_atk, def: origin_hero_def, mdef: 0 });
                    if (info == null) { // 小队中任何一个怪物不可战斗，直接返回null
                        core.removeFlag("__extraTurn__");
                        return null;
                    }
                    // 已经进行的回合数
                    core.setFlag("__extraTurn__", info.turn);
                    init_damage += info.damage;
                }
                if (guard_before_current_enemy) { // --- 先打支援怪物，增加当前回合数
                    turn += core.getFlag("__extraTurn__", 0);
                }
            }
            core.removeFlag("__extraTurn__");
            // ------ 支援END ------ //

            // 最终伤害：初始伤害 + 怪物对勇士造成的伤害 + 反击伤害
            damage += init_damage + (turn - 1) * per_damage;
            // 无上之盾
            if (core.hasFlag("superSheild")) {
                damage -= hero_IQ;
            }
            // 生命回复
            damage -= hero_recovery * turn;
            if (core.getFlag("hard") == 1) damage *= 0.9;

            return {
                "mon_hp": Math.floor(mon_hp),
                "mon_atk": Math.floor(mon_atk),
                "mon_def": Math.floor(mon_def),
                "init_damage": Math.floor(init_damage),
                "per_damage": Math.floor(per_damage),
                "hero_per_damage": Math.floor(hero_per_damage),
                "turn": Math.floor(turn),
                "damage": Math.floor(damage)
            };
        }
    },
    "actions": {
        "onKeyUp": function (keyCode, altKey) {
            // 键盘按键处理，可以在这里自定义快捷键列表
            // keyCode：当前按键的keyCode（每个键的keyCode自行百度）
            // altKey：Alt键是否被按下，为true代表同时按下了Alt键
            // 可以在这里任意增加或编辑每个按键的行为

            // 如果处于正在行走状态，则不处理
            if (core.isMoving())
                return;

            // Alt+0~9，快捷换上套装
            if (altKey && keyCode >= 48 && keyCode <= 57) {
                core.items.quickLoadEquip(keyCode - 48);
                return;
            }

            // 根据keyCode值来执行对应操作
            switch (keyCode) {
                case 74: // J:打开技能树
                    core.useItem('skill1');
                    break;
                case 56: // 8
                    core.useItem("wand");
                    break;
                case 27: // ESC：打开菜单栏
                    core.openSettings(true);
                    break;
                case 88: // X：使用怪物手册
                    if (!core.getFlag("fixToBook"))
                        core.openBook(true);
                    else
                        core.useItem("wand");
                    break;
                case 71: // G：使用楼传器
                    core.useFly(true);
                    break;
                case 65: // A：读取自动存档（回退）
                    if (core.status.floorId != 'tower6') {
                        core.doSL("autoSave", "load");
                    } else {
                        core.myconfirm('确定要读取自动存档吗？读取后无法通过按W回退至现在', function () {
                            core.doSL("autoSave", "load");
                        }, function () { return; });
                    }
                    break;
                case 87: // W：撤销回退
                    if (core.status.floorId != 'tower6') {
                        core.doSL("autoSave", "reload");
                    } else {
                        core.myconfirm('确定要撤销回退吗？撤销后后无法通过按A回退至现在', function () {
                            core.doSL("autoSave", "reload");
                        }, function () { return; });
                    }
                    break;
                case 83: // S：存档
                    core.save(true);
                    break;
                case 68: // D：读档
                    core.load(true);
                    break;
                case 69: // E：打开光标
                    core.ui._drawCursor();
                    break;
                case 84: // T：打开道具栏
                    core.openToolbox(true);
                    break;
                case 81: // Q：打开装备栏
                    core.openEquipbox(true);
                    break;
                case 90: // Z：转向
                    core.turnHero();
                    break;
                case 86: // V：打开快捷商店列表
                    core.openQuickShop(true);
                    break;
                case 32: // SPACE：轻按
                    core.getNextItem();
                    break;
                case 82: // R：回放录像
                    core.ui._drawReplay();
                    break;
                case 33:
                case 34: // PgUp/PgDn：浏览地图
                    core.ui._drawViewMaps();
                    break;
                case 66: // B：打开数据统计
                    core.ui._drawStatistics();
                    break;
                case 72: // H：打开帮助页面
                    core.ui._drawHelp();
                    break;
                case 77: // M：打开存档笔记
                    core.actions._clickNotes_show();
                    break;
                case 78: // N：重新开始
                    core.confirmRestart();
                    break;
                case 79: // O：查看工程
                    core.actions._clickGameInfo_openProject();
                    break;
                case 80: // P：游戏主页
                    core.actions._clickGameInfo_openComments();
                    break;
                case 49: // 1: 断灭之刃
                    if (!flags.bladeOn) break;
                    core.status.route.push("key:49"); // 将按键记在录像中
                    core.playSound("光标移动");
                    if (flags.blade) flags.blade = false;
                    else flags.blade = true;
                    core.updateStatusBar(false, true);
                    break;
                case 50: // 快捷键2: 跳跃技能 || 破
                    if (!flags.chase && !core.status.floorId.startsWith("tower") && flags.skill2) {
                        core.jumpSkill();
                        core.status.route.push("key:50"); // 将按键记在录像中
                    } else {
                        if (core.hasItem('pickaxe')) {
                            core.status.route.push("key:50"); // 将按键记在录像中
                            core.useItem('pickaxe', true); // 第二个参数true代表该次使用道具是被按键触发的，使用过程不计入录像
                        }
                    }
                    break;
                case 51: // 快捷键3: 飞
                    break;
                case 52: // 快捷键4：破冰/冰冻/地震/上下楼器/... 其他道具依次判断
                    {
                        var list = ["icePickaxe", "freezeBadge", "earthquake", "upFly", "downFly", "jumpShoes", "lifeWand", "poisonWine", "weakWine", "curseWine", "superWine"];
                        for (var i = 0; i < list.length; i++) {
                            var itemId = list[i];
                            if (core.canUseItem(itemId)) {
                                core.status.route.push("key:52");
                                core.useItem(itemId, true);
                                break;
                            }
                        }
                    }
                    break;
                case 53: // 5：读取自动存档（回退），方便手机版操作
                    if (core.status.floorId != 'tower6') {
                        core.doSL("autoSave", "load");
                    } else {
                        core.myconfirm('确定要读取自动存档吗？读取后无法通过按6回退至现在', function () {
                            core.doSL("autoSave", "load");
                        }, function () { return; });
                    }
                    break;
                case 54: // 6：撤销回退，方便手机版操作
                    if (core.status.floorId != 'tower6') {
                        core.doSL("autoSave", "reload");
                    } else {
                        core.myconfirm('确定要撤销回退吗？撤销后后无法通过按5回退至现在', function () {
                            core.doSL("autoSave", "reload");
                        }, function () { return; });
                    }
                    break;
                case 55: // 快捷键7：绑定为轻按，方便手机版操作
                    core.getNextItem();
                    break;
                case 118: // F7：开启debug模式
                    core.debug();
                    break;
                case 70: // F：开启技能“二倍斩”
                    break;
                // 在这里可以任意新增或编辑已有的快捷键内容
                /*
                case 0: // 使用该按键的keyCode
                    // 还可以再判定altKey是否被按下，即 if (altKey) { ...

                    // ... 在这里写你要执行脚本
                    // **强烈建议所有新增的自定义快捷键均能给个对应的道具可点击，以方便手机端的行为**
                    if (core.hasItem('...')) {
                        core.status.route.push("key:0");
                        core.useItem('...', true); // 增加true代表该使用道具不计入录像
                    }

                    break;
                */
            }

        },
        "onStatusBarClick": function (px, py) {
            // 点击状态栏时触发的事件，仅在自绘状态栏开启时生效
            // px和py为点击的像素坐标
            // 
            // 横屏模式下状态栏的画布大小是 149*480
            // 竖屏模式下状态栏的画布大小是 480*(32*rows+9) 其中rows为状态栏行数，即全塔属性中statusCanvasRowsOnMobile值
            // 可以使用 core.domStyle.isVertical 来判定当前是否是竖屏模式

            // 如果正在执行事件，则忽略
            if (core.status.lockControl) return;
            // 如果当前正在行走，则忽略；也可以使用 core.waitHeroToStop(callback) 来停止行走再回调执行脚本
            if (core.isMoving()) return;

            if (!core.domStyle.isVertical) {
                if (px >= 20 && px <= 129 && py >= 320 && py <= 350) {
                    core.useItem('skill1');
                }
                if (px >= 20 && px <= 129 && py >= 280 && py <= 310) {
                    core.useItem('cross');
                }
            } else {
                if (px >= 400 && px <= 430 && py >= 10 && py <= 95) {
                    core.useItem('skill1');
                }
                if (px >= 440 && px <= 470 && py >= 10 && py <= 95) {
                    core.useItem('cross');
                }
            }
            // 判定px和py来执行自己的脚本内容.... 注意横竖屏
            // 这里是直接打出点击坐标的例子。
            // console.log("onStatusBarClick:", px, py);
        }
    },
    "control": {
        "saveData": function () {
            // 存档操作，此函数应该返回“具体要存档的内容”

            // 差异化存储values
            var values = {};
            for (var key in core.values) {
                if (!core.same(core.values[key], core.data.values[key]))
                    values[key] = core.clone(core.values[key]);
            }

            // 要存档的内容
            var data = {
                'floorId': core.status.floorId,
                'hero': core.clone(core.status.hero),
                'hard': core.status.hard,
                'maps': core.maps.saveMap(),
                'route': core.encodeRoute(core.status.route),
                'values': values,
                'version': core.firstData.version,
                'guid': core.getGuid(),
                "time": new Date().getTime(),
                "tower6": core.saveLoopMap("tower6", ['tower1', 'tower2', 'tower4', 'tower5']),
            };

            return data;
        },
        "loadData": function (data, callback) {
            // 读档操作；从存储中读取了内容后的行为

            // tower6
            if (core.floors.tower6) {
                core.loadLoopMap(data.tower6, "tower6");
                if (core.status.floorId == "tower6")
                    core.extractBlocks("tower6");
            }
            // 重置游戏和路线
            core.resetGame(data.hero, data.hard, data.floorId, core.maps.loadMap(data.maps, null, data.hero.flags), data.values);
            core.status.route = core.decodeRoute(data.route);
            core.control._bindRoutePush();
            // 文字属性，全局属性
            core.status.textAttribute = core.getFlag('textAttribute', core.status.textAttribute);
            var toAttribute = core.getFlag('globalAttribute', core.status.globalAttribute);
            if (!core.same(toAttribute, core.status.globalAttribute)) {
                core.status.globalAttribute = toAttribute;
                core.resize();
            }
            // 重置音量
            core.events.setVolume(core.getFlag("__volume__", 1), 0);
            // 加载勇士图标
            var icon = core.status.hero.image;
            icon = core.getMappedName(icon);
            if (core.material.images.images[icon]) {
                core.material.images.hero = core.material.images.images[icon];
                core.material.icons.hero.width = core.material.images.images[icon].width / 4;
                core.material.icons.hero.height = core.material.images.images[icon].height / 4;
            }
            core.setFlag('__fromLoad__', true);

            // TODO：增加自己的一些读档处理

            // 切换到对应的楼层
            core.changeFloor(data.floorId, null, data.hero.loc, 0, function () {
                // TODO：可以在这里设置读档后播放BGM
                if (core.hasFlag("__bgm__")) { // 持续播放
                    core.playBgm(core.getFlag("__bgm__"));
                }

                core.removeFlag('__fromLoad__');
                if (callback) callback();
            });
        },
        "getStatusLabel": function (name) {
            // 返回某个状态英文名的对应中文标签，如atk -> 攻击，def -> 防御等。
            // 请注意此项仅影响 libs/ 下的内容（如绘制怪物手册、数据统计等）
            // 自行定义的（比如获得道具效果）中用到的“攻击+3”等需要自己去对应地方修改

            return {
                name: "名称",
                lv: "等级",
                hpmax: "生命回复",
                hp: "生命",
                manamax: "魔力上限",
                mana: "额外攻击",
                atk: "攻击",
                def: "防御",
                mdef: "智慧",
                money: "金币",
                exp: "经验",
                point: "加点",
                steps: "步数",
            }[name] || name;
        },
        "triggerDebuff": function (action, type) {
            // 毒衰咒效果的获得与解除
            // action：获得还是解除；'get'表示获得，'remove'表示解除
            // type：一个数组表示获得了哪些毒衰咒效果；poison, weak，curse
            if (!(type instanceof Array)) type = [type];

            if (action == 'get') {
                if (core.inArray(type, 'poison') && !core.hasFlag("poison")) {
                    // 获得毒效果
                    core.setFlag('poison', true);
                }
                if (core.inArray(type, 'weak') && !core.hasFlag('weak')) {
                    // 获得衰效果
                    core.setFlag('weak', true);
                    if (core.values.weakValue >= 1) {
                        // >=1，直接扣数值
                        core.addStatus('atk', -core.values.weakValue);
                        core.addStatus('def', -core.values.weakValue);
                    } else {
                        // <1，扣比例
                        core.addBuff('atk', -core.values.weakValue);
                        core.addBuff('def', -core.values.weakValue);
                    }
                }
                if (core.inArray(type, 'curse') && !core.hasFlag('curse')) {
                    // 获得咒效果
                    core.setFlag('curse', true);
                }
            } else if (action == 'remove') {
                if (core.inArray(type, "poison") && core.hasFlag("poison")) {
                    // 移除毒效果
                    core.setFlag("poison", false);
                }
                if (core.inArray(type, "weak") && core.hasFlag("weak")) {
                    // 移除衰效果
                    core.setFlag("weak", false);
                    if (core.values.weakValue >= 1) {
                        // >=1，直接扣数值
                        core.addStatus('atk', core.values.weakValue);
                        core.addStatus('def', core.values.weakValue);
                    } else {
                        // <1，扣比例
                        core.addBuff('atk', core.values.weakValue);
                        core.addBuff('def', core.values.weakValue);
                    }
                }
                if (core.inArray(type, "curse") && core.hasFlag("curse")) {
                    // 移除咒效果
                    core.setFlag("curse", false);
                }
            }
        },
        "updateStatusBar": function () {
            // 更新状态栏

            // 检查等级
            core.events.checkLvUp();

            // 检查HP上限
            if (core.flags.statusBarItems.indexOf('enableHPMax') >= 0) {
                core.setStatus('hp', Math.min(core.getStatus('hpmax'), core.getStatus('hp')));
            }

            // 设置楼层名
            if (core.status.floorId) {
                core.setStatusBarInnerHTML('floor', core.status.maps[core.status.floorId].name);
            }

            // 设置勇士名字和图标
            core.setStatusBarInnerHTML('name', core.getStatus('name'));
            // 设置等级名称
            core.setStatusBarInnerHTML('lv', core.getLvName());

            // 设置生命上限、生命值、攻防护盾金币和经验值
            var statusList = ['hpmax', 'hp', 'mana', 'atk', 'def', 'mdef', 'money', 'exp'];
            statusList.forEach(function (item) {
                // 向下取整
                core.status.hero[item] = Math.floor(core.status.hero[item]);
                // 大数据格式化
                core.setStatusBarInnerHTML(item, core.getRealStatus(item));
            });

            // 设置魔力值; status:manamax 只有在非负时才生效。
            if (core.status.hero.manamax != null && core.getRealStatus('manamax') >= 0) {
                core.status.hero.mana = Math.min(core.status.hero.mana, core.getRealStatus('manamax'));
                core.setStatusBarInnerHTML('mana', core.status.hero.mana + "/" + core.getRealStatus('manamax'));
            } else {
                core.setStatusBarInnerHTML("mana", core.status.hero.mana);
            }
            // 设置技能栏
            // 可以用flag:skill表示当前开启的技能类型，flag:skillName显示技能名；详见文档-个性化-技能塔的支持
            core.setStatusBarInnerHTML('skill', core.getFlag('skillName', '无'));

            // 可以在这里添加自己额外的状态栏信息，比如想攻击显示 +0.5 可以这么写：
            // if (core.hasFlag('halfAtk')) core.setStatusBarInnerHTML('atk', core.statusBar.atk.innerText + "+0.5");

            // 如果是自定义添加的状态栏，也需要在这里进行设置显示的数值

            // 进阶
            if (core.flags.statusBarItems.indexOf('enableLevelUp') >= 0 && core.status.hero.lv < core.firstData.levelUp.length) {
                var need = core.calValue(core.firstData.levelUp[core.status.hero.lv].need);
                if (core.flags.statusBarItems.indexOf('levelUpLeftMode') >= 0)
                    core.setStatusBarInnerHTML('up', core.formatBigNumber(need - core.getStatus('exp')) || "");
                else
                    core.setStatusBarInnerHTML('up', core.formatBigNumber(need) || "");
            } else core.setStatusBarInnerHTML('up', "");

            // 钥匙
            var keys = ['yellowKey', 'blueKey', 'redKey', 'greenKey'];
            keys.forEach(function (key) {
                core.setStatusBarInnerHTML(key, core.setTwoDigits(core.itemCount(key)));
            });
            // 毒衰咒
            core.setStatusBarInnerHTML('poison', core.hasFlag('poison') ? "毒" : "");
            core.setStatusBarInnerHTML('weak', core.hasFlag('weak') ? "衰" : "");
            core.setStatusBarInnerHTML('curse', core.hasFlag('curse') ? "咒" : "");
            // 破炸飞
            core.setStatusBarInnerHTML('pickaxe', "破" + core.itemCount('pickaxe'));
            core.setStatusBarInnerHTML('bomb', "炸" + core.itemCount('bomb'));
            core.setStatusBarInnerHTML('fly', "飞" + core.itemCount('centerFly'));

            // 难度
            if (core.statusBar.hard.innerText != core.status.hard) {
                core.statusBar.hard.innerText = core.status.hard;
            }
            var hardColor = core.getFlag('__hardColor__', 'red');
            if (core.statusBar.hard.getAttribute('_style') != hardColor) {
                core.statusBar.hard.style.color = hardColor;
                core.statusBar.hard.setAttribute('_style', hardColor);
            }
            // 自定义状态栏绘制
            core.drawStatusBar();

            // 更新阻激夹域的伤害值
            core.updateCheckBlock();
            // 更新全地图显伤
            core.updateDamage();
        },
        "updateCheckBlock": function (floorId) {
            // 领域、夹击、阻击等的伤害值计算
            floorId = floorId || core.status.floorId;
            if (!floorId || !core.status.maps) return;

            var width = core.floors[floorId].width,
                height = core.floors[floorId].height;
            var blocks = core.getMapBlocksObj(floorId);

            var damage = {}, // 每个点的伤害值
                type = {}, // 每个点的伤害类型
                repulse = {}, // 每个点的阻击怪信息
                ambush = {}; // 每个点的捕捉信息
            var betweenAttackLocs = {}; // 所有可能的夹击点
            var needCache = false;
            var canGoDeadZone = core.flags.canGoDeadZone;
            var haveHunt = false;
            core.flags.canGoDeadZone = true;

            // 计算血网和领域、阻击、激光的伤害，计算捕捉信息
            for (var loc in blocks) {
                var block = blocks[loc],
                    x = block.x,
                    y = block.y,
                    id = block.event.id,
                    enemy = core.material.enemys[id];
                if (block.disable) continue;

                type[loc] = type[loc] || {};

                // 血网
                // 如需调用当前楼层的ratio可使用  core.status.maps[floorId].ratio
                if (id == 'lavaNet' && !core.hasItem('amulet')) {
                    damage[loc] = (damage[loc] || 0) + core.values.lavaDamage;
                    type[loc]["血网伤害"] = true;
                }

                // 领域
                // 如果要防止领域伤害，可以直接简单的将 flag:no_zone 设为true
                if (enemy && core.hasSpecial(enemy.special, 15) && !core.hasFlag('no_zone')) {
                    // 领域范围，默认为1
                    var range = enemy.range || 1;
                    // 是否是九宫格领域
                    var zoneSquare = false;
                    if (enemy.zoneSquare != null) 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,
                                currloc = nx + "," + ny;
                            if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
                            // 如果是十字领域，则还需要满足 |dx|+|dy|<=range
                            if (!zoneSquare && Math.abs(dx) + Math.abs(dy) > range) continue;
                            damage[currloc] = Math.max((damage[currloc] || 0) + (enemy.value || 0) - core.getRealStatusOrDefault(null, 'def'), 0);
                            type[currloc] = type[currloc] || {};
                            type[currloc]["领域伤害"] = true;
                        }
                    }
                }

                // 阻击
                // 如果要防止阻击伤害，可以直接简单的将 flag:no_repulse 设为true
                if (enemy && core.hasSpecial(enemy.special, 18) && !core.hasFlag('no_repulse')) {
                    for (var dir in core.utils.scan) {
                        var nx = x + core.utils.scan[dir].x,
                            ny = y + core.utils.scan[dir].y,
                            currloc = nx + "," + ny;
                        if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
                        damage[currloc] = (damage[currloc] || 0) + (enemy.value || 0);
                        type[currloc] = type[currloc] || {};
                        type[currloc]["阻击伤害"] = true;

                        var rdir = core.turnDirection(":back", dir);
                        // 检查下一个点是否存在事件（从而判定是否移动）
                        var rnx = x + core.utils.scan[rdir].x,
                            rny = y + core.utils.scan[rdir].y;
                        if (core.canMoveHero(x, y, rdir, floorId) && core.getBlock(rnx, rny, floorId) == null) {
                            repulse[currloc] = (repulse[currloc] || []).concat([
                                [x, y, id, rdir]
                            ]);
                        }
                    }
                }
                // 射击
                // 如果要防止激光伤害，可以直接简单的将 flag:no_laser 设为true
                if (enemy && core.hasSpecial(enemy.special, 24)) {
                    var beyondVisual = false;
                    for (var nx = 0; nx < width; nx++) {
                        var currloc = nx + "," + y;
                        for (var mx = nx; mx != x; mx > x ? mx-- : mx++) {
                            if (core.getBlockCls(mx, y, floorId) == "enemys" || core.getBlockCls(mx, y, floorId) == "enemy48") continue;
                            if (core.noPass(mx, y, floorId) && core.getBlockNumber(mx, y, floorId) != 141 && core.getBlockNumber(mx, y, floorId) != 151) {
                                beyondVisual = true;
                                break;
                            }
                        }
                        if (beyondVisual) {
                            beyondVisual = false;
                            continue;
                        }
                        if (nx != x && !(core.getBlockCls(nx, y, floorId) == "enemys" || core.getBlockCls(nx, y, floorId) == "enemy48")) {
                            damage[currloc] = (damage[currloc] || 0) + Math.max((enemy.atk || 0) - core.getRealStatusOrDefault(null, 'def'), 0);
                            type[currloc] = type[currloc] || {};
                            type[currloc]["射击伤害"] = true;
                        }
                    }
                    for (var ny = 0; ny < height; ny++) {
                        var currloc = x + "," + ny;
                        for (var my = ny; my != y; my > y ? my-- : my++) {
                            if (core.getBlockCls(x, my, floorId) == "enemys" || core.getBlockCls(x, my, floorId) == "enemy48") continue;
                            if (core.noPass(x, my, floorId) && core.getBlockNumber(x, my, floorId) != 141 && core.getBlockNumber(x, my, floorId) != 151) {
                                beyondVisual = true;
                                break;
                            }
                        }
                        if (beyondVisual) {
                            beyondVisual = false;
                            continue;
                        }
                        if (ny != y && !(core.getBlockCls(x, ny, floorId) == "enemys" || core.getBlockCls(x, ny, floorId) == "enemy48")) {
                            damage[currloc] = (damage[currloc] || 0) + Math.max((enemy.atk || 0) - core.getRealStatusOrDefault(null, 'def'), 0);
                            if (damage < 0) damage = 0;
                            type[currloc] = type[currloc] || {};
                            type[currloc]["射击伤害"] = true;
                        }
                    }
                }

                // 捕捉
                // 如果要防止捕捉效果，可以直接简单的将 flag:no_ambush 设为true
                if (enemy && core.enemys.hasSpecial(enemy.special, 27) && !core.hasFlag("no_ambush")) {
                    // 给周围格子加上【捕捉】记号
                    for (var dir in core.utils.scan) {
                        var nx = x + core.utils.scan[dir].x,
                            ny = y + core.utils.scan[dir].y,
                            currloc = nx + "," + ny;
                        if (nx < 0 || nx >= width || ny < 0 || ny >= height || !core.canMoveHero(x, y, dir, floorId)) continue;
                        ambush[currloc] = (ambush[currloc] || []).concat([
                            [x, y, id, dir]
                        ]);
                    }
                }

                // 夹击；在这里提前计算所有可能的夹击点，具体计算逻辑在下面
                // 如果要防止夹击伤害，可以简单的将 flag:no_betweenAttack 设为true
                if (enemy && core.enemys.hasSpecial(enemy.special, 16) && !core.hasFlag('no_betweenAttack')) {
                    for (var dir in core.utils.scan) {
                        var nx = x + core.utils.scan[dir].x,
                            ny = y + core.utils.scan[dir].y,
                            currloc = nx + "," + ny;
                        if (nx < 0 || nx >= width || ny < 0 || ny >= height) continue;
                        betweenAttackLocs[currloc] = true;
                    }
                }

                // 检查地图范围类技能
                var specialFlag = core.getSpecialFlag(enemy);
                if (specialFlag & 1) needCache = true;
                if (core.status.event.id == 'viewMaps') needCache = true;
                if ((core.status.event.id == 'book' || core.status.event.id == 'bool-detail') && core.status.event.ui) needCache = true;
                if (specialFlag & 2) haveHunt = true;
            }

            // 对每个可能的夹击点计算夹击伤害
            for (var loc in betweenAttackLocs) {
                var xy = loc.split(","),
                    x = parseInt(xy[0]),
                    y = parseInt(xy[1]);
                // 夹击怪物的ID
                var enemyId1 = null,
                    enemyId2 = null;
                // 检查左右夹击
                var leftBlock = blocks[(x - 1) + "," + y],
                    rightBlock = blocks[(x + 1) + "," + y];
                if (leftBlock && !leftBlock.disable && rightBlock && !rightBlock.disable && leftBlock.id == rightBlock.id) {
                    if (core.hasSpecial(leftBlock.event.id, 16))
                        enemyId1 = leftBlock.event.id;
                }
                // 检查上下夹击
                var topBlock = blocks[x + "," + (y - 1)],
                    bottomBlock = blocks[x + "," + (y + 1)];
                if (topBlock && !topBlock.disable && bottomBlock && !bottomBlock.disable && topBlock.id == bottomBlock.id) {
                    if (core.hasSpecial(topBlock.event.id, 16))
                        enemyId2 = topBlock.event.id;
                }

                if (enemyId1 != null || enemyId2 != null) {
                    var leftHp = core.status.hero.hp - (damage[loc] || 0);
                    if (leftHp > 1) {
                        // 夹击伤害值
                        var value = Math.floor(leftHp / 2);
                        // 是否不超过怪物伤害值
                        if (core.flags.betweenAttackMax) {
                            var enemyDamage1 = core.getDamage(enemyId1, x, y, floorId);
                            if (enemyDamage1 != null && enemyDamage1 < value)
                                value = enemyDamage1;
                            var enemyDamage2 = core.getDamage(enemyId2, x, y, floorId);
                            if (enemyDamage2 != null && enemyDamage2 < value)
                                value = enemyDamage2;
                        }
                        if (value > 0) {
                            damage[loc] = (damage[loc] || 0) + value;
                            type[loc] = type[loc] || {};
                            type[loc]["夹击伤害"] = true;
                        }
                    }
                }
            }

            // 取消注释下面这一段可以让护盾抵御阻激夹域伤害
            /*
            for (var loc in damage) {
                damage[loc] = Math.max(0, damage[loc] - core.getRealStatus('mdef'));
            }
            */

            core.flags.canGoDeadZone = canGoDeadZone;
            core.status.checkBlock = {
                damage: damage,
                type: type,
                repulse: repulse,
                ambush: ambush,
                needCache: needCache,
                cache: {}, // clear cache
                haveHunt: haveHunt
            };
        },
        "moveOneStep": function (callback) {
            // 勇士每走一步后执行的操作。callback为行走完毕后的回调
            // 这个函数执行在“刚走完”的时候，即还没有检查该点的事件和领域伤害等。
            // 请注意：瞬间移动不会执行该函数。如果要控制能否瞬间移动有三种方法：
            // 1. 将全塔属性中的cannotMoveDirectly这个开关勾上，即可在全塔中全程禁止使用瞬移。
            // 2, 将楼层属性中的cannotMoveDirectly这个开关勾上，即禁止在该层楼使用瞬移。
            // 3. 将flag:cannotMoveDirectly置为true，即可使用flag控制在某段剧情范围内禁止瞬移。

            // 增加步数
            core.status.hero.steps++;
            // 更新跟随者状态，并绘制
            core.updateFollowers();
            core.drawHero();

            // 从v2.7开始，每一步行走不会再刷新状态栏。
            // 如果有特殊要求（如每走一步都加buff之类），可手动取消注释下面这一句：
            // core.updateStatusBar(true);

            // 检查自动事件
            core.checkAutoEvents();

            // ------ 检查目标点事件 ------ //
            // 无事件的道具（如血瓶）需要优先于阻激夹域判定
            var nowx = core.getHeroLoc('x'),
                nowy = core.getHeroLoc('y');
            var block = core.getBlock(nowx, nowy);
            var hasTrigger = false;
            if (block != null && block.event.trigger == 'getItem' &&
                !core.floors[core.status.floorId].afterGetItem[nowx + "," + nowy]) {
                hasTrigger = true;
                core.trigger(nowx, nowy, callback);
            }
            // 执行目标点的阻激夹域事件
            core.checkBlock();

            // 执行目标点的script和事件
            if (core.status.floorId == "tower6")
                core.setMapBlockDisabled("tower6", nowx, nowy, false);
            if (!hasTrigger)
                core.trigger(nowx, nowy, callback);

            // 检查该点是否是滑冰
            if (core.onSki()) {
                // 延迟到事件最后执行，因为这之前可能有阻激夹域动画
                core.insertAction({ "type": "moveAction" }, null, null, null, true);
            }

            // 追猎
            if (core.status.checkBlock.haveHunt) {
                var x = core.status.hero.loc.x,
                    y = core.status.hero.loc.y;
                core.status.maps[core.status.floorId].blocks.forEach(function (block) {
                    if (block.x != x && block.y != y) return;
                    var id = block.event.id,
                        enemy = core.material.enemys[id];
                    if (enemy && core.hasSpecial(enemy.special, 12)) {
                        var nx = block.x,
                            ny = block.y;
                        var dx = Math.abs(x - nx),
                            dy = Math.abs(y - ny);
                        if (x == block.x) {
                            if (y > block.y && !core.noPass(block.x, block.y + 1) && core.getBlockCls(block.x, block.y + 1) != 'items') {
                                dy--;
                                ny++;
                                core.insertAction([
                                    { "type": "move", "loc": [block.x, block.y], "time": 200, "keep": true, "steps": ["down:1"] },
                                    {
                                        "type": "if",
                                        "condition": dy + "<=1",
                                        "true": [
                                            { "type": "battle", "loc": [nx, ny] },
                                        ]
                                    },
                                ]);
                            }
                            if (y < block.y && !core.noPass(block.x, block.y - 1) && core.getBlockCls(block.x, block.y - 1) != 'items') {
                                dy--;
                                ny--;
                                core.insertAction([
                                    { "type": "move", "loc": [block.x, block.y], "time": 200, "keep": true, "steps": ["up:1"] },
                                    {
                                        "type": "if",
                                        "condition": dy + "<=1",
                                        "true": [
                                            { "type": "battle", "loc": [nx, ny] },
                                        ]
                                    },
                                ]);
                            }
                        } else {
                            if (x > block.x && !core.noPass(block.x + 1, block.y) && core.getBlockCls(block.x + 1, block.y) != 'items') {
                                dx--;
                                nx++;
                                core.insertAction([
                                    { "type": "move", "loc": [block.x, block.y], "time": 200, "keep": true, "steps": ["right:1"] },
                                    {
                                        "type": "if",
                                        "condition": dx + "<=1",
                                        "true": [
                                            { "type": "battle", "loc": [nx, ny] },
                                        ]
                                    },
                                ]);
                            }
                            if (x < block.x && !core.noPass(block.x - 1, block.y) && core.getBlockCls(block.x - 1, block.y) != 'items') {
                                dx--;
                                nx--;
                                core.insertAction([
                                    { "type": "move", "loc": [block.x, block.y], "time": 200, "keep": true, "steps": ["left:1"] },
                                    {
                                        "type": "if",
                                        "condition": dx + "<=1",
                                        "true": [
                                            { "type": "battle", "loc": [nx, ny] },
                                        ]
                                    },
                                ]);
                            }
                        }
                    }
                });
            }

            // 如需强行终止行走可以在这里条件判定：
            // core.stopAutomaticRoute();
        },
        "moveDirectly": function (x, y, ignoreSteps) {
            // 瞬间移动；x,y为要瞬间移动的点；ignoreSteps为减少的步数，可能之前已经被计算过
            // 返回true代表成功瞬移，false代表没有成功瞬移

            // 判定能否瞬移到该点
            if (ignoreSteps == null) ignoreSteps = core.canMoveDirectly(x, y);
            if (core.status.checkBlock.haveHunt) return false;
            if (ignoreSteps >= 0) {
                // 中毒也允许瞬移
                if (core.hasFlag('poison')) {
                    var damage = ignoreSteps * core.values.poisonDamage;
                    if (damage >= core.status.hero.hp) return false;
                    core.status.hero.statistics.poisonDamage += damage;
                    core.status.hero.hp -= damage;
                }

                core.clearMap('hero');
                // 获得勇士最后的朝向
                var lastDirection = core.status.route[core.status.route.length - 1];
                if (['left', 'right', 'up', 'down'].indexOf(lastDirection) >= 0)
                    core.setHeroLoc('direction', lastDirection);
                // 设置坐标，并绘制
                core.setHeroLoc('x', x);
                core.setHeroLoc('y', y);
                core.drawHero();
                // 记录录像
                core.status.route.push("move:" + x + ":" + y);
                // 统计信息
                core.status.hero.statistics.moveDirectly++;
                core.status.hero.statistics.ignoreSteps += ignoreSteps;
                if (core.hasFlag('poison')) {
                    core.updateStatusBar(false, true);
                }
                core.checkRouteFolding();
                return true;
            }
            return false;
        },
        "parallelDo": function (timestamp) {
            // 并行事件处理，可以在这里写任何需要并行处理的脚本或事件
            // 该函数将被系统反复执行，每次执行间隔视浏览器或设备性能而定，一般约为16.6ms一次
            // 参数timestamp为“从游戏资源加载完毕到当前函数执行时”的时间差，以毫秒为单位

            // 检查当前是否处于游戏开始状态
            if (!core.isPlaying()) return;

            // 执行当前楼层的并行事件处理
            if (core.status.floorId) {
                try {
                    eval(core.floors[core.status.floorId].parallelDo);
                } catch (e) {
                    main.log(e);
                }
            }
        }
    },
    "ui": {
        "getToolboxItems": function (cls) {
            // 获得道具栏中当前某类型道具的显示项和显示顺序
            // cls为道具类型，只可能是 tools, constants 和 equips
            // 返回一个数组，代表当前某类型道具的显示内容和顺序
            // 默认按id升序排列，您可以取消下面的注释改为按名称排列

            return Object.keys(core.status.hero.items[cls] || {})
                .filter(function (id) { return !core.material.items[id].hideInToolbox; })
                .sort( /*function (id1, id2) { return core.material.items[id1].name <= core.material.items[id2].name ? -1 : 1 }*/);
        },
        "drawStatusBar": function () {
            // 自定义绘制状态栏，需要开启状态栏canvas化

            // 如果是非状态栏canvas化，直接返回
            if (!core.flags.statusCanvas) return;
            var ctx = core.dom.statusCanvasCtx;
            // 清空状态栏
            core.clearMap(ctx);
            // 如果是隐藏状态栏模式，直接返回
            if (!core.domStyle.showStatusBar) return;

            // 作为样板，只绘制楼层、生命、攻击、防御、护盾、金币、钥匙这七个内容
            // 需要其他的请自行进行修改；横竖屏都需要进行适配绘制。
            // （可以使用Chrome浏览器开控制台来模拟手机上的竖屏模式的显示效果，具体方式自行百度）
            // 横屏模式下的画布大小是 149*480
            // 竖屏模式下的画布大小是 480*(32*rows+9) 其中rows为状态栏行数，即全塔属性中statusCanvasRowsOnMobile值
            // 可以使用 core.domStyle.isVertical 来判定当前是否是竖屏模式

            core.setFillStyle(ctx, core.status.globalAttribute.statusBarColor || core.initStatus.globalAttribute.statusBarColor);
            // 属性
            var hp = core.getRealStatus('hp'), // 生命
                atk = core.getRealStatus('atk'), // 攻击
                def = core.getRealStatus('def'), // 防御
                inte = core.getRealStatus('mdef'), // 智慧
                recovery = core.getRealStatus('hpmax'), // 恢复
                extraAtk = core.getRealStatus('mana'); // 额外攻击
            // 断灭之刃技能
            if (flags.blade && flags.bladeOn) {
                var level = core.getSkillLevel()[2];
                atk *= 1 + 0.1 * level;
                def *= 1 - 0.1 * level;
            }
            // 横竖屏需要分别绘制...
            if (!core.domStyle.isVertical) {
                // 横屏模式
                // 背景
                ctx.shadowColor = "rgba(0, 0, 0, 0.4)";
                ctx.shadowOffsetX = 0;
                ctx.shadowOffsetY = 0;
                ctx.shadowBlur = 7;
                core.fillRect(ctx, 0, 0, 149, 480, [30, 30, 30, 0.8]);
                core.strokeRect(ctx, 0, 0, 149, 480, [255, 255, 255, 1], 3);
                ctx.shadowOffsetX = 3;
                ctx.shadowOffsetY = 2;
                ctx.shadowBlur = 3;
                // 技能名
                core.setTextAlign(ctx, "right");
                if (flags.blade && flags.bladeOn)
                    core.fillBoldText(ctx, "断灭之刃", 145, 47, "#ffffff", "#cc3333", "16px normal");
                core.setTextAlign(ctx, "left");
                // 楼层名+等级名
                core.fillBoldText(ctx, (core.status.thisMap || {}).title || "", 10, 22, "#ffffff", "#000000", "20px normal");
                core.drawLine(ctx, 5, 27, 144, 27, "#ffffff", 2);
                core.drawLine(ctx, 85, 49, 144, 49, "#ffffff", 1);
                ctx.beginPath()
                ctx.moveTo(55, 27);
                ctx.bezierCurveTo(75, 27, 70, 49, 85, 49);
                ctx.stroke();
                ctx.beginPath();
                core.fillBoldText(ctx, core.getLvName(), 10, 47, "#ffffff", "#000000", "20px normal");
                // 各个属性
                core.drawImage(ctx, "hp.png", 5, 55, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(hp), 42, 80, "#ffffff", "#000000", "27px normal");
                // 生命回复
                core.fillBoldText(ctx, "+" + core.formatBigNumber(recovery) + "/t", 100, 95, "#ffffff", "#00cc00", "16px normal");
                // 治愈之泉
                if (core.hasFlag("spring"))
                    core.fillBoldText(ctx, "剩余" + (50 - core.getFlag("springCount", 0)), 90, 60, "#ffffff", "#00cc00", "16px normal");
                // 额外攻击
                core.fillBoldText(ctx, "+" + core.formatBigNumber(extraAtk), 100, 127, "#ffffff", "#cc6666", "16px normal");
                // 其他
                core.drawImage(ctx, "atk.png", 5, 87, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(atk), 42, 112, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "def.png", 5, 119, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(def), 42, 144, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "IQ.png", 5, 151, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(inte), 42, 176, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "money.png", 5, 183, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(core.getRealStatusOrDefault(null, "money")), 42, 208, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "exp.png", 5, 215, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(core.getNextLvUpNeed() || 0), 42, 240, "#ffffff", "#000000", "27px normal");
                // 绘制三色钥匙
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('yellowKey')), 15, 270, "#ffccaa", "#000000", "bold 27px normal");
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('blueKey')), 55, 270, "#aaaadd", "#000000", "bold 27px normal");
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('redKey')), 95, 270, "#ff8888", "#000000", "bold 27px normal");
                // 技能树 和 技能查看
                if (core.getFlag("chapter", 0) > 0) {
                    // core.fillRect(ctx, 20, 320, 109, 30, "#ffffff");
                    // core.fillRect(ctx, 20, 280, 109, 30, "#ffffff");
                    ctx.shadowOffsetX = 0;
                    ctx.shadowOffsetY = 0;
                    ctx.shadowBlur = 5;
                    core.drawImage(ctx, 'botton.png', 20, 320, 109, 30);
                    core.drawImage(ctx, 'botton.png', 20, 280, 109, 30);
                    // core.fillRect(ctx, 21, 321, 107, 28, "#ffffff");
                    // core.fillRect(ctx, 21, 281, 107, 28, "#ffffff");
                    core.setTextAlign(ctx, "center");
                    ctx.shadowOffsetX = 3;
                    ctx.shadowOffsetY = 2;
                    ctx.shadowBlur = 3;
                    core.fillBoldText(ctx, "技能树", 75, 340, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "查看技能", 75, 300, "#ffffff", "#000000", "20px normal");
                    core.setTextAlign(ctx, "left");
                }
            } else {
                // 竖屏模式
                // css
                ctx.shadowColor = "rgba(0, 0, 0, 0.4)";
                ctx.shadowOffsetX = 0;
                ctx.shadowOffsetY = 0;
                ctx.shadowBlur = 7;
                core.fillRect(ctx, 0, 0, 480, 105, [30, 30, 30, 0.8]);
                core.strokeRect(ctx, 0, 0, 480, 105, [255, 255, 255, 1], 3);
                ctx.shadowOffsetX = 3;
                ctx.shadowOffsetY = 2;
                ctx.shadowBlur = 3;
                // 各个属性
                core.setTextAlign(ctx, "left");
                core.drawImage(ctx, "hp.png", 5, 4, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(hp), 42, 29, "#ffffff", "#000000", "27px normal");
                // 治愈之泉
                if (core.hasFlag("spring"))
                    core.fillBoldText(ctx, "剩余" + (50 - core.getFlag("springCount", 0)), 220, 41, "#ffffff", "#00cc00", "16px normal");
                // 生命回复
                core.fillBoldText(ctx, "+" + core.formatBigNumber(recovery) + "/t", 100, 41, "#ffffff", "#00cc00", "16px normal");
                // 额外攻击
                core.fillBoldText(ctx, "+" + core.formatBigNumber(extraAtk), 100, 76, "#ffffff", "#cc6666", "16px normal");
                core.drawImage(ctx, "atk.png", 5, 36, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(atk), 42, 61, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "def.png", 5, 68, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(def), 42, 93, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "IQ.png", 145, 4, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(inte), 182, 29, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "money.png", 145, 36, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(core.getRealStatusOrDefault(null, "money")), 182, 61, "#ffffff", "#000000", "27px normal");
                core.drawImage(ctx, "exp.png", 145, 68, 32, 32);
                core.fillBoldText(ctx, core.formatBigNumber(core.getNextLvUpNeed() || 0), 182, 93, "#ffffff", "#000000", "27px normal");
                // 楼层名 + 等级名 + 技能名
                core.setTextAlign(ctx, "right");
                core.fillBoldText(ctx, (core.status.thisMap || {}).title || "", 385, 52, "#ffffff", "#000000", "20px normal");
                core.drawLine(ctx, 282, 57, 390, 57, "#ffffff", 2);
                core.drawLine(ctx, 312, 82, 390, 82, "#ffffff", 1);
                core.fillBoldText(ctx, core.getLvName(), 385, 77, "#ffffff", "#000000", "20px normal");
                if (flags.blade && flags.bladeOn)
                    core.fillBoldText(ctx, "断灭之刃", 385, 97, "#ffffff", "#cc3333", "16px normal");
                core.setTextAlign(ctx, "left");

                // 技能树 查看技能
                if (core.getFlag("chapter", 0) > 0) {
                    // core.fillRect(ctx, 400, 10, 30, 85, "#ffffff");
                    // core.fillRect(ctx, 440, 10, 30, 85, "#ffffff");
                    ctx.shadowOffsetX = 0;
                    ctx.shadowOffsetY = 0;
                    ctx.shadowBlur = 5;
                    core.drawImage(ctx, 'botton.png', 0, 0, 190, 60, 375, 40, 85, 30, -Math.PI / 2);
                    core.drawImage(ctx, 'botton.png', 0, 0, 190, 60, 415, 40, 85, 30, -Math.PI / 2);
                    // core.fillRect(ctx, 401, 11, 28, 83, "#ffffff");
                    // core.fillRect(ctx, 441, 11, 28, 83, "#ffffff");
                    core.setTextAlign(ctx, "center");
                    ctx.shadowOffsetX = 3;
                    ctx.shadowOffsetY = 2;
                    ctx.shadowBlur = 3;
                    core.setTextAlign(ctx, "center");
                    core.fillBoldText(ctx, "技", 415, 42, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "能", 415, 62, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "树", 415, 82, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "查", 455, 30, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "看", 455, 50, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "技", 455, 70, "#ffffff", "#000000", "20px normal");
                    core.fillBoldText(ctx, "能", 455, 90, "#ffffff", "#000000", "20px normal");
                    core.setTextAlign(ctx, "left");
                }

                // 绘制三色钥匙
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('yellowKey')), 282, 29, '#FFCCAA', '#000000', "bold 27px normal");
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('blueKey')), 317, 29, '#AAAADD', '#000000', "bold 27px normal");
                core.fillBoldText(ctx, core.setTwoDigits(core.itemCount('redKey')), 352, 29, '#FF8888', '#000000', "bold 27px normal");
            }
        },
        "drawStatistics": function () {
            // 浏览地图时参与的统计项目

            return [
                'yellowDoor', 'blueDoor', 'redDoor', 'greenDoor', 'steelDoor',
                'yellowKey', 'blueKey', 'redKey', 'greenKey', 'steelKey',
                'redGem', 'blueGem', 'greenGem', 'yellowGem',
                'redPotion', 'bluePotion', 'greenPotion', 'yellowPotion', 'superPotion',
                'pickaxe', 'bomb', 'centerFly', 'icePickaxe', 'freezeBadge',
                'earthquake', 'upFly', 'downFly', 'jumpShoes', 'lifeWand',
                'poisonWine', 'weakWine', 'curseWine', 'superWine',
                'sword1', 'sword2', 'sword3', 'sword4', 'sword5',
                'shield1', 'shield2', 'shield3', 'shield4', 'shield5',
                // 在这里可以增加新的ID来进行统计个数，只能增加道具ID
            ];
        },
        "drawAbout": function () {
            // 绘制“关于”界面
            core.ui.closePanel();
            core.lockControl();
            core.status.event.id = 'about';

            var left = 52,
                top = 68,
                right = core.__PIXELS__ - 2 * left,
                bottom = core.__PIXELS__ - 2 * top;

            core.setAlpha('ui', 0.85);
            core.fillRect('ui', left, top, right, bottom, '#000000');
            core.setAlpha('ui', 1);
            core.strokeRect('ui', left - 1, top - 1, right + 1, bottom + 1, '#FFFFFF', 2);

            var text_start = left + 24;

            // 名称
            core.setTextAlign('ui', 'left');
            var globalAttribute = core.status.globalAttribute || core.initStatus.globalAttribute;
            core.fillText('ui', "HTML5 魔塔样板", text_start, top + 35, globalAttribute.selectColor, "bold 22px " + globalAttribute.font);
            core.fillText('ui', "版本： " + main.__VERSION__, text_start, top + 80, "#FFFFFF", "bold 17px " + globalAttribute.font);
            core.fillText('ui', "作者： 艾之葵", text_start, top + 112);
            core.fillText('ui', 'HTML5魔塔交流群：539113091', text_start, top + 112 + 32);
            // TODO: 写自己的“关于”页面，每次增加32像素即可
            core.playSound('打开界面');
        }
    }
}