605 lines
16 KiB
TypeScript
605 lines
16 KiB
TypeScript
/*
|
|
* Copyright 2021 James Lyne
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import {DynmapMarkerSetUpdates, DynmapTileUpdate, DynmapUpdate} from "@/dynmap";
|
|
import {
|
|
LiveAtlasArea,
|
|
LiveAtlasChat,
|
|
LiveAtlasCircle,
|
|
LiveAtlasComponentConfig,
|
|
LiveAtlasDimension,
|
|
LiveAtlasLine,
|
|
LiveAtlasMarker, LiveAtlasPlayerImageSize,
|
|
LiveAtlasServerConfig,
|
|
LiveAtlasServerMessageConfig,
|
|
LiveAtlasWorldDefinition
|
|
} from "@/index";
|
|
import {getPoints} from "@/util/areas";
|
|
import {decodeHTMLEntities, endWorldNameRegex, netherWorldNameRegex, titleColoursRegex} from "@/util";
|
|
import {getLinePoints} from "@/util/lines";
|
|
import LiveAtlasMapDefinition from "@/model/LiveAtlasMapDefinition";
|
|
import {
|
|
Configuration,
|
|
Marker, MarkerArea, MarkerCircle, MarkerLine, MarkerSet,
|
|
Options,
|
|
WorldConfiguration,
|
|
WorldMapConfiguration
|
|
} from "dynmap";
|
|
import {PointTuple} from "leaflet";
|
|
|
|
export function buildServerConfig(response: Options): LiveAtlasServerConfig {
|
|
let title = 'Dynmap';
|
|
|
|
if(response.title) {
|
|
title = response.title.replace(titleColoursRegex, '') || title;
|
|
}
|
|
|
|
const followZoom = parseInt(response.followzoom || "", 10);
|
|
|
|
return {
|
|
defaultMap: response.defaultmap || undefined,
|
|
defaultWorld: response.defaultworld || undefined,
|
|
defaultZoom: response.defaultzoom || 0,
|
|
followMap: response.followmap || undefined,
|
|
followZoom: isNaN(followZoom) ? undefined : followZoom,
|
|
title: title,
|
|
expandUI: !!response.sidebaropened && response.sidebaropened !== 'false', //Sent as a string for some reason
|
|
};
|
|
}
|
|
|
|
export function buildMessagesConfig(response: Options): LiveAtlasServerMessageConfig {
|
|
return {
|
|
chatPlayerJoin: response.joinmessage || '',
|
|
chatPlayerQuit: response.quitmessage || '',
|
|
chatAnonymousJoin: response['msg-hiddennamejoin'] || '',
|
|
chatAnonymousQuit: response['msg-hiddennamequit'] || '',
|
|
chatErrorNotAllowed: response['msg-chatnotallowed'] || '',
|
|
chatErrorRequiresLogin: response['msg-chatrequireslogin'] || '',
|
|
chatErrorCooldown: response.spammessage || '',
|
|
worldsHeading: response['msg-maptypes'] || '',
|
|
playersHeading: response['msg-players'] ? `${response['msg-players']} ({cur}/{max})` : '',
|
|
}
|
|
}
|
|
|
|
export function buildWorlds(response: Configuration): Array<LiveAtlasWorldDefinition> {
|
|
const worlds: Map<string, LiveAtlasWorldDefinition> = new Map<string, LiveAtlasWorldDefinition>();
|
|
|
|
//Get all the worlds first so we can handle append_to_world properly
|
|
(response.worlds || []).forEach((world: WorldConfiguration) => {
|
|
let worldType: LiveAtlasDimension = 'overworld';
|
|
|
|
if (netherWorldNameRegex.test(world.name) || (world.name == 'DIM-1')) {
|
|
worldType = 'nether';
|
|
} else if (endWorldNameRegex.test(world.name) || (world.name == 'DIM1')) {
|
|
worldType = 'end';
|
|
}
|
|
|
|
worlds.set(world.name, {
|
|
name: world.name,
|
|
displayName: world.title || '',
|
|
dimension: worldType,
|
|
seaLevel: world.sealevel || 64,
|
|
center: {
|
|
x: world.center.x || 0,
|
|
y: world.center.y || 0,
|
|
z: world.center.z || 0
|
|
},
|
|
maps: new Map(),
|
|
});
|
|
});
|
|
|
|
(response.worlds || []).forEach((world: WorldConfiguration) => {
|
|
(world.maps || []).forEach((map: WorldMapConfiguration) => {
|
|
const actualWorld = worlds.get(world.name),
|
|
// @ts-ignore
|
|
assignedWorldName = map.append_to_world || world.name, //handle append_to_world
|
|
assignedWorld = worlds.get(assignedWorldName);
|
|
|
|
if (!assignedWorld || !actualWorld) {
|
|
console.warn(`Ignoring map '${map.name}' associated with non-existent world '${assignedWorldName}'`);
|
|
return;
|
|
}
|
|
|
|
assignedWorld.maps.set(map.name, Object.freeze(new LiveAtlasMapDefinition({
|
|
world: actualWorld, //Ignore append_to_world here for Dynmap URL parity
|
|
background: map.background || '#000000',
|
|
backgroundDay: map.backgroundday || '#000000',
|
|
backgroundNight: map.backgroundnight || '#000000',
|
|
icon: (map.icon || undefined) as string | undefined,
|
|
imageFormat: map['image-format'] || 'png',
|
|
name: map.name || '(Unnamed map)',
|
|
nightAndDay: map.nightandday || false,
|
|
prefix: map.prefix || '',
|
|
displayName: map.title || '',
|
|
mapToWorld: map.maptoworld || undefined,
|
|
worldToMap: map.worldtomap || undefined,
|
|
nativeZoomLevels: map.mapzoomout || 1,
|
|
extraZoomLevels: map.mapzoomin || 0
|
|
})));
|
|
});
|
|
});
|
|
|
|
return Array.from(worlds.values());
|
|
}
|
|
|
|
export function buildComponents(response: Configuration): LiveAtlasComponentConfig {
|
|
const components: LiveAtlasComponentConfig = {
|
|
markers: {
|
|
showLabels: false,
|
|
},
|
|
chatBox: undefined,
|
|
chatBalloons: false,
|
|
playerMarkers: undefined,
|
|
playerList: {
|
|
showImages: response.showplayerfacesinmenu || false,
|
|
},
|
|
coordinatesControl: undefined,
|
|
layerControl: !!response.showlayercontrol && response.showlayercontrol !== 'false', //Sent as a string for some reason
|
|
linkControl: false,
|
|
clockControl: undefined,
|
|
logoControls: [],
|
|
login: response['login-enabled'] || false,
|
|
};
|
|
|
|
(response.components || []).forEach((component: any) => {
|
|
const type = component.type || "unknown";
|
|
let imageSize: LiveAtlasPlayerImageSize = 'large';
|
|
|
|
switch (type) {
|
|
case "markers":
|
|
components.markers = {
|
|
showLabels: component.showlabel || false,
|
|
}
|
|
|
|
break;
|
|
|
|
case "playermarkers":
|
|
if(!component.showplayerfaces) {
|
|
imageSize = 'none';
|
|
} else if(component.smallplayerfaces) {
|
|
imageSize = 'small';
|
|
} else if(component.showplayerbody) {
|
|
imageSize = 'body';
|
|
}
|
|
|
|
components.playerMarkers = {
|
|
grayHiddenPlayers: response.grayplayerswhenhidden || false,
|
|
hideByDefault: component.hidebydefault || false,
|
|
layerName: component.label || "Players",
|
|
layerPriority: component.layerprio || 0,
|
|
imageSize,
|
|
showHealth: component.showplayerhealth || false,
|
|
showArmor: component.showplayerhealth || false,
|
|
showYaw: false,
|
|
}
|
|
|
|
break;
|
|
|
|
case "coord":
|
|
components.coordinatesControl = {
|
|
showY: !(component.hidey || false),
|
|
label: component.label || "Location: ",
|
|
showRegion: component['show-mcr'] || false,
|
|
showChunk: component['show-chunk'] || false,
|
|
}
|
|
|
|
break;
|
|
|
|
case "link":
|
|
components.linkControl = true;
|
|
|
|
break;
|
|
|
|
case "digitalclock":
|
|
components.clockControl = {
|
|
showDigitalClock: true,
|
|
showWeather: false,
|
|
showTimeOfDay: false,
|
|
}
|
|
break;
|
|
|
|
case "timeofdayclock":
|
|
components.clockControl = {
|
|
showTimeOfDay: true,
|
|
showDigitalClock: component.showdigitalclock || false,
|
|
showWeather: component.showweather || false,
|
|
}
|
|
break;
|
|
|
|
case "logo":
|
|
components.logoControls.push({
|
|
text: component.text || '',
|
|
url: component.linkurl || undefined,
|
|
position: component.position.replace('-', '') || 'topleft',
|
|
image: component.logourl || undefined,
|
|
});
|
|
break;
|
|
|
|
case "chat":
|
|
if (response.allowwebchat) {
|
|
components.chatSending = {
|
|
loginRequired: response['webchat-requires-login'] || false,
|
|
maxLength: response['chatlengthlimit'] || 256,
|
|
cooldown: response['webchat-interval'] || 5,
|
|
}
|
|
}
|
|
break;
|
|
|
|
case "chatbox":
|
|
components.chatBox = {
|
|
allowUrlName: component.allowurlname || false,
|
|
showPlayerFaces: component.showplayerfaces || false,
|
|
messageLifetime: component.messagettl || Infinity,
|
|
messageHistory: component.scrollback || Infinity,
|
|
}
|
|
break;
|
|
|
|
case "chatballoon":
|
|
components.chatBalloons = true;
|
|
}
|
|
});
|
|
|
|
return components;
|
|
}
|
|
|
|
export function buildMarkerSet(id: string, data: MarkerSet): any {
|
|
return {
|
|
id,
|
|
label: data.label || "Unnamed set",
|
|
hidden: data.hide || false,
|
|
priority: data.layerprio || 0,
|
|
showLabels: data.showlabels || undefined,
|
|
minZoom: typeof data.minzoom !== 'undefined' && data.minzoom > -1 ? data.minzoom : undefined,
|
|
maxZoom: typeof data.maxzoom !== 'undefined' && data.maxzoom > -1 ? data.maxzoom : undefined,
|
|
}
|
|
}
|
|
|
|
export function buildMarkers(data: any): Map<string, LiveAtlasMarker> {
|
|
const markers = Object.freeze(new Map()) as Map<string, LiveAtlasMarker>;
|
|
|
|
for (const key in data) {
|
|
if (!Object.prototype.hasOwnProperty.call(data, key)) {
|
|
continue;
|
|
}
|
|
|
|
markers.set(key, buildMarker(data[key]));
|
|
}
|
|
|
|
return markers;
|
|
}
|
|
|
|
export function buildMarker(data: Marker): LiveAtlasMarker {
|
|
let dimensions;
|
|
|
|
if(data.dim) {
|
|
dimensions = data.dim.split('x').slice(0, 2).map(value => parseInt(value));
|
|
|
|
if(dimensions.length !== 2) {
|
|
dimensions = undefined;
|
|
}
|
|
}
|
|
|
|
const marker = Object.seal({
|
|
label: data.label || '',
|
|
isLabelHTML: data.markup || false,
|
|
location: {
|
|
x: data.x || 0,
|
|
y: data.y || 0,
|
|
z: data.z || 0,
|
|
},
|
|
dimensions: (dimensions || [16, 16]) as PointTuple,
|
|
icon: data.icon || "default",
|
|
minZoom: typeof data.minzoom !== 'undefined' && data.minzoom > -1 ? data.minzoom : undefined,
|
|
maxZoom: typeof data.maxzoom !== 'undefined' && data.maxzoom > -1 ? data.maxzoom : undefined,
|
|
popupContent: data.desc || undefined,
|
|
});
|
|
|
|
//Fix double escaping on non-HTML labels
|
|
if(!marker.isLabelHTML) {
|
|
marker.label = decodeHTMLEntities(marker.label);
|
|
}
|
|
|
|
return marker;
|
|
}
|
|
|
|
export function buildAreas(data: any): Map<string, LiveAtlasArea> {
|
|
const areas = Object.freeze(new Map()) as Map<string, LiveAtlasArea>;
|
|
|
|
for (const key in data) {
|
|
if (!Object.prototype.hasOwnProperty.call(data, key)) {
|
|
continue;
|
|
}
|
|
|
|
areas.set(key, buildArea(data[key]));
|
|
}
|
|
|
|
return areas;
|
|
}
|
|
|
|
export function buildArea(area: MarkerArea): LiveAtlasArea {
|
|
const opacity = area.fillopacity || 0,
|
|
x = area.x || [0, 0],
|
|
y: [number, number] = [area.ybottom || 0, area.ytop || 0],
|
|
z = area.z || [0, 0];
|
|
|
|
return Object.seal({
|
|
style: {
|
|
color: area.color || '#ff0000',
|
|
opacity: area.opacity || 1,
|
|
weight: area.weight || 1,
|
|
fillColor: area.fillcolor || '#ff0000',
|
|
fillOpacity: area.fillopacity || 0,
|
|
},
|
|
outline: !opacity,
|
|
points: getPoints(x, y, z, !opacity),
|
|
minZoom: typeof area.minzoom !== 'undefined' && area.minzoom > -1 ? area.minzoom : undefined,
|
|
maxZoom: typeof area.maxzoom !== 'undefined' && area.maxzoom > -1 ? area.maxzoom : undefined,
|
|
|
|
isPopupHTML: area.desc ? true : area.markup || false,
|
|
popupContent: area.desc || area.label || undefined,
|
|
});
|
|
}
|
|
|
|
export function buildLines(data: any): Map<string, LiveAtlasLine> {
|
|
const lines = Object.freeze(new Map()) as Map<string, LiveAtlasLine>;
|
|
|
|
for (const key in data) {
|
|
if (!Object.prototype.hasOwnProperty.call(data, key)) {
|
|
continue;
|
|
}
|
|
|
|
lines.set(key, buildLine(data[key]));
|
|
}
|
|
|
|
return lines;
|
|
}
|
|
|
|
export function buildLine(line: MarkerLine): LiveAtlasLine {
|
|
return Object.seal({
|
|
style: {
|
|
color: line.color || '#ff0000',
|
|
opacity: line.opacity || 1,
|
|
weight: line.weight || 1,
|
|
},
|
|
points: getLinePoints(line.x || [0, 0], line.y || [0, 0], line.z || [0, 0]),
|
|
minZoom: typeof line.minzoom !== 'undefined' && line.minzoom > -1 ? line.minzoom : undefined,
|
|
maxZoom: typeof line.maxzoom !== 'undefined' && line.maxzoom > -1 ? line.maxzoom : undefined,
|
|
|
|
isPopupHTML: line.desc ? true : line.markup || false,
|
|
popupContent: line.desc || line.label || undefined,
|
|
});
|
|
}
|
|
|
|
export function buildCircles(data: any): Map<string, LiveAtlasCircle> {
|
|
const circles = Object.freeze(new Map()) as Map<string, LiveAtlasCircle>;
|
|
|
|
for (const key in data) {
|
|
if (!Object.prototype.hasOwnProperty.call(data, key)) {
|
|
continue;
|
|
}
|
|
|
|
circles.set(key, buildCircle(data[key]));
|
|
}
|
|
|
|
return circles;
|
|
}
|
|
|
|
export function buildCircle(circle: MarkerCircle): LiveAtlasCircle {
|
|
return Object.seal({
|
|
location: {
|
|
x: circle.x || 0,
|
|
y: circle.y || 0,
|
|
z: circle.z || 0,
|
|
},
|
|
radius: [circle.xr || 0, circle.zr || 0],
|
|
style: {
|
|
fillColor: circle.fillcolor || '#ff0000',
|
|
fillOpacity: circle.fillopacity || 0,
|
|
color: circle.color || '#ff0000',
|
|
opacity: circle.opacity || 1,
|
|
weight: circle.weight || 1,
|
|
},
|
|
minZoom: typeof circle.minzoom !== 'undefined' && circle.minzoom > -1 ? circle.minzoom : undefined,
|
|
maxZoom: typeof circle.maxzoom !== 'undefined' && circle.maxzoom > -1 ? circle.maxzoom : undefined,
|
|
|
|
isPopupHTML: circle.desc ? true : circle.markup || false,
|
|
popupContent: circle.desc || circle.label || undefined,
|
|
});
|
|
}
|
|
|
|
export function buildUpdates(data: Array<any>, lastUpdate: Date) {
|
|
const updates = {
|
|
markerSets: new Map<string, DynmapMarkerSetUpdates>(),
|
|
tiles: [] as DynmapTileUpdate[],
|
|
chat: [] as LiveAtlasChat[],
|
|
},
|
|
dropped = {
|
|
stale: 0,
|
|
noSet: 0,
|
|
noId: 0,
|
|
unknownType: 0,
|
|
unknownCType: 0,
|
|
incomplete: 0,
|
|
notImplemented: 0,
|
|
};
|
|
|
|
let accepted = 0;
|
|
|
|
for (const entry of data) {
|
|
switch (entry.type) {
|
|
case 'component': {
|
|
if (lastUpdate && entry.timestamp < lastUpdate) {
|
|
dropped.stale++;
|
|
continue;
|
|
}
|
|
|
|
if (!entry.id) {
|
|
dropped.noId++;
|
|
continue;
|
|
}
|
|
|
|
//Set updates don't have a set field, the id is the set
|
|
const set = entry.msg.startsWith("set") ? entry.id : entry.set;
|
|
|
|
if (!set) {
|
|
dropped.noSet++;
|
|
continue;
|
|
}
|
|
|
|
if (entry.ctype !== 'markers') {
|
|
dropped.unknownCType++;
|
|
continue;
|
|
}
|
|
|
|
if (!updates.markerSets.has(set)) {
|
|
updates.markerSets.set(set, {
|
|
areaUpdates: [],
|
|
markerUpdates: [],
|
|
lineUpdates: [],
|
|
circleUpdates: [],
|
|
removed: false,
|
|
});
|
|
}
|
|
|
|
const markerSetUpdates = updates.markerSets.get(set),
|
|
update: DynmapUpdate = {
|
|
id: entry.id,
|
|
removed: entry.msg.endsWith('deleted'),
|
|
};
|
|
|
|
if (entry.msg.startsWith("set")) {
|
|
markerSetUpdates!.removed = update.removed;
|
|
markerSetUpdates!.payload = update.removed ? undefined : buildMarkerSet(set, entry);
|
|
} else if (entry.msg.startsWith("marker")) {
|
|
update.payload = update.removed ? undefined : buildMarker(entry);
|
|
markerSetUpdates!.markerUpdates.push(Object.freeze(update));
|
|
} else if (entry.msg.startsWith("area")) {
|
|
update.payload = update.removed ? undefined : buildArea(entry);
|
|
markerSetUpdates!.areaUpdates.push(Object.freeze(update));
|
|
|
|
} else if (entry.msg.startsWith("circle")) {
|
|
update.payload = update.removed ? undefined : buildCircle(entry);
|
|
markerSetUpdates!.circleUpdates.push(Object.freeze(update));
|
|
|
|
} else if (entry.msg.startsWith("line")) {
|
|
update.payload = update.removed ? undefined : buildLine(entry);
|
|
markerSetUpdates!.lineUpdates.push(Object.freeze(update));
|
|
}
|
|
|
|
accepted++;
|
|
|
|
break;
|
|
}
|
|
|
|
case 'chat':
|
|
if (!entry.message || !entry.timestamp) {
|
|
dropped.incomplete++;
|
|
continue;
|
|
}
|
|
|
|
if (entry.timestamp < lastUpdate) {
|
|
dropped.stale++;
|
|
continue;
|
|
}
|
|
|
|
if (entry.source !== 'player' && entry.source !== 'web' && entry.source !== 'plugin') {
|
|
dropped.notImplemented++;
|
|
continue;
|
|
}
|
|
|
|
updates.chat.push({
|
|
type: 'chat',
|
|
source: entry.source || undefined,
|
|
playerAccount: entry.account || undefined,
|
|
playerName: entry.playerName || undefined,
|
|
message: entry.message || "",
|
|
timestamp: entry.timestamp,
|
|
channel: entry.channel || undefined,
|
|
});
|
|
break;
|
|
|
|
case 'playerjoin':
|
|
if (!entry.account || !entry.timestamp) {
|
|
dropped.incomplete++;
|
|
continue;
|
|
}
|
|
|
|
if (entry.timestamp < lastUpdate) {
|
|
dropped.stale++;
|
|
continue;
|
|
}
|
|
|
|
updates.chat.push({
|
|
type: 'playerjoin',
|
|
playerAccount: entry.account,
|
|
playerName: entry.playerName || "",
|
|
timestamp: entry.timestamp || undefined,
|
|
});
|
|
break;
|
|
|
|
case 'playerquit':
|
|
if (!entry.account || !entry.timestamp) {
|
|
dropped.incomplete++;
|
|
continue;
|
|
}
|
|
|
|
if (entry.timestamp < lastUpdate) {
|
|
dropped.stale++;
|
|
continue;
|
|
}
|
|
|
|
updates.chat.push({
|
|
type: 'playerleave',
|
|
playerAccount: entry.account,
|
|
playerName: entry.playerName || "",
|
|
timestamp: entry.timestamp || undefined,
|
|
});
|
|
break;
|
|
|
|
case 'tile':
|
|
if (!entry.name || !entry.timestamp) {
|
|
dropped.incomplete++;
|
|
continue;
|
|
}
|
|
|
|
if (lastUpdate && entry.timestamp < lastUpdate) {
|
|
dropped.stale++;
|
|
continue;
|
|
}
|
|
|
|
updates.tiles.push({
|
|
name: entry.name,
|
|
timestamp: entry.timestamp,
|
|
});
|
|
|
|
accepted++;
|
|
break;
|
|
|
|
default:
|
|
dropped.unknownType++;
|
|
}
|
|
}
|
|
|
|
//Sort chat by newest first
|
|
updates.chat = updates.chat.sort((one, two) => {
|
|
return two.timestamp - one.timestamp;
|
|
});
|
|
|
|
console.debug(`Updates: ${accepted} accepted. Rejected: `, dropped);
|
|
|
|
return updates;
|
|
}
|