AncTe/HumanBreak
1
0
Fork 0
mirror of https://github.com/unanmed/HumanBreak.git synced 2025-01-19 12:49:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
b38e334753
HumanBreak/public/project/plugins.js
unanmed 6034d959e0 修复一些问题
2022-11-19 13:07:42 +08:00

10649 lines
399 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

///<reference path="../../src/types/core.d.ts" />
var plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1 = {
init: function () {
this._afterLoadResources = function () {};
},
sprite: function () {
const sprites = {};
// 终于能用es6了（恼
class Sprite {
constructor(x, y, w, h, z, reference, name) {
this.x = x;
this.y = y;
this.width = w;
this.height = h;
this.zIndex = z;
this.reference = reference;
/** @type {HTMLCanvasElement} */
this.canvas = null;
/** @type {CanvasRenderingContext2D} */
this.context = null;
this.count = 0;
this.name = name;
this.key = [];
this.init();
}
init() {
const name = this.name || `_sprite_${Sprite.count}`;
this.name = name;
if (this.reference === 'window') {
const canvas = document.createElement('canvas');
this.canvas = canvas;
this.context = canvas.getContext('2d');
canvas.width = this.width;
canvas.height = this.height;
canvas.style.width = this.width + 'px';
canvas.style.height = this.height + 'px';
canvas.style.position = 'absolute';
canvas.style.top = this.y + 'px';
canvas.style.left = this.x + 'px';
canvas.style.zIndex = this.zIndex.toString();
document.body.appendChild(canvas);
} else {
this.context = core.createCanvas(
name,
this.x,
this.y,
this.width,
this.height,
this.zIndex
);
this.canvas = this.context.canvas;
this.count = Sprite.count;
this.canvas.style.pointerEvents = 'auto';
}
Sprite.count++;
sprites[this.name] = this;
}
setCss(css) {
css = css.replace('\n', ';').replace(';;', ';');
const effects = css.split(';');
const canvas = this.canvas;
effects.forEach(v => {
const content = v.split(':');
let name = content[0];
let value = content[1];
name = name
.trim()
.split('-')
.reduce((pre, curr, i, a) => {
if (i === 0 && curr !== '') return curr;
if (a[0] === '' && i === 1) return curr;
return pre + curr.toUpperCase()[0] + curr.slice(1);
}, '');
if (name in canvas.style) canvas.style[name] = value;
});
return this;
}
move(x, y, isDelta) {
if (x !== undefined && x !== null) this.x = x;
if (y !== undefined && y !== null) this.y = y;
if (this.reference === 'window') {
var ele = this.canvas;
ele.style.left =
x + (isDelta ? parseFloat(ele.style.left) : 0) + 'px';
ele.style.top =
y + (isDelta ? parseFloat(ele.style.top) : 0) + 'px';
} else core.relocateCanvas(this.context, x, y, isDelta);
return this;
}
resize(w, h, styleOnly) {
if (w !== undefined && w !== null) this.width = w;
if (h !== undefined && h !== null) this.height = h;
if (this.reference === 'window') {
const ele = this.canvas;
ele.style.width = w + 'px';
ele.style.height = h + 'px';
if (!styleOnly) {
ele.width = w;
ele.height = h;
}
} else core.resizeCanvas(this.context, w, h, styleOnly);
return this;
}
rotate(angle, cx, cy) {
if (this.reference === 'window') {
const left = this.x;
const top = this.y;
this.canvas.style.transformOrigin =
cx - left + 'px ' + (cy - top) + 'px';
if (angle === 0) {
canvas.style.transform = '';
} else {
canvas.style.transform = 'rotate(' + angle + 'deg)';
}
} else {
core.rotateCanvas(this.context, angle, cx, cy);
}
return this;
}
destroy() {
if (this.reference === 'window') {
if (this.canvas) document.body.removeChild(this.canvas);
} else {
core.deleteCanvas(this.name);
}
this.key?.forEach(v =>
document.removeEventListener(v[0], v[1])
);
sprites[this.name] = void 0;
}
/**
* 类似样板registerAction接口，但是是以该sprite的左上角为(0,0)计算的
* @param {keyof HTMLElementEventMap} type
* @param {(...param: any[]) => void} handler
*/
on(type, handler) {
if (this.reference !== 'game')
throw new ReferenceError(
`当sprite的reference为window时，不可使用该函数`
);
const mouse = [
'auxclick',
'click',
'contextmenu',
'dblclick',
'mousedown',
'mouseup',
'mouseenter',
'mouseleave',
'mousemove',
'mouseout',
'mouseover'
];
const key = ['keydown', 'keypress', 'keyup'];
const touch = [
'touchstart',
'touchend',
'touchcancel',
'touchmove'
];
if (mouse.includes(type)) {
this.addEventListener(type, e => {
const px = e.offsetX / core.domStyle.scale,
py = e.offsetY / core.domStyle.scale;
handler(px, py);
});
} else if (type === 'wheel') {
this.addEventListener('wheel', e => {
handler(e.deltaY, e.deltaX, e.deltaZ);
});
} else if (key.includes(type)) {
// 键盘事件只能加到document上
const listener = e => {
handler(
e.key,
e.keyCode,
e.altKey,
e.ctrlKey,
e.shiftKey
);
};
this.key.push([type, listener]);
document.addEventListener(type, listener);
} else if (touch.includes(type)) {
this.addEventListener(type, e => {
/** @type {TouchList} */
const touches = e.touches;
const locs = [];
for (let i = 0; i < touches.length; i++) {
const t = touches[i];
const { x, y } = core.actions._getClickLoc(
t.clientX,
t.clientY
);
const px = x / core.domStyle.scale,
py = y / core.domStyle.scale;
locs.push([px, py]);
}
handler(...locs);
});
}
}
addEventListener() {
this.canvas.addEventListener.apply(this.canvas, arguments);
}
removeEventListener() {
this.canvas.removeEventListener.apply(this.canvas, arguments);
}
}
this.getSprite = function (name) {
const s = sprites[name];
if (!s) throw new ReferenceError(`不能获得不存在的sprite`);
return sprites[name];
};
Sprite.count = 0;
window.Sprite = Sprite;
},
shop: function () {
// 【全局商店】相关的功能
//
// 打开一个全局商店
// shopId：要打开的商店id；noRoute：是否不计入录像
this.openShop = function (shopId, noRoute) {
var shop = core.status.shops[shopId];
// Step 1: 检查能否打开此商店
if (!this.canOpenShop(shopId)) {
core.drawTip('该商店尚未开启');
return false;
}
// Step 2: （如有必要）记录打开商店的脚本事件
if (!noRoute) {
core.status.route.push('shop:' + shopId);
}
// Step 3: 检查道具商店 or 公共事件
if (shop.item) {
if (core.openItemShop) {
core.openItemShop(shopId);
} else {
core.playSound('操作失败');
core.insertAction(
'道具商店插件不存在！请检查是否存在该插件！'
);
}
return;
}
if (shop.commonEvent) {
core.insertCommonEvent(shop.commonEvent, shop.args);
return;
}
// Step 4: 执行标准公共商店
core.insertAction(this._convertShop(shop));
return true;
};
////// 将一个全局商店转变成可预览的公共事件 //////
this._convertShop = function (shop) {
return [
{
type: 'function',
function: "() => {core.setFlag('@temp@shop', true);}"
},
{
type: 'while',
condition: 'true',
data: [
// 检测能否访问该商店
{
type: 'if',
condition: "core.isShopVisited('" + shop.id + "')",
true: [
// 可以访问，直接插入执行效果
{
type: 'function',
function:
"() => { core.plugin._convertShop_replaceChoices('" +
shop.id +
"', false) }"
}
],
false: [
// 不能访问的情况下：检测能否预览
{
type: 'if',
condition: shop.disablePreview,
true: [
// 不可预览，提示并退出
{ type: 'playSound', name: '操作失败' },
'当前无法访问该商店！',
{ type: 'break' }
],
false: [
// 可以预览：将商店全部内容进行替换
{
type: 'tip',
text: '当前处于预览模式，不可购买'
},
{
type: 'function',
function:
"() => { core.plugin._convertShop_replaceChoices('" +
shop.id +
"', true) }"
}
]
}
]
}
]
},
{
type: 'function',
function: "() => {core.removeFlag('@temp@shop');}"
}
];
};
this._convertShop_replaceChoices = function (shopId, previewMode) {
var shop = core.status.shops[shopId];
var choices = (shop.choices || [])
.filter(choice => {
if (choice.condition == null || choice.condition == '')
return true;
try {
return core.calValue(choice.condition);
} catch (e) {
return true;
}
})
.map(choice => {
var ableToBuy = core.calValue(choice.need);
return {
text: choice.text,
icon: choice.icon,
color:
ableToBuy && !previewMode
? choice.color
: [153, 153, 153, 1],
action:
ableToBuy && !previewMode
? [{ type: 'playSound', name: '确定' }].concat(
choice.action
)
: [
{ type: 'playSound', name: '操作失败' },
{
type: 'tip',
text: previewMode
? '预览模式下不可购买'
: '购买条件不足'
}
]
};
})
.concat({ text: '离开', action: [{ type: 'break' }] });
core.insertAction({
type: 'choices',
text: shop.text,
choices: choices
});
};
/// 是否访问过某个快捷商店
this.isShopVisited = function (id) {
if (!core.hasFlag('__shops__')) core.setFlag('__shops__', {});
var shops = core.getFlag('__shops__');
if (!shops[id]) shops[id] = {};
return shops[id].visited;
};
/// 当前应当显示的快捷商店列表
this.listShopIds = function () {
return Object.keys(core.status.shops).filter(id => {
return (
core.isShopVisited(id) || !core.status.shops[id].mustEnable
);
});
};
/// 是否能够打开某个商店
this.canOpenShop = function (id) {
if (this.isShopVisited(id)) return true;
var shop = core.status.shops[id];
if (shop.item || shop.commonEvent || shop.mustEnable) return false;
return true;
};
/// 启用或禁用某个快捷商店
this.setShopVisited = function (id, visited) {
if (!core.hasFlag('__shops__')) core.setFlag('__shops__', {});
var shops = core.getFlag('__shops__');
if (!shops[id]) shops[id] = {};
if (visited) shops[id].visited = true;
else delete shops[id].visited;
};
/// 能否使用快捷商店
this.canUseQuickShop = function (id) {
// 如果返回一个字符串，表示不能，字符串为不能使用的提示
// 返回null代表可以使用
// 检查当前楼层的canUseQuickShop选项是否为false
if (core.status.thisMap.canUseQuickShop === false)
return '当前楼层不能使用快捷商店。';
return null;
};
/// 允许商店X键退出
core.registerAction(
'keyUp',
'shops',
keycode => {
if (
!core.status.lockControl ||
!core.hasFlag('@temp@shop') ||
core.status.event.id != 'action'
)
return false;
if (core.status.event.data.type != 'choices') return false;
var data = core.status.event.data.current;
var choices = data.choices;
var topIndex =
core.actions.HSIZE -
parseInt((choices.length - 1) / 2) +
(core.status.event.ui.offset || 0);
if (keycode == 88 || keycode == 27) {
// X, ESC
core.actions._clickAction(
core.actions.HSIZE,
topIndex + choices.length - 1
);
return true;
}
if (keycode == 13 || keycode == 32) return true;
return false;
},
60
);
/// 允许长按空格或回车连续执行操作
core.registerAction(
'keyDown',
'shops',
keycode => {
if (
!core.status.lockControl ||
!core.hasFlag('@temp@shop') ||
core.status.event.id != 'action'
)
return false;
if (core.status.event.data.type != 'choices') return false;
var data = core.status.event.data.current;
var choices = data.choices;
var topIndex =
core.actions.HSIZE -
parseInt((choices.length - 1) / 2) +
(core.status.event.ui.offset || 0);
if (keycode == 13 || keycode == 32) {
// Space, Enter
core.actions._clickAction(
core.actions.HSIZE,
topIndex + core.status.event.selection
);
return true;
}
return false;
},
60
);
// 允许长按屏幕连续执行操作
core.registerAction(
'longClick',
'shops',
(x, y, px, py) => {
if (
!core.status.lockControl ||
!core.hasFlag('@temp@shop') ||
core.status.event.id != 'action'
)
return false;
if (core.status.event.data.type != 'choices') return false;
var data = core.status.event.data.current;
var choices = data.choices;
var topIndex =
core.actions.HSIZE -
parseInt((choices.length - 1) / 2) +
(core.status.event.ui.offset || 0);
if (
x >= core.actions.CHOICES_LEFT &&
x <= core.actions.CHOICES_RIGHT &&
y >= topIndex &&
y < topIndex + choices.length
) {
core.actions._clickAction(x, y);
return true;
}
return false;
},
60
);
},
removeMap: function () {
// 高层塔砍层插件，删除后不会存入存档，不可浏览地图也不可飞到。
// 推荐用法：
// 对于超高层或分区域塔，当在1区时将2区以后的地图删除；1区结束时恢复2区，进二区时删除1区地图，以此类推
// 这样可以大幅减少存档空间，以及加快存读档速度
// 删除楼层
// core.removeMaps("MT1", "MT300") 删除MT1~MT300之间的全部层
// core.removeMaps("MT10") 只删除MT10层
this.removeMaps = function (fromId, toId) {
toId = toId || fromId;
var fromIndex = core.floorIds.indexOf(fromId),
toIndex = core.floorIds.indexOf(toId);
if (toIndex < 0) toIndex = core.floorIds.length - 1;
flags.__visited__ = flags.__visited__ || {};
flags.__removed__ = flags.__removed__ || [];
flags.__disabled__ = flags.__disabled__ || {};
flags.__leaveLoc__ = flags.__leaveLoc__ || {};
for (var i = fromIndex; i <= toIndex; ++i) {
var floorId = core.floorIds[i];
if (core.status.maps[floorId].deleted) continue;
delete flags.__visited__[floorId];
flags.__removed__.push(floorId);
delete flags.__disabled__[floorId];
delete flags.__leaveLoc__[floorId];
(core.status.autoEvents || []).forEach(event => {
if (event.floorId == floorId && event.currentFloor) {
core.autoEventExecuting(event.symbol, false);
core.autoEventExecuted(event.symbol, false);
}
});
core.status.maps[floorId].deleted = true;
core.status.maps[floorId].canFlyTo = false;
core.status.maps[floorId].canFlyFrom = false;
core.status.maps[floorId].cannotViewMap = true;
}
};
// 恢复楼层
// core.resumeMaps("MT1", "MT300") 恢复MT1~MT300之间的全部层
// core.resumeMaps("MT10") 只恢复MT10层
this.resumeMaps = function (fromId, toId) {
toId = toId || fromId;
var fromIndex = core.floorIds.indexOf(fromId),
toIndex = core.floorIds.indexOf(toId);
if (toIndex < 0) toIndex = core.floorIds.length - 1;
flags.__removed__ = flags.__removed__ || [];
for (var i = fromIndex; i <= toIndex; ++i) {
var floorId = core.floorIds[i];
if (!core.status.maps[floorId].deleted) continue;
flags.__removed__ = flags.__removed__.filter(f => {
return f != floorId;
});
core.status.maps[floorId] = core.loadFloor(floorId);
}
};
// 分区砍层相关
var inAnyPartition = floorId => {
var inPartition = false;
(core.floorPartitions || []).forEach(floor => {
var fromIndex = core.floorIds.indexOf(floor[0]);
var toIndex = core.floorIds.indexOf(floor[1]);
var index = core.floorIds.indexOf(floorId);
if (fromIndex < 0 || index < 0) return;
if (toIndex < 0) toIndex = core.floorIds.length - 1;
if (index >= fromIndex && index <= toIndex) inPartition = true;
});
return inPartition;
};
// 分区砍层
this.autoRemoveMaps = function (floorId) {
if (main.mode != 'play' || !inAnyPartition(floorId)) return;
// 根据分区信息自动砍层与恢复
(core.floorPartitions || []).forEach(floor => {
var fromIndex = core.floorIds.indexOf(floor[0]);
var toIndex = core.floorIds.indexOf(floor[1]);
var index = core.floorIds.indexOf(floorId);
if (fromIndex < 0 || index < 0) return;
if (toIndex < 0) toIndex = core.floorIds.length - 1;
if (index >= fromIndex && index <= toIndex) {
core.resumeMaps(
core.floorIds[fromIndex],
core.floorIds[toIndex]
);
} else {
core.removeMaps(
core.floorIds[fromIndex],
core.floorIds[toIndex]
);
}
});
};
},
fiveLayers: function () {
// 是否启用五图层（增加背景2层和前景2层） 将__enable置为true即会启用；启用后请保存后刷新编辑器
// 背景层2将会覆盖背景层 被事件层覆盖 前景层2将会覆盖前景层
// 另外 请注意加入两个新图层 会让大地图的性能降低一些
// 插件作者：ad
var __enable = true;
if (!__enable) return;
// 创建新图层
function createCanvas(name, zIndex) {
if (!name) return;
var canvas = document.createElement('canvas');
canvas.id = name;
canvas.className = 'gameCanvas';
// 编辑器模式下设置zIndex会导致加入的图层覆盖优先级过高
if (main.mode != 'editor') canvas.style.zIndex = zIndex || 0;
// 将图层插入进游戏内容
document.getElementById('gameDraw').appendChild(canvas);
var ctx = canvas.getContext('2d');
core.canvas[name] = ctx;
if (core.domStyle.hdCanvas.indexOf('name') >= 0)
core.maps._setHDCanvasSize(
ctx,
core.__PIXELS__,
core.__PIXELS__
);
else {
canvas.width = core.__PIXELS__;
canvas.height = core.__PIXELS__;
}
return canvas;
}
var bg2Canvas = createCanvas('bg2', 20);
var fg2Canvas = createCanvas('fg2', 63);
// 大地图适配
core.bigmap.canvas = [
'bg2',
'fg2',
'bg',
'event',
'event2',
'fg',
'damage'
];
core.initStatus.bg2maps = {};
core.initStatus.fg2maps = {};
if (main.mode == 'editor') {
/*插入编辑器的图层 不做此步新增图层无法在编辑器显示*/
// 编辑器图层覆盖优先级 eui > efg > fg(前景层) > event2(48*32图块的事件层) > event(事件层) > bg(背景层)
// 背景层2(bg2) 插入事件层(event)之前(即bg与event之间)
document
.getElementById('mapEdit')
.insertBefore(bg2Canvas, document.getElementById('event'));
// 前景层2(fg2) 插入编辑器前景(efg)之前(即fg之后)
document
.getElementById('mapEdit')
.insertBefore(fg2Canvas, document.getElementById('ebm'));
// 原本有三个图层 从4开始添加
var num = 4;
// 新增图层存入editor.dom中
editor.dom.bg2c = core.canvas.bg2.canvas;
editor.dom.bg2Ctx = core.canvas.bg2;
editor.dom.fg2c = core.canvas.fg2.canvas;
editor.dom.fg2Ctx = core.canvas.fg2;
editor.dom.maps.push('bg2map', 'fg2map');
editor.dom.canvas.push('bg2', 'fg2');
// 创建编辑器上的按钮
var createCanvasBtn = name => {
// 电脑端创建按钮
var input = document.createElement('input');
// layerMod4/layerMod5
var id = 'layerMod' + num++;
// bg2map/fg2map
var value = name + 'map';
input.type = 'radio';
input.name = 'layerMod';
input.id = id;
input.value = value;
editor.dom[id] = input;
input.onchange = () => {
editor.uifunctions.setLayerMod(value);
};
return input;
};
var createCanvasBtn_mobile = name => {
// 手机端往选择列表中添加子选项
var input = document.createElement('option');
var id = 'layerMod' + num++;
var value = name + 'map';
input.name = 'layerMod';
input.value = value;
editor.dom[id] = input;
return input;
};
if (!editor.isMobile) {
var input = createCanvasBtn('bg2');
var input2 = createCanvasBtn('fg2');
// 获取事件层及其父节点
var child = document.getElementById('layerMod'),
parent = child.parentNode;
// 背景层2插入事件层前
parent.insertBefore(input, child);
// 不能直接更改背景层2的innerText 所以创建文本节点
var txt = document.createTextNode('背2');
// 插入事件层前(即新插入的背景层2前)
parent.insertBefore(txt, child);
// 向最后插入前景层2(即插入前景层后)
parent.appendChild(input2);
var txt2 = document.createTextNode('前2');
parent.appendChild(txt2);
} else {
var input = createCanvasBtn_mobile('bg2');
var input2 = createCanvasBtn_mobile('fg2');
// 手机端因为是选项 所以可以直接改innerText
input.innerText = '背景2';
input2.innerText = '前景2';
var parent = document.getElementById('layerMod');
parent.insertBefore(input, parent.children[1]);
parent.appendChild(input2);
}
}
core.maps._loadFloor_doNotCopy = function () {
return [
'firstArrive',
'eachArrive',
'blocks',
'parallelDo',
'map',
'bgmap',
'fgmap',
'bg2map',
'fg2map',
'events',
'changeFloor',
'afterBattle',
'afterGetItem',
'afterOpenDoor',
'cannotMove'
];
};
////// 绘制背景和前景层 //////
core.maps._drawBg_draw = function (
floorId,
toDrawCtx,
cacheCtx,
config
) {
config.ctx = cacheCtx;
core.maps._drawBg_drawBackground(floorId, config);
// ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制背景图块；后绘制的覆盖先绘制的。
core.maps._drawFloorImages(
floorId,
config.ctx,
'bg',
null,
null,
config.onMap
);
core.maps._drawBgFgMap(floorId, 'bg', config);
if (config.onMap) {
core.drawImage(
toDrawCtx,
cacheCtx.canvas,
core.bigmap.v2 ? -32 : 0,
core.bigmap.v2 ? -32 : 0
);
core.clearMap('bg2');
core.clearMap(cacheCtx);
}
core.maps._drawBgFgMap(floorId, 'bg2', config);
if (config.onMap)
core.drawImage(
'bg2',
cacheCtx.canvas,
core.bigmap.v2 ? -32 : 0,
core.bigmap.v2 ? -32 : 0
);
config.ctx = toDrawCtx;
};
core.maps._drawFg_draw = function (
floorId,
toDrawCtx,
cacheCtx,
config
) {
config.ctx = cacheCtx;
// ------ 调整这两行的顺序来控制是先绘制贴图还是先绘制前景图块；后绘制的覆盖先绘制的。
core.maps._drawFloorImages(
floorId,
config.ctx,
'fg',
null,
null,
config.onMap
);
core.maps._drawBgFgMap(floorId, 'fg', config);
if (config.onMap) {
core.drawImage(
toDrawCtx,
cacheCtx.canvas,
core.bigmap.v2 ? -32 : 0,
core.bigmap.v2 ? -32 : 0
);
core.clearMap('fg2');
core.clearMap(cacheCtx);
}
core.maps._drawBgFgMap(floorId, 'fg2', config);
if (config.onMap)
core.drawImage(
'fg2',
cacheCtx.canvas,
core.bigmap.v2 ? -32 : 0,
core.bigmap.v2 ? -32 : 0
);
config.ctx = toDrawCtx;
};
////// 移动判定 //////
core.maps._generateMovableArray_arrays = function (floorId) {
return {
bgArray: this.getBgMapArray(floorId),
fgArray: this.getFgMapArray(floorId),
eventArray: this.getMapArray(floorId),
bg2Array: this._getBgFgMapArray('bg2', floorId),
fg2Array: this._getBgFgMapArray('fg2', floorId)
};
};
},
itemShop: function () {
// 道具商店相关的插件
// 可在全塔属性-全局商店中使用「道具商店」事件块进行编辑（如果找不到可以在入口方块中找）
var shopId = null; // 当前商店ID
var type = 0; // 当前正在选中的类型，0买入1卖出
var selectItem = 0; // 当前正在选中的道具
var selectCount = 0; // 当前已经选中的数量
var page = 0;
var totalPage = 0;
var totalMoney = 0;
var list = [];
var shopInfo = null; // 商店信息
var choices = []; // 商店选项
var use = 'money';
var useText = '金币';
var bigFont = core.ui._buildFont(20, false),
middleFont = core.ui._buildFont(18, false);
this._drawItemShop = function () {
// 绘制道具商店
// Step 1: 背景和固定的几个文字
core.ui._createUIEvent();
core.clearMap('uievent');
core.ui.clearUIEventSelector();
core.setTextAlign('uievent', 'left');
core.setTextBaseline('uievent', 'top');
core.fillRect('uievent', 0, 0, 480, 480, 'black');
core.drawWindowSkin('winskin.png', 'uievent', 0, 0, 480, 64);
core.drawWindowSkin('winskin.png', 'uievent', 0, 64, 360, 64);
core.drawWindowSkin('winskin.png', 'uievent', 0, 128, 360, 352);
core.drawWindowSkin('winskin.png', 'uievent', 360, 64, 120, 64);
core.drawWindowSkin('winskin.png', 'uievent', 360, 128, 120, 352);
core.setFillStyle('uievent', 'white');
core.setStrokeStyle('uievent', 'white');
core.fillText('uievent', '购买', 32, 84, 'white', bigFont);
core.fillText('uievent', '卖出', 152, 84);
core.fillText('uievent', '离开', 272, 84);
core.fillText(
'uievent',
'当前' + useText,
374,
75,
null,
middleFont
);
core.setTextAlign('uievent', 'right');
core.fillText(
'uievent',
core.formatBigNumber(core.status.hero.money),
466,
100
);
core.setTextAlign('uievent', 'left');
core.ui.drawUIEventSelector(
1,
'winskin.png',
22 + 120 * type,
76,
60,
33
);
if (selectItem != null) {
core.setTextAlign('uievent', 'center');
core.fillText(
'uievent',
type == 0 ? '买入个数' : '卖出个数',
420,
360,
null,
bigFont
);
core.fillText(
'uievent',
'< ' + selectCount + ' >',
420,
390
);
core.fillText('uievent', '确定', 420, 420);
}
// Step 2：获得列表并展示
list = choices.filter(one => {
if (one.condition != null && one.condition != '') {
try {
if (!core.calValue(one.condition)) return false;
} catch (e) {}
}
return (
(type == 0 && one.money != null) ||
(type == 1 && one.sell != null)
);
});
var per_page = 7;
totalPage = Math.ceil(list.length / per_page);
page = Math.floor((selectItem || 0) / per_page) + 1;
// 绘制分页
if (totalPage > 1) {
var half = 180;
core.setTextAlign('uievent', 'center');
core.fillText(
'uievent',
page + ' / ' + totalPage,
half,
450,
null,
middleFont
);
if (page > 1)
core.fillText('uievent', '上一页', half - 80, 450);
if (page < totalPage)
core.fillText('uievent', '下一页', half + 80, 450);
}
core.setTextAlign('uievent', 'left');
// 绘制每一项
var start = (page - 1) * per_page;
for (var i = 0; i < per_page; ++i) {
var curr = start + i;
if (curr >= list.length) break;
var item = list[curr];
core.drawIcon('uievent', item.id, 10, 141 + i * 40);
core.setTextAlign('uievent', 'left');
core.fillText(
'uievent',
core.material.items[item.id].name,
50,
148 + i * 40,
null,
bigFont
);
core.setTextAlign('uievent', 'right');
core.fillText(
'uievent',
(type == 0
? core.calValue(item.money)
: core.calValue(item.sell)) +
useText +
'/个',
340,
149 + i * 40,
null,
middleFont
);
core.setTextAlign('uievent', 'left');
if (curr == selectItem) {
// 绘制描述，文字自动放缩
var text =
core.material.items[item.id].text || '该道具暂无描述';
try {
text = core.replaceText(text);
} catch (e) {}
for (var fontSize = 20; fontSize >= 8; fontSize -= 2) {
var config = {
left: 10,
fontSize: fontSize,
maxWidth: 467
};
var height = core.getTextContentHeight(text, config);
if (height <= 60) {
config.top = (64 - height) / 2;
core.drawTextContent('uievent', text, config);
break;
}
}
core.ui.drawUIEventSelector(
2,
'winskin.png',
8,
137 + i * 40,
343,
40
);
if (type == 0 && item.number != null) {
core.fillText(
'uievent',
'存货',
370,
152,
null,
bigFont
);
core.setTextAlign('uievent', 'right');
core.fillText(
'uievent',
item.number,
470,
152,
null,
null,
60
);
} else if (type == 1) {
core.fillText(
'uievent',
'数量',
370,
152,
null,
bigFont
);
core.setTextAlign('uievent', 'right');
core.fillText(
'uievent',
core.itemCount(item.id),
470,
152,
null,
null,
40
);
}
core.setTextAlign('uievent', 'left');
core.fillText('uievent', '预计' + useText, 370, 280);
core.setTextAlign('uievent', 'right');
totalMoney =
selectCount *
(type == 0
? core.calValue(item.money)
: core.calValue(item.sell));
core.fillText(
'uievent',
core.formatBigNumber(totalMoney),
470,
310
);
core.setTextAlign('uievent', 'left');
core.fillText(
'uievent',
type == 0 ? '已购次数' : '已卖次数',
370,
190
);
core.setTextAlign('uievent', 'right');
core.fillText(
'uievent',
(type == 0 ? item.money_count : item.sell_count) || 0,
470,
220
);
}
}
core.setTextAlign('uievent', 'left');
core.setTextBaseline('uievent', 'alphabetic');
};
var _add = (item, delta) => {
if (item == null) return;
selectCount = core.clamp(
selectCount + delta,
0,
Math.min(
type == 0
? Math.floor(
core.status.hero[use] / core.calValue(item.money)
)
: core.itemCount(item.id),
type == 0 && item.number != null
? item.number
: Number.MAX_SAFE_INTEGER
)
);
};
var _confirm = item => {
if (item == null || selectCount == 0) return;
if (type == 0) {
core.status.hero[use] -= totalMoney;
core.getItem(item.id, selectCount);
if (item.number != null) item.number -= selectCount;
item.money_count = (item.money_count || 0) + selectCount;
} else {
core.status.hero[use] += totalMoney;
core.removeItem(item.id, selectCount);
core.drawTip(
'成功卖出' +
selectCount +
'个' +
core.material.items[item.id].name,
item.id
);
if (item.number != null) item.number += selectCount;
item.sell_count = (item.sell_count || 0) + selectCount;
}
selectCount = 0;
};
this._performItemShopKeyBoard = function (keycode) {
var item = list[selectItem] || null;
// 键盘操作
switch (keycode) {
case 38: // up
if (selectItem == null) break;
if (selectItem == 0) selectItem = null;
else selectItem--;
selectCount = 0;
break;
case 37: // left
if (selectItem == null) {
if (type > 0) type--;
break;
}
_add(item, -1);
break;
case 39: // right
if (selectItem == null) {
if (type < 2) type++;
break;
}
_add(item, 1);
break;
case 40: // down
if (selectItem == null) {
if (list.length > 0) selectItem = 0;
break;
}
if (list.length == 0) break;
selectItem = Math.min(selectItem + 1, list.length - 1);
selectCount = 0;
break;
case 13:
case 32: // Enter/Space
if (selectItem == null) {
if (type == 2) core.insertAction({ type: 'break' });
else if (list.length > 0) selectItem = 0;
break;
}
_confirm(item);
break;
case 27: // ESC
if (selectItem == null) {
core.insertAction({ type: 'break' });
break;
}
selectItem = null;
break;
}
};
this._performItemShopClick = function (px, py) {
var item = list[selectItem] || null;
// 鼠标操作
if (px >= 22 && px <= 82 && py >= 81 && py <= 112) {
// 买
if (type != 0) {
type = 0;
selectItem = null;
selectCount = 0;
}
return;
}
if (px >= 142 && px <= 202 && py >= 81 && py <= 112) {
// 卖
if (type != 1) {
type = 1;
selectItem = null;
selectCount = 0;
}
return;
}
if (px >= 262 && px <= 322 && py >= 81 && py <= 112)
// 离开
return core.insertAction({ type: 'break' });
// <，>
if (px >= 370 && px <= 395 && py >= 392 && py <= 415)
return _add(item, -1);
if (px >= 445 && px <= 470 && py >= 302 && py <= 415)
return _add(item, 1);
// 确定
if (px >= 392 && px <= 443 && py >= 421 && py <= 446)
return _confirm(item);
// 上一页/下一页
if (px >= 70 && px <= 130 && py >= 450) {
if (page > 1) {
selectItem -= 7;
selectCount = 0;
}
return;
}
if (px >= 230 && px <= 290 && py >= 450) {
if (page < totalPage) {
selectItem = Math.min(selectItem + 7, list.length - 1);
selectCount = 0;
}
return;
}
// 实际区域
if (px >= 9 && px <= 351 && py >= 142 && py < 422) {
if (list.length == 0) return;
var index = parseInt((py - 142) / 40);
var newItem = 7 * (page - 1) + index;
if (newItem >= list.length) newItem = list.length - 1;
if (newItem != selectItem) {
selectItem = newItem;
selectCount = 0;
}
return;
}
};
this._performItemShopAction = function () {
if (flags.type == 0)
return this._performItemShopKeyBoard(flags.keycode);
else return this._performItemShopClick(flags.px, flags.py);
};
this.openItemShop = function (itemShopId) {
shopId = itemShopId;
type = 0;
page = 0;
selectItem = null;
selectCount = 0;
core.isShopVisited(itemShopId);
shopInfo = flags.__shops__[shopId];
if (shopInfo.choices == null)
shopInfo.choices = core.clone(
core.status.shops[shopId].choices
);
choices = shopInfo.choices;
use = core.status.shops[shopId].use;
if (use != 'exp') use = 'money';
useText = use == 'money' ? '金币' : '经验';
core.insertAction([
{
type: 'while',
condition: 'true',
data: [
{
type: 'function',
function: '() => { core.plugin._drawItemShop(); }'
},
{ type: 'wait' },
{
type: 'function',
function:
'() => { core.plugin._performItemShopAction(); }'
}
]
},
{
type: 'function',
function:
"() => { core.deleteCanvas('uievent'); core.ui.clearUIEventSelector(); }"
}
]);
};
},
heroFourFrames: function () {
// 样板的勇士/跟随者移动时只使用2、4两帧，观感较差。本插件可以将四帧全用上。
// 是否启用本插件
var __enable = true;
if (!__enable) return;
['up', 'down', 'left', 'right'].forEach(one => {
// 指定中间帧动画
core.material.icons.hero[one].midFoot = 2;
});
var heroMoving = timestamp => {
if (core.status.heroMoving <= 0) return;
if (
timestamp - core.animateFrame.moveTime >
core.values.moveSpeed
) {
core.animateFrame.leftLeg++;
core.animateFrame.moveTime = timestamp;
}
core.drawHero(
['stop', 'leftFoot', 'midFoot', 'rightFoot'][
core.animateFrame.leftLeg % 4
],
4 * core.status.heroMoving
);
};
core.registerAnimationFrame('heroMoving', true, heroMoving);
core.events._eventMoveHero_moving = function (step, moveSteps) {
var curr = moveSteps[0];
var direction = curr[0],
x = core.getHeroLoc('x'),
y = core.getHeroLoc('y');
// ------ 前进/后退
var o = direction == 'backward' ? -1 : 1;
if (direction == 'forward' || direction == 'backward')
direction = core.getHeroLoc('direction');
var faceDirection = direction;
if (direction == 'leftup' || direction == 'leftdown')
faceDirection = 'left';
if (direction == 'rightup' || direction == 'rightdown')
faceDirection = 'right';
core.setHeroLoc('direction', direction);
if (curr[1] <= 0) {
core.setHeroLoc('direction', faceDirection);
moveSteps.shift();
return true;
}
if (step <= 4) core.drawHero('stop', 4 * o * step);
else if (step <= 8) core.drawHero('leftFoot', 4 * o * step);
else if (step <= 12) core.drawHero('midFoot', 4 * o * (step - 8));
else if (step <= 16) core.drawHero('rightFoot', 4 * o * (step - 8)); // if (step == 8) {
if (step == 8 || step == 16) {
core.setHeroLoc(
'x',
x + o * core.utils.scan2[direction].x,
true
);
core.setHeroLoc(
'y',
y + o * core.utils.scan2[direction].y,
true
);
core.updateFollowers();
curr[1]--;
if (curr[1] <= 0) moveSteps.shift();
core.setHeroLoc('direction', faceDirection);
return step == 16;
}
return false;
};
},
minimap: function () {
// 该插件可自定义空间很大，自定义内容请看注释
// ------------------------- 安装说明 ------------------------- //
// 先安装基于canvas的sprite化插件（2.10.0以上自带）
// 确保自己的编辑器已安装造塔群内的编辑器升级压缩包（在HTML5魔塔样板文件夹内，2.10.1以上样板自带）
// 再将以下代码复制进插件中
// 提供的api请看以this.xxx = function开头的函数，函数前会有函数说明及参数说明，调用时只需core.plugin.xxx(参数)即可
// ------------------------- 使用说明 ------------------------- //
/*
* 直接复制进插件中，然后添加一个快捷键或道具效果为core.plugin.drawFlyMap()即可使用，不需额外设置
* 楼层id中不要出现下划线
* 该插件具体功能有：
* 1.绘制区域内的地图
* 2.可以拖动地图
* 3.点击地图可直接传送至目标地图，同时降低背景的不透明度，方便观察
* 4.滚轮或双指可以放缩绘制内容
* 5.放缩较大时，绘制地图的缩略图，可能会比较卡，但移动不会卡
* 6.整合漏怪检测，如果想忽略怪物，请在下方改动或用脚本修改core.plugin.ignoreEnemies，类型为数组
* 7.整合区域显示，所有单独或连在一起的地图会被视为一个区域
* 8.键盘操作，上下左右移动
*/
// ------------------------- 插件说明 ------------------------- //
/*
* 该插件注释极其详细，可以帮助那些想要提升代码力，但实力有不足的作者
* 注意！！！该插件难度极大，没有代码底力的不建议研究
* 该插件涉及部分较为高级的算法，如bfs
*/
// 录像验证直接干掉这个插件
if (main.replayChecking || main.mode === 'editor') return;
// ----- 不可自定义 杂七杂八的变量
/** @type {{[x: string]: BFSResult}} */
let mapCache = {}; // 地图缓存
let drawCache = {}; // 绘制信息缓存
let status = 'none'; // 当前的绘制状态
/** @type {{[x: string]: Sprite}} */
let sprites = {}; // 当前所有的sprite
/** @type {{[x: string]: Sprite}} */
let canDrag = {}; // 可以拖拽的sprite
/** @type {{[x: string]: Button}} */
let areaSprite = {}; // 区域列表对应的sprite
let clicking = false; // 是否正在点击，用于拖拽判定
let drawingMap = ''; // 正在绘制的中心楼层
let nowScale = 0; // 当前绘制的放缩比例
let lastTouch = {}; // 上一次的单点点击信息
let lastLength = 0; // 手机端缩放时上一次的两指间距离
let nowDepth = 0; // 当前的遍历深度
let drawedThumbnail = {}; // 已经绘制过的缩略图
let moved = false; // 鼠标按下后是否移动了
let noBorder = false; // 是否是无边框拼接模式
let lastScale = 0; // 上一次缩放，用于优化缩略图绘制
let showEnemy = false; // 是否显示漏怪
let areaPage = 0; // 区域显示的当前页数
let nowArea = 0; // 当前区域index
let selecting = ''; // 选择时当前正在选择的地图
// ---- 不可自定义，常量
/** @type {Area} */
let areas = []; // 区域信息
const perPage = Math.floor((core._PY_ - 60) / 30); // 区域的每页显示数量
// ---- 可自定义，默认的切换地图的图块id
const defaultChange = {
left: 'leftPortal', // 左箭头
up: 'upPortal', // 上箭头
right: 'rightPortal', // 右箭头
down: 'downPortal', // 下箭头
upFloor: 'upFloor', // 上楼
downFloor: 'downFloor' // 下楼
};
// ---- 可自定义，默认数值
const defaultValue = {
font: 'Verdana', // 默认字体
scale: 3, // 默认地图缩放比例
depth: Infinity // 默认的遍历深度
};
// ---- 不可自定义，计算数据
const dirData = {
up: [1, 0],
down: [-1, 0],
left: [0, 1],
right: [0, -1],
upFloor: [0, 0],
downFloor: [0, 0]
};
let ignoreEnemies = (this.ignoreEnemies = []);
let allChangeEntries = Object.entries(defaultChange);
const reset = core.events.resetGame;
core.events.resetGame = function () {
reset.apply(core.events, arguments);
areas = [];
// 获取所有分区，使用异步函数，保证不会卡顿
// 原理是用bfs扫，将所有连在一起的地图合并成一个区域
(async function () {
let all = core.floorIds.slice();
const scanned = { [all[0]]: true };
while (all.length > 0) {
let now = all.shift();
if (core.status.maps[now].deleted) continue;
if (!now) return;
await new Promise(res => {
const result = bfsSearch(now, Infinity, true);
mapCache[`${now}_Infinity_false`] = result;
areas.push({
name: core.floors[now].title,
maps: result.order
});
for (const map of result.order) {
scanned[map] = true;
all = all.filter(v => !result.order.includes(v));
}
res('success');
});
}
})();
};
/** 工具按钮 */
class Button extends Sprite {
constructor(
name,
x,
y,
w,
h,
text,
fontSize = '20px',
transition = true
) {
const btn = super(x, y, w, h, 1050, 'game', name);
this.css(transition);
setTimeout(() => btn.setCss(`opacity: 1;`), 50);
const ctx = btn.context;
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
core.fillText(
ctx,
text,
w / 2,
h / 2,
'#fff',
`${fontSize} normal`,
w - 10
);
sprites[name] = btn;
}
css(transition) {
this.setCss(
'transition: opacity 0.6s linear, transform 0.2s linear;' +
'background-color: #aaa;' +
'box-shadow: 0px 0px 0px black;' +
(transition ? 'opacity: 0;' : '') +
'filter: drop-shadow(1px 1px 2px black);' +
'box-shadow: 0px 0px 4px black;' +
'cursor: pointer;'
);
}
}
/** 背景 */
class Back extends Sprite {
constructor(name, x, y, w, h, z, color) {
const sprite = super(x, y, w, h, z, 'game', name);
sprites[name] = sprite;
this.setCss(`transition: all 0.6s linear;`);
setTimeout(() => {
this.setCss(`background-color: ${color};`);
}, 50);
}
}
/**
* 获取绘制信息
* @param {string?} center 中心地图id
* @param {number?} depth 搜索深度
* @param {boolean?} noCache 是否不使用缓存
* @returns {MapDrawInfo}
*/
this.getMapDrawInfo = function (
center = core.status.floorId,
depth = defaultValue.depth,
noCache = false
) {
nowDepth = depth;
drawingMap = center;
const id = `${center}_${depth}_${noBorder}`;
// 检查缓存
if (drawCache[id] && !noCache) return drawCache[id];
const map = bfsSearch(center, depth, noCache);
mapCache[id] = map;
const res = getDrawInfo(map.res, center, map.order);
res.upOrDown = map.upOrDown;
drawCache[id] = res;
return res;
};
/**
* 绘制大地图，可拖动、滚轮缩放、点击对应位置可以楼传等
* @param {string} floorId 中心地图的id
* @param {number} depth 遍历深度
* @param {boolean} noCache 是否不使用缓存
* @param {number} scale 绘制的缩放比例
*/
this.drawFlyMap = function (
floorId = core.status.floorId,
depth = defaultValue.depth,
noCache = false,
scale = defaultValue.scale
) {
if (core.isReplaying()) return;
// 把区域页码归零
nowArea = areas.findIndex(v =>
v.maps.includes(core.status.floorId)
);
areaPage = 0;
nowScale = scale;
selecting = floorId;
const info = this.getMapDrawInfo(floorId, depth, noCache);
if (status !== 'scale' && status !== 'border') {
drawBack();
drawTools();
}
drawMap(info, scale);
status = 'flyMap';
core.lockControl();
core.canvas.data.canvas.style.zIndex = '990';
};
/**
* 获得某个区域的剩余怪物
* @param {string} floorId 区域包含的地图或要扫描的地图
* @param {boolean} area 是否扫描整个区域
* @returns {RemainEnemy} 怪物总数、所在地图、位置
* 返回值格式：{
* rough: 每种怪物的数量及所有怪物的总数，为字符串，每个怪物独占一行
* detail: 每个怪物的所在位置，每个怪物独占一行，以每20个整合成字符串，为字符串数组形式
* data: 怪物数量的原始信息，格式为{ 楼层id: { 'x,y': 怪物id } }
* }
*/
this.getRemainEnemy = function (
floorId = core.status.floorId,
area = false
) {
const res = bfsSearch(floorId, Infinity, true);
// 整合怪物总数
/** @type {{[x: string]: number}} */
const category = {};
const toShow = area ? res.order : [floorId];
const strArr = [];
const add = (...num) => num.reduce((pre, cur) => pre + cur, 0);
const name = id => core.material.enemys[id].name;
const title = id => core.status.maps[id].title;
for (const id of toShow) {
const enemies = res.enemies[id];
Object.values(enemies).forEach(v => {
// 编辑器不支持 ??=，悲
category[v] = category[v] ?? 0;
category[v]++;
});
// 每个怪物的信息
strArr.push(
...Object.entries(enemies).map(
v =>
`${name(v[1])} 楼层:${title(
id
)},楼层id:${id},坐标:${v[0]}`
)
);
}
// 输出字符串
const all = `当前${area ? '区域' : '地图'}中剩余怪物数量：${add(
...Object.values(category)
)}`;
const classified = Object.entries(category).map(
v => `${name(v[0])} × ${v[1]}`
).join`\n`;
const detail = [];
while (strArr.length > 0) {
detail.push(strArr.splice(0, 20).join`\n`);
}
return {
rough: `${all}\n${classified}`,
detail,
data: res.enemies
};
};
/**
* 广度优先搜索搜索地图路径
* @param {string} center 中心地图的id
* @param {number} depth 搜索深度
* @param {boolean} noCache 是否不使用缓存
* @returns {BFSResult} 格式：floorId_x_y_dir: floorId_x_y
*/
function bfsSearch(center, depth, noCache) {
// 检查缓存
const id = `${center}_${depth}_${noBorder}`;
if (mapCache[id] && !noCache) return mapCache[id];
const used = { [center]: true }; // 搜索过的楼层
let queue = [];
let stack = [center]; // 当前栈
let nowDepth = -1;
const mapOrder = [center]; // 遍历顺序，顺便还能记录遍历了哪些楼层
const res = {}; // 输出结果，格式：floorId_x_y_dir: floorId_x_y
const enemies = {};
const upOrDown = {};
// 开始循环搜索
while (nowDepth < depth && stack.length > 0) {
const now = stack.shift(); // 当前id
if (core.status.maps[now].deleted) continue;
const blocks = core.getMapBlocksObj(now); // 获取当前地图的每点的事件
enemies[now] = {};
// 遍历，获取可以传送的点，只检测绿点事件，因此可用红点事件进行传送来实现分区功能
for (const i in blocks) {
const block = blocks[i];
// 整合漏怪检测，所以要检测怪物
if (block.event.trigger === 'battle') {
const id = block.event.id;
if (ignoreEnemies.includes(id)) continue;
else enemies[now][i] = block.event.id;
continue;
}
// 检测触发器是否为切换楼层，不是则直接跳过
if (block.event.trigger !== 'changeFloor') continue;
const dirEntries = allChangeEntries.find(
v => v[1] === block.event.id
);
// 如果不是那六种传送门，直接忽略
if (!dirEntries) continue;
const data = block.event.data;
const dir = dirEntries[0];
const route = `${now}_${i.replace(',', '_')}_${dir}`;
const target = `${data.floorId}_${data.loc.join('_')}`;
if (!used[data.floorId]) {
if (dir === 'upFloor' || dir === 'downFloor') {
upOrDown[now] = upOrDown[id] ?? [];
upOrDown[now].push(dir);
}
queue.push(data.floorId); // 没有搜索过，则加入栈中
mapOrder.push(data.floorId);
used[data.floorId] = true;
}
res[route] = target;
}
if (stack.length === 0) {
stack = queue;
queue = [];
nowDepth++;
}
if (stack.length === 0 && queue.length === 0) break;
}
return { res, order: mapOrder, enemies, upOrDown };
}
/**
* 提供地图的绘制信息
* @param {{[x: string]: string}} map 要绘制的地图，格式：floorId_x_y_dir: floorId_x_y
* @param {string} center 中心地图的id
* @param {string[]} order 遍历顺序
* @returns {MapDrawInfo} 地图的绘制信息
*/
function getDrawInfo(map, center, order) {
// 先根据地图id分类，从而确定每个地图连接哪些地图，同时方便处理
const links = {};
for (const i in map) {
const splitted = i.split('_');
const id = splitted[0];
if (!links[id]) links[id] = {};
links[id][i] = map[i];
}
// 分类完毕，然后根据连接点先计算出各个地图的坐标，然后再进行判断
const centerFloor = core.status.maps[center];
const visitedCenter = core.hasVisitedFloor(center);
const locs = {
// 格式：[中心x, 中心y, 宽, 高, 是否到达过]
[center]: [
0,
0,
centerFloor.width,
centerFloor.height,
visitedCenter
]
};
const lines = {}; // 地图间的连线
// 可以上楼下楼的地图
const upOrDown = {};
for (const id of order) {
const now = links[id];
// 遍历每一个地图的连接情况
for (const from in now) {
const to = now[from];
// 先根据from to计算物理位置
const fromData = from.split('_'),
toData = to.split('_');
const dir = fromData[3];
if (dir === 'upFloor' || dir === 'downFloor') continue;
if (!defaultChange[dir]) continue;
const v = dirData[dir][1], // 竖直数值
h = dirData[dir][0], // 水平数值
ha = Math.abs(h),
va = Math.abs(v);
const fx = parseInt(fromData[1]), // fromX
fy = parseInt(fromData[2]), // fromY
tx = parseInt(toData[1]), // toX
ty = parseInt(toData[2]), // toY
ff = id, // fromFloorId
tf = toData[0]; // toFloorId
const fromFloor = core.status.maps[ff],
toFloor = core.status.maps[tf];
const fhw = Math.floor(fromFloor.width / 2), // fromFloorHalfWidth
fhh = Math.floor(fromFloor.height / 2),
thw = Math.floor(toFloor.width / 2),
thh = Math.floor(toFloor.height / 2);
const fLoc = locs[id] ?? [0, 0];
if (!locs[ff]) continue;
let x, y;
const dis = noBorder ? 1 : 5;
if (locs && locs[tf]) {
x = locs[tf][0];
y = locs[tf][1];
} else {
// 计算坐标，公式可以通过画图推断出
x =
fLoc[0] -
ha * (fhw - fx + tx - thw) -
v * (fhw + thw + dis);
y =
fLoc[1] -
va * (fhh - fy + ty - thh) -
h * (fhh + thh + dis);
}
locs[tf] = locs[tf] ?? [
x,
y,
toFloor.width,
toFloor.height,
core.hasVisitedFloor(tf)
];
// 添加连线
lines[`${from}_${to}`] = [
[
fx - fhw + locs[ff][0],
fy - fhh + locs[ff][1],
x + tx - thw,
y + ty - thh
]
];
}
}
// 获取地图绘制需要的长宽
let width = 0,
height = 0;
let left, right, up, down;
for (const id in locs) {
const [x, y, w, h] = locs[id];
if (left === void 0) {
left = right = x;
up = down = y;
}
left = Math.min(x - w / 2 - 1, left);
right = Math.max(x + w / 2 + 1, right);
up = Math.min(y - h / 2 - 1, up);
down = Math.max(y + h / 2 + 1, down);
}
width = right - left;
height = down - up;
// 所有地图和连线向右下移动，避免绘制出现问题
for (const id in locs) {
const loc = locs[id];
loc[0] -= left; // 这时候left和up是负值，所以要减
loc[1] -= up;
}
for (const route in lines) {
const line = lines[route];
for (const node of line) {
node[0] -= left;
node[1] -= up;
node[2] -= left;
node[3] -= up;
}
}
return { locs, lines, width, height, layer: upOrDown };
}
/** 绘制背景 */
function drawBack() {
if (status !== 'none') return;
new Back(
'__map_back__',
0,
0,
core._PX_,
core._PY_,
175,
'rgba(0, 0, 0, 0.9)'
);
const listen = new Sprite(
0,
0,
core._PX_,
core._PY_,
1000,
'game',
'__map_listen__'
);
addDrag(listen);
const exit = new Button(
'__map_exit__',
core._PX_ - 64,
core._PY_ - 26,
60,
22,
'退出'
);
exit.addEventListener('click', close);
sprites.listen = listen;
}
/** 绘制工具栏 */
function drawTools() {
new Back(
'__map_toolback__',
0,
core._PY_ - 30,
core._PX_,
30,
600,
'rgba(200, 200, 200, 0.9)'
);
// 无边框
const border = new Button(
'__map_border__',
core._PX_ - 150,
core._PY_ - 26,
60,
22,
'边框'
);
border.addEventListener('click', changeBorder);
// 怪物数量
const enemy = new Button(
'__map_enemy__',
core._PX_ - 240,
core._PY_ - 26,
60,
22,
'怪物'
);
enemy.addEventListener('click', triggerEnemy);
// 区域显示
const area = new Back(
'__map_areasback__',
core._PX_ - 80,
0,
80,
core._PY_ - 30,
550,
'rgba(200, 200, 200, 0.9)'
);
drawAreaList();
core.drawLine(
area.context,
0,
core._PY_ - 30,
80,
core._PY_ - 30,
'#222',
2
);
}
/** 绘制区域列表 */
function drawAreaList(transition = true) {
const start = perPage * areaPage;
Object.values(areaSprite).forEach(v => v.destroy());
areaSprite = {};
for (let i = start; i < start + perPage && areas[i]; i++) {
const n = i % perPage;
const { name, maps } = areas[i];
const btn = new Button(
`_area_${maps[0]}`,
core._PX_ - 75,
4 + 30 * n,
70,
22,
name,
'16px',
transition
);
areaSprite[maps[0]] = btn;
if (i === nowArea) btn.setCss(`border: 2px solid gold;`);
btn.addEventListener('click', e => {
if (i === nowArea) return;
changeArea(i);
});
}
// 上一页下一页
if (areaPage > 0) {
const last = new Button(
'_area_last_',
core._PX_ - 75,
core._PY_ - 50,
30,
16,
'上一页',
'14px',
transition
);
areaSprite._area_last_ = last;
last.addEventListener('click', e => {
areaPage--;
drawAreaList(false);
});
}
if (areaPage < Math.floor(areas.length / perPage)) {
const next = new Button(
'_area_next_',
core._PX_ - 35,
core._PY_ - 50,
30,
16,
'下一页',
'14px',
transition
);
areaSprite._area_next_ = next;
next.addEventListener('click', e => {
areaPage++;
drawAreaList(false);
});
}
}
/**
* 绘制大地图
* @param {MapDrawInfo} info 地图绘制信息
* @param {number} scale 地图的绘制比例
*/
function drawMap(info, scale = defaultValue.scale) {
if (status === 'flyMap') return;
const PX = core._PX_,
PY = core._PY_;
const w = info.width * scale,
h = info.height * scale;
const id = `__flyMap__`;
const cx = PX / 2 - w / 2,
cy = PY / 2 - h / 2;
const map = new Sprite(cx, cy, w, h, 500, 'game', id);
sprites[id] = map;
canDrag[id] = map;
map.canvas.className = 'fly-map';
const ctx = map.context;
core.clearMap(ctx);
if (!noBorder) {
const drawed = {}; // 绘制过的线
// 先绘制连线
const lines = info.lines;
for (const route in lines) {
const line = lines[route];
for (const node of line) {
const from = `${node[0]},${node[1]}`,
to = `${node[2]},${node[3]}`;
if (drawed[`${from}-${to}`] || drawed[`${to}-${from}`])
continue;
drawed[`${from}-${to}`] = true;
let lineWidth = scale / 2;
core.drawLine(
ctx,
node[0] * scale,
node[1] * scale,
node[2] * scale,
node[3] * scale,
'#fff',
lineWidth
);
}
}
// 再绘制楼层
const locs = info.locs;
for (const id in locs) {
const loc = locs[id];
let color = '#000';
if (!loc[4]) color = '#f0f';
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
let dx = 0,
dy = 0; // 避免绘图误差
if (loc[2] % 2 === 0) dx = 0.5 * scale;
if (loc[3] % 2 === 0) dy = 0.5 * scale;
const fx = x - w / 2 - dx,
fy = y - h / 2 - dy;
core.fillRect(ctx, fx, fy, w, h, color);
if (id === selecting)
core.strokeRect(ctx, fx, fy, w, h, 'gold', scale / 2);
else core.strokeRect(ctx, fx, fy, w, h, '#fff', scale / 2);
const layer = info.upOrDown[id];
const min = Math.min(w, h);
if (layer?.includes('upFloor'))
core.drawIcon(
ctx,
defaultChange.upFloor,
fx,
fy,
min / 3,
min / 3
);
if (layer?.includes('downFloor'))
core.drawIcon(
ctx,
defaultChange.downFloor,
fx + w - min / 3,
fy + h - min / 3,
min / 3,
min / 3
);
// 显示漏怪数量
if (showEnemy) {
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
const c = `${drawingMap}_${nowDepth}_${noBorder}`;
const n = Object.keys(mapCache[c].enemies[id]).length;
color = '#3f3';
if (n > 0) color = '#fff';
if (n > 10) color = '#fc3';
if (n > 20) color = '#f22';
ctx.shadowBlur = 0.6 * nowScale;
ctx.shadowColor = '#000';
core.fillText(
ctx,
`怪物数量：${n}`,
x,
y,
color,
`${2 * nowScale}px normal`
);
ctx.shadowBlur = 0;
}
}
}
checkThumbnail();
}
/**
* 重新绘制缩略图
* @param {Sprite} sprite
* @param {string} floor
*/
function drawThumbnail(sprite, floor, x, y, w, h) {
const ctx = sprite.context;
const scale = nowScale;
core.drawThumbnail(floor, void 0, {
ctx: ctx,
x: x - w / 2,
y: y - h / 2,
damage: true,
all: true,
size: Math.max(w, h) / Math.max(core._PX_, core._PY_),
fromMap: true
});
const color = floor === core.status.floorId ? 'gold' : '#fff';
if (!noBorder)
core.strokeRect(
ctx,
x - w / 2,
y - h / 2,
w,
h,
color,
scale / 2
);
}
/** 检查是否需要绘制缩略图 */
function checkThumbnail() {
const id = `${drawingMap}_${nowDepth}_${noBorder}`;
const locs = drawCache[id].locs;
const map = canDrag[`__flyMap__`];
for (const id in locs) {
const loc = locs[id];
const scale = nowScale;
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
let dx = 0,
dy = 0; // 避免绘图误差
if (loc[2] % 2 === 0) dx = 0.5 * scale;
if (loc[3] % 2 === 0) dy = 0.5 * scale;
if (
!drawedThumbnail[id] &&
x + map.x > 0 &&
x + map.x < core._PX_ &&
y + map.y > 0 &&
y + map.y < core._PY_
) {
if (!noBorder && core.hasVisitedFloor(id) && scale > 5) {
drawThumbnail(map, id, x - dx, y - dy, w, h);
drawedThumbnail[id] = true;
}
if (noBorder) {
drawThumbnail(map, id, x - dx, y - dy, w, h);
drawedThumbnail[id] = true;
if (!core.hasVisitedFloor(id))
core.fillRect(
map.context,
x - dx - w / 2,
y - dy - h / 2,
w,
h,
'rgba(255,0,255,0.2)'
);
}
}
}
// 如果是无边框模式，那就只绘制当前地图的边框
if (noBorder) {
const loc = locs[selecting];
const scale = nowScale;
if (loc) {
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
core.strokeRect(
map.context,
x - w / 2,
y - h / 2,
w,
h,
'gold',
scale / 2
);
}
}
}
/** 检查点击点是否在以x,y为中心的某一矩形中 */
function inRect(x, y, w, h, px, py) {
x -= w / 2;
y -= h / 2;
return px > x && px < x + w && py > y && py < y + h;
}
/** 测试画布是否超过上限，摘自https://github.com/jhildenbiddle/canvas-size */
function canvasTest(size) {
const width = Math.max(Math.ceil(size[0]), 1);
const height = Math.max(Math.ceil(size[1]), 1);
if (width === 0 || height === 0) return true;
const fill = [width - 1, height - 1, 1, 1];
let cropCvs, testCvs;
cropCvs = document.createElement('canvas');
cropCvs.width = 1;
cropCvs.height = 1;
testCvs = document.createElement('canvas');
testCvs.width = width;
testCvs.height = height;
const cropCtx = cropCvs.getContext('2d');
const testCtx = testCvs.getContext('2d');
if (testCtx) {
testCtx.fillRect.apply(testCtx, fill);
cropCtx.drawImage(
testCvs,
width - 1,
height - 1,
1,
1,
0,
0,
1,
1
);
}
const isTestPass =
cropCtx && cropCtx.getImageData(0, 0, 1, 1).data[3] !== 0;
return isTestPass;
}
/** 检查浏览器限制 */
function checkMaximum(before, scale) {
for (const id in canDrag) {
const sprite = canDrag[id];
const rate = scale / before;
const w = sprite.width * rate * core.domStyle.scale,
h = sprite.height * rate * core.domStyle.scale;
const valid = canvasTest([w, h]);
if (!valid) {
core.drawTip('画布大小将超过浏览器限制！请勿继续放大！');
return true;
}
}
return false;
}
/** 关闭事件 */
function close() {
document.body.removeEventListener('keyup', keyboard);
Object.values(sprites).forEach(v => {
v.setCss('transition: opacity 0.6s linear;');
});
setTimeout(() => {
Object.values(sprites).forEach(v => {
v.setCss('opacity: 0;');
});
}, 50);
setTimeout(() => {
core.unlockControl();
Object.values(sprites).forEach(v => {
v.destroy();
});
drawedThumbnail = {};
sprites = {};
canDrag = {};
status = 'none';
core.canvas.data.canvas.style.zIndex = '170';
}, 650);
}
/**
* 点击地图事件，尝试楼层传送
* @param {MouseEvent} e
*/
function clickMap(e) {
if (moved) return (moved = false);
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
let px = x / core.domStyle.scale,
py = y / core.domStyle.scale;
const scale = nowScale;
const id = `${drawingMap}_${nowDepth}_${noBorder}`;
const locs = drawCache[id].locs;
const sprite = canDrag.__flyMap__;
px -= sprite.x;
py -= sprite.y;
for (const id in locs) {
const loc = locs[id];
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
if (inRect(x, y, w, h, px, py)) {
return flyTo(id);
}
}
}
/** 飞向某个楼层 */
function flyTo(id) {
if (!core.hasItem('fly')) return core.drawTip('你没有楼层传送器');
sprites.__map_back__.setCss('opacity: 0.2;');
return core.flyTo(id, () =>
setTimeout(() => {
if (sprites.__map_back__) core.lockControl();
}, 100)
);
}
/**
* 拖拽事件
* @param {MouseEvent} e
*/
function drag(e) {
if (!clicking) return;
const scale = core.domStyle.scale;
moveEle(e.movementX / scale, e.movementY / scale);
}
/**
* 手机端点击拖动事件
* @param {TouchEvent} e
* @this {HTMLCanvasElement}
*/
function touchDrag(e) {
moved = true;
const scale = core.domStyle.scale;
if (e.touches.length === 1) {
// 拖拽
const info = e.touches[0];
if (!lastTouch[this.id]) {
lastTouch[this.id] = [info.clientX, info.clientY];
return;
}
const { clientX: x, clientY: y } = info;
const dx = x - lastTouch[this.id][0],
dy = y - lastTouch[this.id][1];
moveEle(dx / scale, dy / scale);
lastTouch[this.id] = [info.clientX, info.clientY];
} else if (e.touches.length >= 2) {
// 双指放缩
const first = e.touches[0],
second = e.touches[1];
const dx = first.clientX - second.clientX,
dy = first.clientY - second.clientY;
if (lastLength === 0) {
lastLength = Math.sqrt(dx * dx + dy * dy);
return;
}
let cx = (first.clientX + second.clientX) / 2,
cy = (first.clientY + second.clientY) / 2;
const { x, y } = core.actions._getClickLoc(cx, cy);
const mx = x / scale;
const my = y / scale;
const length = Math.sqrt(dx * dx + dy * dy);
const delta = (lastLength / length) ** (1 / 3);
const info = {};
for (const id in canDrag) {
const sprite = canDrag[id];
const sx = sprite.x + sprite.width / 2,
sy = sprite.y + sprite.height / 2;
const dx = sx - mx,
dy = sy - my;
info[id] = [mx + dx * delta, my + dy * delta];
}
scaleMap(delta * nowScale, info);
}
}
/**
* 滚轮缩放
* @param {WheelEvent} e
*/
function wheel(e) {
const delta = 1 - Math.sign(e.deltaY) / 10;
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
const scale = core.domStyle.scale;
const mx = x / scale,
my = y / scale;
const info = {};
for (const id in canDrag) {
const sprite = canDrag[id];
const cx = sprite.x + sprite.width / 2,
cy = sprite.y + sprite.height / 2;
const dx = cx - mx,
dy = cy - my;
info[id] = [mx + dx * delta, my + dy * delta];
}
scaleMap(delta * nowScale, info);
}
/** 切换边框 */
function changeBorder() {
noBorder = !noBorder;
redraw('border');
}
/** 切换是否显示漏怪数量 */
function triggerEnemy() {
showEnemy = !showEnemy;
redraw('enemy');
}
/** 改变区域 */
function changeArea(index) {
nowArea = index;
drawAreaList(false);
drawedThumbnail = {};
status = 'area';
nowScale = defaultValue.scale;
drawMap(core.plugin.getMapDrawInfo(areas[index].maps[0]));
}
/** 重绘 */
function redraw(id, px, py, move = true) {
const { x, y } = canDrag.__flyMap__;
status = id;
drawedThumbnail = {};
drawMap(
core.plugin.getMapDrawInfo(drawingMap, nowDepth, true),
nowScale
);
if (move) canDrag.__flyMap__.move(px ?? x, py ?? y);
checkThumbnail();
}
/**
* 拖拽时移动需要元素
* @param {string} dx
* @param {string} dy
*/
function moveEle(dx, dy) {
moved = true;
for (const id in canDrag) {
const sprite = canDrag[id];
const ctx = sprite.context;
sprite.x += dx;
sprite.y += dy;
core.relocateCanvas(ctx, dx, dy, true);
}
checkThumbnail();
}
/**
* 缩放绘制地图
* @param {number} target 目标缩放比例
* @param {{[x: string]: [number, number]}} info 缩放后的sprite位置数据
*/
function scaleMap(target, info) {
// 检查浏览器限制
if (checkMaximum(nowScale, target)) return;
clearTimeout(lastScale);
const [x, y] = info.__flyMap__;
// 先直接修改style，延迟200ms再绘制，进行性能优化
const sprite = canDrag.__flyMap__;
const rate = target / nowScale;
nowScale = target;
sprite.resize(sprite.width * rate, sprite.height * rate, true);
sprite.move(x - sprite.width / 2, y - sprite.height / 2);
lastScale = setTimeout(() => {
redraw('scale', x - sprite.width / 2, y - sprite.height / 2);
}, 200);
}
/** 键盘操作
* @param {KeyboardEvent} e
*/
function keyboard(e) {
if (
e.key === 'Enter' ||
e.key === 'C' ||
e.key === 'c' ||
e.key === ' '
) {
return flyTo(selecting);
} else if (e.key === 'Escape' || e.key === 'x' || e.key === 'X') {
return close();
} else if (e.key.startsWith('Arrow')) {
const dir = e.key.slice(5).toLowerCase();
// 获取目标楼层
const res =
mapCache[`${drawingMap}_${nowDepth}_${noBorder}`].res;
const key = Object.keys(res).find(v => {
const [floorId, x, y, d] = v.split('_');
return floorId === selecting && d === dir;
});
if (!key) return;
const target = res[key].split('_')[0];
selecting = target;
redraw('key');
}
}
/**
* 给需要的元素添加拖拽等事件
* @param {HTMLCanvasElement} ele
*/
function addDrag(ele) {
ele.addEventListener('wheel', wheel);
ele.addEventListener('mousemove', drag);
ele.addEventListener('touchmove', touchDrag);
ele.addEventListener('click', clickMap);
ele.addEventListener('mousedown', () => {
clicking = true;
});
ele.addEventListener('mouseup', () => {
clicking = false;
});
ele.addEventListener('touchend', () => {
lastTouch = {};
lastLength = 0;
});
document.body.addEventListener('keyup', keyboard);
}
maps.prototype._drawThumbnail_drawToTarget = function (
floorId,
options
) {
const ctx = core.getContextByName(options.ctx);
if (ctx == null) return;
const x = options.x || 0,
y = options.y || 0,
size = options.size || 1;
// size的含义改为(0,1]范围的系数以适配长方形，默认为1，楼传为3/4，SL界面为0.3
let w = Math.ceil(size * core._PX_),
h = Math.ceil(size * core._PY_);
// 特判是否为编辑器，编辑器中长宽均采用core.js的遗留正方形像素边长，以保证下面的绘制正常
if (main.mode == 'editor') w = h = size * core.__PIXELS__;
const width = core.floors[floorId].width,
height = core.floors[floorId].height;
let centerX = options.centerX,
centerY = options.centerY;
if (centerX == null) centerX = Math.floor(width / 2);
if (centerY == null) centerY = Math.floor(height / 2);
const tempCanvas = core.bigmap.tempCanvas;
if (options.all) {
const tempWidth = tempCanvas.canvas.width,
tempHeight = tempCanvas.canvas.height;
// 绘制全景图
if (tempWidth <= tempHeight) {
const realHeight = h,
realWidth = (realHeight * tempWidth) / tempHeight;
const side = (w - realWidth) / 2;
if (options.fromMap) {
return core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y,
realWidth,
realHeight
);
}
core.fillRect(ctx, x, y, side, realHeight, '#000000');
core.fillRect(ctx, x + w - side, y, side, realHeight);
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x + side,
y,
realWidth,
realHeight
);
} else {
const realWidth = w,
realHeight = (realWidth * tempHeight) / tempWidth;
const side = (h - realHeight) / 2;
if (options.fromMap) {
return core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y,
realWidth,
realHeight
);
}
core.fillRect(ctx, x, y, realWidth, side, '#000000');
core.fillRect(ctx, x, y + h - side, realWidth, side);
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y + side,
realWidth,
realHeight
);
}
} else {
// 只绘制可见窗口
let pw = core._PX_,
ph = core._PY_,
hw = core._HALF_WIDTH_,
hh = core._HALF_HEIGHT_,
W = core._WIDTH_,
H = core._HEIGHT_;
const ratio = core.domStyle.isVertical
? core.domStyle.ratio
: core.domStyle.scale;
if (main.mode == 'editor') {
pw = ph = core.__PIXELS__;
hw = hh = core.__HALF_SIZE__;
W = H = core.__SIZE__;
}
if (options.v2) {
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
pw * ratio,
ph * ratio,
x,
y,
w,
h
);
} else {
const offsetX = core.clamp(centerX - hw, 0, width - W),
offsetY = core.clamp(centerY - hh, 0, height - H);
if (options.noHD) {
core.drawImage(
ctx,
tempCanvas.canvas,
offsetX * 32,
offsetY * 32,
pw,
ph,
x,
y,
w,
h
);
return;
}
core.drawImage(
ctx,
tempCanvas.canvas,
offsetX * 32 * ratio,
offsetY * 32 * ratio,
pw * ratio,
ph * ratio,
x,
y,
w,
h
);
}
}
};
},
fixed: function () {
return;
// 该插件可自定义空间很大，可自定义内容请看注释
// -------------------- 安装说明 -------------------- //
/* 1.安装基于canvas的sprite化插件（2.10以上样板自带）和响应式变量插件（不要使用vue原生版）
* 2.确保自己的编辑器已安装造塔群内的编辑器升级压缩包（在HTML5魔塔样板文件夹内，2.10.1以上样板自带）
* 3.将以下代码复制进插件
*/
// -------------------- 使用说明 -------------------- //
// -------------------- 插件说明 -------------------- //
// 录像验证忽略
if (main.replayChecking || main.mode === 'editor') return;
// ----- 不可自定义变量
/** @type {{[x: string]: Sprite}} */
let sprites = {}; // 所有的sprite
/** @type {{[x: string]: EnemyBox}} */
let enemyBoxes = {}; // 所有的enemyBox
/** @type {{[x: string]: TextBox}} */
let textBoxes = {}; // 所有的textBox
let timeout = 0; // 鼠标放到怪物上时setTimeout的id
let dblTimeout = 0; // 双击时判定双击的timeout的id
/** @type {EnemyCollection[]} */
let enemies = []; // 所有的怪物信息
// ----- 不可自定义常量
const specials = core.getSpecials(); // 所有怪物的属性
const originClick = main.dom.data.onmouseup;
// ----- 可自定义变量
let allowMap = true; // 是否允许直接在地图上移动鼠标显示怪物信息
let allowDbl = true; // 是否允许双击地图上的怪物显示其详细信息，当然在点击怪物时会发生约0.2s的卡顿，以判断双击
let guardsFirst = false; // 先攻击支援怪还是后攻击支援怪，用于计算每个怪物的伤害和回合数，请保证与getDamageInfo中相同
let nDefDamage = true; // 为true时，显示 当前地图宝石倍率 防减伤，为false时，显示1防减伤
// ----- 可自定义常量
const showStatus = ['name', 'hp', 'atk', 'def', 'money', 'exp']; // 粗略信息显示的项，伤害与特殊属性必显示
const font = 'normal'; // 默认字体
const op = 'c'; // 信息框背景的不透明度，范围 0-f 十六进制
// 属性名对应的颜色
const colorDict = {
name: '#fff',
hp: '#8f8',
atk: '#f88',
def: '#88f',
money: 'gold',
exp: '#7f7'
};
/** 背景 */
class Back extends Sprite {
constructor(name, color, z, time = 0.6) {
super(0, 0, core._PX_, core._PY_, z, 'game', name);
sprites[name] = this;
this.setCss(`
background-color: ${color};
opacity: 0;
transition: all ${time}s linear;
`);
setTimeout(() => this.setCss(`opacity: 1;`), 50);
}
destroy() {
this.setCss(`opacity: 0;`);
setTimeout(() => super.destroy(), 600);
delete sprites[this.name];
}
}
/** 怪物 */
class EnemyBox extends Sprite {
constructor(name, x, y, w, h, id, big, e) {
const scale = core.domStyle.scale;
const s = 1 / scale / 2;
super(x - s, y - s, w + 2 * s, h + 2 * s, 300, 'game', name);
this.id = id;
/** @type {EnemyCollection} */
this.enemy = e;
this.setCss(`
border: 1px solid #ddd;
background-color: #222;
opacity: 0;
transition: all 0.6s ease-out, transform 0.2s linear;
`);
setTimeout(() => this.setCss(`opacity: 1;`), 50);
this.animate(big);
this.frame = 0;
enemyBoxes[this.name] = sprites[this.name] = this;
this.listen();
}
/** 播放动画 */
animate(big) {
const ctx = this.context;
this.interval = setInterval(() => {
const size = big ? 32 : void 0;
this.frame++;
this.frame %= 2;
// 用drawBlock还不如用drawIcon呢
core.clearMap(ctx);
core.drawIcon(ctx, this.id, 0, 0, size, size, this.frame);
}, core.values.animateSpeed);
}
destroy() {
clearInterval(this.interval);
delete enemyBoxes[this.name];
super.destroy();
}
/** 监听 */
listen() {
this.addEventListener('mouseenter', () => {
this.setCss(`transform: scale(1.1);`);
drawRough(this.enemy);
});
this.addEventListener('mouseleave', () => {
this.setCss(`transform: none;`);
textBoxes[
`_text_${this.enemy.loc.x}_${this.enemy.loc.y}_`
].destroy();
});
}
}
/** 文字框 */
class TextBox extends Sprite {
constructor(x, y, w, h, text, fontSize, ex, ey) {
const id = `_text_${ex}_${ey}_`;
super(x, y, w, h, 310, 'game', id);
this.setCss(`
opacity: 0;
border: thick double #32a1ce;
transition: opacity 0.2s linear;
background-color: #333${op};
box-shadow: 0px 0px 3px #000;
`);
setTimeout(() => this.setCss(`opacity: 1;`), 50);
setTimeout(() => {
clearInterval(core.status.event.interval);
this.render(text, fontSize);
}, 250);
textBoxes[id] = sprites[id] = this;
this.ex = ex;
this.ey = ey;
}
render(text, fontSize) {
/** @type {TextContentConfig} */
const config = {
left: 10,
top: 10,
maxWidth: this.width - 20,
time: 10,
fontSize,
font
};
core.drawTextContent(this.context, text, config);
}
destroy() {
this.setCss(`opacity: 0;`);
setTimeout(() => super.destroy(), 200);
delete textBoxes[`_text_${this.ex}_${this.ey}_`];
}
}
/** 打开定点查看界面 */
this.openFixed = function () {
if (core.isReplaying()) return;
const info = getEnemies();
enemies = info;
drawFixed(info);
core.lockControl();
};
// 监听 & 复写
main.dom.data.addEventListener('mousemove', moveOnPlaying);
main.dom.data.addEventListener('dblclick', dblClick);
main.dom.data.onmouseup = e => {
if (allowDbl) {
clearTimeout(dblTimeout);
dblTimeout = setTimeout(() => {
originClick.call(main.dom.data, e);
}, 200);
} else {
originClick.call(main.dom.data, e);
}
};
/**
* 获取怪物位置和其属性
* @param {string} floorId 地图id
* @returns {EnemyCollection[]} 怪物信息数组
*/
function getEnemies(floorId = core.status.floorId) {
const res = [];
// 遍历所有图块，然后找出在显示范围内的怪物，异步执行，
core.extractBlocks(floorId);
const blocks = core.status.maps[floorId].blocks;
for (const block of blocks) {
const x = block.x,
y = block.y;
// 判断是否为怪物
if (block.event.trigger !== 'battle') continue;
// 判断是否在范围内
if (!inView(x, y)) continue;
res.push(generateCollection(block.event.id, x, y, floorId));
}
return res;
}
function generateCollection(id, x, y, floorId) {
const enemy = core.material.enemys[id];
const info = core.getEnemyInfo(id, void 0, x, y, floorId);
const data = Object.assign({}, enemy);
for (const key in info) data[key] = info[key];
return { loc: { x, y }, data };
}
/**
* 根据属性名获得颜色
* @param {string} status
*/
function color(status) {
return colorDict[status] ?? 'white';
}
/**
* 根据伤害获得伤害颜色
* @param {number} damage
*/
function colorDamage(damage) {
if (typeof damage === 'string' || !damage) return '#f00';
const hp = core.status.hero.hp;
const n = ~~((damage / hp) * 255);
return `rgb(${n}, ${255 - n}, 0)`;
}
/**
* 获取怪物的粗略信息
* @param {Enemy} info
*/
function getRough(info, x, y) {
// 先获得常量中明确指定的
const text = showStatus.map(v => {
return `\\r[${color(v)}]${core.getStatusLabel(v)}\\r[]：${
info[v]
}`;
});
// 特殊属性
if (info.special?.length > 0) {
const names = core.getSpecialText(info);
const color = core.getSpecialColor(info);
const all = names.map((v, i) => `\\r[${color[i]}]${v}\\r[]`);
text.push(`\\r[#f8f]特殊属性\\r[]：${all.join` `}`);
}
// 伤害
const damage = core.getDamageInfo(info, void 0, x, y)?.damage;
const d = core.formatBigNumber(damage);
text.push(
`\\r[#f44]伤害\\r[]：\\r[${colorDamage(damage)}]${
d === '???' ? '无法战胜' : d
}\\r[]`
);
// 支援
if (info.guards?.length > 0) {
const guards = getGuards(info, x, y);
text.push(
`\\r[#3cf]支援\\r[]：${guards.map(v => `\\i[${v.id}]`)
.join` `}`
);
text.push(`支援怪攻击顺序 -->`);
}
if (allowDbl) text.push('双击怪物查看详细信息');
return text.join`\n`;
}
/**
* 获得特殊属性说明、名称、颜色
* @param {SpecialCollection} data
* @param {Enemy} enemy
*/
function executeSpecial(data, enemy) {
let name = '';
if (typeof data[1] === 'string') name = data[1];
else name = data[1](enemy);
let text = '';
if (typeof data[2] === 'string') text = data[2];
else text = data[2](enemy);
return { name, text, color: data[3] };
}
/**
* 获得某个怪物的详细信息，包括特殊属性说明、支援怪攻击顺序
* @param {EnemyCollection} info getEnemies获取的怪物信息
*/
function getDetail(info) {
// ----- status
const status = {};
showStatus.forEach(v => {
status[v] = {
id: v,
name: core.getStatusLabel(v),
value: info.data[v]
};
});
// ----- special
const text = [];
const special = info.data.special;
if (special?.length > 0) {
for (const n of special) {
const data = specials.find(v => v[0] === n);
if (!data)
throw new ReferenceError(
`'${info.data.name}'拥有不存在的特殊属性'${n}'`
);
const {
name,
text: desc,
color
} = executeSpecial(data, info.data);
text.push(`\\r[${color}]${name}\\r[]：${desc}`);
}
}
// ---- damage & turn
const damageInfo = core.getDamageInfo(
info.data,
void 0,
info.loc.x,
info.loc.y
);
let damage = core.formatBigNumber(damageInfo?.damage);
if (damage === '???') damage = '无法战胜';
const color = colorDamage(damageInfo?.damage);
const turn = damageInfo?.turn ?? 0;
// ----- 4 criticals & n def
const criticals = core.nextCriticals(
info.data,
4,
info.loc.x,
info.loc.y
);
const n = nDefDamage ? core.status.thisMap.ratio : 1;
const def = core.getDefDamage(info.data, n, info.loc.x, info.loc.y);
return {
status,
text,
damage: { damage, color, turn },
criticals,
def
};
}
/**
* 获取支援怪信息，攻击顺序
* @param {Enemy} info 怪物信息
* @param {EnemyCollection[]} all 所有的怪物信息
* @returns {GuardCollection[]} 支援怪的顺序信息
*/
function getGuards(info, all) {
/** @type {[number, number, string][]} */
const guards = info.guards;
if (!guards) return;
return guards.map(([x, y, id]) => {
const res = {
loc: { x, y },
id
};
// 寻找符合条件的怪物
const enemy = all.find(v => v.loc.x === x && v.loc.y === y);
res.enemy = enemy;
return res;
});
}
/**
* 获取每个支援怪造成的伤害、回合数等
* @param {EnemyCollection} info
*/
function getGuardsDetail(info) {
// 很神秘的一个功能
const guards = getGuards(info, enemies); // 这时候获得的已经是按顺序排好的了
const col = { enemy: info.data, loc: info.loc };
if (guardsFirst) guards.push(col);
else guards.unshift(col);
const turn = ref(0);
const res = [];
watch(turn, v => (flags.__extraTurn__ = v)); // 使用样板的额外回合flag
const status = ['atk', 'def', 'hp'].map(v => ({
[v]: core.getRealStatus(v)
}));
const hero = Object.assign({}, ...status, { mdef: 0 });
for (let i = 0; i < guards.length; i++) {
const e = guards[i];
const data = core.getDamageInfo(
e.enemy,
i === 0 ? void 0 : hero,
e.loc.x,
e.loc.y
);
if (!data) {
res.push({ battlable: false });
continue;
}
turn.value += data.turn;
res.push({
battlable: true,
damage: data.damage,
turn: data.turn
});
}
return res;
}
/**
* 是否在视野范围内
* @param {number} x 要判断的格子
* @param {number} y
*/
function inView(x, y) {
const { x: hx, y: hy } = core.status.hero.loc;
const w = core._WIDTH_,
h = core._HEIGHT_;
return x <= hx + w && x >= hx - w && y <= hy + h && y >= hy - h;
}
/**
* 计算像素位置
* @param {number} x
* @param {number} y
* @param {number} w
* @param {number} h
*/
function calPixel(x, y, w, h) {
const px = x * 32 + 16 - w / 2,
py = (y + 1) * 32 - h;
return { px, py, w, h };
}
/**
* 根据鼠标位置获得矩形的绘制信息
* @param {number} px
* @param {number} py
*/
function calRect(px, py, text) {
const onRight = px >= core._PX_ / 2;
let x = px + 32;
const width = Math.min(
core._PX_ / 2 - 32,
onRight ? px - 32 : core._PX_ - x
);
if (onRight) x = px - width - 32;
const config = {
maxWidth: width - 20,
font,
fontSize: 19,
left: 10
};
let height = 500;
while (height > core._PY_ - 20) {
config.fontSize--;
height = core.getTextContentHeight(text, config) + 20;
}
const y = core.clamp(py - height / 2, 10, core._PY_ - 20 - height);
return { x, y, width, height, font: config.fontSize };
}
/**
* 绘制定点查看界面
* @param {EnemyCollection[]} info 怪物信息
*/
function drawFixed(info) {
// 绘制，当然还有动画
new Back('_fixed_sback_', 'rgba(0, 0, 0, 0.9)', 200);
drawChoice(info);
const exit = new Sprite(
core._PX_ - 60,
4,
56,
24,
400,
'game',
'_exit_'
);
exit.setCss(`
background-color: #aaa;
box-shadow: 0px 0px 3px #000;
cursor: pointer;
transition: all 0.6s linear;
opacity: 0;
`);
setTimeout(() => exit.setCss(`opacity: 1;`), 50);
const ctx = exit.context;
ctx.shadowBlur = 3;
ctx.shadowColor = '#000';
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
core.fillText(ctx, '退出', 28, 12, '#fff', '18px normal');
exit.addEventListener('click', close);
sprites['_exit_'] = exit;
}
/**
* 绘制每个怪物
* @param {EnemyCollection[]} info
*/
function drawChoice(info) {
for (const e of info) {
const { x, y } = e.loc;
const data = e.data;
const { bigImage, height } = core.getBlockInfo(data.id);
const w = bigImage?.width ?? 32,
h = bigImage?.height ?? height;
const { px, py } = calPixel(x, y, w, h);
new EnemyBox(
`_enemybox_${x}_${y}_`,
px,
py,
w,
h,
data.id,
!!bigImage,
e
);
}
}
/**
* 绘制怪物的粗略信息
* @param {EnemyCollection} info
*/
function drawRough(info) {
const { x, y } = info.loc;
const text = getRough(info.data, x, y);
const rect = calRect(x * 32 + 16, y * 32 + 16, text);
new TextBox(
rect.x,
rect.y,
rect.width,
rect.height,
text,
rect.font,
x,
y
);
}
/**
* 绘制详细信息的主界面
* @param {EnemyCollection} info
* @param {EnemyBox} enemyBox
*/
function drawMain(info, enemyBox) {
const { bigImage, height } = core.getBlockInfo(info.data.id);
const w = bigImage?.width ?? 32,
h = bigImage?.height ?? height;
const box =
enemyBox ??
new EnemyBox(
`_enemy_main_`,
16,
16,
w,
h,
info.data.id,
!!bigImage,
info
);
box.move(16, 16);
box.setCss(`
border: 0;
background-color: transparent;
transform: none;
z-index: 1000;
`);
const { status, text, damage, criticals, def } = getDetail(info);
const back = new Back(
`_detail_back_`,
'linear-gradient(to bottom, #333, #777)',
600,
0.2
);
// draw
const sv = Object.values(status);
sv.forEach(e => {});
}
/**
* 绘制怪物详细信息界面
* @param {EnemyCollection} info 怪物的信息
* @param {boolean} animate 是否要有动画
*/
function drawDetail(info, animate) {
const { x, y } = info.loc;
const box = enemyBoxes[`_enemybox_${x}_${y}_`];
if (!animate) box?.destroy();
drawMain(info, box);
}
/** 关闭界面 */
function close() {
Object.values(sprites).forEach(v => v.destroy());
setTimeout(core.unlockControl, 600);
}
function getEnemy(px, py) {
const evenX = core._WIDTH_ % 2 === 0 ? 0.5 : 0,
evenY = core._HEIGHT_ % 2 === 0 ? 0.5 : 0;
const bx = Math.round(
~~(px / 32) - core.bigmap.offsetX / 32 + evenX
),
by = Math.round(~~(py / 32) - core.bigmap.offsetY / 32 + evenY);
const loc = `${bx},${by}`;
const blocks = core.getMapBlocksObj();
const block = blocks[loc];
if (!block) return;
if (block?.event?.trigger === 'battle')
return generateCollection(block.event.id, bx, by);
}
/**
* 在游戏时移动鼠标，延迟500ms显示怪物信息
* @param {MouseEvent} e
*/
function moveOnPlaying(e) {
if (!allowMap) return;
if (!core.isPlaying()) return;
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
const px = x / core.domStyle.scale,
py = y / core.domStyle.scale;
clearTimeout(timeout);
// 清空所有的信息栏
Object.values(textBoxes).forEach(v => v.destroy());
const enemy = getEnemy(px, py);
if (block?.event?.trigger !== 'battle') return;
lastLoc = loc;
timeout = setTimeout(() => {
drawRough(enemy);
}, 500);
}
/**
* 双击鼠标时
* @param {MouseEvent} e
*/
function dblClick(e) {
if (!allowDbl) return;
if (!core.isPlaying()) return;
if (e.detail !== 2) return;
clearTimeout(dblTimeout);
clearTimeout(timeout);
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
const px = x / core.domStyle.scale,
py = y / core.domStyle.scale;
const enemy = getEnemy(px, py);
drawDetail(enemy);
}
},
itemDetail: function () {
core.bigmap.threshold = 256;
core.control.updateDamage = function (floorId, ctx) {
floorId = floorId || core.status.floorId;
if (!floorId || core.status.gameOver || main.mode != 'play') return;
var onMap = ctx == null;
// 没有怪物手册
if (!core.hasItem('book')) return;
core.status.damage.posX = core.bigmap.posX;
core.status.damage.posY = core.bigmap.posY;
if (!onMap) {
var width = core.floors[floorId].width,
height = core.floors[floorId].height;
// 地图过大的缩略图不绘制显伤
if (width * height > core.bigmap.threshold) return;
}
this._updateDamage_damage(floorId, onMap);
this._updateDamage_extraDamage(floorId, onMap);
core.getItemDetail(floorId); // 宝石血瓶详细信息
this.drawDamage(ctx);
};
// 绘制地图显示
control.prototype._drawDamage_draw = function (ctx, onMap) {
if (!core.hasItem('book')) return;
core.setFont(ctx, '15px normal');
core.setTextAlign(ctx, 'left');
core.status.damage.data.forEach(one => {
var px = one.px,
py = one.py;
if (onMap && core.bigmap.v2) {
px -= core.bigmap.posX * 32;
py -= core.bigmap.posY * 32;
if (
px < -32 * 2 ||
px > core.__PIXELS__ + 32 ||
py < -32 ||
py > core.__PIXELS__ + 32
)
return;
}
core.fillBoldText(ctx, one.text, px, py, one.color);
});
core.setTextAlign(ctx, 'center');
core.status.damage.extraData.forEach(one => {
var px = one.px,
py = one.py;
if (onMap && core.bigmap.v2) {
px -= core.bigmap.posX * 32;
py -= core.bigmap.posY * 32;
if (
px < -32 ||
px > core.__PIXELS__ + 32 ||
py < -32 ||
py > core.__PIXELS__ + 32
)
return;
}
core.fillBoldText(ctx, one.text, px, py, one.color);
});
};
core.formatBigNumber = function (x, onMap, onCritical) {
x = Math.floor(parseFloat(x));
if (!core.isset(x) || !Number.isFinite(x)) return '???';
if (x > 1e24 || x < -1e24) return x.toExponential(2);
var c = x < 0 ? '-' : '';
if (onCritical) c = '-> ';
x = Math.abs(x);
if (x <= 9999 || (!onMap && x <= 999999)) return c + x;
var all = [
{ val: 1e20, c: 'g' },
{ val: 1e16, c: 'j' },
{ val: 1e12, c: 'z' },
{ val: 1e8, c: 'e' },
{ val: 1e4, c: 'w' }
];
for (var i = 0; i < all.length; i++) {
var one = all[i];
if (onMap) {
if (x >= one.val) {
var v = x / one.val;
return (
c +
v.toFixed(
Math.max(
0,
Math.floor(
(c == '-' ? 2 : 3) - Math.log10(v + 1)
)
)
) +
one.c
);
}
} else {
if (x >= 10 * one.val) {
var v = x / one.val;
return (
c +
v.toFixed(
Math.max(0, Math.floor(4 - Math.log10(v + 1)))
) +
one.c
);
}
}
}
return c + x;
};
// 获取宝石信息 并绘制
this.getItemDetail = function (floorId) {
if (!core.getFlag('itemDetail')) return;
floorId = floorId || core.status.thisMap.floorId;
core.status.maps[floorId].blocks.forEach(block => {
if (block.event.cls !== 'items') return;
var x = block.x,
y = block.y;
// v2优化，只绘制范围内的部分
if (core.bigmap.v2) {
if (
x < core.bigmap.posX - core.bigmap.extend ||
x >
core.bigmap.posX +
core.__SIZE__ +
core.bigmap.extend ||
y < core.bigmap.posY - core.bigmap.extend ||
y >
core.bigmap.posY +
core.__SIZE__ +
core.bigmap.extend
) {
return;
}
}
var id = block.event.id;
var item = core.material.items[id];
if (item.cls === 'equips') {
// 装备也显示
var diff = item.equip.value || {};
var per = item.equip.percentage;
for (var name in per) {
diff[name + 'per'] = per[name].toString() + '%';
}
drawItemDetail(diff, x, y);
return;
}
var before = core.clone(core.status.hero);
// 跟数据统计原理一样 执行效果 前后比较
core.setFlag('__statistics__', true);
try {
eval(item.itemEffect);
} catch (error) {}
var diff = compareObject(before, core.status.hero);
core.status.hero = hero = before;
flags = core.status.hero.flags;
drawItemDetail(diff, x, y);
});
};
// 比较两个对象之间每一项的数值差异（弱等于） 返回数值差异
function compareObject(a, b) {
a = a || {};
b = b || {};
var diff = {}; // 差异
for (var name in a) {
diff[name] = b[name] - (a[name] || 0);
if (!diff[name]) diff[name] = void 0;
}
return diff;
}
// 绘制
function drawItemDetail(diff, x, y) {
if (core.same(diff, {}) || !diff) return;
var px = 32 * x + 2,
py = 32 * y + 30;
var content = '';
// 获得数据和颜色
var i = 0;
for (var name in diff) {
if (!diff[name]) continue;
var color = '#ffffff';
if (typeof diff[name] === 'number')
diff[name] = core.formatBigNumber(diff[name], true);
switch (name) {
case 'atk':
case 'atkper':
color = '#FF7A7A';
break;
case 'def':
case 'defper':
color = '#00E6F1';
break;
case 'mdef':
case 'mdefper':
color = '#6EFF83';
break;
case 'hp':
color = '#A4FF00';
break;
case 'hpmax':
case 'hpmaxper':
color = '#F9FF00';
break;
case 'mana':
color = '#cc6666';
break;
}
content = diff[name];
// 绘制
core.status.damage.data.push({
text: content,
px: px,
py: py - 10 * i,
color: color
});
i++;
}
}
},
chapter: function () {
// 章节显示
var chapter = '',
description = '';
// 显示章节
this.displayChapter = function (index) {
if (core.isReplaying()) return;
var number = core.replaceNumberWithChinese(index);
// 获取第几章
chapter = '第' + number + '章';
if (index == 0) chapter = '序章';
// 获取描述
switch (index) {
case 0:
description = '起源';
break;
case 1:
description = '勇气';
break;
case 2:
description = '智慧';
break;
}
core.coreChapterAnimate(chapter, description);
};
// 替换数字大小写
this.replaceNumberWithChinese = function (number) {
if (number == 0) return '零';
if (number == 1) return '一';
if (number == 2) return '二';
if (number == 3) return '三';
if (number == 4) return '四';
if (number == 5) return '五';
if (number == 6) return '六';
if (number == 7) return '七';
if (number == 8) return '八';
if (number == 9) return '九';
if (number == 10) return '十';
};
// 核心动画运算
this.coreChapterAnimate = function (chapter, description) {
// 先建画布
if (core.isReplaying()) return;
core.createCanvas('chapter', 0, 0, 480, 480, 100);
var frame = 0,
speed = 0,
left = -480,
down = 240;
// 一秒50帧
core.lockControl();
var interval = setInterval(() => {
core.clearMap('chapter');
speed = core.hyperbolicCosine((frame - 84) * 0.05);
left += speed / 2;
// 背景
if (frame <= 110) {
core.fillRect(
'chapter',
0,
-240 - left,
480,
left + 480,
'#000000'
);
core.fillRect(
'chapter',
0,
240,
480,
left + 480,
'#000000'
);
} else {
core.fillRect('chapter', 0, 0, 480, down, '#000000');
core.fillRect(
'chapter',
0,
480 - down,
480,
down,
'#000000'
);
down -= speed / 2;
}
// 中间矩形
if (frame <= 100) {
core.fillRect(
'chapter',
0,
240 - frame / 5,
480,
frame / 2.5,
[255, 255, 255, 0.5 + frame / 200]
);
} else {
core.fillRect(
'chapter',
0,
240 - 2100 / (205 - frame),
480,
4200 / (205 - frame),
[255, 255, 255, (175 - frame) / 75]
);
}
// 上下方线
core.fillRect('chapter', left, 210, 300, 10, '#FF4D00');
core.fillRect('chapter', 180 - left, 260, 300, 10, '#2DFFFC');
core.fillRect('chapter', left + 310, 210, 10, 10, '#FF4D00');
core.fillRect('chapter', 160 - left, 260, 10, 10, '#2DFFFC');
core.fillPolygon(
'chapter',
[
[left + 330, 210],
[left + 330, 220],
[left + 340, 220]
],
'#FF4D00'
);
core.fillPolygon(
'chapter',
[
[150 - left, 260],
[140 - left, 260],
[150 - left, 270]
],
'#2DFFFC'
);
// 闪光条
for (var i = 5; i > 0; i--) {
if (frame <= 150) {
core.drawLine(
'chapter',
0,
220,
left + 320,
220,
[255, 255, 255, 0.4],
i
);
core.drawLine(
'chapter',
480,
260,
160 - left,
260,
[255, 255, 255, 0.4],
i
);
} else {
core.drawLine(
'chapter',
0,
220,
left + 320,
220,
[255, 255, 255, 0.4 - (frame - 150) / 125],
i
);
core.drawLine(
'chapter',
480,
260,
160 - left,
260,
[255, 255, 255, 0.4 - (frame - 150) / 125],
i
);
}
}
core.fillEllipse(
'chapter',
left + 320,
220,
7,
3,
0,
[255, 255, 255, 0.8]
);
core.fillEllipse(
'chapter',
left + 320,
220,
2,
10,
0,
[255, 255, 255, 0.8]
);
core.fillEllipse(
'chapter',
160 - left,
260,
7,
3,
0,
[255, 255, 255, 0.8]
);
core.fillEllipse(
'chapter',
160 - left,
260,
2,
10,
0,
[255, 255, 255, 0.8]
);
// 字
core.setTextAlign('chapter', 'center');
core.fillBoldText(
'chapter',
chapter + ' ' + description,
left + 360,
250,
'#ffffff',
'#000000',
'28px scroll'
);
if (frame >= 200) {
clearInterval(interval);
core.deleteCanvas('chapter');
core.unlockControl();
}
if (frame == 80) core.playSound('chapter.mp3');
frame++;
}, 20);
};
// 返回双曲余弦值
this.hyperbolicCosine = function (number) {
return 0.5 * (Math.pow(Math.E, number) + Math.pow(Math.E, -number));
};
},
intelligenceTree: function () {
// 智慧加点
var list;
var levels;
var currPage = 1,
selector = [1, 1];
// 获取技能等级
this.getSkillLevel = function () {
if (!flags.levels) flags.levels = [];
for (var i = 0; i < 10; i++) {
if (flags.levels[i] == null) flags.levels[i] = 0;
}
return flags.levels;
};
// 初始化
this.initializeList = function (changePage) {
// 初始化等级
levels = core.clone(core.getSkillLevel());
// 技能定义 0索引 1名称 2描述 3等级 4消耗 5前置技能[索引,等级,索引,等级] 6位置(5×5) 7最大等级 8页码数 9效果
list = [
[
0,
'力量',
'力量就是根本！可以通过智慧增加力量',
0,
10 * levels[0] + 10,
null,
[1, 2],
10,
1,
'攻击＋' + levels[0] * 2
],
[
1,
'致命一击',
'爆发出全部力量攻击敌人',
0,
30 * levels[1] + 30,
[0, 5],
[2, 1],
10,
1,
'每回合额外伤害＋' + levels[1] * 5
],
[
2,
'断灭之刃',
'\\r[#dddd44]主动技能\\r[]，开启后会在战斗时会额外增加一定量的攻击， 但同时减少一定量的防御，快捷键1',
0,
200 * levels[2] + 400,
[1, 5],
[4, 1],
5,
1,
levels[2] * 10 +
'%攻击加成，减少' +
levels[2] * 10 +
'%的防御'
],
[
3,
'坚韧',
'由智慧转化出坚韧！',
0,
10 * levels[3] + 10,
null,
[1, 4],
10,
1,
'防御+' + levels[3] * 2
],
[
4,
'回春',
'让智慧化为治愈之泉水！',
0,
20 + levels[4] * 20,
[3, 5],
[2, 5],
25,
1,
'每回合回复' + 1 * levels[4] + '生命'
],
[
5,
'治愈之泉',
'让生命变得更多一些吧！每吃50瓶血瓶就增加当前生命回复10%的生命回复',
0,
1500,
[4, 25],
[4, 5],
1,
1,
'50瓶血10%生命回复'
],
[
6,
'坚固之盾',
'让护甲更加坚硬一些吧！',
0,
50 + levels[6] * 50,
[3, 5],
[2, 3],
10,
1,
'防御+' + 10 * levels[6]
],
[
7,
'无上之盾',
'\\r[#dddd44]第一章终极技能\\r[]，战斗时智慧会充当等量护盾',
0,
2500,
[6, 10, 5, 1, 2, 2],
[5, 3],
1,
1,
'战斗时智慧会充当护盾'
]
];
// 深拷贝list
list = core.clone(list);
var acted = false;
for (var i in list) {
list[i][3] = levels[i];
if (!list[i][5]) list[i][5] = [];
// 根据页码获取光标应该在的位置
if (changePage && !acted) {
if (list[i][8] == currPage) {
selector = list[i][6];
acted = true;
}
}
}
};
// 升级效果
this.treeEffect = function (index) {
index = parseInt(index);
switch (index) {
case 0: // 力量 +2攻击
core.status.hero.atk += 2;
break;
case 1: // 致命一击 +5额外攻击
core.status.hero.mana += 5;
break;
case 2: // 断灭之刃
core.setFlag('bladeOn', true);
break;
case 3: // 坚韧 +2防御
core.status.hero.def += 2;
break;
case 4: // 回春 +1回复
core.status.hero.hpmax += 1;
break;
case 5: // 治愈之泉
core.setFlag('spring', true);
break;
case 6: // 坚固之盾 +10防御
core.status.hero.def += 10;
break;
case 7: // 无上之盾
core.setFlag('superSheild', true);
break;
}
core.status.hero.mdef -= list[index][4];
};
// 由光标位置获得索引
this.getIdBySelector = function (x, y, page) {
for (var i in list) {
if (
list[i][8] == page &&
x == list[i][6][0] &&
y == list[i][6][1]
) {
return i;
}
}
};
// 绘制技能树界面
this.drawTree = function (changePage) {
// 初始化
if (!changePage) changePage = false;
core.initializeList(changePage);
var id = core.getIdBySelector(selector[0], selector[1], currPage);
var name = list[id][1],
description = list[id][2],
level = levels[id],
cost = list[id][4],
foreSkill = list[id][5],
max = list[id][7],
effect = list[id][9];
// 先建画布
core.createCanvas('tree', 0, 0, 480, 480, 130);
// 背景
core.fillRect('tree', 0, 0, 480, 480, [0, 0, 0, 0.95]);
core.drawLine('tree', 0, 172, 480, 172, [200, 200, 200, 0.95], 1);
core.drawLine('tree', 308, 172, 308, 480, [200, 200, 200, 0.95], 1);
core.drawLine('tree', 308, 450, 480, 450, [200, 200, 200, 0.95], 1);
core.drawLine('tree', 308, 220, 480, 220, [200, 200, 200, 0.95], 1);
core.drawLine('tree', 308, 413, 480, 413, [200, 200, 200, 0.95], 1);
for (var i = 0; i <= 239; i++) {
core.drawLine(
'tree',
i,
40,
480 - i,
40,
[0, 255, 107, 0.002],
2
);
}
// 每一项技能图标
for (var i in list) {
if (list[i][8] != currPage) continue;
// 技能间的线
for (var j = 0; j < list[i][5].length; j += 2) {
if (!list[i][5]) break;
if (levels[list[i][5][j]] < list[i][5][j + 1])
core.drawLine(
'tree',
list[list[i][5][j]][6][0] * 56 - 14,
list[list[i][5][j]][6][1] * 56 + 158,
list[i][6][0] * 56 - 14,
list[i][6][1] * 56 + 158,
'#aaaaaa',
1
);
else
core.drawLine(
'tree',
list[list[i][5][j]][6][0] * 56 - 14,
list[list[i][5][j]][6][1] * 56 + 158,
list[i][6][0] * 56 - 14,
list[i][6][1] * 56 + 158,
'#00FF88',
1
);
}
}
// 图标
for (var i in list) {
// 图标
core.drawImage(
'tree',
'skill' + i + '.png',
0,
0,
114,
114,
list[i][6][0] * 56 - 28,
list[i][6][1] * 56 + 144,
28,
28
);
// 方框
if (levels[i] == 0)
core.strokeRect(
'tree',
list[i][6][0] * 56 - 28,
list[i][6][1] * 56 + 144,
28,
28,
'#888888',
1
);
else if (levels[i] == list[i][7])
core.strokeRect(
'tree',
list[i][6][0] * 56 - 28,
list[i][6][1] * 56 + 144,
28,
28,
'#F7FF68',
1
);
else
core.strokeRect(
'tree',
list[i][6][0] * 56 - 28,
list[i][6][1] * 56 + 144,
28,
28,
'#00FF69',
1
);
// 光标
core.strokeRect(
'tree',
selector[0] * 56 - 28,
selector[1] * 56 + 144,
28,
28,
'#ffff00',
1
);
}
// 说明
core.setTextAlign('tree', 'center');
core.fillText('tree', name, 240, 30, '#00FFD5', '28px normal');
core.setTextAlign('tree', 'left');
core.drawTextContent('tree', ' ' + description, {
left: 10,
top: 42,
maxWidth: 460,
font: 'normal',
fontSize: 18
});
// 效果
if (level != 0)
core.drawTextContent('tree', '当前效果：' + effect, {
left: 10,
top: 122,
maxWidth: 460,
font: 'normal',
fontSize: 18
});
if (level != max) {
flags.levels[id] += 1;
core.initializeList(false);
effect = list[id][9];
core.drawTextContent('tree', '下一级效果：' + effect, {
left: 10,
top: 147,
maxWidth: 460,
font: 'normal',
fontSize: 18
});
flags.levels[id]--;
core.initializeList(false);
effect = list[id][9];
}
core.setTextAlign('tree', 'center');
// 等级
core.fillText(
'tree',
'等级：' + level + '/' + max,
394,
190,
'#ffffff',
'18px normal'
);
// 升级
if (level != max)
core.fillText(
'tree',
'升级花费：' + cost,
394,
210,
'#ffffff',
'18px normal'
);
// 退出
core.fillText('tree', '退出', 394, 470, '#ffffff', '18px normal');
// 页码数
var text = core.replaceNumberWithChinese(currPage);
core.fillText(
'tree',
'第' + text + '章',
394,
440,
'#ffffff',
'24px normal'
);
if (currPage != 1)
core.fillText('tree', '<', 334, 440, '#ffffff', '24px normal');
if (currPage != flags.chapter)
core.fillText('tree', '>', 454, 440, '#ffffff', '24px normal');
// 前置技能
core.fillText(
'tree',
'前置技能',
394,
245,
'#ffffff',
'20px normal'
);
if (foreSkill.length > 0) {
for (var i = 0; i < foreSkill.length; i += 2) {
core.fillText(
'tree',
foreSkill[i + 1] + '级 ' + list[foreSkill[i]][1],
394,
270 + 10 * i
);
}
}
};
// 升级操作
this.upgradeTree = function (index) {
// 执行操作
if (levels[index] == list[index][7]) {
core.playSound('操作失败');
core.insertAction(['该技能已满级！']);
return;
}
// 判断前置技能
var fore = list[index][5];
for (var i = 0; i < fore.length; i += 2) {
if (levels[fore[i]] < fore[i + 1]) {
core.playSound('操作失败');
core.insertAction(['前置技能未满足！']);
return;
}
}
if (core.status.hero.mdef < list[index][4]) {
core.playSound('操作失败');
core.insertAction(['智慧点不足！']);
return;
}
flags.levels[index]++;
core.treeEffect(index);
// 刷新
core.drawTree(false);
core.updateStatusBar();
core.updateDamage();
// 音效
core.playSound('tree.mp3');
core.insertAction([{ type: 'sleep', time: 100, noSkip: true }]);
};
// 上下左右
this.moveSelector = function (keycode, times) {
times = times || 0;
core.playSound('光标移动');
if (keycode == 37 || keycode == 39) {
// left right
if (times > 3) {
// 正左右没有东西 移动至下一列
selector[0] -= 3 * (keycode - 38);
for (var i in list) {
if (list[i][8] != currPage) continue;
if (list[i][6][0] == selector[0]) {
selector = list[i][6];
return;
}
}
selector[0] -= keycode - 38;
return;
}
selector[0] += keycode - 38;
for (var i in list) {
// 正左右有技能 移动至最近的技能
if (list[i][8] != currPage) continue;
if (
list[i][6][0] == selector[0] &&
list[i][6][1] == selector[1]
) {
selector = list[i][6];
return;
}
}
return core.moveSelector(keycode, times + 1);
} else {
// up down
if (times > 3) {
selector[1] -= 3 * (keycode - 39);
for (var i in list) {
if (list[i][8] != currPage) continue;
if (list[i][6][1] == selector[1]) {
selector = list[i][6];
return;
}
}
selector[1] -= keycode - 39;
return;
}
selector[1] += keycode - 39;
for (var i in list) {
if (list[i][8] != currPage) continue;
if (
list[i][6][1] == selector[1] &&
list[i][6][0] == selector[0]
) {
selector = list[i][6];
return;
}
}
return core.moveSelector(keycode, times + 1);
}
};
// 由点击位置获取光标位置
this.getSelectorByLoc = function (px, py) {
if (px % 56 < 28 || (py - 172) % 56 < 28) return;
var x = Math.ceil(px / 56),
y = Math.ceil((py - 172) / 56);
if (selector[0] == x && selector[1] == y) {
var id = core.getIdBySelector(
selector[0],
selector[1],
currPage
);
core.upgradeTree(id);
} else {
for (var i in list) {
if (list[i][8] != currPage) continue;
if (list[i][6][0] == x && list[i][6][1] == y) {
selector = [x, y];
core.playSound('光标移动');
return;
}
}
}
};
// 键盘操作
this.treeKeyboard = function (keycode) {
var id = core.getIdBySelector(selector[0], selector[1], currPage);
switch (keycode) {
case 13:
case 32: // 确认升级
core.upgradeTree(id);
break;
case 27:
case 88: // 退出
core.playSound('取消');
core.insertAction({ type: 'break' });
break;
case 37:
case 38:
case 39:
case 40: // 移动光标
core.moveSelector(keycode);
break;
}
};
// 点击操作
this.treeClick = function (px, py) {
if (px >= 308 && py >= 450) {
core.playSound('取消');
core.insertAction({ type: 'break' });
}
if (px <= 308 && py >= 172) {
core.getSelectorByLoc(px, py);
}
};
// 操作
this.actTree = function () {
if (flags.type == 0) return this.treeKeyboard(flags.keycode);
else return this.treeClick(flags.px, flags.py);
};
// 开启
this.openTree = function () {
// 插入事件
core.initializeList(true);
core.playSound('打开界面');
core.insertAction([
{
type: 'while',
condition: 'true',
data: [
{
type: 'function',
function: '() => { core.plugin.drawTree(false); }'
},
{ type: 'wait' },
{
type: 'function',
function: '() => { core.plugin.actTree(); }'
}
]
},
{
type: 'function',
function: "() => { core.deleteCanvas('tree');}"
}
]);
};
},
skills: function () {
// 所有的主动技能效果
var ignoreInJump = {
event: ['X20007', 'X20001', 'X20006', 'X20014', 'X20010', 'X20007'],
bg: [
'X20037',
'X20038',
'X20039',
'X20045',
'X20047',
'X20053',
'X20054',
'X20055',
'X20067',
'X20068',
'X20075',
'X20076'
]
};
// 跳跃
this.jumpSkill = function () {
if (core.status.floorId.startsWith('tower'))
return core.drawTip('当无法使用该技能');
if (!flags.skill2) return;
if (!flags['jump_' + core.status.floorId])
flags['jump_' + core.status.floorId] = 0;
if (
core.status.floorId == 'MT14' &&
flags['jump_' + core.status.floorId] == 2 &&
!flags.MT14Jump
) {
if (
!(
core.status.hero.loc.x == 77 &&
core.status.hero.loc.y == 5 &&
core.status.hero.loc.direction == 'right'
)
) {
return core.drawTip('该地图还有一个必跳的地方，你还没有跳');
} else flags.MT14Jump = true;
}
if (flags['jump_' + core.status.floorId] >= 3)
return core.drawTip('当前地图使用次数已用完');
core.autosave();
var direction = core.status.hero.loc.direction;
var loc = core.status.hero.loc;
var checkLoc = {};
switch (direction) {
case 'up':
checkLoc.x = loc.x;
checkLoc.y = loc.y - 1;
break;
case 'right':
checkLoc.x = loc.x + 1;
checkLoc.y = loc.y;
break;
case 'down':
checkLoc.x = loc.x;
checkLoc.y = loc.y + 1;
break;
case 'left':
checkLoc.x = loc.x - 1;
checkLoc.y = loc.y;
break;
}
// 前方是否可通行 或 是怪物
var cls = core.getBlockCls(checkLoc.x, checkLoc.y);
var noPass = core.noPass(checkLoc.x, checkLoc.y);
var id = core.getBlockId(checkLoc.x, checkLoc.y) || '';
var bgId =
core.getBlockByNumber(core.getBgNumber(checkLoc.x, checkLoc.y))
.event.id || '';
// 可以通行
if (
!noPass ||
cls == 'items' ||
(id.startsWith('X') && !ignoreInJump.event.includes(id)) ||
(bgId.startsWith('X') && !ignoreInJump.bg.includes(bgId))
)
return core.drawTip('当前无法使用技能');
// 不是怪物且不可以通行
if (noPass && !(cls == 'enemys' || cls == 'enemy48')) {
var toLoc = checkNoPass(
direction,
checkLoc.x,
checkLoc.y,
true
);
if (!toLoc) return;
core.status.hero.hp -= 200 * flags.hard;
core.updateStatusBar();
flags['jump_' + core.status.floorId]++;
if (core.status.hero.hp <= 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose('你跳死了');
}
core.playSound('015-Jump01.ogg');
core.insertAction([
{ type: 'jumpHero', loc: [toLoc.x, toLoc.y], time: 500 }
]);
}
// 是怪物
if (cls == 'enemys' || cls == 'enemy48') {
var firstNoPass = checkNoPass(
direction,
checkLoc.x,
checkLoc.y,
false
);
if (!firstNoPass) return;
core.status.hero.hp -= 200 * flags.hard;
core.updateStatusBar();
flags['jump_' + core.status.floorId]++;
if (core.status.hero.hp <= 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose('你跳死了');
}
core.playSound('015-Jump01.ogg');
core.insertAction([
{
type: 'jump',
from: [checkLoc.x, checkLoc.y],
to: [firstNoPass.x, firstNoPass.y],
time: 500,
keep: true
}
]);
}
// 检查一条线上的不可通过
function checkNoPass(direction, x, y, startNo) {
if (!startNo) startNo = false;
switch (direction) {
case 'up':
y--;
break;
case 'right':
x++;
break;
case 'down':
y++;
break;
case 'left':
x--;
break;
}
if (
x > core.status.thisMap.width - 1 ||
y > core.status.thisMap.height - 1 ||
x < 0 ||
y < 0
)
return core.drawTip('当前无法使用技能');
var id = core.getBlockId(x, y) || '';
if (core.getBgNumber(x, y))
var bgId =
core.getBlockByNumber(core.getBgNumber(x, y)).event
.id || '';
else var bgId = '';
if (
core.noPass(x, y) ||
core.getBlockCls(x, y) == 'items' ||
(id.startsWith('X') && !ignoreInJump.event.includes(id)) ||
(bgId.startsWith('X') && !ignoreInJump.bg.includes(bgId)) ||
core.getBlockCls(x, y) == 'animates'
)
return checkNoPass(direction, x, y, true);
if (!startNo) return checkNoPass(direction, x, y, false);
return { x: x, y: y };
}
};
},
changeFly: async function () {
// 该插件可自定义空间很大，自定义内容请看注释
// ------------------------- 安装说明 ------------------------- //
// 先安装基于canvas的sprite化插件（2.10.0以上自带）
// 再将以下代码复制进插件中，并将第一行的 function () 改为 async function ()
// 提供的api请看以this.xxx = function开头的函数，函数前会有函数说明及参数说明
// ------------------------- 使用说明 ------------------------- //
/*
* 直接复制进插件中，然后添加一个快捷键或道具效果为core.plugin.drawFlyMap()即可使用，不需额外设置
* 楼层id中不要出现下划线
* 该插件具体功能有：
* 1.绘制区域内的地图
* 2.可以拖动地图
* 3.点击地图可直接传送至目标地图，同时降低背景的不透明度，方便观察
* 4.滚轮或双指可以放缩绘制内容
* 5.放缩较大时，绘制地图的缩略图，可能会比较卡，但移动不会卡
* 6.整合漏怪检测，如果想忽略怪物，请在下方改动或用脚本修改core.plugin.ignoreEnemies，类型为数组
* 7.整合区域显示，所有单独或连在一起的地图会被视为一个区域
* 8.键盘操作，上下左右移动
*/
// ------------------------- 插件说明 ------------------------- //
/*
* 该插件注释极其详细，可以帮助那些想要提升代码力，但实力有不足的作者
* 注意！！！该插件难度极大，没有代码底力的不建议研究
* 该插件涉及部分较为高级的算法，如bfs
*/
// 录像验证直接干掉这个插件
if (main.replayChecking || main.mode === 'editor') return;
// 延迟初始化，就不用安装到sprite化插件之后了
await new Promise(res => setTimeout(res, 500));
// ----- 不可自定义 杂七杂八的变量
/** @type {{[x: string]: BFSResult}} */
let mapCache = {}; // 地图缓存
let drawCache = {}; // 绘制信息缓存
let status = 'none'; // 当前的绘制状态
/** @type {{[x: string]: Sprite}} */
let sprites = {}; // 当前所有的sprite
/** @type {{[x: string]: Sprite}} */
let canDrag = {}; // 可以拖拽的sprite
/** @type {{[x: string]: Button}} */
let areaSprite = {}; // 区域列表对应的sprite
let clicking = false; // 是否正在点击，用于拖拽判定
let drawingMap = ''; // 正在绘制的中心楼层
let nowScale = 0; // 当前绘制的放缩比例
let lastTouch = {}; // 上一次的单点点击信息
let lastLength = 0; // 手机端缩放时上一次的两指间距离
let nowDepth = 0; // 当前的遍历深度
let drawedThumbnail = {}; // 已经绘制过的缩略图
let moved = false; // 鼠标按下后是否移动了
let noBorder = false; // 是否是无边框拼接模式
let lastScale = 0; // 上一次缩放，用于优化缩略图绘制
let showEnemy = false; // 是否显示漏怪
let areaPage = 0; // 区域显示的当前页数
let nowArea = 0; // 当前区域index
let selecting = ''; // 选择时当前正在选择的地图
// ---- 不可自定义，常量
/** @type {Area} */
let areas = []; // 区域信息
const perPage = Math.floor((core._PY_ - 60) / 30); // 区域的每页显示数量
// ---- 可自定义，默认的切换地图的图块id
const defaultChange = {
left: 'leftPortal', // 左箭头
up: 'upPortal', // 上箭头
right: 'rightPortal', // 右箭头
down: 'downPortal', // 下箭头
upFloor: 'upFloor', // 上楼
downFloor: 'downFloor' // 下楼
};
// ---- 可自定义，默认数值
const defaultValue = {
font: 'Verdana', // 默认字体
scale: 3, // 默认地图缩放比例
depth: Infinity // 默认的遍历深度
};
// ---- 不可自定义，计算数据
const dirData = {
up: [1, 0],
down: [-1, 0],
left: [0, 1],
right: [0, -1],
upFloor: [0, 0],
downFloor: [0, 0]
};
let ignoreEnemies = (this.ignoreEnemies = []);
let allChangeEntries = Object.entries(defaultChange);
const reset = core.events.resetGame;
core.events.resetGame = function () {
reset.apply(core.events, arguments);
areas = [];
// 获取所有分区，使用异步函数，保证不会卡顿
// 原理是用bfs扫，将所有连在一起的地图合并成一个区域
(async function () {
let all = core.floorIds.slice();
const scanned = { [all[0]]: true };
while (all.length > 0) {
let now = all.shift();
if (core.status.maps[now].deleted) continue;
if (!now) return;
await new Promise(res => {
const result = bfsSearch(now, Infinity, true);
mapCache[`${now}_Infinity_false`] = result;
areas.push({
name: core.floors[now].title,
maps: result.order
});
for (const map of result.order) {
scanned[map] = true;
all = all.filter(v => !result.order.includes(v));
}
res('success');
});
}
})();
};
/** 工具按钮 */
class Button extends Sprite {
constructor(
name,
x,
y,
w,
h,
text,
fontSize = '20px',
transition = true
) {
const btn = super(x, y, w, h, 1050, 'game', name);
this.css(transition);
setTimeout(() => btn.setCss(`opacity: 1;`), 50);
const ctx = btn.context;
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
core.fillText(
ctx,
text,
w / 2,
h / 2,
'#fff',
`${fontSize} normal`,
w - 10
);
sprites[name] = btn;
}
css(transition) {
this.setCss(
'transition: opacity 0.6s linear, transform 0.2s linear;' +
'background-color: #aaa;' +
'box-shadow: 0px 0px 0px black;' +
(transition ? 'opacity: 0;' : '') +
'filter: drop-shadow(1px 1px 2px black);' +
'box-shadow: 0px 0px 4px black;' +
'cursor: pointer;'
);
}
}
/** 背景 */
class Back extends Sprite {
constructor(name, x, y, w, h, z, color) {
const sprite = super(x, y, w, h, z, 'game', name);
sprites[name] = sprite;
this.setCss(`transition: all 0.6s linear;`);
setTimeout(() => {
this.setCss(`background-color: ${color};`);
}, 50);
}
}
/**
* 获取绘制信息
* @param {string?} center 中心地图id
* @param {number?} depth 搜索深度
* @param {boolean?} noCache 是否不使用缓存
* @returns {MapDrawInfo}
*/
this.getMapDrawInfo = function (
center = core.status.floorId,
depth = defaultValue.depth,
noCache = false
) {
nowDepth = depth;
drawingMap = center;
const id = `${center}_${depth}_${noBorder}`;
// 检查缓存
if (drawCache[id] && !noCache) return drawCache[id];
const map = bfsSearch(center, depth, noCache);
mapCache[id] = map;
const res = getDrawInfo(map.res, center, map.order);
res.upOrDown = map.upOrDown;
drawCache[id] = res;
return res;
};
/**
* 绘制大地图，可拖动、滚轮缩放、点击对应位置可以楼传等
* @param {string} floorId 中心地图的id
* @param {number} depth 遍历深度
* @param {boolean} noCache 是否不使用缓存
* @param {number} scale 绘制的缩放比例
*/
this.drawFlyMap = function (
floorId = core.status.floorId,
depth = defaultValue.depth,
noCache = false,
scale = defaultValue.scale
) {
if (core.isReplaying()) return;
// 把区域页码归零
nowArea = areas.findIndex(v =>
v.maps.includes(core.status.floorId)
);
areaPage = 0;
nowScale = scale;
selecting = floorId;
const info = this.getMapDrawInfo(floorId, depth, noCache);
if (status !== 'scale' && status !== 'border') {
drawBack();
drawTools();
}
drawMap(info, scale);
status = 'flyMap';
core.lockControl();
core.canvas.data.canvas.style.zIndex = '990';
};
/**
* 获得某个区域的剩余怪物
* @param {string} floorId 区域包含的地图或要扫描的地图
* @param {boolean} area 是否扫描整个区域
* @returns {RemainEnemy} 怪物总数、所在地图、位置
* 返回值格式：{
* rough: 每种怪物的数量及所有怪物的总数，为字符串，每个怪物独占一行
* detail: 每个怪物的所在位置，每个怪物独占一行，以每20个整合成字符串，为字符串数组形式
* data: 怪物数量的原始信息，格式为{ 楼层id: { 'x,y': 怪物id } }
* }
*/
this.getRemainEnemy = function (
floorId = core.status.floorId,
area = false
) {
const res = bfsSearch(floorId, Infinity, false);
// 整合怪物总数
/** @type {{[x: string]: number}} */
const category = {};
const toShow = area ? res.order : [floorId];
const strArr = [];
const add = (...num) => num.reduce((pre, cur) => pre + cur, 0);
const name = id => core.material.enemys[id].name;
const title = id => core.status.maps[id].title;
for (const id of toShow) {
const enemies = res.enemies[id];
Object.values(enemies).forEach(v => {
// 编辑器不支持 ??=，悲
category[v] = category[v] ?? 0;
category[v]++;
});
// 每个怪物的信息
strArr.push(
...Object.entries(enemies).map(
v =>
`${name(v[1])} 楼层:${title(
id
)},楼层id:${id},坐标:${v[0]}`
)
);
}
// 输出字符串
const all = `当前${area ? '区域' : '地图'}中剩余怪物数量：${add(
...Object.values(category)
)}`;
const classified = Object.entries(category).map(
v => `${name(v[0])} × ${v[1]}`
).join`\n`;
const detail = [];
while (strArr.length > 0) {
detail.push(strArr.splice(0, 20).join`\n`);
}
return {
rough: `${all}\n${classified}`,
detail,
data: res.enemies
};
};
/**
* 广度优先搜索搜索地图路径
* @param {string} center 中心地图的id
* @param {number} depth 搜索深度
* @param {boolean} noCache 是否不使用缓存
* @returns {BFSResult} 格式：floorId_x_y_dir: floorId_x_y
*/
function bfsSearch(center, depth, noCache) {
// 检查缓存
const id = `${center}_${depth}_${noBorder}`;
if (mapCache[id] && !noCache) return mapCache[id];
const used = { [center]: true }; // 搜索过的楼层
let queue = [];
let stack = [center]; // 当前栈
let nowDepth = -1;
const mapOrder = [center]; // 遍历顺序，顺便还能记录遍历了哪些楼层
const res = {}; // 输出结果，格式：floorId_x_y_dir: floorId_x_y
const enemies = {};
const upOrDown = {};
// 开始循环搜索
while (nowDepth < depth && stack.length > 0) {
const now = stack.shift(); // 当前id
if (core.status.maps[now].deleted) continue;
const blocks = core.getMapBlocksObj(now); // 获取当前地图的每点的事件
enemies[now] = {};
// 遍历，获取可以传送的点，只检测绿点事件，因此可用红点事件进行传送来实现分区功能
for (const i in blocks) {
const block = blocks[i];
// 整合漏怪检测，所以要检测怪物
if (block.event.trigger === 'battle') {
const id = block.event.id;
if (ignoreEnemies.includes(id)) continue;
else enemies[now][i] = block.event.id;
continue;
}
// 检测触发器是否为切换楼层，不是则直接跳过
if (block.event.trigger !== 'changeFloor') continue;
const dirEntries = allChangeEntries.find(
v => v[1] === block.event.id
);
// 如果不是那六种传送门，直接忽略
if (!dirEntries) continue;
const data = block.event.data;
const dir = dirEntries[0];
const route = `${now}_${i.replace(',', '_')}_${dir}`;
const target = `${data.floorId}_${data.loc.join('_')}`;
if (!used[data.floorId]) {
if (dir === 'upFloor' || dir === 'downFloor') {
upOrDown[now] = upOrDown[id] ?? [];
upOrDown[now].push(dir);
}
queue.push(data.floorId); // 没有搜索过，则加入栈中
mapOrder.push(data.floorId);
used[data.floorId] = true;
}
res[route] = target;
}
if (stack.length === 0) {
stack = queue;
queue = [];
nowDepth++;
}
if (stack.length === 0 && queue.length === 0) break;
}
return { res, order: mapOrder, enemies, upOrDown };
}
/**
* 提供地图的绘制信息
* @param {{[x: string]: string}} map 要绘制的地图，格式：floorId_x_y_dir: floorId_x_y
* @param {string} center 中心地图的id
* @param {string[]} order 遍历顺序
* @returns {MapDrawInfo} 地图的绘制信息
*/
function getDrawInfo(map, center, order) {
// 先根据地图id分类，从而确定每个地图连接哪些地图，同时方便处理
const links = {};
for (const i in map) {
const splitted = i.split('_');
const id = splitted[0];
if (!links[id]) links[id] = {};
links[id][i] = map[i];
}
// 分类完毕，然后根据连接点先计算出各个地图的坐标，然后再进行判断
const centerFloor = core.status.maps[center];
const visitedCenter = core.hasVisitedFloor(center);
const locs = {
// 格式：[中心x, 中心y, 宽, 高, 是否到达过]
[center]: [
0,
0,
centerFloor.width,
centerFloor.height,
visitedCenter
]
};
const lines = {}; // 地图间的连线
// 可以上楼下楼的地图
const upOrDown = {};
for (const id of order) {
const now = links[id];
// 遍历每一个地图的连接情况
for (const from in now) {
const to = now[from];
// 先根据from to计算物理位置
const fromData = from.split('_'),
toData = to.split('_');
const dir = fromData[3];
if (dir === 'upFloor' || dir === 'downFloor') continue;
if (!defaultChange[dir]) continue;
const v = dirData[dir][1], // 竖直数值
h = dirData[dir][0], // 水平数值
ha = Math.abs(h),
va = Math.abs(v);
const fx = parseInt(fromData[1]), // fromX
fy = parseInt(fromData[2]), // fromY
tx = parseInt(toData[1]), // toX
ty = parseInt(toData[2]), // toY
ff = id, // fromFloorId
tf = toData[0]; // toFloorId
const fromFloor = core.status.maps[ff],
toFloor = core.status.maps[tf];
const fhw = Math.floor(fromFloor.width / 2), // fromFloorHalfWidth
fhh = Math.floor(fromFloor.height / 2),
thw = Math.floor(toFloor.width / 2),
thh = Math.floor(toFloor.height / 2);
const fLoc = locs[id] ?? [0, 0];
if (!locs[ff]) continue;
let x, y;
const dis = noBorder ? 1 : 5;
if (locs && locs[tf]) {
x = locs[tf][0];
y = locs[tf][1];
} else {
// 计算坐标，公式可以通过画图推断出
x =
fLoc[0] -
ha * (fhw - fx + tx - thw) -
v * (fhw + thw + dis);
y =
fLoc[1] -
va * (fhh - fy + ty - thh) -
h * (fhh + thh + dis);
}
locs[tf] = locs[tf] ?? [
x,
y,
toFloor.width,
toFloor.height,
core.hasVisitedFloor(tf)
];
// 添加连线
lines[`${from}_${to}`] = [
[
fx - fhw + locs[ff][0],
fy - fhh + locs[ff][1],
x + tx - thw,
y + ty - thh
]
];
}
}
// 获取地图绘制需要的长宽
let width = 0,
height = 0;
let left, right, up, down;
for (const id in locs) {
const [x, y, w, h] = locs[id];
if (left === void 0) {
left = right = x;
up = down = y;
}
left = Math.min(x - w / 2 - 1, left);
right = Math.max(x + w / 2 + 1, right);
up = Math.min(y - h / 2 - 1, up);
down = Math.max(y + h / 2 + 1, down);
}
width = right - left;
height = down - up;
// 所有地图和连线向右下移动，避免绘制出现问题
for (const id in locs) {
const loc = locs[id];
loc[0] -= left; // 这时候left和up是负值，所以要减
loc[1] -= up;
}
for (const route in lines) {
const line = lines[route];
for (const node of line) {
node[0] -= left;
node[1] -= up;
node[2] -= left;
node[3] -= up;
}
}
return { locs, lines, width, height, layer: upOrDown };
}
/** 绘制背景 */
function drawBack() {
if (status !== 'none') return;
new Back(
'__map_back__',
0,
0,
core._PX_,
core._PY_,
175,
'rgba(0, 0, 0, 0.9)'
);
const listen = new Sprite(
0,
0,
core._PX_,
core._PY_,
1000,
'game',
'__map_listen__'
);
addDrag(listen);
const exit = new Button(
'__map_exit__',
core._PX_ - 64,
core._PY_ - 26,
60,
22,
'退出'
);
exit.addEventListener('click', close);
sprites.listen = listen;
}
/** 绘制工具栏 */
function drawTools() {
new Back(
'__map_toolback__',
0,
core._PY_ - 30,
core._PX_,
30,
600,
'rgba(200, 200, 200, 0.9)'
);
// 无边框
const border = new Button(
'__map_border__',
core._PX_ - 150,
core._PY_ - 26,
60,
22,
'边框'
);
border.addEventListener('click', changeBorder);
// 怪物数量
const enemy = new Button(
'__map_enemy__',
core._PX_ - 240,
core._PY_ - 26,
60,
22,
'怪物'
);
enemy.addEventListener('click', triggerEnemy);
// 区域显示
const area = new Back(
'__map_areasback__',
core._PX_ - 80,
0,
80,
core._PY_ - 30,
550,
'rgba(200, 200, 200, 0.9)'
);
drawAreaList();
core.drawLine(
area.context,
0,
core._PY_ - 30,
80,
core._PY_ - 30,
'#222',
2
);
}
/** 绘制区域列表 */
function drawAreaList(transition = true) {
const start = perPage * areaPage;
Object.values(areaSprite).forEach(v => v.destroy());
areaSprite = {};
for (let i = start; i < start + perPage && areas[i]; i++) {
const n = i % perPage;
const { name, maps } = areas[i];
const btn = new Button(
`_area_${maps[0]}`,
core._PX_ - 75,
4 + 30 * n,
70,
22,
name,
'16px',
transition
);
areaSprite[maps[0]] = btn;
if (i === nowArea) btn.setCss(`border: 2px solid gold;`);
btn.addEventListener('click', e => {
if (i === nowArea) return;
changeArea(i);
});
}
// 上一页下一页
if (areaPage > 0) {
const last = new Button(
'_area_last_',
core._PX_ - 75,
core._PY_ - 50,
30,
16,
'上一页',
'14px',
transition
);
areaSprite._area_last_ = last;
last.addEventListener('click', e => {
areaPage--;
drawAreaList(false);
});
}
if (areaPage < Math.floor(areas.length / perPage)) {
const next = new Button(
'_area_next_',
core._PX_ - 35,
core._PY_ - 50,
30,
16,
'下一页',
'14px',
transition
);
areaSprite._area_next_ = next;
next.addEventListener('click', e => {
areaPage++;
drawAreaList(false);
});
}
}
/**
* 绘制大地图
* @param {MapDrawInfo} info 地图绘制信息
* @param {number} scale 地图的绘制比例
*/
function drawMap(info, scale = defaultValue.scale) {
if (status === 'flyMap') return;
const PX = core._PX_,
PY = core._PY_;
const w = info.width * scale,
h = info.height * scale;
const id = `__flyMap__`;
const cx = PX / 2 - w / 2,
cy = PY / 2 - h / 2;
const map = new Sprite(cx, cy, w, h, 500, 'game', id);
sprites[id] = map;
canDrag[id] = map;
map.canvas.className = 'fly-map';
const ctx = map.context;
core.clearMap(ctx);
if (!noBorder) {
const drawed = {}; // 绘制过的线
// 先绘制连线
const lines = info.lines;
for (const route in lines) {
const line = lines[route];
for (const node of line) {
const from = `${node[0]},${node[1]}`,
to = `${node[2]},${node[3]}`;
if (drawed[`${from}-${to}`] || drawed[`${to}-${from}`])
continue;
drawed[`${from}-${to}`] = true;
let lineWidth = scale / 2;
core.drawLine(
ctx,
node[0] * scale,
node[1] * scale,
node[2] * scale,
node[3] * scale,
'#fff',
lineWidth
);
}
}
// 再绘制楼层
const locs = info.locs;
for (const id in locs) {
const loc = locs[id];
let color = '#000';
if (!loc[4]) color = '#f0f';
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
let dx = 0,
dy = 0; // 避免绘图误差
if (loc[2] % 2 === 0) dx = 0.5 * scale;
if (loc[3] % 2 === 0) dy = 0.5 * scale;
const fx = x - w / 2 - dx,
fy = y - h / 2 - dy;
core.fillRect(ctx, fx, fy, w, h, color);
if (id === selecting)
core.strokeRect(ctx, fx, fy, w, h, 'gold', scale / 2);
else core.strokeRect(ctx, fx, fy, w, h, '#fff', scale / 2);
const layer = info.upOrDown[id];
const min = Math.min(w, h);
if (layer?.includes('upFloor'))
core.drawIcon(
ctx,
defaultChange.upFloor,
fx,
fy,
min / 3,
min / 3
);
if (layer?.includes('downFloor'))
core.drawIcon(
ctx,
defaultChange.downFloor,
fx + w - min / 3,
fy + h - min / 3,
min / 3,
min / 3
);
// 显示漏怪数量
if (showEnemy) {
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
const c = `${drawingMap}_${nowDepth}_${noBorder}`;
const n = Object.keys(mapCache[c].enemies[id]).length;
color = '#3f3';
if (n > 0) color = '#fff';
if (n > 10) color = '#fc3';
if (n > 20) color = '#f22';
ctx.shadowBlur = 0.6 * nowScale;
ctx.shadowColor = '#000';
core.fillText(
ctx,
`怪物数量：${n}`,
x,
y,
color,
`${2 * nowScale}px normal`
);
ctx.shadowBlur = 0;
}
}
}
checkThumbnail();
}
/**
* 重新绘制缩略图
* @param {Sprite} sprite
* @param {string} floor
*/
function drawThumbnail(sprite, floor, x, y, w, h) {
const ctx = sprite.context;
const scale = nowScale;
core.drawThumbnail(floor, void 0, {
ctx: ctx,
x: x - w / 2,
y: y - h / 2,
damage: true,
all: true,
size: Math.max(w, h) / Math.max(core._PX_, core._PY_),
fromMap: true
});
const color = floor === core.status.floorId ? 'gold' : '#fff';
if (!noBorder)
core.strokeRect(
ctx,
x - w / 2,
y - h / 2,
w,
h,
color,
scale / 2
);
}
/** 检查是否需要绘制缩略图 */
function checkThumbnail() {
const id = `${drawingMap}_${nowDepth}_${noBorder}`;
const locs = drawCache[id].locs;
const map = canDrag[`__flyMap__`];
for (const id in locs) {
const loc = locs[id];
const scale = nowScale;
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
let dx = 0,
dy = 0; // 避免绘图误差
if (loc[2] % 2 === 0) dx = 0.5 * scale;
if (loc[3] % 2 === 0) dy = 0.5 * scale;
if (
!drawedThumbnail[id] &&
x + map.x > 0 &&
x + map.x < core._PX_ &&
y + map.y > 0 &&
y + map.y < core._PY_
) {
if (!noBorder && core.hasVisitedFloor(id) && scale > 5) {
drawThumbnail(map, id, x - dx, y - dy, w, h);
drawedThumbnail[id] = true;
}
if (noBorder) {
drawThumbnail(map, id, x - dx, y - dy, w, h);
drawedThumbnail[id] = true;
if (!core.hasVisitedFloor(id))
core.fillRect(
map.context,
x - dx - w / 2,
y - dy - h / 2,
w,
h,
'rgba(255,0,255,0.2)'
);
}
}
}
// 如果是无边框模式，那就只绘制当前地图的边框
if (noBorder) {
const loc = locs[selecting];
const scale = nowScale;
if (loc) {
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
core.strokeRect(
map.context,
x - w / 2,
y - h / 2,
w,
h,
'gold',
scale / 2
);
}
}
}
/** 检查点击点是否在以x,y为中心的某一矩形中 */
function inRect(x, y, w, h, px, py) {
x -= w / 2;
y -= h / 2;
return px > x && px < x + w && py > y && py < y + h;
}
/** 测试画布是否超过上限，摘自https://github.com/jhildenbiddle/canvas-size */
function canvasTest(size) {
const width = Math.max(Math.ceil(size[0]), 1);
const height = Math.max(Math.ceil(size[1]), 1);
if (width === 0 || height === 0) return true;
const fill = [width - 1, height - 1, 1, 1];
let cropCvs, testCvs;
cropCvs = document.createElement('canvas');
cropCvs.width = 1;
cropCvs.height = 1;
testCvs = document.createElement('canvas');
testCvs.width = width;
testCvs.height = height;
const cropCtx = cropCvs.getContext('2d');
const testCtx = testCvs.getContext('2d');
if (testCtx) {
testCtx.fillRect.apply(testCtx, fill);
cropCtx.drawImage(
testCvs,
width - 1,
height - 1,
1,
1,
0,
0,
1,
1
);
}
const isTestPass =
cropCtx && cropCtx.getImageData(0, 0, 1, 1).data[3] !== 0;
return isTestPass;
}
/** 检查浏览器限制 */
function checkMaximum(before, scale) {
for (const id in canDrag) {
const sprite = canDrag[id];
const rate = scale / before;
const w = sprite.width * rate * core.domStyle.scale,
h = sprite.height * rate * core.domStyle.scale;
const valid = canvasTest([w, h]);
if (!valid) {
core.drawTip('画布大小将超过浏览器限制！请勿继续放大！');
return true;
}
}
return false;
}
/** 关闭事件 */
function close() {
document.body.removeEventListener('keyup', keyboard);
Object.values(sprites).forEach(v => {
v.setCss('transition: opacity 0.6s linear;');
});
setTimeout(() => {
Object.values(sprites).forEach(v => {
v.setCss('opacity: 0;');
});
}, 50);
setTimeout(() => {
core.unlockControl();
Object.values(sprites).forEach(v => {
v.destroy();
});
drawedThumbnail = {};
sprites = {};
canDrag = {};
status = 'none';
core.canvas.data.canvas.style.zIndex = '170';
}, 650);
}
/**
* 点击地图事件，尝试楼层传送
* @param {MouseEvent} e
*/
function clickMap(e) {
if (moved) return (moved = false);
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
let px = x / core.domStyle.scale,
py = y / core.domStyle.scale;
const scale = nowScale;
const id = `${drawingMap}_${nowDepth}_${noBorder}`;
const locs = drawCache[id].locs;
const sprite = canDrag.__flyMap__;
px -= sprite.x;
py -= sprite.y;
for (const id in locs) {
const loc = locs[id];
const [x, y, w, h] = loc.map(
v => typeof v === 'number' && v * scale
);
if (inRect(x, y, w, h, px, py)) {
return flyTo(id);
}
}
}
/** 飞向某个楼层 */
function flyTo(id) {
if (!core.hasItem('fly')) return core.drawTip('你没有楼层传送器');
sprites.__map_back__.setCss('opacity: 0.2;');
return core.flyTo(id, () =>
setTimeout(() => {
if (sprites.__map_back__) core.lockControl();
}, 100)
);
}
/**
* 拖拽事件
* @param {MouseEvent} e
*/
function drag(e) {
if (!clicking) return;
const scale = core.domStyle.scale;
moveEle(e.movementX / scale, e.movementY / scale);
}
/**
* 手机端点击拖动事件
* @param {TouchEvent} e
* @this {HTMLCanvasElement}
*/
function touchDrag(e) {
moved = true;
const scale = core.domStyle.scale;
if (e.touches.length === 1) {
// 拖拽
const info = e.touches[0];
if (!lastTouch[this.id]) {
lastTouch[this.id] = [info.clientX, info.clientY];
return;
}
const { clientX: x, clientY: y } = info;
const dx = x - lastTouch[this.id][0],
dy = y - lastTouch[this.id][1];
moveEle(dx / scale, dy / scale);
lastTouch[this.id] = [info.clientX, info.clientY];
} else if (e.touches.length >= 2) {
// 双指放缩
const [first, second] = e.touches;
const dx = first.clientX - second.clientX,
dy = first.clientY - second.clientY;
if (lastLength === 0) {
lastLength = Math.sqrt(dx * dx + dy * dy);
return;
}
let cx = (first.clientX + second.clientX) / 2,
cy = (first.clientY + second.clientY) / 2;
const { x, y } = core.actions._getClickLoc(cx, cy);
cx = x / scale;
cy = y / scale;
const length = Math.sqrt(dx * dx + dy * dy);
const delta = length / lastLength;
const info = {};
for (const id in canDrag) {
const sprite = canDrag[id];
const sx = sprite.x + sprite.width / 2,
sy = sprite.y + sprite.height / 2;
const dx = sx - mx,
dy = sy - my;
info[id] = [cx + dx * delta, cy + dy * delta];
}
scaleMap(delta * nowScale, info);
}
}
/**
* 滚轮缩放
* @param {WheelEvent} e
*/
function wheel(e) {
const delta = 1 - Math.sign(e.deltaY) / 10;
const { x, y } = core.actions._getClickLoc(e.clientX, e.clientY);
const scale = core.domStyle.scale;
const mx = x / scale,
my = y / scale;
const info = {};
for (const id in canDrag) {
const sprite = canDrag[id];
const cx = sprite.x + sprite.width / 2,
cy = sprite.y + sprite.height / 2;
const dx = cx - mx,
dy = cy - my;
info[id] = [mx + dx * delta, my + dy * delta];
}
scaleMap(delta * nowScale, info);
}
/** 切换边框 */
function changeBorder() {
noBorder = !noBorder;
redraw('border');
}
/** 切换是否显示漏怪数量 */
function triggerEnemy() {
showEnemy = !showEnemy;
redraw('enemy');
}
/** 改变区域 */
function changeArea(index) {
nowArea = index;
drawAreaList(false);
drawedThumbnail = {};
status = 'area';
nowScale = defaultValue.scale;
drawMap(core.plugin.getMapDrawInfo(areas[index].maps[0]));
}
/** 重绘 */
function redraw(id, px, py, move = true) {
const { x, y } = canDrag.__flyMap__;
status = id;
drawedThumbnail = {};
drawMap(
core.plugin.getMapDrawInfo(drawingMap, nowDepth, true),
nowScale
);
if (move) canDrag.__flyMap__.move(px ?? x, py ?? y);
checkThumbnail();
}
/**
* 拖拽时移动需要元素
* @param {string} dx
* @param {string} dy
*/
function moveEle(dx, dy) {
moved = true;
for (const id in canDrag) {
const sprite = canDrag[id];
const ctx = sprite.context;
sprite.x += dx;
sprite.y += dy;
core.relocateCanvas(ctx, dx, dy, true);
}
checkThumbnail();
}
/**
* 缩放绘制地图
* @param {number} target 目标缩放比例
* @param {{[x: string]: [number, number]}} info 缩放后的sprite位置数据
*/
function scaleMap(target, info) {
// 检查浏览器限制
if (checkMaximum(nowScale, target)) return;
clearTimeout(lastScale);
const [x, y] = info.__flyMap__;
// 先直接修改style，延迟200ms再绘制，进行性能优化
const sprite = canDrag.__flyMap__;
const rate = target / nowScale;
nowScale = target;
sprite.resize(sprite.width * rate, sprite.height * rate, true);
sprite.move(x - sprite.width / 2, y - sprite.height / 2);
lastScale = setTimeout(() => {
redraw('scale', x - sprite.width / 2, y - sprite.height / 2);
}, 200);
}
/** 键盘操作
* @param {KeyboardEvent} e
*/
function keyboard(e) {
if (
e.key === 'Enter' ||
e.key === 'C' ||
e.key === 'c' ||
e.key === ''
) {
return flyTo(selecting);
} else if (e.key === 'Escape' || e.key === 'x' || e.key === 'X') {
return close();
} else if (e.key.startsWith('Arrow')) {
const dir = e.key.slice(5).toLowerCase();
// 获取目标楼层
const res =
mapCache[`${drawingMap}_${nowDepth}_${noBorder}`].res;
const key = Object.keys(res).find(v => {
const [floorId, x, y, d] = v.split('_');
return floorId === selecting && d === dir;
});
if (!key) return;
const target = res[key].split('_')[0];
selecting = target;
redraw('key');
}
}
/**
* 给需要的元素添加拖拽等事件
* @param {HTMLCanvasElement} ele
*/
function addDrag(ele) {
ele.addEventListener('wheel', wheel);
ele.addEventListener('mousemove', drag);
ele.addEventListener('touchmove', touchDrag);
ele.addEventListener('click', clickMap);
ele.addEventListener('mousedown', () => {
clicking = true;
});
ele.addEventListener('mouseup', () => {
clicking = false;
});
ele.addEventListener('touchend', () => {
lastTouch = {};
lastLength = 0;
});
document.body.addEventListener('keyup', keyboard);
}
maps.prototype._drawThumbnail_drawToTarget = function (
floorId,
options
) {
const ctx = core.getContextByName(options.ctx);
if (ctx == null) return;
const x = options.x || 0,
y = options.y || 0,
size = options.size || 1;
// size的含义改为(0,1]范围的系数以适配长方形，默认为1，楼传为3/4，SL界面为0.3
let w = Math.ceil(size * core._PX_),
h = Math.ceil(size * core._PY_);
// 特判是否为编辑器，编辑器中长宽均采用core.js的遗留正方形像素边长，以保证下面的绘制正常
if (main.mode == 'editor') w = h = size * core.__PIXELS__;
const width = core.floors[floorId].width,
height = core.floors[floorId].height;
let centerX = options.centerX,
centerY = options.centerY;
if (centerX == null) centerX = Math.floor(width / 2);
if (centerY == null) centerY = Math.floor(height / 2);
const tempCanvas = core.bigmap.tempCanvas;
if (options.all) {
const tempWidth = tempCanvas.canvas.width,
tempHeight = tempCanvas.canvas.height;
// 绘制全景图
if (tempWidth <= tempHeight) {
const realHeight = h,
realWidth = (realHeight * tempWidth) / tempHeight;
const side = (w - realWidth) / 2;
if (options.fromMap) {
return core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y,
realWidth,
realHeight
);
}
core.fillRect(ctx, x, y, side, realHeight, '#000000');
core.fillRect(ctx, x + w - side, y, side, realHeight);
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x + side,
y,
realWidth,
realHeight
);
} else {
const realWidth = w,
realHeight = (realWidth * tempHeight) / tempWidth;
const side = (h - realHeight) / 2;
if (options.fromMap) {
return core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y,
realWidth,
realHeight
);
}
core.fillRect(ctx, x, y, realWidth, side, '#000000');
core.fillRect(ctx, x, y + h - side, realWidth, side);
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
tempWidth,
tempHeight,
x,
y + side,
realWidth,
realHeight
);
}
} else {
// 只绘制可见窗口
let pw = core._PX_,
ph = core._PY_,
hw = core._HALF_WIDTH_,
hh = core._HALF_HEIGHT_,
W = core._WIDTH_,
H = core._HEIGHT_;
const ratio = core.domStyle.isVertical
? core.domStyle.ratio
: core.domStyle.scale;
if (main.mode == 'editor') {
pw = ph = core.__PIXELS__;
hw = hh = core.__HALF_SIZE__;
W = H = core.__SIZE__;
}
if (options.v2) {
core.drawImage(
ctx,
tempCanvas.canvas,
0,
0,
pw * ratio,
ph * ratio,
x,
y,
w,
h
);
} else {
const offsetX = core.clamp(centerX - hw, 0, width - W),
offsetY = core.clamp(centerY - hh, 0, height - H);
if (options.noHD) {
core.drawImage(
ctx,
tempCanvas.canvas,
offsetX * 32,
offsetY * 32,
pw,
ph,
x,
y,
w,
h
);
return;
}
core.drawImage(
ctx,
tempCanvas.canvas,
offsetX * 32 * ratio,
offsetY * 32 * ratio,
pw * ratio,
ph * ratio,
x,
y,
w,
h
);
}
}
};
},
loopMap: function () {
// 循环式地图相关
// 防止重开游戏出问题
////// 加载某个楼层（从剧本或存档中） //////
maps.prototype.loadFloor = function (floorId, map, fromReset) {
var floor = fromReset ? main.floors[floorId] : core.floors[floorId];
if (!map) map = floor.map;
if (map instanceof Array) {
map = { map: map };
}
if (!map.map) map.map = core.clone(floor.map);
var content = {};
var notCopy = this._loadFloor_doNotCopy();
for (var name in floor) {
if (notCopy.indexOf(name) == -1 && floor[name] != null)
content[name] = core.clone(floor[name]);
}
for (var name in map) {
if (notCopy.indexOf(name) == -1 && map[name] != null)
content[name] = core.clone(map[name]);
}
content.map = map.map;
if (main.mode == 'editor') {
this.extractBlocks(content);
}
return content;
};
////// 自动存档 //////
control.prototype.autosave = function (removeLast) {
if (
core.hasFlag('__forbidSave__') ||
core.status.floorId == 'tower6'
)
return;
var x = null;
if (removeLast) {
x = core.status.route.pop();
core.status.route.push('turn:' + core.getHeroLoc('direction'));
}
if (core.status.event.id == 'action')
// 事件中的自动存档
core.setFlag('__events__', core.clone(core.status.event.data));
if (core.saves.autosave.data == null) {
core.saves.autosave.data = [];
}
core.saves.autosave.data.splice(
core.saves.autosave.now,
0,
core.saveData()
);
core.saves.autosave.now += 1;
if (core.saves.autosave.data.length > core.saves.autosave.max) {
if (core.saves.autosave.now < core.saves.autosave.max / 2)
core.saves.autosave.data.pop();
else {
core.saves.autosave.data.shift();
core.saves.autosave.now = core.saves.autosave.now - 1;
}
}
core.saves.autosave.updated = true;
core.saves.ids[0] = true;
core.removeFlag('__events__');
if (removeLast) {
core.status.route.pop();
if (x) core.status.route.push(x);
}
};
////// 重置地图 //////
maps.prototype.resetMap = function (floorId) {
floorId = floorId || core.status.floorId;
if (!floorId) return;
if (typeof floorId == 'string') floorId = [floorId];
var needRefresh = false;
floorId.forEach(t => {
core.status.maps[t] = core.maps.loadFloor(t, null, true);
// 重置本层的全部独立事件
Object.keys(core.status.hero.flags).forEach(one => {
if (one.startsWith(floorId + '@'))
delete core.status.hero.flags[one];
});
// 重置本层的图块删除信息
delete (flags.__disabled__ || {})[t];
delete (core.status.mapBlockObjs || {})[t];
if (t == core.status.floorId) needRefresh = true;
['bg', 'bg2', 'fg', 'fg2'].forEach(layer => {
core.floors[floorId] = main.floors[floorId];
});
});
if (needRefresh) this.drawMap();
core.drawTip('地图重置成功');
};
// 勇士不动图层动
control.prototype._moveAction_moving = function (callback) {
core.setHeroMoveInterval(() => {
if (core.status.floorId != 'tower6') {
core.setHeroLoc('x', core.nextX(), true);
} else {
if (
core.status.hero.loc.direction != 'down' &&
core.status.hero.loc.direction != 'up'
) {
core.setHeroLoc('x', 12, true);
var block = core.getMapBlocksObj(core.status.floorId)[
core.nextX() + ',' + core.nextY
];
if (block) var trigger = block.event.trigger;
else var trigger = '';
if (trigger != 'battle') {
core.changeEventsBgFg(
core.status.hero.loc.direction,
'tower6',
['tower1', 'tower2', 'tower4', 'tower5']
);
}
core.drawMap();
}
}
core.setHeroLoc('y', core.nextY(), true);
var direction = core.getHeroLoc('direction');
core.control._moveAction_popAutomaticRoute();
core.status.route.push(direction);
core.moveOneStep();
core.checkRouteFolding();
if (callback) callback();
});
};
////// 设置行走的效果动画 //////
control.prototype.setHeroMoveInterval = function (callback) {
if (core.status.heroMoving > 0) return;
if (core.status.replay.speed == 24) {
if (callback) callback();
return;
}
core.status.heroMoving = 1;
var toAdd = 1;
if (core.status.replay.speed > 3) toAdd = 2;
if (core.status.replay.speed > 6) toAdd = 4;
if (core.status.replay.speed > 12) toAdd = 8;
core.interval.heroMoveInterval = window.setInterval(() => {
core.status.heroMoving += toAdd;
if (core.status.floorId == 'tower6')
core.backgroundImage('tower6.jpeg');
if (core.status.heroMoving >= 8) {
clearInterval(core.interval.heroMoveInterval);
core.status.heroMoving = 0;
if (callback) callback();
}
}, ((core.values.moveSpeed / 8) * toAdd) / core.status.replay.speed);
};
// 事件层前景层背景层平移
this.changeEventsBgFg = function (direction, floorId, fromIds) {
if (direction == 'up' || direction == 'down') return;
var floor = core.floors[floorId];
// 原始层楼层转换平移
fromIds.forEach(id => {
var toChanges = {};
for (var one in core.floors[id].changeFloor) {
var data = core.floors[id].changeFloor[one];
var x = data.loc[0],
y = data.loc[1];
var blocks = core.getMapBlocksObj(id);
var toFloor = data.floorId;
if (blocks[one] && !blocks[one].event.id.startsWith('A')) {
toChanges[one] = { floorId: toFloor, loc: [x, y] };
continue;
} else {
if (direction == 'left')
x = x >= floor.width - 1 ? 0 : x + 1;
else x = x <= 0 ? floor.width - 1 : x - 1;
toChanges[one] = { floorId: toFloor, loc: [x, y] };
}
}
// 转换
delete core.floors[id].changeFloor;
core.floors[id].changeFloor = toChanges;
delete core.status.maps[id].blocks;
core.extractBlocks(id);
core.getMapBlocksObj(id, true);
});
var list = ['events', 'changeFloor'];
list.forEach(name => {
var toEvents = {};
// 获得事件并删除原事件
for (var one in floor[name]) {
var loc = one.split(',');
var x = parseInt(loc[0]),
y = parseInt(loc[1]);
if (direction == 'left') {
var toX = x == floor.width - 1 ? 0 : x + 1;
toEvents[toX + ',' + y] = floor[name][one];
} else {
var toX = x == 0 ? floor.width - 1 : x - 1;
toEvents[toX + ',' + y] = floor[name][one];
}
delete core.floors[floorId][name][one];
}
// 转换
core.floors[floorId][name] = toEvents;
});
// 前景事件背景层图块平移
list = ['bgmap', 'bg2map', 'map', 'fgmap', 'fg2map'];
list.forEach(one => {
if (one == 'map') {
var toBlocks = core.clone(core.status.maps[floorId].map);
} else {
var toBlocks = core.clone(floor[one]);
}
if (toBlocks.length == 0) return;
for (var y = 0; y < toBlocks.length; y++) {
for (var x = 0; x < toBlocks[y].length; x++) {
if (direction == 'left') {
if (one != 'map')
floor[one][y][x] =
toBlocks[y][
x == 0 ? floor.width - 1 : x - 1
];
else
core.status.maps[floorId].map[y][x] =
toBlocks[y][
x == 0 ? floor.width - 1 : x - 1
];
} else {
if (one != 'map')
floor[one][y][x] =
toBlocks[y][
x == floor.width - 1 ? 0 : x + 1
];
else
core.status.maps[floorId].map[y][x] =
toBlocks[y][
x == floor.width - 1 ? 0 : x + 1
];
}
}
}
});
delete core.status.maps[floorId].blocks;
core.setMapBlockDisabled(
floorId,
core.nextX(),
core.nextY(),
false
);
core.extractBlocks(floorId);
core.getMapBlocksObj(floorId, true);
};
// 背景图
this.backgroundImage = function (image) {
if (typeof image == 'string') {
image = core.getMappedName(image);
image = core.material.images.images[image];
if (!image) return;
}
var h = image.height,
w = image.width;
// 裁剪
var sx = w / 2 - 240,
sy =
(core.bigmap.offsetY /
(core.status.thisMap.height * 32 - 480)) *
(h - 480);
// 背景层遮挡
core.createCanvas('bImage', 0, 0, 480, 480, 25);
// 事件层遮挡
core.createCanvas('eImage', 0, 0, 480, 480, 70);
core.clearMap('bImage');
// 左半边
core.drawImage('bImage', image, sx, sy, 96, 480, 0, 0, 96, 480);
core.drawImage('eImage', image, sx, sy, 64, 480, 0, 0, 64, 480);
// 右半边
sx = w / 2 + 144;
core.drawImage('bImage', image, sx, sy, 96, 480, 384, 0, 96, 480);
core.drawImage(
'eImage',
image,
sx + 32,
sy,
64,
480,
416,
0,
64,
480
);
};
// 到达地图重定位
this.relocateLoopMap = function (floorId, heroLoc, fromIds) {
var floor = core.floors[floorId];
var nowX = heroLoc.x;
var toX = Math.floor(floor.width / 2);
if (nowX == toX) return;
// 设置勇士位置
core.setHeroLoc('x', 12);
// 计算偏移量
var dx = toX - nowX;
// 转换
// 原始层楼层转换平移
if (floorId == 'tower6')
fromIds = ['tower1', 'tower2', 'tower4', 'tower5'];
fromIds.forEach(id => {
var toChanges = {};
for (var one in core.floors[id].changeFloor) {
var data = core.floors[id].changeFloor[one];
var x = data.loc[0],
y = data.loc[1];
var blocks = core.getMapBlocksObj(id);
var toFloor = data.floorId;
if (blocks[one] && !blocks[one].event.id.startsWith('A')) {
toChanges[one] = { floorId: toFloor, loc: [x, y] };
continue;
}
if (dx > 0)
x =
x + dx > floor.width - 1
? dx + x - floor.width
: dx + x;
else x = x + dx < 0 ? dx + x + floor.width : dx + x;
toChanges[one] = { floorId: toFloor, loc: [x, y] };
}
// 转换
delete core.floors[id].changeFloor;
core.floors[id].changeFloor = toChanges;
delete core.status.maps[id].blocks;
core.extractBlocks(id);
core.getMapBlocksObj(id, true);
});
var list = ['events', 'changeFloor'];
list.forEach(name => {
var toEvents = {};
// 获得事件并删除原事件
for (var one in floor[name]) {
var loc = one.split(',');
var x = parseInt(loc[0]),
y = parseInt(loc[1]);
if (x + dx > floor.width - 1) {
x = dx + x - floor.width;
} else if (x + dx < 0) {
x = x + dx + floor.width;
} else {
x += dx;
}
toEvents[x + ',' + y] = floor[name][one];
delete core.floors[floorId][name][one];
}
// 转换
core.floors[floorId][name] = toEvents;
});
dx = -dx;
// 前景事件背景层图块平移
list = ['bgmap', 'bg2map', 'map', 'fgmap', 'fg2map'];
list.forEach(one => {
if (one == 'map') {
var toBlocks = core.clone(core.status.maps[floorId].map);
} else {
var toBlocks = core.clone(floor[one]);
}
if (toBlocks.length == 0) return;
for (var y = 0; y < toBlocks.length; y++) {
for (var x = 0; x < toBlocks[y].length; x++) {
if (dx > 0) {
if (one != 'map')
floor[one][y][x] =
toBlocks[y][
x + dx > floor.width - 1
? dx + x - floor.width
: dx + x
];
else
core.status.maps[floorId].map[y][x] =
toBlocks[y][
x + dx > floor.width - 1
? dx + x - floor.width
: dx + x
];
} else {
if (one != 'map')
floor[one][y][x] =
toBlocks[y][
x + dx < 0
? dx + x + floor.width
: dx + x
];
else
core.status.maps[floorId].map[y][x] =
toBlocks[y][
x + dx < 0
? dx + x + floor.width
: dx + x
];
}
}
}
});
delete core.status.maps[floorId].blocks;
core.extractBlocks(floorId);
core.getMapBlocksObj(floorId, true);
};
////// 将当前地图重新变成数字，以便于存档 //////
maps.prototype.saveMap = function (floorId) {
if (floorId == 'tower6') return;
var maps = core.status.maps;
if (!floorId) {
var map = {};
for (var id in maps) {
if (id == 'tower6') continue;
var obj = this.saveMap(id);
if (Object.keys(obj).length > 0) map[id] = obj;
}
return map;
}
// 砍层状态：直接返回
if ((flags.__removed__ || []).indexOf(floorId) >= 0) {
return {};
}
var map = maps[floorId];
var thisFloor = this._compressFloorData(map, core.floors[floorId]);
var mapArr = this.compressMap(
map.blocks
? this._getMapArrayFromBlocks(
map.blocks,
map.width,
map.height,
true
)
: map.map,
floorId
);
if (mapArr != null) thisFloor.map = mapArr;
return thisFloor;
};
// 存档问题
this.saveLoopMap = function (floorId, fromIds) {
// 当前层
var data = {};
['bg2map', 'bgmap', 'changeFloor', 'fgmap', 'fg2map'].forEach(
one => {
data[one] = core.floors[floorId][one];
}
);
// 可以到达该层的楼层转换
data.map = core.status.maps[floorId].map;
data.changes = {};
fromIds.forEach(id => {
data.changes[id] = core.floors[id].changeFloor;
});
return data;
};
// 读档
this.loadLoopMap = function (data, floorId) {
if (!data) return;
for (var one in data) {
// 非楼层转换
if (one != 'changes') {
core.floors[floorId][one] = data[one];
} else {
// 楼层转换
for (var id in data.changes) {
core.floors[id].changeFloor = data.changes[id];
}
}
}
// 解析图块
if (data.changes)
for (var id in data.changes) {
core.extractBlocks(id);
}
};
},
towerBoss: function () {
// 智慧boss
// 变量们
var stage = 1,
hp = 10000,
seconds = 0,
boomLocs = [], // 随机轰炸
heroHp;
// 初始化
this.initTowerBoss = function () {
stage = 1;
hp = 10000;
seconds = 0;
heroHp = core.status.hero.hp;
core.dynamicChangeHp(0, 10000, 10000);
core.autoFixRouteBoss(true);
core.insertAction([{ type: 'sleep', time: 1000, noSkip: true }]);
setTimeout(core.bossCore, 1000);
};
// 录像自动修正
this.autoFixRouteBoss = function (isStart) {
var route = core.status.route;
if (isStart) {
// 开始修正 记录当前录像长度
flags.startFix = route.length - 1;
return;
}
// 结束修正 删除录像 并追加跳过步骤
route.splice(flags.startFix);
route.push('choices:0');
delete flags.startFix;
};
// 血条
this.healthBar = function (now, total) {
// 关闭小地图
flags.__useMinimap__ = false;
core.drawMinimap();
var nowLength = (now / total) * 476; // 当前血量下绘制长度
var color = [
255 * 2 - (now / total) * 2 * 255,
(now / total) * 2 * 255,
0,
1
]; // 根据当前血量计算颜色
// 建画布
if (!core.dymCanvas.healthBar)
core.createCanvas('healthBar', 0, 0, 480, 16, 140);
else core.clearMap('healthBar');
// 底
core.fillRect('healthBar', 0, 0, 480, 16, '#bbbbbb');
// css特效
var style = document.getElementById('healthBar').getContext('2d');
style.shadowColor = 'rgba(0, 0, 0, 0.8)';
style.shadowBlur = 5;
style.shadowOffsetX = 10;
style.shadowOffsetY = 5;
style.filter = 'blur(1px)';
// 绘制
core.fillRect('healthBar', 2, 2, nowLength, 12, color);
// css特效
style.shadowColor = 'rgba(0, 0, 0, 0.5)';
style.shadowOffsetX = 0;
style.shadowOffsetY = 0;
// 绘制边框
core.strokeRect('healthBar', 1, 1, 478, 14, '#ffffff', 2);
// 绘制文字
style.shadowColor = 'rgba(0, 0, 0, 1)';
style.shadowBlur = 3;
style.shadowOffsetX = 2;
style.shadowOffsetY = 1;
style.filter = 'none';
core.fillText(
'healthBar',
now + '/' + total,
5,
13.5,
'#ffffff',
'16px normal'
);
};
// 血量变化
this.dynamicChangeHp = function (from, to, total) {
var frame = 0,
speed = (to - from) / 50,
now = from;
var interval = window.setInterval(() => {
frame++;
if (frame == 50) {
clearInterval(interval);
core.healthBar(to, total);
}
now += speed;
core.healthBar(now, total);
}, 20);
};
// boss说话跳字
this.skipWord = function (words, x, y, time) {
x = x || 0;
y = y || 16;
time = time || 3000;
// 创建画布
if (!core.dymCanvas.words)
core.createCanvas('words', x, y, 480, 24, 135);
else core.clearMap('words');
if (flags.wordsTimeOut) clearTimeout(flags.wordsTimeOut);
core.dynamicCurtain(y, y + 24, time / 3);
// css
var style = document.getElementById('words').getContext('2d');
style.shadowColor = 'rgba(0, 0, 0, 1)';
style.shadowBlur = 3;
style.shadowOffsetX = 2;
style.shadowOffsetY = 1;
// 一个一个绘制
skip1(0);
// 跳字
function skip1(now) {
if (parseInt(now) >= words.length) {
flags.wordsTimeOut = setTimeout(() => {
core.deleteCanvas('words');
core.deleteCanvas('wordsBg');
}, time);
return;
}
var frame = 0,
blur = 2,
nx = 4 + now * 24;
var skip2 = window.setInterval(() => {
blur -= 0.4;
frame++;
core.clearMap('words', nx, 0, 24, 24);
style.filter = 'blur(' + blur + 'px)';
core.fillText(
'words',
words[now],
nx,
20,
'#ffffff',
'22px normal'
);
if (frame == 5) {
clearInterval(skip2);
skip1(now + 1);
}
}, 20);
}
};
// 匀变速下降背景
this.dynamicCurtain = function (from, to, time, width) {
width = width || 480;
if (!core.dymCanvas.wordsBg)
core.createCanvas('wordsBg', 0, from, width, 24, 130);
else core.clearMap('wordsBg');
time /= 1000;
var ny = from,
frame = 0,
a = (2 * (to - from)) / Math.pow(time * 50, 2),
speed = a * time * 50;
var style = document.getElementById('wordsBg').getContext('2d');
style.shadowColor = 'rgba(0, 0, 0, 0.8)';
var wordsInterval = window.setInterval(() => {
frame++;
speed -= a;
ny += speed;
core.clearMap('wordsBg');
style.shadowBlur = 8;
style.shadowOffsetY = 2;
core.fillRect(
'wordsBg',
0,
0,
width,
ny - from,
[180, 180, 180, 0.7]
);
style.shadowBlur = 3;
style.shadowOffsetY = 0;
core.strokeRect(
'wordsBg',
1,
1,
width - 2,
ny - from - 2,
[255, 255, 255, 0.7],
2
);
if (frame >= time * 50) {
clearInterval(wordsInterval);
core.clearMap('wordsBg');
style.shadowBlur = 8;
style.shadowOffsetY = 2;
core.fillRect(
'wordsBg',
0,
0,
width,
to - from,
[180, 180, 180, 0.7]
);
style.shadowBlur = 3;
style.shadowOffsetY = 0;
core.strokeRect(
'wordsBg',
1,
1,
width - 2,
ny - from - 2,
[255, 255, 255, 0.7],
2
);
}
}, 20);
};
// 攻击boss
this.attackBoss = function () {
// 每秒钟地面随机出现伤害图块 踩上去攻击boss 500血
if (flags.canAttack) return;
if (Math.random() < 0.8) return;
if (hp > 3500) {
var nx = Math.floor(Math.random() * 13 + 1),
ny = Math.floor(Math.random() * 13 + 1);
} else if (hp > 2000) {
var nx = Math.floor(Math.random() * 11 + 2),
ny = Math.floor(Math.random() * 11 + 2);
} else if (hp > 1000) {
var nx = Math.floor(Math.random() * 9 + 3),
ny = Math.floor(Math.random() * 9 + 3);
} else {
var nx = Math.floor(Math.random() * 7 + 4),
ny = Math.floor(Math.random() * 7 + 4);
}
// 在地图上显示
flags.canAttack = true;
if (!core.dymCanvas.attackBoss)
core.createCanvas('attackBoss', 0, 0, 480, 480, 35);
else core.clearMap('attackBoss');
var style = document.getElementById('attackBoss').getContext('2d');
var frame1 = 0,
blur = 3,
scale = 2,
speed = 0.04,
a = 0.0008;
var atkAnimate = window.setInterval(() => {
core.clearMap('attackBoss');
frame1++;
speed -= a;
scale -= speed;
blur -= 0.06;
style.filter = 'blur(' + blur + 'px)';
core.strokeCircle(
'attackBoss',
nx * 32 + 16,
ny * 32 + 16,
16 * scale,
[255, 150, 150, 0.7],
4
);
core.fillCircle(
'attackBoss',
nx * 32 + 16,
ny * 32 + 16,
3 * scale,
[255, 150, 150, 0.7]
);
if (frame1 == 50) {
clearInterval(atkAnimate);
core.clearMap('attactkBoss');
style.filter = 'none';
core.strokeCircle(
'attackBoss',
nx * 32 + 16,
ny * 32 + 16,
16,
[255, 150, 150, 0.7],
4
);
core.fillCircle(
'attackBoss',
nx * 32 + 16,
ny * 32 + 16,
3,
[255, 150, 150, 0.7]
);
}
}, 20);
// 实时检测勇士位置
var frame2 = 0;
var atkBoss = window.setInterval(() => {
frame2++;
var x = core.status.hero.loc.x,
y = core.status.hero.loc.y;
// 2秒超时
if (frame2 > 100) {
setTimeout(() => {
delete flags.canAttack;
}, 4000);
clearInterval(atkBoss);
core.deleteCanvas('attackBoss');
return;
}
if (nx == x && ny == y) {
setTimeout(() => {
delete flags.canAttack;
}, 4000);
core.dynamicChangeHp(hp, hp - 500, 10000);
hp -= 500;
clearInterval(atkBoss);
core.deleteCanvas('attackBoss');
if (hp > 3500) core.drawAnimate('hand', 7, 1);
else if (hp > 2000) core.drawAnimate('hand', 7, 2);
else if (hp > 1000) core.drawAnimate('hand', 7, 3);
else core.drawAnimate('hand', 7, 4);
return;
}
}, 20);
};
// 核心函数
this.bossCore = function () {
var interval = window.setInterval(() => {
if (stage == 1) {
if (seconds == 8)
core.skipWord('智慧之神：你和之前来的人不一样');
if (seconds == 12)
core.skipWord('智慧之神：他们只会一股脑地向前冲');
if (seconds == 16)
core.skipWord('智慧之神：而你却会躲避这些攻击');
if (seconds == 20)
core.skipWord('提示：踩在红圈上可以对智慧之神造成伤害');
if (seconds > 10) core.attackBoss();
if (seconds % 10 == 0) core.intelligentArrow();
if (seconds % 7 == 0 && seconds != 0)
core.intelligentDoor();
if (seconds > 20 && seconds % 13 == 0) core.icyMomentem();
}
if (stage == 1 && hp <= 7000) {
stage++;
seconds = 0;
core.skipWord('智慧之神：不错小伙子');
core.pauseBgm();
}
if (stage == 2) {
if (seconds == 4) core.skipWord('智慧之神：你很有潜力');
if (seconds == 8)
core.skipWord('智慧之神：看来你很可能成为改变历史的人');
if (seconds == 12)
core.skipWord('智慧之神：不过，这场战斗才刚刚开始');
if (seconds == 25)
core.skipWord('提示：方形区域均为危险区域');
if (seconds == 15)
setTimeout(() => {
core.playSound('thunder.mp3');
}, 500);
if (seconds == 16) core.startStage2();
if (seconds > 20) core.attackBoss();
if (seconds % 4 == 0 && seconds > 20) core.randomThunder();
if (seconds > 30 && seconds % 12 == 0) core.ballThunder();
}
if (hp <= 3500 && stage == 2) {
stage++;
seconds = 0;
core.skipWord('智慧之神：不得不说小伙子');
core.pauseBgm();
}
if (stage >= 3) {
if (seconds == 4)
core.skipWord('智慧之神：我越来越欣赏你了');
if (seconds == 8)
core.skipWord('智慧之神：不过，你还得再过我一关！');
if (seconds == 12) core.startStage3();
if (seconds == 15) {
flags.booming = true;
core.randomBoom();
}
if (seconds > 20) core.attackBoss();
if (seconds > 20 && seconds % 10 == 0) core.chainThunder();
if (hp == 2000 && stage == 3) {
stage++;
flags.booming = false;
core.skipWord('智慧之神：还没有结束！');
core.startStage4();
setTimeout(() => {
flags.booming = true;
core.randomBoom();
}, 5000);
}
if (hp == 1000 && stage == 4) {
stage++;
flags.booming = false;
core.skipWord('智慧之神：还没有结束！！！！！！');
core.startStage5();
setTimeout(() => {
flags.booming = true;
core.randomBoom();
}, 5000);
}
}
if (hp == 0) {
clearInterval(interval);
clearInterval(flags.boom);
core.status.hero.hp = heroHp;
core.autoFixRouteBoss(false);
delete flags.__bgm__;
core.pauseBgm();
core.insertAction([
'\t[智慧之神,E557]\b[down,7,4]不错不错，你确实可以成为改变历史的人',
'\t[智慧之神,E557]\b[down,7,4]我的职责就到此结束了',
'\t[智慧之神,E557]\b[down,7,4]之后还是要看你自己了，千万不要让我失望！',
'\t[智慧之神,E557]\b[down,7,4]东边的机关门我已经替你打开了',
{ type: 'openDoor', loc: [13, 6], floorId: 'MT19' },
'\t[智慧之神,E557]\b[down,7,4]我这就把你传送出去',
{ type: 'setValue', name: 'flag:boss1', value: 'true' },
{ type: 'changeFloor', floorId: 'MT20', loc: [7, 9] },
{
type: 'function',
function: '() => {\ncore.deleteAllCanvas();\n}'
},
{ type: 'forbidSave' }
]);
}
seconds++;
}, 1000);
};
// ------ 第一阶段 10000~7000血 ------ //
// 技能1 智慧之箭 1000伤害
this.intelligentArrow = function (fromSelf) {
// 坐标
var loc = Math.floor(Math.random() * 13 + 1);
var direction = Math.random() > 0.5 ? 'horizon' : 'vertical';
// 执行次数
if (!fromSelf) {
var times = Math.ceil(Math.random() * 8) + 4;
var nowTime = 1;
var times1 = window.setInterval(() => {
core.intelligentArrow(true);
nowTime++;
if (nowTime >= times) {
clearInterval(times1);
}
}, 200);
}
// 防重复
if (core.dymCanvas['inteArrow' + loc + direction])
return core.intelligentArrow(true);
// 危险区域
if (!core.dymCanvas.danger1)
core.createCanvas('danger1', 0, 0, 480, 480, 35);
if (direction == 'horizon') {
for (var nx = 1; nx < 14; nx++) {
core.fillRect(
'danger1',
nx * 32 + 2,
loc * 32 + 2,
28,
28,
[255, 0, 0, 0.6]
);
}
} else {
for (var ny = 1; ny < 14; ny++) {
core.fillRect(
'danger1',
loc * 32 + 2,
ny * 32 + 2,
28,
28,
[255, 0, 0, 0.6]
);
}
}
// 箭
if (!core.dymCanvas['inteArrow' + loc + direction])
core.createCanvas(
'inteArrow' + loc + direction,
0,
0,
544,
544,
65
);
core.clearMap('inteArrow' + loc + direction);
if (direction == 'horizon')
core.drawImage(
'inteArrow' + loc + direction,
'arrow.png',
448,
loc * 32,
102,
32
);
else
core.drawImage(
'inteArrow' + loc + direction,
'arrow.png',
0,
0,
259,
75,
loc * 32 - 32,
480,
102,
32,
Math.PI / 2
);
// 动画与伤害函数
setTimeout(() => {
core.playSound('arrow.mp3');
core.deleteCanvas('danger1');
// 动画效果
var nloc = 0,
speed = 0;
var damaged = {};
var skill1 = window.setInterval(() => {
speed -= 1;
nloc += speed;
if (direction == 'horizon')
core.relocateCanvas(
'inteArrow' + loc + direction,
nloc,
0
);
else
core.relocateCanvas(
'inteArrow' + loc + direction,
0,
nloc
);
if (nloc < -480) {
core.deleteCanvas('inteArrow' + loc + direction);
clearInterval(skill1);
}
// 伤害判定
if (!damaged[loc + direction]) {
var x = core.status.hero.loc.x,
y = core.status.hero.loc.y;
if (direction == 'horizon') {
if (
y == loc &&
Math.floor((480 + nloc) / 32) == x
) {
damaged[loc + direction] = true;
core.drawHeroAnimate('hand');
core.status.hero.hp -= 1000;
core.popupDamage(1000, x, y, false);
core.updateStatusBar();
if (core.status.hero.hp < 0) {
clearInterval(skill1);
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
}
}
} else {
if (
x == loc &&
Math.floor((480 + nloc) / 32) == y
) {
damaged[loc + direction] = true;
core.drawHeroAnimate('hand');
core.status.hero.hp -= 1000;
core.popupDamage(1000, x, y, false);
core.updateStatusBar();
if (core.status.hero.hp < 0) {
clearInterval(skill1);
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
}
}
}
}
}, 20);
}, 3000);
};
// 技能2 智慧之门 随机传送
this.intelligentDoor = function () {
if (Math.random() < 0.5) return;
// 随机位置
var toX = Math.floor(Math.random() * 13) + 1,
toY = Math.floor(Math.random() * 13) + 1;
// 在勇士身上绘制动画
core.drawHeroAnimate('magicAtk');
// 在目标位置绘制动画
if (!core.dymCanvas['door' + toX + '_' + toY])
core.createCanvas('door' + toX + '_' + toY, 0, 0, 480, 480, 35);
else core.clearMap('door' + toX + '_' + toY);
var style = document
.getElementById('door' + toX + '_' + toY)
.getContext('2d');
var frame = 0,
width = 0,
a = 0.0128,
speed = 0.64;
// 动画
var skill2 = window.setInterval(() => {
frame++;
if (frame < 40) return;
if (frame == 100) {
clearInterval(skill2);
// 执行传送
core.insertAction([{ type: 'changePos', loc: [toX, toY] }]);
// 删除传送门
setTimeout(() => {
core.deleteCanvas('door' + toX + '_' + toY);
}, 2000);
return;
}
width += speed * 2;
speed -= a;
core.clearMap('door' + toX + '_' + toY);
style.shadowColor = 'rgba(255, 255, 255, 1)';
style.shadowBlur = 7;
style.filter = 'blur(5px)';
core.fillRect(
'door' + toX + '_' + toY,
toX * 32,
toY * 32 - 24,
width,
48,
[255, 255, 255, 0.7]
);
style.shadowColor = 'rgba(0, 0, 0, 0.5)';
style.filter = 'blur(3px)';
core.strokeRect(
'door' + toX + '_' + toY,
toX * 32,
toY * 32 - 24,
width,
48,
[255, 255, 255, 0.7],
3
);
}, 20);
};
// 技能3 万冰之势 全屏随机转换滑冰 如果转换时在滑冰上造成5000点伤害
this.icyMomentem = function () {
if (flags.haveIce) return;
if (Math.random() < 0.5) return;
var times = Math.floor(Math.random() * 100);
// 防卡 就setInterval吧
var locs = [],
now = 0;
flags.haveIce = true;
if (!core.dymCanvas.icyMomentem)
core.createCanvas('icyMomentem', 0, 0, 480, 480, 35);
else core.clearMap('icyMomentem');
var skill3 = window.setInterval(() => {
var nx = Math.floor(Math.random() * 13) + 1,
ny = Math.floor(Math.random() * 13) + 1;
if (!locs.includes([nx, ny])) {
locs.push([nx, ny]);
core.fillRect(
'icyMomentem',
locs[now][0] * 32 + 2,
locs[now][1] * 32 + 2,
28,
28,
[150, 150, 255, 0.6]
);
}
if (now == times) {
clearInterval(skill3);
skill3Effect();
}
now++;
}, 20);
// 动画和伤害函数
function skill3Effect() {
// 防卡 setInterval
var index = 0;
var effect = window.setInterval(() => {
var x = core.status.hero.loc.x,
y = core.status.hero.loc.y;
core.clearMap(
'icyMomentem',
locs[index][0] * 32,
locs[index][1] * 32,
32,
32
);
core.setBgFgBlock(
'bg',
167,
locs[index][0],
locs[index][1]
);
core.drawAnimate('ice', locs[index][0], locs[index][1]);
if (x == locs[index][0] && y == locs[index][1]) {
core.drawHeroAnimate('hand');
core.status.hero.hp -= 5000;
core.popupDamage(5000, x, y, false);
core.updateStatusBar();
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
clearInterval(effect);
return;
}
}
if (index >= locs.length - 1) {
clearInterval(effect);
setTimeout(() => {
deleteIce(locs);
}, 5000);
}
index++;
}, 50);
}
// 删除函数
function deleteIce(locs) {
// 照样 setInterval
var index = 0;
var deleteIce = window.setInterval(() => {
core.setBgFgBlock('bg', 0, locs[index][0], locs[index][1]);
index++;
if (index >= locs.length) {
clearInterval(deleteIce);
core.deleteCanvas('icyMomentem');
setTimeout(() => {
delete flags.haveIce;
}, 5000);
}
}, 50);
}
};
// ------ 第二阶段 7000~3500 ------ //
// 开始第二阶段
this.startStage2 = function () {
// 闪烁
core.createCanvas('flash', 0, 0, 480, 480, 160);
var alpha = 0;
var frame = 0;
var start1 = window.setInterval(() => {
core.clearMap('flash');
frame++;
if (frame <= 8) alpha += 0.125;
else alpha -= 0.01;
core.fillRect('flash', 0, 0, 480, 480, [255, 255, 255, alpha]);
if (alpha == 0) {
clearInterval(start1);
core.deleteCanvas('flash');
}
if (frame == 8) {
changeWeather();
}
});
// 切换天气
function changeWeather() {
core.setWeather();
core.setWeather('rain', 10);
core.setWeather('fog', 8);
// 色调也得换
core.setCurtain([0, 0, 0, 0.3]);
// bgm
core.playBgm('towerBoss2.mp3');
}
};
// ----- 打雷相关 ----- //
// 随机打雷
this.randomThunder = function () {
var x = Math.floor(Math.random() * 13) + 1,
y = Math.floor(Math.random() * 13) + 1,
power = Math.ceil(Math.random() * 6);
// 绘制危险区域
if (!core.dymCanvas.thunderDanger)
core.createCanvas('thunderDanger', 0, 0, 480, 480, 35);
else core.clearMap('thunderDanger');
// 3*3范围
for (var nx = x - 1; nx <= x + 1; nx++) {
for (var ny = y - 1; ny <= y + 1; ny++) {
core.fillRect(
'thunderDanger',
nx * 32 + 2,
ny * 32 + 2,
28,
28,
[255, 255, 255, 0.6]
);
}
}
core.deleteCanvas('flash');
setTimeout(() => {
core.playSound('thunder.mp3');
}, 500);
setTimeout(() => {
core.deleteCanvas('thunderDanger');
core.drawThunder(x, y, power);
}, 1000);
};
// 绘制
this.drawThunder = function (x, y, power) {
var route = core.getThunderRoute(x * 32 + 16, y * 32 + 16, power);
// 开始绘制
if (!core.dymCanvas.thunder)
core.createCanvas('thunder', 0, 0, 480, 480, 65);
else core.clearMap('thunder');
var style = core.dymCanvas.thunder;
style.shadowColor = 'rgba(220, 220, 255, 1)';
style.shadowBlur = power;
style.filter = 'blur(2.5px)';
for (var num in route) {
// 一个个绘制
for (var i = 0; i < route[num].length - 1; i++) {
var now = route[num][i],
next = route[num][i + 1];
core.drawLine(
'thunder',
now[0],
now[1],
next[0],
next[1],
'#ffffff',
2.5
);
}
}
// 伤害
core.getThunderDamage(x, y, power);
// 闪一下
var frame1 = 0,
alpha = 0.5;
if (!core.dymCanvas.flash)
core.createCanvas('flash', 0, 0, 480, 480, 160);
else core.clearMap('flash');
var thunderFlash = window.setInterval(() => {
alpha -= 0.05;
frame1++;
core.clearMap('flash');
core.fillRect('flash', 0, 0, 480, 480, [255, 255, 255, alpha]);
if (frame1 >= 10) {
clearInterval(thunderFlash);
core.deleteCanvas('flash');
// 删除闪电
setTimeout(() => {
core.deleteCanvas('thunder');
}, 700);
}
}, 20);
};
// 获得雷电路径
this.getThunderRoute = function (x, y, power) {
var route = [];
for (var num = 0; num < power; num++) {
var nx = x,
ny = y;
route[num] = [];
for (var i = 0; ny >= 0; i++) {
if (i > 0) {
nx += Math.random() * 30 - 15;
ny -= Math.random() * 80 + 30;
} else {
nx += Math.random() * 16 - 8;
ny += Math.random() * 16 - 8;
}
route[num].push([nx, ny]);
}
}
return route;
};
// 打雷伤害判定
this.getThunderDamage = function (x, y, power) {
var hx = core.status.hero.loc.x,
hy = core.status.hero.loc.y;
if (Math.abs(hx - x) <= 1 && Math.abs(hy - y) <= 1) {
core.status.hero.hp -= 3000 * power;
core.popupDamage(3000 * power, x, y, false);
core.updateStatusBar();
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
}
}
};
// ----- 打雷 END ----- //
// 球形闪电 横竖
this.ballThunder = function () {
// 随机数量
var times = Math.ceil(Math.random() * 12) + 6;
var now = 0,
locs = [];
// setInterval执行
var ballThunder = window.setInterval(() => {
// 画布
if (!core.dymCanvas['ballThunder' + now])
core.createCanvas('ballThunder' + now, 0, 0, 480, 480, 35);
else core.clearMap('ballThunder' + now);
var nx = Math.floor(Math.random() * 13) + 1,
ny = Math.floor(Math.random() * 13) + 1;
// 添加位置 绘制危险区域
if (!locs.includes([nx, ny])) {
locs.push([nx, ny]);
// 横竖都要画
for (var mx = 1; mx < 14; mx++) {
core.fillRect(
'ballThunder' + now,
mx * 32 + 2,
ny * 32 + 2,
28,
28,
[190, 190, 255, 0.6]
);
}
for (var my = 1; my < 14; my++) {
core.fillRect(
'ballThunder' + now,
nx * 32 + 2,
my * 32 + 2,
28,
28,
[190, 190, 255, 0.6]
);
}
}
now++;
if (now >= times) {
clearInterval(ballThunder);
setTimeout(() => {
thunderAnimate(locs);
}, 1000);
}
}, 200);
// 动画 伤害
function thunderAnimate(locs) {
var frame = 0;
// 画布
if (!core.dymCanvas.ballAnimate)
core.createCanvas('ballAnimate', 0, 0, 480, 480, 65);
else core.clearMap('ballAnimate');
var style = core.dymCanvas.ballAnimate;
style.shadowColor = 'rgba(255, 255, 255, 1)';
var damaged = [];
var animate = window.setInterval(() => {
core.clearMap('ballAnimate');
for (var i = 0; i < locs.length; i++) {
style.shadowBlur = 16 * Math.random();
// 错开执行动画
if (frame - 10 * i > 0) {
var now = frame - 10 * i;
if (now == 1) core.playSound('electron.mp3');
// 动画
var nx = locs[i][0] * 32 + 16,
ny = locs[i][1] * 32 + 16;
if (now <= 2) {
core.fillCircle(
'ballAnimate',
nx,
ny,
16 + 3 * now,
[255, 255, 255, 0.9]
);
} else {
// 上
core.fillCircle(
'ballAnimate',
nx,
ny - 4 * now,
7 + 2 * Math.random(),
[255, 255, 255, 0.7]
);
// 下
core.fillCircle(
'ballAnimate',
nx,
ny + 4 * now,
7 + 2 * Math.random(),
[255, 255, 255, 0.7]
);
// 左
core.fillCircle(
'ballAnimate',
nx - 4 * now,
ny,
7 + 2 * Math.random(),
[255, 255, 255, 0.7]
);
// 右
core.fillCircle(
'ballAnimate',
nx + 4 * now,
ny,
7 + 2 * Math.random(),
[255, 255, 255, 0.7]
);
}
// 清除危险区域
core.clearMap(
'ballThunder' + i,
nx - 16,
ny - 16 - 4 * now,
32,
32
);
core.clearMap(
'ballThunder' + i,
nx - 16,
ny - 16 + 4 * now,
32,
32
);
core.clearMap(
'ballThunder' + i,
nx - 16 - 4 * now,
ny - 16,
32,
32
);
core.clearMap(
'ballThunder' + i,
nx - 16 + 4 * now,
ny - 16,
32,
32
);
// 伤害
if (!damaged[i]) {
var x = core.status.hero.loc.x,
y = core.status.hero.loc.y;
if (
((Math.floor((nx - 16 - 4 * now) / 32) ==
x ||
Math.floor((nx - 16 + 4 * now) / 32) ==
x) &&
locs[i][1] == y) ||
((Math.floor((ny - 16 - 4 * now) / 32) ==
y ||
Math.floor((ny - 16 + 4 * now) / 32) ==
y) &&
locs[i][0] == x)
) {
damaged[i] = true;
core.status.hero.hp -= 3000;
core.popupDamage(3000, x, y, false);
core.updateStatusBar();
core.playSound('electron.mp3');
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
clearInterval(animate);
return;
}
}
}
// 结束
if (i == locs.length - 1 && now > 120) {
clearInterval(animate);
}
}
}
frame++;
}, 20);
}
};
// ------ 第三阶段 3500~0 ------ //
this.startStage3 = function () {
// 闪烁
core.createCanvas('flash', 0, 0, 480, 480, 160);
var alpha = 0;
var frame = 0;
var start1 = window.setInterval(() => {
core.clearMap('flash');
frame++;
if (frame <= 8) alpha += 0.125;
else alpha -= 0.01;
core.fillRect('flash', 0, 0, 480, 480, [255, 255, 255, alpha]);
if (alpha == 0) {
clearInterval(start1);
core.deleteCanvas('flash');
}
if (frame == 8) {
core.playSound('thunder.mp3');
changeTerra();
core.insertAction([{ type: 'changePos', loc: [7, 7] }]);
}
});
// 改变地形
function changeTerra() {
for (var nx = 0; nx < 15; nx++) {
for (var ny = 0; ny < 15; ny++) {
if (nx == 0 || nx == 14 || ny == 0 || ny == 14) {
core.removeBlock(nx, ny);
}
if (
(nx == 1 || nx == 13 || ny == 1 || ny == 13) &&
nx != 0 &&
nx != 14 &&
ny != 0 &&
ny != 14
) {
core.setBlock(527, nx, ny);
}
}
}
core.createCanvas('tower7', 0, 0, 480, 480, 15);
// 画贴图
core.drawImage(
'tower7',
'tower7.jpeg',
360,
0,
32,
480,
0,
0,
32,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
840,
0,
32,
480,
448,
0,
32,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
392,
0,
416,
32,
32,
0,
416,
32
);
core.drawImage(
'tower7',
'tower7.jpeg',
392,
448,
416,
32,
32,
448,
416,
32
);
core.setBlock('E557', 7, 2);
core.playBgm('towerBoss3.mp3');
}
};
// 进入第四阶段
this.startStage4 = function () {
// 闪烁
core.createCanvas('flash', 0, 0, 480, 480, 160);
var alpha = 0;
var frame = 0;
var start1 = window.setInterval(() => {
core.clearMap('flash');
frame++;
if (frame <= 8) alpha += 0.125;
else alpha -= 0.01;
core.fillRect('flash', 0, 0, 480, 480, [255, 255, 255, alpha]);
if (alpha == 0) {
clearInterval(start1);
core.deleteCanvas('flash');
}
if (frame == 8) {
core.playSound('thunder.mp3');
changeTerra();
core.insertAction([{ type: 'changePos', loc: [7, 7] }]);
}
});
// 改变地形
function changeTerra() {
for (var nx = 1; nx < 14; nx++) {
for (var ny = 1; ny < 14; ny++) {
if (nx == 1 || nx == 13 || ny == 1 || ny == 13) {
core.removeBlock(nx, ny);
}
if (
(nx == 2 || nx == 12 || ny == 2 || ny == 12) &&
nx != 1 &&
nx != 13 &&
ny != 1 &&
ny != 13
) {
core.setBlock(527, nx, ny);
}
}
}
core.createCanvas('tower7', 0, 0, 480, 480, 15);
// 画贴图
core.drawImage(
'tower7',
'tower7.jpeg',
360,
0,
64,
480,
0,
0,
64,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
776,
0,
64,
480,
416,
0,
64,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
424,
0,
352,
64,
64,
0,
352,
64
);
core.drawImage(
'tower7',
'tower7.jpeg',
424,
416,
352,
64,
64,
416,
352,
64
);
core.setBlock('E557', 7, 3);
}
};
// 进入第五阶段
this.startStage5 = function () {
// 闪烁
core.createCanvas('flash', 0, 0, 480, 480, 160);
var alpha = 0;
var frame = 0;
var start1 = window.setInterval(() => {
core.clearMap('flash');
frame++;
if (frame <= 8) alpha += 0.125;
else alpha -= 0.01;
core.fillRect('flash', 0, 0, 480, 480, [255, 255, 255, alpha]);
if (alpha == 0) {
clearInterval(start1);
core.deleteCanvas('flash');
}
if (frame == 8) {
core.playSound('thunder.mp3');
changeTerra();
core.insertAction([{ type: 'changePos', loc: [7, 7] }]);
}
});
// 改变地形
function changeTerra() {
for (var nx = 2; nx < 13; nx++) {
for (var ny = 2; ny < 13; ny++) {
if (nx == 2 || nx == 12 || ny == 2 || ny == 12) {
core.removeBlock(nx, ny);
}
if (
(nx == 3 || nx == 11 || ny == 3 || ny == 11) &&
nx != 2 &&
nx != 12 &&
ny != 2 &&
ny != 12
) {
core.setBlock(527, nx, ny);
}
}
}
core.createCanvas('tower7', 0, 0, 480, 480, 15);
// 画贴图
core.drawImage(
'tower7',
'tower7.jpeg',
360,
0,
96,
480,
0,
0,
96,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
744,
0,
96,
480,
384,
0,
96,
480
);
core.drawImage(
'tower7',
'tower7.jpeg',
456,
0,
288,
96,
96,
0,
288,
96
);
core.drawImage(
'tower7',
'tower7.jpeg',
456,
384,
288,
96,
96,
384,
288,
96
);
core.setBlock('E557', 7, 4);
}
};
// 链状闪电 随机连接 碰到勇士则受伤
this.chainThunder = function () {
// 随机次数
var times = Math.ceil(Math.random() * 6) + 3;
// 画布
if (!core.dymCanvas.chainDanger)
core.createCanvas('chainDanger', 0, 0, 480, 480, 35);
else core.clearMap('chainDanger');
// setInterval执行
var locs = [],
now = 0;
var chain = window.setInterval(() => {
if (hp > 2000) {
var nx = Math.floor(Math.random() * 11) + 2,
ny = Math.floor(Math.random() * 11) + 2;
} else if (hp > 1000) {
var nx = Math.floor(Math.random() * 9) + 3,
ny = Math.floor(Math.random() * 9) + 3;
} else {
var nx = Math.floor(Math.random() * 7) + 4,
ny = Math.floor(Math.random() * 7) + 4;
}
if (!locs.includes([nx, ny])) {
locs.push([nx, ny]);
} else return;
// 危险线
if (now > 0) {
core.drawLine(
'chainDanger',
locs[now - 1][0] * 32 + 16,
locs[now - 1][1] * 32 + 16,
nx * 32 + 16,
ny * 32 + 16,
[220, 100, 255, 0.6],
3
);
}
if (now >= times) {
clearInterval(chain);
setTimeout(() => {
core.getChainRoute(locs);
core.deleteCanvas('chainDanger');
}, 1000);
}
now++;
}, 100);
};
// 链状闪电 动画
this.chainAnimate = function (route) {
if (!route) return core.chainThunder();
// 画布
if (!core.dymCanvas.chain)
core.createCanvas('chain', 0, 0, 480, 480, 65);
else core.clearMap('chain');
var style = core.dymCanvas.chain;
style.shadowBlur = 3;
style.shadowColor = 'rgba(255, 255, 255, 1)';
style.filter = 'blur(2px)';
// 当然还是setInterval
var frame = 0,
now = 0;
var animate = window.setInterval(() => {
if (now >= route.length - 1) {
clearInterval(animate);
setTimeout(() => {
core.deleteCanvas('chain');
}, 1000);
return;
}
frame++;
if (frame % 2 != 0) return;
core.drawLine(
'chain',
route[now][0],
route[now][1],
route[now + 1][0],
route[now + 1][1],
'#ffffff',
3
);
// 节点
if (now == 0) {
core.fillCircle(
'chain',
route[0][0],
route[0][1],
7,
'#ffffff'
);
}
if (
(route[now + 1][0] - 16) % 32 == 0 &&
(route[now + 1][1] - 16) % 32 == 0
) {
core.fillCircle(
'chain',
route[now + 1][0],
route[now + 1][1],
7,
'#ffffff'
);
}
// 判断伤害
core.lineDamage(
route[now][0],
route[now][1],
route[now + 1][0],
route[now + 1][1],
4000
);
now++;
}, 20);
};
// 链状闪电 获得闪电路径
this.getChainRoute = function (locs) {
// 照样用setInterval
var now = 0,
routes = [];
var route = window.setInterval(() => {
var nx = locs[now][0] * 32 + 16,
ny = locs[now][1] * 32 + 16;
var tx = locs[now + 1][0] * 32 + 16,
ty = locs[now + 1][1] * 32 + 16;
var dx = tx - nx,
dy = ty - ny;
var angle = Math.atan(dy / dx);
if (dy < 0 && dx < 0) angle += Math.PI;
if (dx < 0 && dy > 0) angle += Math.PI;
// 循环 + 随机
var times = 0;
while (true) {
times++;
nx += Math.random() * 50 * Math.cos(angle);
ny += Math.random() * 50 * Math.sin(angle);
routes.push([nx, ny]);
if (
Math.sqrt(
Math.pow(ny - ty, 2) + Math.pow(nx - tx, 2)
) <= 100
) {
routes.push([tx, ty]);
break;
}
if (times >= 20) {
clearInterval(route);
routes = null;
return;
}
}
now++;
if (now >= locs.length - 1) {
clearInterval(route);
core.chainAnimate(routes);
}
}, 2);
};
// 随机轰炸
this.randomBoom = function () {
// 停止轰炸
if (!flags.booming) {
clearInterval(flags.boom);
return;
}
// 根据阶段数 分攻击速率 和范围
var boomTime;
var range;
if (hp > 2000) {
boomTime = 500;
range = 11;
} else if (hp > 1000) {
boomTime = 400;
range = 9;
} else {
boomTime = 300;
range = 7;
}
// setInterval
flags.boom = window.setInterval(() => {
var nx = Math.floor(Math.random() * range) + (15 - range) / 2,
ny = Math.floor(Math.random() * range) + (15 - range) / 2;
boomLocs.push([nx, ny, 0]);
if (!flags.booming) clearInterval(flags.boom);
}, boomTime);
// 动画要在这里调用
core.boomingAnimate();
};
// 随机轰炸 动画
this.boomingAnimate = function () {
// 直接setInterval
if (!core.dymCanvas.boom)
core.createCanvas('boom', 0, 0, 480, 480, 65);
else core.clearMap('boom');
var boomAnimate = window.setInterval(() => {
if (boomLocs.length == 0) return;
if (!flags.booming && boomLocs.length == 0) {
clearInterval(boomAnimate);
return;
}
core.clearMap('boom');
boomLocs.forEach((loc, index) => {
loc[2]++;
var x = loc[0] * 32 + 16,
y = loc[1] * 32 + 16;
if (loc[2] >= 20) {
var alpha = 1,
radius = 12;
} else {
var radius = 0.12 * Math.pow(20 - loc[2], 2) + 12,
alpha = Math.max(1, 2 - loc[2] * 0.1);
}
var angle = (loc[2] * Math.PI) / 50;
// 开始绘制
core.fillCircle('boom', x, y, 3, [255, 50, 50, alpha]);
core.strokeCircle(
'boom',
x,
y,
radius,
[255, 50, 50, alpha],
2
);
// 旋转的线
core.drawLine(
'boom',
x + radius * Math.cos(angle),
y + radius * Math.sin(angle),
x + (radius + 15) * Math.cos(angle),
y + (radius + 15) * Math.sin(angle),
[255, 50, 50, alpha],
1
);
angle += Math.PI;
core.drawLine(
'boom',
x + radius * Math.cos(angle),
y + radius * Math.sin(angle),
x + (radius + 15) * Math.cos(angle),
y + (radius + 15) * Math.sin(angle),
[255, 50, 50, alpha],
1
);
// 炸弹 下落
if (loc[2] > 70) {
var h =
y -
(20 * (85 - loc[2]) +
2.8 * Math.pow(85 - loc[2], 2));
core.drawImage(
'boom',
'boom.png',
x - 18,
h - 80,
36,
80
);
}
if (loc[2] == 85) {
core.drawAnimate(
'explosion1',
(x - 16) / 32,
(y - 16) / 32
);
boomLocs.splice(index, 1);
if (boomLocs.length == 0) core.deleteCanvas('boom');
// 伤害判定
var hx = core.status.hero.loc.x,
hy = core.status.hero.loc.y;
if (loc[0] == hx && loc[1] == hy) {
core.status.hero.hp -= 3000;
core.popupDamage(3000, hx, hy, false);
core.updateStatusBar();
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
clearInterval(boomAnimate);
flags.booming = false;
return;
}
}
}
});
}, 20);
};
// 直线型伤害判定
this.lineDamage = function (x1, y1, x2, y2, damage) {
// 获得勇士坐标
var x = core.status.hero.loc.x,
y = core.status.hero.loc.y;
// 是否可能碰到勇士
if (
(x1 < x * 32 - 12 && x2 < x * 32 - 12) ||
(x1 > x * 32 + 12 && x2 > x * 32 + 12) ||
(y1 < y * 32 - 16 && y2 < y * 32 - 16) ||
(y1 > y * 32 + 16 && y2 > y * 32 + 16)
)
return;
// 对角线的端点是否在直线异侧 勇士视为24 * 32
for (var time = 1; time <= 2; time++) {
// 左下右上
if (time == 1) {
var loc1 = [x * 32 - 12, y * 32 + 16],
loc2 = [x * 32 + 12, y * 32 - 16];
// 直线方程 y == (y2 - y1) / (x2 - x1) * (x - x1) + y1
var n1 =
((y2 - y1) / (x2 - x1)) * (loc1[0] - x1) +
y1 -
loc1[1],
n2 =
((y2 - y1) / (x2 - x1)) * (loc2[0] - x1) +
y1 -
loc2[1];
if (n1 * n2 <= 0) {
core.status.hero.hp -= damage;
core.popupDamage(damage, x, y, false);
core.updateStatusBar();
core.playSound('electron.mp3');
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
}
return;
}
} else {
// 左上右下
var loc1 = [x * 32 - 12, y * 32 - 16],
loc2 = [x * 32 + 12, y * 32 + 16];
// 直线方程 y == (y2 - y1) / (x2 - x1) * (x - x1) + y1
var n1 =
((y2 - y1) / (x2 - x1)) * (loc1[0] - x1) +
y1 -
loc1[1],
n2 =
((y2 - y1) / (x2 - x1)) * (loc2[0] - x1) +
y1 -
loc2[1];
if (n1 * n2 <= 0) {
core.status.hero.hp -= damage;
core.popupDamage(damage, x, y, false);
core.updateStatusBar();
core.playSound('electron.mp3');
if (core.status.hero.hp < 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
}
return;
}
}
}
};
},
weatherSuperimpose: function () {
// 天气叠加功能
////// 更改天气效果 //////
control.prototype.setWeather = function (type, level) {
// 非雨雪
if (type == null) {
Object.keys(core.control.weathers).forEach(one => {
core.deleteCanvas('weather' + one);
});
core.animateFrame.weather.type = [];
core.animateFrame.weather.nodes = {};
core.animateFrame.weather.level = {};
core.animateFrame.weather.time = {};
return;
}
if (!core.animateFrame.weather.level || level == null)
core.animateFrame.weather.level = {};
if (!core.animateFrame.weather.type)
core.animateFrame.weather.type = [];
level = core.clamp(parseInt(level) || 5, 1, 10);
// 当前天气：则忽略
if (
core.animateFrame.weather.type.includes(type) &&
level == core.animateFrame.weather.level[type]
)
return;
if (core.animateFrame.weather.nodes[type]) return;
// 计算当前的宽高
core.createCanvas(
'weather' + type,
0,
0,
core.__PIXELS__,
core.__PIXELS__,
80
);
core.animateFrame.weather.type.push(type);
core.animateFrame.weather.level[type] = level;
this._setWeather_createNodes(type, level);
};
control.prototype._setWeather_createNodes = function (type, level) {
var number =
level *
parseInt(
(20 * core.bigmap.width * core.bigmap.height) /
(core.__SIZE__ * core.__SIZE__)
);
if (!core.animateFrame.weather.nodes[type])
core.animateFrame.weather.nodes[type] = [];
switch (type) {
case 'rain':
for (var a = 0; a < number; a++) {
core.animateFrame.weather.nodes.rain.push({
x: Math.random() * core.bigmap.width * 32,
y: Math.random() * core.bigmap.height * 32,
l: Math.random() * 2.5,
xs: -4 + Math.random() * 4 + 2,
ys: Math.random() * 10 + 10
});
}
break;
case 'snow':
for (var a = 0; a < number; a++) {
core.animateFrame.weather.nodes.snow.push({
x: Math.random() * core.bigmap.width * 32,
y: Math.random() * core.bigmap.height * 32,
r: Math.random() * 5 + 1,
d: Math.random() * Math.min(level, 200)
});
}
break;
case 'fog':
if (core.animateFrame.weather.fog) {
core.animateFrame.weather.nodes[type] = [
{
level: number,
x: 0,
y: -core.__PIXELS__ / 2,
dx: -Math.random() * 1.5,
dy: Math.random(),
delta: 0.001
}
];
}
break;
case 'cloud':
if (core.animateFrame.weather.cloud) {
core.animateFrame.weather.nodes[type] = [
{
level: number,
x: 0,
y: -core.__PIXELS__ / 2,
dx: -Math.random() * 1.5,
dy: Math.random(),
delta: 0.001
}
];
}
break;
case 'sun':
if (core.animateFrame.weather.sun) {
// 直接绘制
core.clearMap('weather' + type);
core.setAlpha('weather' + type, level / 10);
core.drawImage(
'weather' + type,
core.animateFrame.weather.sun,
0,
0,
core.animateFrame.weather.sun.width,
core.animateFrame.weather.sun.height,
0,
0,
core.__PIXELS__,
core.__PIXELS__
);
core.setAlpha('weather' + type, 1);
}
break;
}
};
core.registerAnimationFrame('weather', true, timestamp => {
var weather = core.animateFrame.weather;
if (!weather.type) return;
weather.type.forEach(one => {
if (
timestamp - weather.time[one] <= 30 ||
!core.dymCanvas['weather' + one]
)
return;
core.control['_animationFrame_weather_' + one]();
weather.time[one] = timestamp;
});
});
// 雨
control.prototype._animationFrame_weather_rain = function () {
var ctx = core.dymCanvas.weatherrain,
ox = core.bigmap.offsetX,
oy = core.bigmap.offsetY;
core.clearMap('weatherrain');
ctx.strokeStyle = 'rgba(174,194,224,0.8)';
ctx.lineWidth = 1;
ctx.lineCap = 'round';
core.animateFrame.weather.nodes.rain.forEach(p => {
ctx.beginPath();
ctx.moveTo(p.x - ox, p.y - oy);
ctx.lineTo(p.x + p.l * p.xs - ox, p.y + p.l * p.ys - oy);
ctx.stroke();
p.x += p.xs;
p.y += p.ys;
if (
p.x > core.bigmap.width * 32 ||
p.y > core.bigmap.height * 32
) {
p.x = Math.random() * core.bigmap.width * 32;
p.y = -10;
}
});
ctx.fill();
};
// 雪
control.prototype._animationFrame_weather_snow = function () {
var ctx = core.dymCanvas.weathersnow,
ox = core.bigmap.offsetX,
oy = core.bigmap.offsetY;
core.clearMap('weathersnow');
ctx.fillStyle = 'rgba(255, 255, 255, 0.8)';
ctx.beginPath();
if (!core.animateFrame.weather.data)
core.animateFrame.weather.data = {};
core.animateFrame.weather.data.snow =
core.animateFrame.weather.data.snow || 0;
core.animateFrame.weather.data.snow += 0.01;
var angle = core.animateFrame.weather.data.snow;
core.animateFrame.weather.nodes.snow.forEach(p => {
ctx.moveTo(p.x - ox, p.y - oy);
ctx.arc(p.x - ox, p.y - oy, p.r, 0, Math.PI * 2, true);
// update
p.x += Math.sin(angle) * core.animateFrame.weather.level.snow;
p.y += Math.cos(angle + p.d) + 1 + p.r / 2;
if (
p.x > core.bigmap.width * 32 + 5 ||
p.x < -5 ||
p.y > core.bigmap.height * 32
) {
if (Math.random() > 1 / 3) {
p.x = Math.random() * core.bigmap.width * 32;
p.y = -10;
} else {
if (Math.sin(angle) > 0) p.x = -5;
else p.x = core.bigmap.width * 32 + 5;
p.y = Math.random() * core.bigmap.height * 32;
}
}
});
ctx.fill();
};
// 图片天气
control.prototype.__animateFrame_weather_image = function (
image,
type
) {
if (!image) return;
var node = core.animateFrame.weather.nodes[type][0];
core.setAlpha('weather' + type, node.level / 500);
var wind = 1.5;
var width = image.width,
height = image.height;
node.x += node.dx * wind;
node.y += (2 * node.dy - 1) * wind;
if (node.x + 3 * width <= core.__PIXELS__) {
node.x += 4 * width;
while (node.x > 0) node.x -= width;
}
node.dy += node.delta;
if (node.dy >= 1) {
node.delta = -0.001;
} else if (node.dy <= 0) {
node.delta = 0.001;
}
if (node.y + 3 * height <= core.__PIXELS__) {
node.y += 4 * height;
while (node.y > 0) node.y -= height;
} else if (node.y >= 0) {
node.y -= height;
}
for (var i = 0; i < 3; ++i) {
for (var j = 0; j < 3; ++j) {
if (
node.x + (i + 1) * width <= 0 ||
node.x + i * width >= core.__PIXELS__ ||
node.y + (j + 1) * height <= 0 ||
node.y + j * height >= core.__PIXELS__
)
continue;
core.drawImage(
'weather' + type,
image,
node.x + i * width,
node.y + j * height
);
}
}
core.setAlpha('weather' + type, 1);
};
// 雾
control.prototype._animationFrame_weather_fog = function () {
core.clearMap('weatherfog');
this.__animateFrame_weather_image(
core.animateFrame.weather.fog,
'fog'
);
};
// 云
control.prototype._animationFrame_weather_cloud = function () {
core.clearMap('weathercloud');
this.__animateFrame_weather_image(
core.animateFrame.weather.cloud,
'cloud'
);
};
},
popupDamage: function () {
// 伤害弹出
// 复写阻激夹域检测
control.prototype.checkBlock = function () {
var x = core.getHeroLoc('x'),
y = core.getHeroLoc('y'),
loc = x + ',' + y;
var damage = core.status.checkBlock.damage[loc];
if (damage) {
core.addPop(x * 32 + 12, y * 32 + 20, damage, '#f00', '#000');
core.status.hero.hp -= damage;
var text =
Object.keys(core.status.checkBlock.type[loc] || {}).join(
'，'
) || '伤害';
core.drawTip('受到' + text + damage + '点');
core.drawHeroAnimate('zone');
this._checkBlock_disableQuickShop();
core.status.hero.statistics.extraDamage += damage;
if (core.status.hero.hp <= 0) {
core.status.hero.hp = 0;
core.updateStatusBar();
core.events.lose();
return;
} else {
core.updateStatusBar();
}
}
this._checkBlock_ambush(core.status.checkBlock.ambush[loc]);
this._checkBlock_repulse(core.status.checkBlock.repulse[loc]);
};
},
equipBox: function () {
// 注：///// *** 裹起来的区域： 该区域内参数可以随意更改调整ui绘制 不会影响总体布局
// 请尽量修改该区域而不是其他区域 修改的时候最好可以对照现有ui修改
///// *** 道具类型
// cls对应name
var itemClsName = {
constants: '永久道具',
tools: '消耗道具'
};
// 一页最大放的道具数量 将把整个道具左栏分成num份 每份是一个道具项
var itemNum = 12;
///// ***
// 背景设置
this.drawBoxBackground = function (ctx) {
core.setTextAlign(ctx, 'left');
core.clearMap(ctx);
core.deleteCanvas('_selector');
var info = core.status.thisUIEventInfo || {};
///// *** 背景设置
var max = core.__PIXELS__;
var x = 2,
y = x,
w = max - x * 2,
h = w;
var borderWidth = 2,
borderRadius = 5, // radius:圆角矩形的圆角半径
borderStyle = '#fff';
var backgroundColor = 'gray';
// 设置背景不透明度(0.85)
var backgroundAlpha = 0.85;
///// ***
var start_x = x + borderWidth / 2,
start_y = y + borderWidth / 2,
width = max - start_x * 2,
height = max - start_y * 2;
// 渐变色背景的一个例子(黑色渐变白色)：
// 有关渐变色的具体知识请网上搜索canvas createGradient了解
var grd = ctx.createLinearGradient(x, y, x + w, y);
grd.addColorStop(0, '#555555');
grd.addColorStop(1, '#cccccc');
backgroundColor = grd;
// 使用图片背景要注释掉下面的strokeRect和fillRoundRect
// 图片背景的一个例子：
/*
core.drawImage(ctx, "xxx.png", x, y, w, h);
core.strokeRect(ctx, x, y, w, h, borderStyle, borderWidth);
*/
core.setAlpha(ctx, backgroundAlpha);
core.strokeRoundRect(
ctx,
x,
y,
w,
h,
borderRadius,
borderStyle,
borderWidth
);
core.fillRoundRect(
ctx,
start_x,
start_y,
width,
height,
borderRadius,
backgroundColor
);
core.setAlpha(ctx, 1);
///// *** 左栏配置
var leftbar_height = height;
// 左边栏宽度(width*0.6) 本身仅为坐标使用 需要与底下的rightbar_width(width*0.4)同时更改
var leftbar_width = width * 0.6;
///// ***
// xxx_right参数 代表最右侧坐标
var leftbar_right = start_x + leftbar_width - borderWidth / 2;
var leftbar_bottom = start_y + leftbar_height;
var leftbar_x = start_x;
var leftbar_y = start_y;
///// *** 道具栏配置
var boxName_color = '#fff';
var boxName_fontSize = 15;
var boxName_font = core.ui._buildFont(boxName_fontSize, true);
var arrow_x = 10 + start_x;
var arrow_y = 10 + start_y;
var arrow_width = 20;
var arrow_style = 'white';
// 暂时只能是1 否则不太行 等待新样板(2.7.3)之后对drawArrow做优化
var arrow_lineWidth = 1;
// 右箭头
var rightArrow_right = leftbar_right - 10;
// 道具内栏顶部坐标 本质是通过该项 控制(道具栏顶部文字和箭头)与道具内栏顶部的间隔
var itembar_top = arrow_y + 15;
///// ***
var itembar_right = rightArrow_right;
var boxName =
core.status.event.id == 'toolbox'
? '\r[yellow]道具栏\r | 装备栏'
: '道具栏 | \r[yellow]装备栏\r';
core.drawArrow(
ctx,
arrow_x + arrow_width,
arrow_y,
arrow_x,
arrow_y,
arrow_style,
arrow_lineWidth
);
core.drawArrow(
ctx,
rightArrow_right - arrow_width,
arrow_y,
rightArrow_right,
arrow_y,
arrow_style,
arrow_lineWidth
);
core.setTextAlign(ctx, 'center');
core.setTextBaseline(ctx, 'middle');
var changeBox = () => {
var id = core.status.event.id;
core.closePanel();
if (id == 'toolbox') core.openEquipbox();
else core.openToolbox();
};
core.fillText(
ctx,
boxName,
(leftbar_right + leftbar_x) / 2,
arrow_y + 2,
boxName_color,
boxName_font
);
///// *** 底栏按钮
var pageBtn_radius = 8;
// xxx_left 最左侧坐标
var pageBtn_left = leftbar_x + 3;
var pageBtn_right = leftbar_right - 3;
// xxx_bottom 最底部坐标
var pageBtn_bottom = leftbar_bottom - 2;
var pageBtn_borderStyle = '#fff';
var pageBtn_borderWidth = 2;
var pageText_color = '#fff';
// 底部按钮与上面的道具内栏的间隔大小
var bottomSpace = 8;
///// ***
core.drawItemListbox_setPageBtn(
ctx,
pageBtn_left,
pageBtn_right,
pageBtn_bottom,
pageBtn_radius,
pageBtn_borderStyle,
pageBtn_borderWidth
);
var page = info.page || 1;
var pageFontSize = pageBtn_radius * 2 - 4;
var pageFont = core.ui._buildFont(pageFontSize);
core.setPageItems(page);
var num = itemNum;
if (core.status.event.id == 'equipbox') num -= 5;
var maxPage = info.maxPage;
var pageText = page + ' / ' + maxPage;
core.setTextAlign(ctx, 'center');
core.setTextBaseline(ctx, 'bottom');
core.fillText(
ctx,
pageText,
(leftbar_x + leftbar_right) / 2,
pageBtn_bottom,
pageText_color,
pageFont
);
core.addUIEventListener(
start_x,
start_y,
leftbar_right - start_x,
arrow_y - start_y + 13,
changeBox
);
var itembar_height = Math.ceil(
pageBtn_bottom -
pageBtn_radius * 2 -
pageBtn_borderWidth / 2 -
bottomSpace -
itembar_top
);
var oneItemHeight = (itembar_height - 4) / itemNum;
return {
x: start_x,
y: start_y,
width: width,
height: height,
leftbar_right: leftbar_right,
obj: {
x: arrow_x,
y: itembar_top,
width: itembar_right - arrow_x,
height: itembar_height,
oneItemHeight: oneItemHeight
}
};
};
this.drawItemListbox = function (ctx, obj) {
ctx = ctx || core.canvas.ui;
var itembar_x = obj.x,
itembar_y = obj.y,
itembar_width = obj.width,
itembar_height = obj.height,
itemNum = obj.itemNum,
oneItemHeight = obj.oneItemHeight;
var itembar_right = itembar_x + itembar_width;
var info = core.status.thisUIEventInfo || {};
var obj = {};
var page = info.page || 1,
index = info.index,
select = info.select || {};
///// *** 道具栏内栏配置
var itembar_style = 'black';
var itembar_alpha = 0.7;
// 一个竖屏下减少道具显示的例子:
// if (core.domStyle.isVertical) itemNum = 10;
// 每个道具项的上下空隙占总高度的比例
var itembar_marginHeightRatio = 0.2;
// 左右间隔空隙
var item_marginLeft = 2;
var item_x = itembar_x + 2,
item_y = itembar_y + 2,
item_right = itembar_right - 2,
itemName_color = '#fff';
// 修改此项以更换闪烁光标
var item_selector = 'winskin.png';
///// ***
core.setAlpha(ctx, itembar_alpha);
core.fillRect(
ctx,
itembar_x,
itembar_y,
itembar_width,
itembar_height,
itembar_style
);
core.setAlpha(ctx, 1);
var pageItems = core.setPageItems(page);
var marginHeight = itembar_marginHeightRatio * oneItemHeight;
core.setTextBaseline(ctx, 'middle');
var originColor = itemName_color;
for (var i = 0; i < pageItems.length; i++) {
itemName_color = originColor;
var item = pageItems[i];
// 设置某个的字体颜色的一个例子
// if (item.id == "xxx") itemName_color = "green";
core.drawItemListbox_drawItem(
ctx,
item_x,
item_right,
item_y,
oneItemHeight,
item_marginLeft,
marginHeight,
itemName_color,
pageItems[i]
);
if (index == i + 1)
core.ui._drawWindowSelector(
item_selector,
item_x + 1,
item_y - 1,
item_right - item_x - 2,
oneItemHeight - 2
);
item_y += oneItemHeight;
}
};
this.drawToolboxRightbar = function (ctx, obj) {
ctx = ctx || core.canvas.ui;
var info = core.status.thisUIEventInfo || {};
var page = info.page || 1,
index = info.index || 1,
select = info.select || {};
var start_x = obj.x,
start_y = obj.y,
width = obj.width,
height = obj.height;
var toolboxRight = start_x + width,
toolboxBottom = start_y + height;
///// *** 侧边栏(rightbar)背景设置(物品介绍)
var rightbar_width = width * 0.4;
var rightbar_height = height;
var rightbar_lineWidth = 2;
var rightbar_lineStyle = '#fff';
///// ***
var rightbar_x =
toolboxRight - rightbar_width - rightbar_lineWidth / 2;
var rightbar_y = start_y;
core.drawLine(
ctx,
rightbar_x,
rightbar_y,
rightbar_x,
rightbar_y + rightbar_height,
rightbar_lineStyle,
rightbar_lineWidth
);
// 获取道具id(有可能为null)
var itemId = select.id;
var item = core.material.items[itemId];
///// *** 侧边栏物品Icon信息
var iconRect_y = rightbar_y + 10;
// space：间距
// 这里布局设定iconRect与侧边栏左边框 itemName与工具栏右边框 itemRect与itemName的间距均为space
var space = 15;
var iconRect_x = rightbar_x + space;
var iconRect_radius = 2,
iconRect_width = 32,
iconRect_height = 32,
iconRect_style = '#fff',
iconRect_lineWidth = 2;
///// ***
var iconRect_bottom = iconRect_y + iconRect_height,
iconRect_right = iconRect_x + iconRect_width;
///// *** 侧边栏各项信息
var itemTextFontSize = 15,
itemText_x = iconRect_x - 4,
itemText_y = Math.floor(start_y + rightbar_height * 0.25), // 坐标取整防止模糊
itemClsFontSize = 15,
itemClsFont = core.ui._buildFont(itemClsFontSize),
itemClsColor = '#fff',
itemCls_x = itemText_x - itemClsFontSize / 2,
itemCls_middle = (iconRect_bottom + itemText_y) / 2, //_middle代表文字的中心y坐标
itemNameFontSize = 18,
itemNameColor = '#fff',
itemNameFont = core.ui._buildFont(itemNameFontSize, true);
var itemName_x = iconRect_right + space;
var itemName_middle =
iconRect_y + iconRect_height / 2 + iconRect_lineWidth;
// 修改这里可以编辑未选中道具时的默认值
var defaultItem = {
cls: 'constants',
name: '未知道具',
text: '没有道具最永久'
};
var defaultEquip = {
cls: 'equips',
name: '未知装备',
text: '一无所有，又何尝不是一种装备',
equip: {
type: '装备'
}
};
///// ***
var originItem = item;
if (core.status.event.id == 'equipbox') item = item || defaultEquip;
item = item || defaultItem;
var itemCls = item.cls,
itemName = item.name,
itemText = item.text;
/* 一个根据道具id修改道具名字(右栏)的例子
* if (item.id == "xxx") itemNameColor = "red";
*/
var itemClsName = core.getItemClsName(item);
var itemNameMaxWidth =
rightbar_width -
iconRect_width -
iconRect_lineWidth * 2 -
space * 2;
core.strokeRoundRect(
ctx,
iconRect_x,
iconRect_y,
iconRect_width,
iconRect_height,
iconRect_radius,
iconRect_style,
iconRect_lineWidth
);
if (item.id)
core.drawIcon(
ctx,
item.id,
iconRect_x + iconRect_lineWidth / 2,
iconRect_y + iconRect_lineWidth / 2,
iconRect_width - iconRect_lineWidth,
iconRect_height - iconRect_lineWidth
);
core.setTextAlign(ctx, 'left');
core.setTextBaseline(ctx, 'middle');
core.fillText(
ctx,
itemName,
itemName_x,
itemName_middle,
itemNameColor,
itemNameFont,
itemNameMaxWidth
);
core.fillText(
ctx,
'【' + itemClsName + '】',
itemCls_x,
itemCls_middle,
itemClsColor,
itemClsFont
);
var statusText = '';
if (core.status.event.id == 'equipbox') {
var type = item.equip.type;
if (typeof type == 'string')
type = core.getEquipTypeByName(type);
var compare = core.compareEquipment(
item.id,
core.getEquip(type)
);
if (info.select.action == 'unload')
compare = core.compareEquipment(null, item.id);
// --- 变化值...
for (var name in core.status.hero) {
if (typeof core.status.hero[name] != 'number') continue;
var nowValue = core.getRealStatus(name);
// 查询新值
var newValue = Math.floor(
((core.getStatus(name) + (compare.value[name] || 0)) *
(core.getBuff(name) * 100 +
(compare.percentage[name] || 0))) /
100
);
if (nowValue == newValue) continue;
var color = newValue > nowValue ? '#00FF00' : '#FF0000';
nowValue = core.formatBigNumber(nowValue);
newValue = core.formatBigNumber(newValue);
statusText +=
core.getStatusLabel(name) +
' ' +
nowValue +
'->\r[' +
color +
']' +
newValue +
'\r\n';
}
}
itemText = statusText + itemText;
core.drawTextContent(ctx, itemText, {
left: itemText_x,
top: itemText_y,
bold: false,
color: 'white',
align: 'left',
fontSize: itemTextFontSize,
maxWidth:
rightbar_width -
(itemText_x - rightbar_x) * 2 +
itemTextFontSize / 2
});
///// *** 退出按钮设置
var btnRadius = 10;
var btnBorderWidth = 2;
var btnRight = toolboxRight - 2;
var btnBottom = toolboxBottom - 2;
var btnBorderStyle = '#fff';
///// ***
// 获取圆心位置
var btn_x = btnRight - btnRadius - btnBorderWidth / 2;
btn_y = btnBottom - btnRadius - btnBorderWidth / 2;
core.drawToolbox_setExitBtn(
ctx,
btn_x,
btn_y,
btnRadius,
btnBorderStyle,
btnBorderWidth
);
///// *** 使用按钮设置
var useBtnHeight = btnRadius * 2;
// 这里不设置useBtnWidth而是根据各项数据自动得出width
var useBtnRadius = useBtnHeight / 2;
var useBtn_x = rightbar_x + 4,
useBtn_y = btnBottom - useBtnHeight;
var useBtnBorderStyle = '#fff';
var useBtnBorderWidth = btnBorderWidth;
///// ***
core.drawToolbox_setUseBtn(
ctx,
useBtn_x,
useBtn_y,
useBtnRadius,
useBtnHeight,
useBtnBorderStyle,
useBtnBorderWidth
);
};
this.drawEquipbox_drawOthers = function (ctx, obj) {
var info = core.status.thisUIEventInfo;
///// *** 装备格设置
var equipList_lineWidth = 2;
var equipList_boxSize = 32;
var equipList_borderWidth = 2;
var equipList_borderStyle = '#fff';
var equipList_nameColor = '#fff';
///// ***
var equipList_x = obj.x + 4,
equipList_bottom = obj.obj.y - equipList_lineWidth,
equipList_y =
equipList_bottom - obj.obj.oneItemHeight * reduceItem - 2,
equipList_height = equipList_bottom - equipList_y;
var equipList_right = obj.leftbar_right,
equipList_width = equipList_right - equipList_x;
core.drawLine(
ctx,
obj.x,
equipList_bottom + equipList_lineWidth / 2,
equipList_right,
equipList_bottom + equipList_lineWidth / 2,
equipList_borderStyle,
equipList_lineWidth
);
var toDrawList = core.status.globalAttribute.equipName,
len = toDrawList.length;
///// *** 装备格设置
var maxItem = 4;
var box_width = 32,
box_height = 32,
box_borderStyle = '#fff',
box_selectBorderStyle = 'gold', // 选中的装备格的颜色
box_borderWidth = 2;
var boxName_fontSize = 14,
boxName_space = 2,
boxName_color = '#fff'; // 装备格名称与上面的装备格框的距离
var maxLine = Math.ceil(len / maxItem);
///// ***
var l = Math.sqrt(len);
if (Math.pow(l) == len && len != 4) {
if (l <= maxItem) maxItem = l;
}
maxItem = Math.min(toDrawList.length, maxItem);
info.equips = maxItem;
var boxName_font = core.ui._buildFont(boxName_fontSize);
// 总宽高减去所有装备格宽高得到空隙大小
var oneBoxWidth = box_width + box_borderWidth * 2;
var oneBoxHeight =
box_height +
boxName_fontSize +
boxName_space +
2 * box_borderWidth;
var space_y =
(equipList_height - maxLine * oneBoxHeight) / (1 + maxLine),
space_x =
(equipList_width - maxItem * oneBoxWidth) / (1 + maxItem);
var box_x = equipList_x + space_x,
box_y = equipList_y + space_y;
for (var i = 0; i < len; i++) {
var id = core.getEquip(i),
name = toDrawList[i];
var selectBorder = false;
if (core.status.thisUIEventInfo.select.type == i)
selectBorder = true;
var borderStyle = selectBorder
? box_selectBorderStyle
: box_borderStyle;
core.drawEquipbox_drawOne(
ctx,
name,
id,
box_x,
box_y,
box_width,
box_height,
boxName_space,
boxName_font,
boxName_color,
borderStyle,
box_borderWidth
);
var todo = new Function(
"core.clickOneEquipbox('" + id + "'," + i + ')'
);
core.addUIEventListener(
box_x - box_borderWidth / 2,
box_y - box_borderWidth / 2,
oneBoxWidth,
oneBoxHeight,
todo
);
box_x += space_x + oneBoxWidth;
if ((i + 1) % maxItem == 0) {
box_x = equipList_x + space_x;
box_y += space_y + oneBoxHeight;
}
}
};
this.drawToolbox = function (ctx) {
ctx = ctx || core.canvas.ui;
core.status.thisEventClickArea = [];
var info = core.drawBoxBackground(ctx);
info.itemNum = itemNum;
core.drawItemListbox(ctx, info.obj);
core.drawToolboxRightbar(ctx, info);
core.setTextBaseline(ctx, 'alphabetic');
core.setTextAlign('left');
};
var reduceItem = 4;
this.drawEquipbox = function (ctx) {
ctx = ctx || core.canvas.ui;
core.status.thisEventClickArea = [];
var info = core.drawBoxBackground(ctx);
info.itemNum = itemNum - reduceItem;
info.obj.y += info.obj.oneItemHeight * reduceItem;
info.obj.height -= info.obj.oneItemHeight * reduceItem;
core.drawItemListbox(ctx, info.obj);
core.drawEquipbox_drawOthers(ctx, info);
core.drawToolboxRightbar(ctx, info);
core.setTextBaseline(ctx, 'alphabetic');
core.setTextAlign('left');
};
this.drawEquipbox_drawOne = function (
ctx,
name,
id,
x,
y,
width,
height,
space,
font,
color,
style,
lineWidth
) {
if (id)
core.drawIcon(
ctx,
id,
x + lineWidth / 2,
y + lineWidth / 2,
width,
height
);
core.strokeRect(
ctx,
x,
y,
width + lineWidth,
height + lineWidth,
style,
lineWidth
);
core.setTextAlign(ctx, 'center');
core.setTextBaseline(ctx, 'top');
var tx = (x + x + lineWidth / 2 + width) / 2,
ty = y + height + (lineWidth / 2) * 3 + space;
core.fillText(ctx, name, tx, ty, color, font);
core.setTextBaseline(ctx, 'alphabetic');
core.setTextAlign('left');
};
this.drawItemListbox_drawItem = function (
ctx,
left,
right,
top,
height,
marginLeft,
marginHeight,
style,
id
) {
var info = core.status.thisUIEventInfo;
var nowClick = info.index;
var item = core.material.items[id] || {};
var name = item.name || '???';
var num = core.itemCount(id) || 0;
var fontSize = Math.floor(height - marginHeight * 2);
core.setTextAlign(ctx, 'right');
var numText = 'x' + num;
core.fillText(
ctx,
numText,
right - marginLeft,
top + height / 2,
style,
core.ui._buildFont(fontSize)
);
if (name != '???')
core.drawIcon(
ctx,
id,
left + marginLeft,
top + marginHeight,
fontSize,
fontSize
);
var text_x = left + marginLeft + fontSize + 2;
var maxWidth = right - core.calWidth(ctx, numText) - text_x;
core.setTextAlign(ctx, 'left');
core.fillText(
ctx,
name,
text_x,
top + height / 2,
style,
core.ui._buildFont(fontSize),
maxWidth
);
var todo = new Function(
"var id = '" + id + "';\ncore.clickItemFunc(id)"
);
core.addUIEventListener(left, top, right - left, height, todo);
};
this.setPageItems = function (page) {
var num = itemNum;
if (core.status.event.id == 'equipbox') num -= reduceItem;
var info = core.status.thisUIEventInfo;
if (!info) return;
page = page || info.page;
var items = core.getToolboxItems(
core.status.event.id == 'toolbox' ? 'all' : 'equips'
);
info.allItems = items;
var maxPage = Math.ceil(items.length / num);
info.maxPage = maxPage;
var pageItems = items.slice((page - 1) * num, page * num);
info.pageItems = pageItems;
info.maxItem = pageItems.length;
if (items.length == 0 && pageItems.length == 0) info.index = null;
if (pageItems.length == 0 && info.page > 1) {
info.page = Math.max(1, info.page - 1);
return core.setPageItems(info.page);
}
return pageItems;
};
this.drawToolbox_setExitBtn = function (
ctx,
x,
y,
r,
style,
lineWidth
) {
core.strokeCircle(ctx, x, y, r, style, lineWidth);
ctx.textAlign = 'center';
ctx.textBaseline = 'middle';
var textSize = Math.sqrt(2) * r;
core.fillText(
ctx,
'x',
x,
y,
style,
core.ui._buildFont(textSize),
textSize
);
core.setTextAlign(ctx, 'start');
core.setTextBaseline(ctx, 'top');
var todo = () => {
core.closePanel();
};
core.addUIEventListener(x - r, y - r, r * 2, r * 2, todo);
};
this.drawToolbox_setUseBtn = function (
ctx,
x,
y,
r,
h,
style,
lineWidth
) {
core.setTextAlign(ctx, 'left');
core.setTextBaseline(ctx, 'top');
var fontSize = h - 4;
var font = core.ui._buildFont(fontSize);
var text = core.status.event.id == 'toolbox' ? '使用' : '装备';
if (core.status.thisUIEventInfo.select.action == 'unload')
text = '卸下';
var w = core.calWidth(ctx, text, font) + 2 * r + lineWidth / 2;
core.strokeRoundRect(ctx, x, y, w, h, r, style, lineWidth);
core.fillText(ctx, text, x + r, y + lineWidth / 2 + 2, style, font);
var todo = () => {
core.useSelectItemInBox();
};
core.addUIEventListener(x, y, w, h, todo);
};
this.drawItemListbox_setPageBtn = function (
ctx,
left,
right,
bottom,
r,
style,
lineWidth
) {
var offset = lineWidth / 2 + r;
var x = left + offset;
var y = bottom - offset;
var pos = (Math.sqrt(2) / 2) * (r - lineWidth / 2);
core.fillPolygon(
ctx,
[
[x - pos, y],
[x + pos - 2, y - pos],
[x + pos - 2, y + pos]
],
style
);
core.strokeCircle(ctx, x, y, r, style, lineWidth);
var todo = () => {
core.addItemListboxPage(-1);
};
core.addUIEventListener(
x - r - 2,
y - r - 2,
r * 2 + 4,
r * 2 + 4,
todo
);
x = right - offset;
core.fillPolygon(
ctx,
[
[x + pos, y],
[x - pos + 2, y - pos],
[x - pos + 2, y + pos]
],
style
);
core.strokeCircle(ctx, x, y, r, style, lineWidth);
var todo = () => {
core.addItemListboxPage(1);
};
core.addUIEventListener(
x - r - 2,
y - r - 2,
r * 2 + 4,
r * 2 + 4,
todo
);
};
this.clickItemFunc = function (id) {
var info = core.status.thisUIEventInfo;
if (!info) return;
if (info.select.id == id) return core.useSelectItemInBox();
info.select = {};
info.select.id = id;
core.setIndexAndSelect('index');
core.refreshBox();
};
this.clickOneEquipbox = function (id, type) {
var info = core.status.thisUIEventInfo;
if (!info) return;
if (info.select.id == id && info.select.type == type)
core.useSelectItemInBox();
else
core.status.thisUIEventInfo.select = {
id: id,
type: type,
action: 'unload'
};
return core.refreshBox();
};
core.ui.getToolboxItems = function (cls) {
var list = Object.keys(core.status.hero.items[cls] || {});
if (cls == 'all') {
for (var name in core.status.hero.items) {
if (name == 'equips') continue;
list = list.concat(
Object.keys(core.status.hero.items[name])
);
}
return list
.filter(id => {
return !core.material.items[id].hideInToolbox;
})
.sort();
}
if (this.uidata.getToolboxItems) {
return this.uidata.getToolboxItems(cls);
}
return list
.filter(id => {
return !core.material.items[id].hideInToolbox;
})
.sort();
};
this.useSelectItemInBox = function () {
var info = core.status.thisUIEventInfo;
if (!info) return;
if (!info.select.id) return;
var id = info.select.id;
if (core.status.event.id == 'toolbox') {
core.events.tryUseItem(id);
// core.closePanel();
} else if (core.status.event.id == 'equipbox') {
var action = info.select.action || 'load';
info.index = 1;
if (action == 'load') {
var type = core.getEquipTypeById(id);
core.loadEquip(id, () => {
core.status.route.push('equip:' + id);
info.select.type = type;
core.setIndexAndSelect('select');
core.drawEquipbox();
});
} else {
var type = info.select.type;
core.unloadEquip(type, () => {
core.status.route.push('unEquip:' + type);
core.setIndexAndSelect('select');
core.drawEquipbox();
});
}
}
};
this.setIndexAndSelect = function (toChange) {
var info = core.status.thisUIEventInfo;
if (!info) return;
core.setPageItems(info.page);
var index = info.index || 1;
var items = info.pageItems;
if (info.select.type) {
var type = info.select.type;
id = core.getEquip(type);
info.index = null;
info.select = {
id: id,
action: 'unload',
type: type
};
return;
} else {
info.select.type = null;
}
if (toChange == 'index')
info.index = items.indexOf(info.select.id) + 1;
else {
var id = info.pageItems[index - 1];
info.select.id = id;
}
};
this.addItemListboxPage = function (num) {
var info = core.status.thisUIEventInfo;
if (!info) return;
var maxPage = info.maxPage || 1;
info.page = info.page || 1;
info.page += num;
if (info.page <= 0) info.page = maxPage;
if (info.page > maxPage) info.page = 1;
info.index = 1;
core.setPageItems(info.page);
core.setIndexAndSelect('select');
core.refreshBox();
};
this.addItemListboxIndex = function (num) {
var info = core.status.thisUIEventInfo;
if (!info) return;
var maxItem = info.maxItem || 0;
info.index = info.index || 0;
info.index += num;
if (info.index <= 0) info.index = 1;
if (info.index > maxItem) info.index = maxItem;
core.setIndexAndSelect('select');
core.refreshBox();
};
this.addEquipboxType = function (num) {
var info = core.status.thisUIEventInfo;
var type = info.select.type;
if (type == null && num > 0) info.select.type = 0;
else info.select.type = type + num;
var max = core.status.globalAttribute.equipName.length;
if (info.select.type >= max) {
info.select = {};
return core.addItemListboxPage(0);
} else {
var m = Math.abs(info.select.type);
if (info.select.type < 0) info.select.type = max - m;
core.refreshBox();
return;
}
};
core.actions._keyDownToolbox = function (keycode) {
if (!core.status.thisEventClickArea) return;
if (keycode == 37) {
// left
core.addItemListboxPage(-1);
return;
}
if (keycode == 38) {
// up
core.addItemListboxIndex(-1);
return;
}
if (keycode == 39) {
// right
core.addItemListboxPage(1);
return;
}
if (keycode == 40) {
// down
core.addItemListboxIndex(1);
return;
}
};
////// 工具栏界面时，放开某个键的操作 //////
core.actions._keyUpToolbox = function (keycode) {
if (keycode == 81) {
core.ui.closePanel();
if (core.isReplaying()) core.control._replay_equipbox();
else core.openEquipbox();
return;
}
if (keycode == 84 || keycode == 27 || keycode == 88) {
core.closePanel();
return;
}
if (keycode == 13 || keycode == 32 || keycode == 67) {
var info = core.status.thisUIEventInfo;
if (info.select) {
core.useSelectItemInBox();
}
return;
}
};
core.actions._keyDownEquipbox = function (keycode) {
if (!core.status.thisEventClickArea) return;
if (keycode == 37) {
// left
var info = core.status.thisUIEventInfo;
if (info.index != null) return core.addItemListboxPage(-1);
return core.addEquipboxType(-1);
}
if (keycode == 38) {
// up
var info = core.status.thisUIEventInfo;
if (info.index == 1) {
info.select.type =
core.status.globalAttribute.equipName.length - 1;
core.setIndexAndSelect();
return core.refreshBox();
}
if (info.index) return core.addItemListboxIndex(-1);
return core.addEquipboxType(-1 * info.equips);
}
if (keycode == 39) {
// right
var info = core.status.thisUIEventInfo;
if (info.index != null) return core.addItemListboxPage(1);
return core.addEquipboxType(1);
}
if (keycode == 40) {
// down
var info = core.status.thisUIEventInfo;
if (info.index) return core.addItemListboxIndex(1);
return core.addEquipboxType(info.equips);
}
};
core.actions._keyUpEquipbox = function (keycode, altKey) {
if (altKey && keycode >= 48 && keycode <= 57) {
core.items.quickSaveEquip(keycode - 48);
return;
}
if (keycode == 84) {
core.ui.closePanel();
if (core.isReplaying()) core.control._replay_toolbox();
else core.openToolbox();
return;
}
if (keycode == 81 || keycode == 27 || keycode == 88) {
core.closePanel();
return;
}
if (keycode == 13 || keycode == 32 || keycode == 67) {
var info = core.status.thisUIEventInfo;
if (info.select) core.useSelectItemInBox();
return;
}
};
core.registerAction(
'ondown',
'inEventClickAction',
(x, y, px, py) => {
if (!core.status.thisEventClickArea) return false;
// console.log(px + "," + py);
var info = core.status.thisEventClickArea;
for (var i = 0; i < info.length; i++) {
var obj = info[i];
if (
px >= obj.x &&
px <= obj.x + obj.width &&
py > obj.y &&
py < obj.y + obj.height
) {
if (obj.todo) obj.todo();
break;
}
}
return true;
},
51
);
core.registerAction(
'onclick',
'stopClick',
() => {
if (core.status.thisEventClickArea) return true;
},
51
);
this.addUIEventListener = function (x, y, width, height, todo) {
if (!core.status.thisEventClickArea) return;
var obj = {
x: x,
y: y,
width: width,
height: height,
todo: todo
};
core.status.thisEventClickArea.push(obj);
};
this.initThisEventInfo = function () {
core.status.thisUIEventInfo = {
page: 1,
select: {}
};
core.status.thisEventClickArea = [];
};
this.refreshBox = function () {
if (!core.status.event.id) return;
if (core.status.event.id == 'toolbox') core.drawToolbox();
else core.drawEquipbox();
};
core.ui.closePanel = function () {
if (core.status.hero && core.status.hero.flags) {
// 清除全部临时变量
Object.keys(core.status.hero.flags).forEach(name => {
if (name.startsWith('@temp@') || /^arg\d+$/.test(name)) {
delete core.status.hero.flags[name];
}
});
}
this.clearUI();
core.maps.generateGroundPattern();
core.updateStatusBar(true);
core.unlockControl();
core.status.event.data = null;
core.status.event.id = null;
core.status.event.selection = null;
core.status.event.ui = null;
core.status.event.interval = null;
core.status.thisUIEventInfo = null;
core.status.thisEventClickArea = null;
};
this.getItemClsName = function (item) {
if (item == null) return itemClsName;
if (item.cls == 'equips') {
if (typeof item.equip.type == 'string') return item.equip.type;
var type = core.getEquipTypeById(item.id);
return core.status.globalAttribute.equipName[type];
} else return itemClsName[item.cls] || item.cls;
};
core.events.openToolbox = function (fromUserAction) {
if (core.isReplaying()) return;
if (!this._checkStatus('toolbox', fromUserAction)) return;
core.initThisEventInfo();
core.drawToolbox();
};
core.events.openEquipbox = function (fromUserAction) {
if (core.isReplaying()) return;
if (!this._checkStatus('equipbox', fromUserAction)) return;
core.initThisEventInfo();
core.drawEquipbox();
};
core.control._replay_toolbox = function () {
if (!core.isPlaying() || !core.isReplaying()) return;
if (!core.status.replay.pausing)
return core.drawTip('请先暂停录像');
if (
core.isMoving() ||
core.status.replay.animate ||
core.status.event.id
)
return core.drawTip('请等待当前事件的处理结束');
core.lockControl();
core.status.event.id = 'toolbox';
core.drawToolbox();
};
core.control._replay_equipbox = function () {
if (!core.isPlaying() || !core.isReplaying()) return;
if (!core.status.replay.pausing)
return core.drawTip('请先暂停录像');
if (
core.isMoving() ||
core.status.replay.animate ||
core.status.event.id
)
return core.drawTip('请等待当前事件的处理结束');
core.lockControl();
core.status.event.id = 'equipbox';
core.drawEquipbox();
};
core.control._replayAction_item = function (action) {
if (action.indexOf('item:') != 0) return false;
var itemId = action.substring(5);
if (!core.canUseItem(itemId)) return false;
if (
core.material.items[itemId].hideInReplay ||
core.status.replay.speed == 24
) {
core.useItem(itemId, false, core.replay);
return true;
}
core.status.event.id = 'toolbox';
core.initThisEventInfo();
var info = core.status.thisUIEventInfo;
var items = core.getToolboxItems('all');
core.setPageItems(1);
var index = items.indexOf(itemId) + 1;
info.page = Math.ceil(index / info.maxItem);
info.index = index % info.maxItem || info.maxItem;
core.setIndexAndSelect('select');
core.setPageItems(info.page);
core.drawToolbox();
setTimeout(() => {
core.ui.closePanel();
core.useItem(itemId, false, core.replay);
}, core.control.__replay_getTimeout());
return true;
};
core.control._replayAction_equip = function (action) {
if (action.indexOf('equip:') != 0) return false;
var itemId = action.substring(6);
var items = core.getToolboxItems('equips');
var index = items.indexOf(itemId) + 1;
if (index < 1) return false;
core.status.route.push(action);
if (
core.material.items[itemId].hideInReplay ||
core.status.replay.speed == 24
) {
core.loadEquip(itemId, core.replay);
return true;
}
core.status.event.id = 'equipbox';
core.initThisEventInfo();
var info = core.status.thisUIEventInfo;
core.setPageItems(1);
info.page = Math.ceil(index / info.maxItem);
info.index = index % info.maxItem || info.maxItem;
core.setIndexAndSelect('select');
core.setPageItems(info.page);
core.drawEquipbox();
setTimeout(() => {
core.ui.closePanel();
core.loadEquip(itemId, core.replay);
}, core.control.__replay_getTimeout());
return true;
};
core.control._replayAction_unEquip = function (action) {
if (action.indexOf('unEquip:') != 0) return false;
var equipType = parseInt(action.substring(8));
if (!core.isset(equipType)) return false;
core.status.route.push(action);
if (core.status.replay.speed == 24) {
core.unloadEquip(equipType, core.replay);
return true;
}
core.status.event.id = 'equipbox';
core.initThisEventInfo();
var info = core.status.thisUIEventInfo;
core.setPageItems(1);
info.select.type = equipType;
core.setIndexAndSelect();
core.drawEquipbox();
setTimeout(() => {
core.ui.closePanel();
core.unloadEquip(equipType, core.replay);
}, core.control.__replay_getTimeout());
return true;
};
core.registerReplayAction('item', core.control._replayAction_item);
core.registerReplayAction('equip', core.control._replayAction_equip);
core.registerReplayAction(
'unEquip',
core.control._replayAction_unEquip
);
},
chase: function () {
// 山野追逐战
// 初始变量
// 视野路线 x, y, frame
var route = [
[10, 10, 0],
[0, 10, 100],
[0, 10, 200],
[49, 0, 500],
[49, 0, 550],
[45, 0, 640],
[40, 0, 760],
[40, 0, 820],
[41, 0, 850],
[37, 0, 950],
[31, 0, 1000],
[29, 0, 1020],
[29, 0, 1210],
[25, 0, 1270],
[12, 0, 1330],
[0, 0, 1470],
[0, 0, 2000],
[113, 0, 2500],
[109, 0, 2580],
[104, 0, 2600],
[104, 0, 2830],
[92, 0, 3000],
[84, 0, 3120],
[74, 0, 3300],
[65, 0, 3480],
[58, 0, 3600],
[47, 0, 3800],
[36, 0, 4000],
[0, 0, 4600]
];
// 效果函数
var funcs = [[0, wolfRun], [550, shake1], [10000000]];
var parrallels = [para1, para2]; // 并行脚本
var speed = 0; // 速度
var index = 0; // 当前要到达的索引
var fIndex = 0; // 函数索引
var frame = 0; // 帧数
var acc = 0; // 加速度
var currX = route[0][1] * 32; // 当前x轴
var inBlack = false;
var x = core.getHeroLoc('x');
var y = core.getHeroLoc('y'); // 勇士坐标
// 初始化，删除门和道具
this.initChase = function () {
speed = 0; // 速度
index = 0; // 当前要到达的索引
fIndex = 0; // 函数索引
frame = 0; // 帧数
acc = 0; // 加速度
currX = route[0][1] * 32; // 当前x轴
inBlack = false;
x = core.getHeroLoc('x');
y = core.getHeroLoc('y'); // 勇士坐标
// 循环删除
for (var i = 13; i < 16; i++) {
var floorId = 'MT' + i;
// 不可瞬移
core.status.maps[floorId].cannotMoveDirectly = true;
core.extractBlocks(floorId);
for (
var j = 0;
j < core.status.maps[floorId].blocks.length;
j++
) {
var block = core.status.maps[floorId].blocks[j];
var cls = block.event.cls,
id = block.event.id;
if (
(cls == 'animates' || cls == 'items') &&
!id.endsWith('Portal')
) {
core.removeBlock(block.x, block.y, floorId);
j--;
}
}
}
};
// 函数们
function wolfRun() {
core.moveBlock(
23,
17,
['down', 'down', 'down', 'down', 'down', 'down'],
80
);
setTimeout(() => {
core.setBlock(508, 23, 23);
core.moveBlock(
23,
23,
[
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left',
'left'
],
80,
true
);
}, 500);
}
// MT15函数1
function shake1() {
core.vibrate('vertical', 1000, 25, 2);
for (var tx = 53; tx < 58; tx++) {
for (var ty = 3; ty < 8; ty++) {
core.setBlock(336, tx, ty);
}
}
core.drawAnimate('explosion3', 55, 5);
core.drawAnimate('stone', 55, 5);
setTimeout(() => {
core.setBlock(336, 58, 9);
core.setBlock(336, 59, 9);
core.drawAnimate('explosion1', 58, 9);
core.drawAnimate('explosion1', 59, 9);
}, 250);
setTimeout(() => {
core.setBlock(336, 53, 8);
core.setBlock(336, 52, 8);
core.drawAnimate('explosion1', 53, 8);
core.drawAnimate('explosion1', 52, 8);
}, 360);
setTimeout(() => {
core.setBlock(336, 51, 7);
core.drawAnimate('explosion1', 51, 7);
}, 750);
setTimeout(() => {
core.vibrate('vertical', 6000, 25, 1);
core.setBlock(336, 47, 7);
core.setBlock(336, 49, 9);
core.drawAnimate('explosion1', 49, 9);
core.drawAnimate('explosion1', 47, 7);
}, 1000);
}
// 并行1
function para1() {
if (core.status.floorId != 'MT15') return;
if (x == 45 && y == 8 && !flags.p11) {
core.setBlock(336, 45, 9);
core.drawAnimate('explosion1', 45, 9);
flags.p11 = true;
}
if (x == 45 && y == 6 && !flags.p12) {
core.setBlock(336, 44, 6);
core.drawAnimate('explosion1', 44, 6);
flags.p12 = true;
}
if (x == 45 && y == 4 && !flags.p13) {
core.setBlock(336, 44, 4);
core.drawAnimate('explosion1', 44, 4);
core.drawAnimate('explosion1', 48, 6);
core.removeBlock(48, 6);
flags.p13 = true;
}
if (x == 41 && y == 3 && !flags.p14) {
core.setBlock(336, 41, 4);
core.setBlock(336, 32, 6);
core.drawAnimate('explosion1', 41, 4);
core.drawAnimate('explosion1', 32, 6);
flags.p14 = true;
}
if (x == 35 && y == 3 && !flags.p15) {
core.drawAnimate('explosion3', 37, 7);
core.vibrate('vertical', 1000, 25, 10);
for (var tx = 36; tx < 42; tx++) {
for (var ty = 4; ty < 11; ty++) {
core.setBlock(336, tx, ty);
}
}
flags.p15 = true;
}
if (x == 31 && y == 5 && !flags.p16) {
core.vibrate('vertical', 10000, 25, 1);
core.removeBlock(34, 8);
core.removeBlock(33, 8);
core.drawAnimate('explosion1', 34, 8);
core.drawAnimate('explosion1', 33, 8);
flags.p16 = true;
}
if (x == 33 && y == 7 && !flags.p17) {
core.setBlock(336, 32, 9);
core.drawAnimate('explosion1', 32, 9);
flags.p17 = true;
}
if ((x == 33 || x == 34 || x == 35) && y == 9 && !flags.p18) {
core.removeBlock(32, 9);
core.drawAnimate('explosion1', 32, 9);
flags.p18 = true;
}
if (x > 18 && x < 31 && y == 11 && !flags['p19' + x]) {
core.setBlock(336, x + 1, 11);
core.drawAnimate('explosion1', x + 1, 11);
flags['p19' + x] = true;
}
}
// 并行2
function para2() {
if (core.status.floorId != 'MT14') return;
if (x == 126 && y == 7 && !flags.p21) {
core.setBlock(336, 126, 6);
core.setBlock(336, 124, 6);
core.setBlock(336, 124, 9);
core.setBlock(336, 126, 9);
core.drawAnimate('explosion1', 126, 6);
core.drawAnimate('explosion1', 124, 6);
core.drawAnimate('explosion1', 124, 9);
core.drawAnimate('explosion1', 126, 9);
flags.p21 = true;
}
if (x == 123 && y == 7 && !flags.p22) {
core.setBlock(508, 127, 7);
core.jumpBlock(127, 7, 112, 7, 500, true);
setTimeout(() => {
core.setBlock(509, 112, 7);
}, 520);
core.drawHeroAnimate('amazed');
core.setBlock(336, 121, 6);
core.setBlock(336, 122, 6);
core.setBlock(336, 120, 8);
core.setBlock(336, 121, 8);
core.setBlock(336, 122, 8);
core.drawAnimate('explosion1', 121, 6);
core.drawAnimate('explosion1', 122, 6);
core.drawAnimate('explosion1', 120, 8);
core.drawAnimate('explosion1', 121, 8);
core.drawAnimate('explosion1', 122, 8);
flags.p22 = true;
}
if (x == 110 && y == 10 && !flags.p23) {
core.setBlock(336, 109, 11);
core.removeBlock(112, 8);
core.drawAnimate('explosion1', 109, 11);
core.drawAnimate('explosion1', 112, 8);
core.insertAction([
{ type: 'moveHero', time: 400, steps: ['backward:1'] }
]);
flags.p23 = true;
}
if (x == 112 && y == 8 && !flags.p24 && flags.p23) {
core.jumpBlock(112, 7, 110, 4, 500, true);
core.drawHeroAnimate('amazed');
setTimeout(() => {
core.setBlock(506, 110, 4);
}, 540);
flags.p24 = true;
}
if (x == 118 && y == 7 && !flags.p25) {
core.setBlock(336, 117, 6);
core.setBlock(336, 116, 6);
core.setBlock(336, 115, 6);
core.setBlock(336, 114, 6);
core.setBlock(336, 117, 8);
core.setBlock(336, 116, 8);
core.drawAnimate('explosion1', 117, 6);
core.drawAnimate('explosion1', 116, 6);
core.drawAnimate('explosion1', 115, 6);
core.drawAnimate('explosion1', 114, 6);
core.drawAnimate('explosion1', 116, 8);
core.drawAnimate('explosion1', 117, 8);
flags.p25 = true;
}
if (x == 112 && y == 7 && !flags.p26) {
core.setBlock(336, 112, 8);
core.setBlock(336, 113, 7);
core.drawAnimate('explosion1', 112, 8);
core.drawAnimate('explosion1', 113, 7);
flags.p26 = true;
}
if (x == 115 && y == 7 && !flags.p39) {
for (var tx = 111; tx <= 115; tx++) {
core.setBlock(336, tx, 10);
core.drawAnimate('explosion1', tx, 10);
}
core.setBlock(336, 112, 8);
core.drawAnimate('explosion1', 112, 8);
flags.p39 = true;
}
if (x == 110 && y == 7 && !flags.p27) {
core.jumpBlock(97, 4, 120, -3, 2000);
for (var tx = 109; tx <= 120; tx++) {
for (var ty = 3; ty <= 11; ty++) {
if (ty == 7) continue;
core.setBlock(336, tx, ty);
}
}
core.vibrate('vertical', 3000, 25, 10);
core.drawAnimate('explosion2', 119, 7);
core.insertAction([
{
type: 'autoText',
text: '\t[原始人]\b[down,hero]卧槽！！吓死我了！！',
time: 600
}
]);
core.removeBlock(105, 7);
core.drawAnimate('explosion1', 105, 7);
flags.p27 = true;
}
if (x == 97 && y == 3 && !flags.p28) {
core.setBlock(336, 95, 3);
core.setBlock(336, 93, 6);
core.drawAnimate('explosion1', 95, 3);
core.drawAnimate('explosion1', 93, 6);
flags.p28 = true;
}
if (x == 88 && y == 6 && !flags.p29) {
core.setBlock(336, 87, 4);
core.setBlock(336, 88, 5);
core.drawAnimate('explosion1', 87, 4);
core.drawAnimate('explosion1', 88, 5);
flags.p29 = true;
}
if (x == 86 && y == 6 && !flags.p30) {
core.setBlock(336, 84, 6);
core.setBlock(336, 85, 5);
core.setBlock(336, 86, 8);
core.drawAnimate('explosion1', 84, 6);
core.drawAnimate('explosion1', 85, 5);
core.drawAnimate('explosion1', 86, 8);
flags.p30 = true;
}
if (x == 81 && y == 9 && !flags.p31) {
core.setBlock(336, 81, 8);
core.setBlock(336, 82, 11);
core.drawAnimate('explosion1', 81, 8);
core.drawAnimate('explosion1', 82, 11);
flags.p31 = true;
}
if (x == 72 && y == 11 && !flags.p32) {
core.setBlock(336, 73, 8);
core.setBlock(336, 72, 4);
core.drawAnimate('explosion1', 73, 8);
core.drawAnimate('explosion1', 72, 4);
flags.p32 = true;
}
if (x == 72 && y == 7 && !flags.p33) {
for (var tx = 74; tx < 86; tx++) {
for (var ty = 3; ty < 12; ty++) {
core.setBlock(336, tx, ty);
}
}
core.drawAnimate('explosion2', 79, 7);
core.vibrate('vertical', 4000, 25, 15);
setTimeout(() => {
core.vibrate(10000, null, 4);
});
flags.p33 = true;
}
if (x == 68 && y == 5 && !flags.p34) {
core.setBlock(336, 68, 4);
core.setBlock(336, 67, 6);
core.drawAnimate('explosion1', 68, 4);
core.drawAnimate('explosion1', 67, 6);
flags.p34 = true;
}
if (x == 67 && y == 10 && !flags.p35) {
for (var tx = 65; tx <= 72; tx++) {
for (var ty = 3; ty <= 9; ty++) {
core.setBlock(336, tx, ty);
}
}
core.setBlock(336, 72, 10);
core.setBlock(336, 72, 11);
core.drawAnimate('explosion3', 69, 5);
core.vibrate('vertical', 2000, 25, 7);
flags.p35 = true;
}
if (x == 64 && y == 11 && !flags.p36) {
core.setBlock(336, 63, 9);
core.setBlock(336, 60, 8);
core.setBlock(336, 56, 11);
core.drawAnimate('explosion1', 63, 9);
core.drawAnimate('explosion1', 60, 8);
core.drawAnimate('explosion1', 56, 11);
flags.p36 = true;
}
if (x == 57 && y == 9 && !flags.p37) {
for (tx = 58; tx <= 64; tx++) {
for (var ty = 3; ty <= 11; ty++) {
core.setBlock(336, tx, ty);
}
}
core.drawAnimate('explosion2', 61, 7);
core.vibrate('vertical', 3000, 25, 12);
setTimeout(() => {
core.vibrate(20000, null, 4);
}, 3000);
flags.p37 = true;
}
if (x <= 48 && !flags['p38' + x] && x >= 21) {
for (var ty = 3; ty <= 11; ty++) {
core.setBlock(336, x + 4, ty);
core.drawAnimate('explosion1', x + 4, ty);
}
flags['p38' + x] = true;
}
if (x == 21 && flags.p37) {
core.endChase();
}
}
// 开始追逐
this.startChase = function () {
flags.__lockViewport__ = true;
flags.chase = true;
speed = 0; // 速度
index = 0; // 当前要到达的索引
fIndex = 0; // 函数索引
frame = 0; // 帧数
acc = 0; // 加速度
currX = route[0][1] * 32; // 当前x轴
inBlack = false;
x = core.getHeroLoc('x');
y = core.getHeroLoc('y'); // 勇士坐标
core.values.moveSpeed = 100;
core.loadOneSound('quake.mp3');
core.drawHero();
core.pauseBgm();
core.playBgm('escape.mp3', 43.5);
};
// 视野变化 useAcc:是否匀变速
this.changeChaseView = function (useAcc) {
if (flags.haveLost) return;
var floorId = core.status.floorId;
if (frame >= 3600) useAcc = false;
// 刚进MT15时
if (floorId === 'MT15' && !inBlack) {
frame = 500;
index = 3;
fIndex = 1;
speed = 0;
acc = 0;
currX = 32 * 49;
inBlack = true;
core.setGameCanvasTranslate('hero', 224, 0);
flags.startShake = true;
core.playSound('地震');
core.insertAction([{ type: 'sleep', time: 500, noSkip: true }]);
var interval = setInterval(() => {
core.playSound('地震');
if (index >= route.length - 1) clearInterval(interval);
}, 15000);
core.vibrate('vertical', 1000, 25);
setTimeout(() => {
core.blackEdge();
core.insertAction([
{
type: 'autoText',
text: '\t[原始人]\b[down,hero]糟糕，还地震了！',
time: 1500
},
{
type: 'autoText',
text: '\t[原始人]\b[down,hero]快跑！',
time: 1000
}
]);
flags.startShake = false;
}, 500);
}
// 超范围失败
if (x * 32 > currX + 480 + 64) {
flags.haveLost = true;
core.lose('逃跑失败');
return;
}
// 刚进MT14
if (floorId == 'MT14' && !flags.first14) {
frame = 2500;
index = 17;
fIndex = 2;
speed = 0;
acc = 0;
currX = 117 * 32;
core.vibrate('vertical', 10000, 25, 2);
core.setGameCanvasTranslate('hero', 224, 0);
flags.first14 = true;
}
// 停止运行
if (index >= route.length) return;
// 切换索引
if (frame > route[index][2]) {
index++;
if (index == 3 && floorId == 'MT16') {
core.lose('逃跑失败');
}
if (index >= route.length) {
return;
}
core.changeChaseIndex(useAcc);
}
// 碰到狼就死
if (floorId == 'MT16') {
if (x >= 6) {
if (x > 25 - (frame - 29) / 5) {
flags.haveLost = true;
core.lose('逃跑失败');
return;
}
}
}
// 执行函数
if (frame == funcs[fIndex][0]) {
funcs[fIndex][1]();
fIndex++;
}
// 并行
for (var i in parrallels) {
parrallels[i]();
}
if (useAcc) speed += acc;
currX += speed;
if (floorId == 'MT16') core.setViewport(currX, 320);
else core.setViewport(currX, 0);
x = core.getHeroLoc('x');
y = core.getHeroLoc('y');
frame++;
};
// 路线索引切换
this.changeChaseIndex = function (useAcc) {
var fromR = route[index - 1],
toR = route[index];
var dt = toR[2] - fromR[2],
dx = (toR[0] - fromR[0]) * 32;
if (dx == 0) {
acc = 0;
speed = 0;
}
if (useAcc) {
acc = (2 * (dx - speed * dt)) / (dt * dt);
} else {
speed = dx / dt;
}
};
// 黑边
this.blackEdge = function () {
core.createCanvas('edge', 0, 0, 480, 480, 100);
var f = 0;
var h = 0,
s = 2.56;
// 初始动画
function start() {
core.clearMap('edge');
core.fillRect('edge', 0, 0, 480, h);
core.fillRect('edge', 0, 480, 480, -h);
f++;
s -= 0.0512;
h += s;
if (f == 50) clearInterval(interval);
}
var interval = setInterval(start, 20);
};
// 结束追逐
this.endChase = function () {
flags.chase = false;
flags.__lockViewport__ = false;
core.autoFixRouteBoss(false);
// 黑边消失
clearInterval(interval);
var f = 0;
var h = 64,
s = 0;
var interval = setInterval(() => {
core.clearMap('edge');
core.fillRect('edge', 0, 0, 480, h);
core.fillRect('edge', 0, 480, 480, -h);
f++;
s += 0.0512;
h -= s;
if (f == 50) {
clearInterval(interval);
core.deleteCanvas('edge');
flags.finishChase = true;
}
});
};
},
hotReload: function () {
if (main.mode !== 'play' || main.replayChecking) return;
/**
* 发送请求
* @param {string} url
* @param {string} type
* @param {string} data
* @returns {Promise<string>}
*/
async function post(url, type, data) {
const xhr = new XMLHttpRequest();
xhr.open(type, url);
xhr.send(data);
const res = await new Promise(res => {
xhr.onload = e => {
if (xhr.status !== 200) {
console.error(`hot reload: http ${xhr.status}`);
res('@error');
} else res('success');
};
xhr.onerror = e => {
res('@error');
console.error(`hot reload: error on connection`);
};
});
if (res === 'success') return xhr.response;
else return '@error';
}
/**
* 热重载css
* @param {string} data
*/
function reloadCss(data) {
const all = Array.from(document.getElementsByTagName('link'));
all.forEach(v => {
if (v.rel !== 'stylesheet') return;
if (v.href === `http://127.0.0.1:3000/${data}`) {
v.remove();
const link = document.createElement('link');
link.rel = 'stylesheet';
link.type = 'text/css';
link.href = data;
document.head.appendChild(link);
console.log(`hot reload css: ${data}`);
}
});
}
/**
* 热重载楼层
* @param {string} data
*/
async function reloadFloor(data) {
// 首先重新加载main.floors对应的楼层
await import(`/project/floors/${data}.js?v=${Date.now()}`);
// 然后写入core.floors并解析
core.floors[data] = main.floors[data];
const floor = core.loadFloor(data);
if (core.isPlaying()) {
core.status.maps[data] = floor;
delete core.status.mapBlockObjs[data];
core.extractBlocks(data);
if (data === core.status.floorId) {
core.drawMap(data);
core.setWeather(
core.animateFrame.weather.type,
core.animateFrame.weather.level
);
}
core.updateStatusBar(true, true);
}
console.log(`hot reload floor: ${data}`);
}
/**
* 热重载脚本编辑及插件编写
* @param {string} data
*/
async function reloadScript(data) {
if (data === 'plugins') {
// 插件编写比较好办
const before = plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1;
// 这里不能用动态导入，因为动态导入会变成模块，变量就不是全局的了
const script = document.createElement('script');
script.src = `/project/plugins.js?v=${Date.now()}`;
document.body.appendChild(script);
await new Promise(res => {
script.onload = () => res('success');
});
const after = plugins_bb40132b_638b_4a9f_b028_d3fe47acc8d1;
// 找到差异的函数
for (const id in before) {
const fn = before[id];
if (typeof fn !== 'function') continue;
if (fn.toString() !== after[id]?.toString()) {
try {
core.plugin[id] = after[id];
core.plugin[id].call(core.plugin);
core.updateStatusBar(true, true);
console.log(`plugin hot reload: ${id}`);
} catch (e) {
console.error(e);
}
}
}
} else if (data === 'functions') {
// 脚本编辑略微麻烦点
const before = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a;
// 这里不能用动态导入，因为动态导入会变成模块，变量就不是全局的了
const script = document.createElement('script');
script.src = `/project/functions.js?v=${Date.now()}`;
document.body.appendChild(script);
await new Promise(res => {
script.onload = () => res('success');
});
const after = functions_d6ad677b_427a_4623_b50f_a445a3b0ef8a;
// 找到差异的函数
for (const mod in before) {
const fns = before[mod];
for (const id in fns) {
const fn = fns[id];
if (typeof fn !== 'function' || id === 'hasSpecial')
continue;
const now = after[mod][id];
if (fn.toString() !== now.toString()) {
try {
if (mod === 'events') {
core.events.eventdata[id] = now;
} else if (mod === 'enemys') {
core.enemys.enemydata[id] = now;
} else if (mod === 'actions') {
core.actions.actionsdata[id] = now;
} else if (mod === 'control') {
core.control.controldata[id] = now;
} else if (mod === 'ui') {
core.ui.uidata[id] = now;
}
core.updateStatusBar(true, true);
console.log(
`function hot reload: ${mod}.${id}`
);
} catch (e) {
console.error(e);
}
}
}
}
}
}
/**
* 属性热重载，包括全塔属性等
* @param {string} data
*/
async function reloadData(data) {
const script = document.createElement('script');
script.src = `/project/${data}.js?v=${Date.now()}`;
document.body.appendChild(script);
await new Promise(res => {
script.onload = () => res('success');
});
let after;
if (data === 'data')
after = data_a1e2fb4a_e986_4524_b0da_9b7ba7c0874d;
if (data === 'enemys')
after = enemys_fcae963b_31c9_42b4_b48c_bb48d09f3f80;
if (data === 'icons')
after = icons_4665ee12_3a1f_44a4_bea3_0fccba634dc1;
if (data === 'items')
after = items_296f5d02_12fd_4166_a7c1_b5e830c9ee3a;
if (data === 'maps')
after = maps_90f36752_8815_4be8_b32b_d7fad1d0542e;
if (data === 'events')
after = events_c12a15a8_c380_4b28_8144_256cba95f760;
if (data === 'enemys') {
core.enemys.enemys = after;
core.material.enemys = core.getEnemys();
} else if (data === 'icons') {
core.icons.icons = after;
core.material.icons = core.getIcons();
} else if (data === 'items') {
core.items.items = after;
core.material.items = core.getItems();
} else if (data === 'maps') {
core.maps.blocksInfo = after;
core.status.mapBlockObjs = {};
core.status.number2block = {};
Object.values(core.status.maps).forEach(v => delete v.blocks);
core.extractBlocks();
core.setWeather(
core.animateFrame.weather.type,
core.animateFrame.weather.level
);
core.drawMap();
} else if (data === 'events') {
core.events.commonEvent = after.commonEvent;
} else if (data === 'data') {
location.reload();
}
core.updateStatusBar(true, true);
console.log(`data hot reload: ${data}`);
}
// 初始化
(async function () {
const data = await post('/reload', 'POST', 'test');
if (data === '@error') {
console.log(`未检测到node服务，热重载插件将无法使用`);
} else {
console.log(`热重载插件加载成功`);
// reload
setInterval(async () => {
const res = await post('/reload', 'POST');
if (res === '@error') return;
if (res === 'true') location.reload();
else return;
}, 1000);
// hot reload
setInterval(async () => {
const res = await post('/hotReload', 'POST');
const data = res.split('@@');
data.forEach(v => {
if (v === '') return;
const [type, file] = v.split(':');
if (type === 'css') reloadCss(file);
if (type === 'data') reloadData(file);
if (type === 'floor') reloadFloor(file);
if (type === 'script') reloadScript(file);
});
}, 1000);
}
})();
},
hide: function () {
if (main.mode === 'editor' || main.replayChecking) return;
/**
* 所有的会被视为房间的墙
*/
const WALLS = [
'yellowWall',
'yellowDoor',
'blueDoor',
'redDoor',
'greenDoor'
];
/**
* 房间的最大大小
*/
const MAX_AREA = 25;
/**
* 要隐藏的点
*/
const HIDE_POS = [
['MT1', 2, 3],
['MT2', 4, 5],
['MT3', 7, 1]
];
let showed = {};
/// 初始化游戏
events.prototype.resetGame = function (
hero,
hard,
floorId,
maps,
values
) {
this.eventdata.resetGame(hero, hard, floorId, maps, values);
showed = core.getFlag('__showed__', {});
flags.__showed__ = flags.__showed__ ?? {};
hide();
};
/**
* 显示一个区域
* @param {string} floor
* @param {number} x
* @param {number} y
*/
this.showHidden = function (floor, x, y) {
const pos = bfs(floor, x, y);
for (const [x, y] of pos) {
core.setBgFgBlock('fg', 0, x, y, floor);
const id = `${floor}_${x}_${y}`;
showed[id] = true;
flags.__showed__[id] = true;
}
};
/**
* 隐藏
*/
function hide() {
for (const pos of HIDE_POS) {
const id = pos.join('_');
if (showed[id]) continue;
const p = bfs(...pos);
if (p.length >= MAX_AREA) continue;
for (const [x, y] of p) {
core.setBgFgBlock('fg', 4, x, y, pos[0]);
const id = `${pos[0]}_${x}_${y}`;
showed[id] = true;
flags.__showed__[id] = false;
}
}
}
/**
* @returns {[number, number][]}
*/
function bfs(floorId, x, y) {
core.extractBlocks(floorId);
const blocks = core.getMapBlocksObj(floorId);
const mapped = {
[`${x},${y}`]: true
};
const queue = [[x, y]];
/** @type {[direction, number, number][]} */
const dir = Object.entries(core.utils.scan).map(v => [
v[0],
v[1].x,
v[1].y
]);
const res = [[x, y]];
while (queue.length > 0) {
const [nx, ny] = queue.shift();
dir.forEach(v => {
const [tx, ty] = [nx + v[1], ny + v[2]];
const floor = core.status.maps[floorId];
if (
tx < 0 ||
ty < 0 ||
tx >= floor.width ||
ty >= floor.height
)
return;
const loc = `${tx},${ty}`;
if (mapped[loc]) return;
const block = blocks[loc];
mapped[loc] = true;
if (!block) {
queue.push([tx, ty]);
res.push([tx, ty]);
return;
}
if (WALLS.includes(block.event.id)) return;
queue.push([tx, ty]);
res.push([tx, ty]);
});
}
return res;
}
},
uiChange: function () {
ui.prototype.drawBook = function () {
return (core.plugin.bookOpened.value = true);
};
}
};
Reference in New Issue View Git Blame Copy Permalink