import * as PIXI from 'pixi.js';
|
import * as TWEEDLE from 'tweedle.js';
|
import {
|
MAP_DEFAULT_ROTATION,
|
MAP_MIRROR,
|
DEVICE_TYPE,
|
DEVICE_Z_INDEX,
|
AGV_STATUS_MODE,
|
DEVICE_SPRITE_TINT,
|
DEVICE_SPRITE_TINT_DARK,
|
DEVICE_SELECTED_EFFECT_PADDING,
|
DEVICE_SELECTED_EFFECT_COLOR,
|
POINT_ROUTE_DIRECTION,
|
ANIMATE_DURING_TIME,
|
AGV_ANGLE_OFFSET_VAL,
|
} from './constants';
|
import { getRouteList, fetchAreaList } from './http';
|
import PointRoute from "./PointRoute";
|
|
import shelf from '/map/shelf.svg';
|
import charge from '/map/charge.svg';
|
import station from '/map/station.svg';
|
import direction from '/map/direction.svg';
|
import point from '/map/point.svg';
|
// agv
|
import ctuEmptyNoBattery from '/map/agv/ctuEmptyNoBattery.svg';
|
import ctuEmptyHalfBattery from '/map/agv/ctuEmptyHalfBattery.svg';
|
import ctuEmptyFullBattery from '/map/agv/ctuEmptyFullBattery.svg';
|
import ctuLoadedNoBattery from '/map/agv/ctuLoadedNoBattery.svg';
|
import ctuLoadedHalfBattery from '/map/agv/ctuLoadedHalfBattery.svg';
|
import ctuLoadedFullBattery from '/map/agv/ctuLoadedFullBattery.svg';
|
|
let app, mapContainer, themeMode;
|
let selectedSprite, effectOverlay, effectTicker;
|
let tooltip;
|
|
export function getApp() {
|
return app;
|
}
|
|
export function setApp(param) {
|
app = param;
|
}
|
|
export function getMapContainer() {
|
return mapContainer;
|
}
|
|
export function setMapContainer(param) {
|
mapContainer = param;
|
}
|
|
export function getThemeMode() {
|
return themeMode;
|
}
|
|
export function setThemeMode(param) {
|
themeMode = param;
|
if (mapContainer) {
|
mapContainer.children.forEach(child => {
|
const deviceType = child.data?.type;
|
if (deviceType) {
|
if (themeMode === 'dark') {
|
DEVICE_SPRITE_TINT_DARK[deviceType] != null && (child.tint = DEVICE_SPRITE_TINT_DARK[deviceType]);
|
} else {
|
DEVICE_SPRITE_TINT[deviceType] != null && (child.tint = DEVICE_SPRITE_TINT[deviceType]);
|
}
|
}
|
})
|
}
|
}
|
|
|
export const getRealPosition = (x, y) => {
|
const globalPoint = new PIXI.Point();
|
app.renderer.plugins.interaction.mapPositionToPoint(globalPoint, x, y);
|
const mapPoint = mapContainer.toLocal(globalPoint);
|
return { mapX: mapPoint.x, mapY: mapPoint.y };
|
}
|
|
export const generateSprite = (deviceType, texture) => {
|
let sprite;
|
switch (deviceType) {
|
case DEVICE_TYPE.SHELF:
|
sprite = new PIXI.Sprite(PIXI.Texture.from(shelf, { resourceOptions: { scale: 1 } }));
|
// sprite.width = 50;
|
// sprite.height = 50;
|
sprite.zIndex = DEVICE_Z_INDEX.SHELF;
|
break;
|
case DEVICE_TYPE.CHARGE:
|
sprite = new PIXI.Sprite(PIXI.Texture.from(charge, { resourceOptions: { scale: 1 } }));
|
// sprite.width = 60;
|
// sprite.height = 60;
|
sprite.zIndex = DEVICE_Z_INDEX.CHARGE;
|
break;
|
case DEVICE_TYPE.STATION:
|
sprite = new PIXI.Sprite(PIXI.Texture.from(station, { resourceOptions: { scale: 1 } }));
|
// sprite.width = 112;
|
// sprite.height = 63;
|
sprite.zIndex = DEVICE_Z_INDEX.STATION;
|
break;
|
case DEVICE_TYPE.DIRECTION:
|
sprite = new PIXI.Sprite(PIXI.Texture.from(direction, { resourceOptions: { scale: 1 } }));
|
// sprite.width = 112;
|
// sprite.height = 63;
|
sprite.zIndex = DEVICE_Z_INDEX.DIRECTION;
|
break;
|
|
|
case DEVICE_TYPE.AGV:
|
if (texture) {
|
sprite = new PIXI.Sprite(PIXI.Texture.from(texture, { resourceOptions: { scale: 1 } }));
|
}
|
sprite.width = 750;
|
sprite.height = 1300;
|
sprite.zIndex = DEVICE_Z_INDEX.AGV;
|
break
|
case DEVICE_TYPE.POINT:
|
sprite = new PIXI.Sprite(PIXI.Texture.from(point, { resourceOptions: { scale: 1 } }));
|
// sprite.width = 112;
|
// sprite.height = 63;
|
sprite.zIndex = DEVICE_Z_INDEX.POINT;
|
break
|
default:
|
break;
|
}
|
const tintType = themeMode === 'dark' ? DEVICE_SPRITE_TINT_DARK : DEVICE_SPRITE_TINT;
|
tintType[deviceType] != null && (sprite.tint = tintType[deviceType]);
|
|
if (sprite && deviceType !== DEVICE_TYPE.AGV) {
|
sprite.blendMode = PIXI.BLEND_MODES.MULTIPLY;
|
}
|
return sprite;
|
}
|
|
export const initSprite = (sprite, type) => {
|
sprite.anchor.set(0.5);
|
// sprite.alpha = 1;
|
sprite.cursor = 'pointer';
|
sprite.eventMode = 'static';
|
sprite.data = {
|
type: type,
|
uuid: generateID()
|
};
|
}
|
|
export const querySprite = (type, no) => {
|
if (!mapContainer) {
|
return;
|
}
|
for (const sprite of mapContainer.children) {
|
if (sprite.data?.type === type && sprite.data?.no === no) {
|
return sprite;
|
}
|
}
|
}
|
|
export const findSpriteByUuid = (uuid) => {
|
return mapContainer?.children?.find(child => child?.data?.uuid === uuid);
|
}
|
|
export const markSprite = (sprite) => {
|
sprite.alpha = 0.5;
|
}
|
|
export const unMarkSprite = (sprite) => {
|
sprite.alpha = 1;
|
}
|
|
export const spriteListBeMovable = (selectedSprites, endFn) => {
|
if (selectedSprites && selectedSprites.length > 0) {
|
let batchMove = false;
|
let batchMoveStartPos = null;
|
|
const batchMoving = (event) => {
|
const scaleX = mapContainer.scale.x;
|
const scaleY = mapContainer.scale.y;
|
if (batchMove && batchMoveStartPos) {
|
// offset move val
|
var mouseMovement = {
|
x: (event.global.x - batchMoveStartPos.x) / scaleX,
|
y: (event.global.y - batchMoveStartPos.y) / scaleY
|
};
|
for (let sprite of selectedSprites) {
|
sprite.position.x = sprite.batchMoveStartPos.x - mouseMovement.x;
|
sprite.position.y = sprite.batchMoveStartPos.y - mouseMovement.y;
|
}
|
}
|
}
|
|
const batchMoveEnd = (event) => {
|
batchMove = false;
|
batchMoveStartPos = null;
|
selectedSprites.forEach(child => {
|
unMarkSprite(child);
|
})
|
selectedSprites = [];
|
mapContainer.parent.off('mousedown');
|
mapContainer.parent.off('mousemove');
|
mapContainer.parent.off('mouseup');
|
|
if (endFn) {
|
endFn();
|
}
|
}
|
|
const batchMoveStart = (event) => {
|
batchMoveStartPos = { x: event.data.global.clone().x, y: event.data.global.clone().y };
|
selectedSprites.forEach(child => {
|
child.batchMoveStartPos = { x: child.position.x, y: child.position.y };
|
})
|
|
batchMove = true;
|
mapContainer.parent.off('mousemove');
|
mapContainer.parent.on('mousemove', batchMoving);
|
|
mapContainer.parent.off('mouseup');
|
mapContainer.parent.on('mouseup', batchMoveEnd);
|
}
|
|
mapContainer.parent.off('mousedown')
|
mapContainer.parent.on('mousedown', batchMoveStart);
|
}
|
}
|
|
export const copySprite = (sprite) => {
|
const copiedSprite = generateSprite(sprite.data.type)
|
initSprite(copiedSprite);
|
copiedSprite.position.set(sprite.position.x, sprite.position.y);
|
copiedSprite.scale.set(sprite.scale.x, sprite.scale.y);
|
copiedSprite.rotation = sprite.rotation;
|
copiedSprite.data = deepCopy(sprite.data);
|
copiedSprite.data.uuid = generateID();
|
return copiedSprite;
|
}
|
|
export const isSpriteInSelectionBox = (sprite, selectionBox) => {
|
const spriteBounds = sprite.getBounds();
|
const boxBounds = selectionBox.getBounds();
|
|
return spriteBounds.x + spriteBounds.width > boxBounds.x
|
&& spriteBounds.x < boxBounds.x + boxBounds.width
|
&& spriteBounds.y + spriteBounds.height > boxBounds.y
|
&& spriteBounds.y < boxBounds.y + boxBounds.height;
|
}
|
|
export const beInsight = (sprite, setCurSprite) => {
|
if (!sprite?.data?.type) { return }
|
|
sprite.off('pointerup');
|
sprite.off('pointermove');
|
sprite.off('pointerdown');
|
sprite.off('pointerover');
|
sprite.off('pointerout');
|
sprite.off('click');
|
|
sprite.on("click", (event) => {
|
setCurSprite(sprite);
|
});
|
|
sprite.on('pointerover', onSpriteMouseOver);
|
sprite.on('pointermove', onSpriteMouseMove);
|
sprite.on('pointerout', onSpriteMouseOut);
|
}
|
|
export const beMovable = (sprite) => {
|
sprite.off('pointerup');
|
sprite.off('pointermove');
|
sprite.off('pointerdown');
|
sprite.off('pointerover');
|
sprite.off('pointerout');
|
sprite.off('click');
|
|
sprite.on("pointerdown", onDragStart);
|
|
let dragTarget;
|
function onDragStart(event) {
|
if (event.button === 0) {
|
dragTarget = event.currentTarget;
|
mapContainer.parent.off('pointermove');
|
mapContainer.parent.on('pointermove', onDragMove, dragTarget);
|
|
mapContainer.parent.off('pointerup');
|
mapContainer.parent.on('pointerup', onDragEnd.bind(mapContainer));
|
}
|
}
|
|
function onDragMove(event) {
|
if (this) {
|
this.parent.toLocal(event.global, null, this.position);
|
}
|
}
|
|
function onDragEnd() {
|
if (dragTarget) {
|
this.parent.off('pointermove');
|
this.parent.off('pointerup');
|
dragTarget.alpha = 1;
|
dragTarget = null;
|
}
|
}
|
|
}
|
|
export const beSettings = (sprite, setSpriteSettings) => {
|
if (!sprite?.data?.type) { return }
|
|
sprite.off('pointerup');
|
sprite.off('pointermove');
|
sprite.off('pointerdown');
|
sprite.off('pointerover');
|
sprite.off('pointerout');
|
sprite.off('click');
|
|
sprite.on("click", (event) => {
|
setSpriteSettings(sprite);
|
});
|
|
sprite.on('pointerover', onSpriteMouseOver);
|
sprite.on('pointermove', onSpriteMouseMove);
|
sprite.on('pointerout', onSpriteMouseOut);
|
}
|
|
const createSpriteTooltip = (sprite) => {
|
const style = new PIXI.TextStyle({
|
fontFamily: 'Roboto',
|
fontSize: 12,
|
fill: themeMode === 'light' ? '#000' : '#eee',
|
});
|
const text = new PIXI.Text(`${sprite.data?.type} ${sprite.data?.no}`, style);
|
const background = new PIXI.Graphics();
|
// shadow
|
background.beginFill(themeMode === 'light' ? '#000' : '#eee', 0.1);
|
background.drawRoundedRect(4, 4, text.width + 6, text.height + 6, 4);
|
background.endFill();
|
// background
|
background.beginFill(themeMode === 'light' ? '#fff' : '#333', 1);
|
background.drawRoundedRect(0, 0, text.width + 8, text.height + 8, 4);
|
background.endFill();
|
|
text.x = 5;
|
text.y = 3;
|
background.addChild(text);
|
tooltip = new PIXI.Container();
|
tooltip.name = "tooltip";
|
tooltip.addChild(background);
|
return tooltip;
|
}
|
|
function onSpriteMouseOver(event) {
|
if (tooltip) {
|
app?.stage.removeChild(tooltip);
|
}
|
tooltip = createSpriteTooltip(this);// this => sprite
|
tooltip.x = event.data.global.x + 10;
|
tooltip.y = event.data.global.y + 10;
|
app.stage.addChild(tooltip);
|
}
|
|
function onSpriteMouseMove(event) {
|
if (tooltip) {
|
tooltip.x = event.data.global.x + 10;
|
tooltip.y = event.data.global.y + 10;
|
}
|
}
|
|
function onSpriteMouseOut() {
|
if (tooltip && tooltip.parent) {
|
tooltip.parent?.removeChild(tooltip);
|
tooltip = null;
|
}
|
}
|
|
export const focusSprite = (sprite) => {
|
if (!sprite || !app || !mapContainer) {
|
return;
|
}
|
|
const focusScale = 0.1;
|
mapContainer.scale.set(MAP_MIRROR ? -focusScale : focusScale, focusScale);
|
mapContainer.position.set(0, 0);
|
|
let bounds = sprite.getBounds();
|
let focusPoint = {
|
x: bounds.x + bounds.width / 2,
|
y: bounds.y + bounds.height / 2
|
};
|
|
let targetPos = {
|
x: app.renderer.width / 4 - focusPoint.x,
|
y: app.renderer.height / 2 - focusPoint.y
|
};
|
|
new TWEEDLE.Tween(mapContainer.position)
|
.easing(TWEEDLE.Easing.Quadratic.Out)
|
.to(targetPos, 500)
|
.onComplete(() => {
|
})
|
.start();
|
}
|
|
export const findAreaSpriteById = (areaId) => {
|
if (!mapContainer || areaId == null) {
|
return null;
|
}
|
const targetId = String(areaId);
|
for (let i = 0; i < mapContainer.children.length; i += 1) {
|
const child = mapContainer.children[i];
|
if (child?.data?.type === DEVICE_TYPE.AREA && String(child.data?.id) === targetId) {
|
return child;
|
}
|
}
|
return null;
|
};
|
|
export const clearMapData = () => {
|
if (!mapContainer) {
|
return;
|
}
|
let childList = [];
|
mapContainer.children.forEach(child => {
|
if (child.data?.uuid) {
|
childList.push(child);
|
}
|
})
|
if (childList.length > 0) {
|
childList.forEach(child => {
|
mapContainer.removeChild(child);
|
child.destroy({ children: true, texture: false, baseTexture: false });
|
})
|
childList.forEach((child, index) => {
|
childList[index] = null;
|
});
|
childList = [];
|
}
|
}
|
|
export const showSelectedEffect = (sprite) => {
|
if (!sprite) {
|
return;
|
}
|
// area
|
if (sprite.data?.type === DEVICE_TYPE.AREA) {
|
const { start, end } = sprite.data || {};
|
const hasBounds = start && end;
|
const minX = hasBounds ? Math.min(start.x, end.x) : 0;
|
const maxX = hasBounds ? Math.max(start.x, end.x) : 0;
|
const minY = hasBounds ? Math.min(start.y, end.y) : 0;
|
const maxY = hasBounds ? Math.max(start.y, end.y) : 0;
|
const width = hasBounds ? Math.abs(maxX - minX) : Math.abs(sprite.width);
|
const height = hasBounds ? Math.abs(maxY - minY) : Math.abs(sprite.height);
|
const centerX = hasBounds ? (minX + maxX) / 2 : sprite.x;
|
const centerY = hasBounds ? (minY + maxY) / 2 : sprite.y;
|
const color = DEVICE_SELECTED_EFFECT_COLOR[DEVICE_TYPE.AREA] || (themeMode === 'light' ? '#747d8c' : '#718093');
|
const lineWidth = Math.max(2, 4 / Math.abs(mapContainer.scale.x || 1));
|
|
effectOverlay = new PIXI.Graphics();
|
effectOverlay.lineStyle(lineWidth, color, 1);
|
effectOverlay.drawRect(-width / 2, -height / 2, width, height);
|
effectOverlay.position.set(centerX, centerY);
|
effectOverlay.zIndex = sprite.zIndex + 1;
|
effectOverlay.blendMode = PIXI.BLEND_MODES.NORMAL;
|
mapContainer.addChild(effectOverlay);
|
|
selectedSprite = sprite;
|
effectTicker = null;
|
return;
|
}
|
|
// others
|
if (!sprite?.texture || !sprite?.texture?.valid) {
|
return;
|
}
|
|
const { width, height } = sprite;
|
const maxDimension = Math.max(width, height);
|
const radius = (maxDimension / 2) + (DEVICE_SELECTED_EFFECT_PADDING[sprite.data?.type] || 10);
|
|
let color;
|
const spriteEffectColor = DEVICE_SELECTED_EFFECT_COLOR[sprite.data?.type];
|
if (spriteEffectColor) {
|
color = spriteEffectColor;
|
} else {
|
color = themeMode === 'light' ? '#747d8c' : '#718093';
|
}
|
|
const alpha = 1;
|
|
effectOverlay = new PIXI.Graphics();
|
effectOverlay.beginFill(color, alpha);
|
effectOverlay.drawCircle(0, 0, radius);
|
effectOverlay.endFill();
|
effectOverlay.position.set(sprite.x, sprite.y);
|
effectOverlay.zIndex = -1;
|
effectOverlay.blendMode = PIXI.BLEND_MODES.NORMAL;
|
|
mapContainer.addChild(effectOverlay);
|
|
selectedSprite = sprite;
|
|
let pulseScale = 1;
|
let scalingUp = true;
|
effectTicker = (delta) => {
|
const pulseSpeed = 0.003 * delta;
|
if (scalingUp) {
|
pulseScale += pulseSpeed;
|
if (pulseScale >= 1.1) {
|
scalingUp = false;
|
}
|
} else {
|
pulseScale -= pulseSpeed;
|
if (pulseScale <= 1) {
|
scalingUp = true;
|
}
|
}
|
effectOverlay.scale.set(pulseScale);
|
effectOverlay.position.set(sprite.x, sprite.y);
|
};
|
|
app.ticker.add(effectTicker);
|
};
|
|
export const removeSelectedEffect = () => {
|
if (effectTicker) {
|
app.ticker.remove(effectTicker);
|
effectTicker = null;
|
}
|
if (effectOverlay) {
|
mapContainer?.removeChild(effectOverlay);
|
effectOverlay = null;
|
}
|
selectedSprite = null;
|
};
|
|
export const showRoutes = (curZone, setShowRoutes, setLoading) => {
|
setLoading(true);
|
getRouteList(
|
curZone,
|
(routeList) => {
|
routeList.forEach(route => {
|
const startPoint = querySprite(DEVICE_TYPE.POINT, route.startCodeStr);
|
const endPoint = querySprite(DEVICE_TYPE.POINT, route.endCodeStr);
|
const pointRoute = new PointRoute(POINT_ROUTE_DIRECTION[route.direction]);
|
pointRoute.setPoint(startPoint, endPoint);
|
pointRoute.clear();
|
pointRoute.lineStyle(Math.max(7, 2 * (1 / Math.abs(mapContainer.scale.x))), themeMode === 'light' ? '#ced6e0' : '#535c68');
|
pointRoute.moveTo(startPoint.position.x, startPoint.position.y);
|
pointRoute.lineTo(endPoint.position.x, endPoint.position.y);
|
pointRoute.alpha = 1;
|
mapContainer.addChild(pointRoute);
|
})
|
setLoading(false);
|
setShowRoutes(true);
|
},
|
() => {
|
setLoading(false);
|
},
|
)
|
};
|
|
export const hideRoutes = (curZone, setShowRoutes) => {
|
setShowRoutes(false);
|
for (let i = mapContainer.children.length - 1; i >= 0; i--) {
|
const child = mapContainer.children[i];
|
if (child?.type === DEVICE_TYPE.ROUTE) {
|
mapContainer.removeChild(child);
|
}
|
}
|
}
|
|
export const multipleSelectEnhancer = (selectedSprites, setCurSprite, setBatchSprites) => {
|
selectedSprites = selectedSprites.filter(sprite => sprite.data?.type);
|
|
if (selectedSprites.length === 1) {
|
unMarkSprite(selectedSprites[0]);
|
setCurSprite(selectedSprites[0]);
|
} else {
|
setBatchSprites(selectedSprites);
|
}
|
}
|
|
export const rotationToNum = (rotation) => {
|
let res = rotation * 180 / Math.PI;
|
if (res < 0) {
|
res += 360;
|
} else if (res > 360) {
|
res -= 360;
|
}
|
return res;
|
}
|
|
export const rotationParseNum = (num) => {
|
return num * (Math.PI / 180);
|
}
|
|
const animateRotation = (sprite, targetRotation, rotationOffset = 0) => {
|
if (!mapContainer || !sprite) {
|
return;
|
}
|
// origin
|
let currentRotation = sprite.rotation + rotationOffset;
|
// target
|
targetRotation += rotationOffset;
|
|
// diff
|
let rotationDifference = targetRotation - currentRotation;
|
if (rotationDifference === 0) {
|
return;
|
}
|
rotationDifference = ((rotationDifference + Math.PI) % (2 * Math.PI)) - Math.PI;
|
|
// destination
|
const endRotation = sprite.rotation + rotationDifference;
|
|
new TWEEDLE.Tween(sprite)
|
.to({ rotation: endRotation }, ANIMATE_DURING_TIME)
|
.easing(TWEEDLE.Easing.Linear.None)
|
.onUpdate(() => {
|
// agv
|
if (sprite.updateTextRotation) {
|
sprite.updateTextRotation();
|
}
|
})
|
.start();
|
};
|
|
export const incrementSpriteNo = (str, incrementValue) => {
|
const match = str.match(/(\D*)(\d+)/);
|
if (match) {
|
const prefix = match[1];
|
const numberPart = match[2];
|
const newNumber = parseInt(numberPart, 10) + incrementValue;
|
const paddedNumber = newNumber.toString().padStart(numberPart.length, '0');
|
return `${prefix}${paddedNumber}`;
|
} else {
|
return str;
|
}
|
}
|
|
export const generateID = () => {
|
return Date.now().toString(36) + Math.random().toString(36).substring(2);
|
}
|
|
export const deepCopy = (data) => {
|
return JSON.parse(JSON.stringify(data));
|
}
|
|
export const patchRaLayout = (param) => {
|
const parentElement = document.getElementById('main-content');
|
if (parentElement && parentElement.classList.contains('RaLayout-content')) {
|
parentElement.style.paddingLeft = param;
|
parentElement.style.paddingRight = param;
|
}
|
}
|
|
// service ------------------------
|
|
export const getAgvStatusMode = (backpack, battery) => {
|
if (backpack === 0) {
|
if (battery < 10) {
|
return AGV_STATUS_MODE.EMPTY_NO_BATTERY;
|
}
|
if (battery < 80) {
|
return AGV_STATUS_MODE.EMPTY_HALF_BATTERY;
|
}
|
return AGV_STATUS_MODE.EMPTY_FULL_BATTERY;
|
} else {
|
if (battery < 10) {
|
return AGV_STATUS_MODE.LOADED_NO_BATTERY;
|
}
|
if (battery < 80) {
|
return AGV_STATUS_MODE.LOADED_HALF_BATTERY;
|
}
|
return AGV_STATUS_MODE.LOADED_FULL_BATTERY;
|
}
|
}
|
|
export const generateAgvSpriteTexture = (agvStatusMode) => {
|
switch (agvStatusMode) {
|
case AGV_STATUS_MODE.EMPTY_NO_BATTERY:
|
return ctuEmptyNoBattery;
|
case AGV_STATUS_MODE.EMPTY_HALF_BATTERY:
|
return ctuEmptyHalfBattery;
|
case AGV_STATUS_MODE.EMPTY_FULL_BATTERY:
|
return ctuEmptyFullBattery;
|
case AGV_STATUS_MODE.LOADED_NO_BATTERY:
|
return ctuLoadedNoBattery;
|
case AGV_STATUS_MODE.LOADED_HALF_BATTERY:
|
return ctuLoadedHalfBattery;
|
case AGV_STATUS_MODE.LOADED_FULL_BATTERY:
|
return ctuLoadedFullBattery;
|
default:
|
return;
|
}
|
}
|
|
export function createAgvJobPanel(parentContainer, text) {
|
const panelScale = 4;
|
|
const panel = new PIXI.Container();
|
|
const sideLen = 50 * panelScale;
|
const halfCircle = new PIXI.Graphics();
|
halfCircle.beginFill(themeMode === 'light' ? '#333333' : '#eee');
|
halfCircle.lineStyle(2 * panelScale, themeMode === 'light' ? '#333333' : '#eee');
|
halfCircle.arc(0, 0, sideLen, 0, Math.PI);
|
halfCircle.endFill();
|
|
const rectangle = new PIXI.Graphics();
|
rectangle.lineStyle(2 * panelScale, themeMode === 'light' ? '#333333' : '#eee', .8);
|
rectangle.drawRoundedRect(
|
-sideLen / 2, // 左上角 x
|
-sideLen / 2, // 左上角 y
|
sideLen, // 宽
|
sideLen - (20 * panelScale), // 高 (留一点空间，看起来更像半圆容器)
|
16 * panelScale // 圆角
|
);
|
rectangle.endFill();
|
rectangle.mask = halfCircle;
|
|
panel.addChild(rectangle, halfCircle);
|
|
const msg = new PIXI.Text(text, {
|
fill: themeMode === 'light' ? '#2b2b2b' : '#eee',
|
fontSize: 12 * panelScale,
|
fontFamily: 'MicrosoftYaHei',
|
fontWeight: 'bolder',
|
align: 'center',
|
});
|
msg.anchor.set(0.5);
|
msg.position.set(0, -10 * panelScale);
|
|
panel.addChild(msg);
|
parentContainer.addChild(panel);
|
|
let phase = 0;
|
function onTick(delta) {
|
phase += delta / 6; // 旋转速度可调
|
phase %= (Math.PI * 2);
|
halfCircle.rotation = phase;
|
}
|
app.ticker.add(onTick);
|
|
panel._onTick = onTick;
|
return panel;
|
}
|
|
// dynamic graphic ----------------
|
|
export const generateDynamicGraphic = (curZone, data, setCurSprite) => {
|
for (const agvVo of data.agvVos) {
|
showAgvSprite(curZone, agvVo, setCurSprite);
|
drawerAgvPath(curZone, agvVo);
|
}
|
}
|
|
const agvRotationOffset = rotationParseNum(AGV_ANGLE_OFFSET_VAL);
|
|
const showAgvSprite = (curZone, agvVo, setCurSprite) => {
|
const { agvNo, code, direction, battery, jobType, backpack: backpackCount, slots, error } = agvVo;
|
if (!code) { return; }
|
const codeSprite = querySprite(DEVICE_TYPE.POINT, code);
|
if (!codeSprite) { return; }
|
|
const targetRotation = rotationParseNum(direction);
|
// const backpackCount = backpack?.filter(item => item.loaded === true).length || 0;
|
|
let agvSprite = querySprite(DEVICE_TYPE.AGV, agvNo);
|
if (!agvSprite) {
|
const agvStatusMode = getAgvStatusMode(backpackCount, battery);
|
const agvTexture = generateAgvSpriteTexture(agvStatusMode);
|
agvSprite = generateSprite(DEVICE_TYPE.AGV, agvTexture);
|
|
initSprite(agvSprite, DEVICE_TYPE.AGV);
|
|
agvSprite.data.no = agvNo;
|
agvSprite.data.backpackCount = backpackCount;
|
agvSprite.data.battery = battery;
|
|
agvSprite.position.set(codeSprite.position.x, codeSprite.position.y);
|
agvSprite.rotation = targetRotation + agvRotationOffset;
|
mapContainer.addChild(agvSprite);
|
|
// agvNo sprite
|
const agvText = new PIXI.Text(agvNo.toString(), {
|
fontSize: 50,
|
fill: 0x000000,
|
});
|
agvText.anchor.set(0.5, 0.5);
|
agvText.position.set(0, 8);
|
agvText.scale.set(MAP_MIRROR ? -1 : 1, 1)
|
agvSprite.addChild(agvText);
|
|
agvSprite.updateTextRotation = () => {
|
if (agvText && agvSprite) {
|
agvText.rotation = -agvSprite.rotation - rotationParseNum(MAP_DEFAULT_ROTATION);
|
}
|
};
|
agvSprite.updateTextRotation();
|
|
} else {
|
const prevBackpackCount = agvSprite.data.backpackCount;
|
const prevBattery = agvSprite.data.battery;
|
|
if (backpackCount !== prevBackpackCount || battery !== prevBattery) {
|
const agvStatusMode = getAgvStatusMode(backpackCount, battery);
|
const agvTexture = generateAgvSpriteTexture(agvStatusMode);
|
agvSprite.texture = PIXI.Texture.from(agvTexture, { resourceOptions: { scale: 1 } });
|
// update backpackCount and battery
|
agvSprite.data.backpackCount = backpackCount;
|
agvSprite.data.battery = battery;
|
}
|
|
animateRotation(agvSprite, targetRotation + agvRotationOffset, agvRotationOffset);
|
}
|
|
// job effect
|
if (jobType) {
|
if (!agvSprite.data.jobEffect) {
|
agvSprite.data.jobEffect = createAgvJobPanel(agvSprite, jobType + " (" + backpackCount + "/" + slots + ")");
|
agvSprite.data.jobEffect.x = -80;
|
agvSprite.data.jobEffect.y = 0;
|
}
|
if (agvSprite.data.jobEffect) {
|
agvSprite.data.jobEffect.rotation = -agvSprite.rotation - rotationParseNum(MAP_DEFAULT_ROTATION);
|
}
|
} else {
|
if (agvSprite.data.jobEffect) {
|
app.ticker.remove(agvSprite.data.jobEffect._onTick);
|
agvSprite.removeChild(agvSprite.data.jobEffect);
|
agvSprite.data.jobEffect.destroy(true);
|
agvSprite.data.jobEffect = null;
|
}
|
}
|
|
if (error) {
|
agvSprite.tint = 0xff3f34;
|
} else {
|
agvSprite.tint = themeMode === 'dark'
|
? DEVICE_SPRITE_TINT_DARK[DEVICE_TYPE.AGV]
|
: DEVICE_SPRITE_TINT[DEVICE_TYPE.AGV];
|
}
|
|
beInsight(agvSprite, setCurSprite);
|
|
new TWEEDLE.Tween(agvSprite.position)
|
.to({
|
x: codeSprite.position.x,
|
y: codeSprite.position.y
|
}, ANIMATE_DURING_TIME)
|
.easing(TWEEDLE.Easing.Linear.None)
|
.start();
|
}
|
|
const drawerAgvPath = (curZone, agvVo) => {
|
if (!mapContainer) {
|
return;
|
}
|
const { agvNo, code: curCode, dynamicRoute } = agvVo;
|
if (!dynamicRoute || dynamicRoute.indexOf(curCode) === -1) {
|
return;
|
}
|
|
const agvPathName = 'agvPath-' + agvNo;
|
let agvPath = mapContainer.getChildByName(agvPathName);
|
if (agvPath) {
|
mapContainer.removeChild(agvPath);
|
}
|
agvPath = new PIXI.Graphics();
|
agvPath.name = agvPathName;
|
agvPath.lineStyle(
|
Math.max(200, 4 * (1 / mapContainer?.scale.x || 1)),
|
themeMode === 'dark' ? 0x40739e : 0x2f68ac,
|
0.8,
|
);
|
agvPath.zIndex = DEVICE_Z_INDEX.DYNAMIC_ROUTE;
|
// agvPath.blendMode = PIXI.BLEND_MODES.NORMAL;
|
|
let firstNode = true;
|
for (let i = Math.max(0, dynamicRoute.indexOf(curCode)); i < dynamicRoute.length; i++) {
|
const node = dynamicRoute[i];
|
const codeSprite = querySprite(DEVICE_TYPE.POINT, node);
|
if (!codeSprite) { continue };
|
const { x, y } = codeSprite.position;
|
if (firstNode) {
|
agvPath.moveTo(x, y);
|
firstNode = false;
|
} else {
|
agvPath.lineTo(x, y);
|
}
|
}
|
|
mapContainer.addChild(agvPath);
|
}
|
|
export const removeAgvGraphics = () => {
|
if (!mapContainer) {
|
return;
|
}
|
for (let i = mapContainer.children.length - 1; i >= 0; i--) {
|
const child = mapContainer.children[i];
|
if (child?.data?.type === DEVICE_TYPE.AGV) {
|
if (child.data.jobEffect) {
|
app?.ticker.remove(child.data.jobEffect._onTick);
|
child.removeChild(child.data.jobEffect);
|
child.data.jobEffect.destroy(true);
|
child.data.jobEffect = null;
|
}
|
mapContainer.removeChild(child);
|
child.destroy({ children: true, texture: false, baseTexture: false });
|
} else if (child?.name?.startsWith('agvPath-')) {
|
mapContainer.removeChild(child);
|
child.destroy({ children: true, texture: false, baseTexture: false });
|
}
|
}
|
}
|
|
|
// area operator -------------------------------
|
|
let areaDrawingCleanup = null;
|
const AREA_COLOR = 0x3498db;
|
const AREA_BORDER_COLOR = 0x6c7a89;
|
|
const addAreaLabel = (draft, text, from, to) => {
|
const centerX = (from.x + to.x) / 2;
|
const centerY = (from.y + to.y) / 2;
|
const currentScale = Math.abs(mapContainer.scale.x || 1);
|
const labelStyle = new PIXI.TextStyle({
|
fontFamily: 'Inter, "Segoe UI", sans-serif',
|
fill: themeMode === 'dark' ? '#f1f2f6' : '#606060ff',
|
fontSize: Math.max(16, 20 / currentScale),
|
fontWeight: 600,
|
letterSpacing: 10,
|
// stroke: themeMode === 'dark' ? '#1e272e' : '#ffffff',
|
// strokeThickness: Math.max(1, 2 / currentScale),
|
// dropShadow: true,
|
// dropShadowColor: themeMode === 'dark' ? '#00000066' : '#95a5a6',
|
// dropShadowBlur: 1.5,
|
// dropShadowAngle: Math.PI / 4,
|
// dropShadowDistance: 2,
|
});
|
const label = new PIXI.Text(text ?? '', labelStyle);
|
label.anchor.set(0.5);
|
label.position.set(centerX, centerY);
|
label.rotation = rotationParseNum(MAP_DEFAULT_ROTATION);
|
label.scale.set(MAP_MIRROR ? -1 : 1, 1);
|
draft.addChild(label);
|
};
|
|
export const updateAreaSpriteName = (sprite, newName) => {
|
if (!sprite || sprite?.data?.type !== DEVICE_TYPE.AREA) {
|
return;
|
}
|
sprite.data.name = newName;
|
const label = sprite.children?.find((child) => child instanceof PIXI.Text);
|
if (label) {
|
label.text = newName ?? '';
|
}
|
};
|
|
export const removeAreaSprite = (sprite) => {
|
if (!sprite || sprite?.data?.type !== DEVICE_TYPE.AREA) {
|
return;
|
}
|
const parent = sprite.parent || mapContainer;
|
if (parent) {
|
parent.removeChild(sprite);
|
}
|
sprite.destroy({ children: true, texture: false, baseTexture: false });
|
};
|
|
export const loadAreas = (curZone, setCurSprite, callback) => {
|
if (!mapContainer) return;
|
clearAreas();
|
fetchAreaList(curZone).then((areas) => {
|
areas.forEach((area) => {
|
const { name, color, id } = area || {};
|
const start = area?.start;
|
const end = area?.end;
|
if (!start || !end || !name || !id) {
|
return;
|
}
|
const graphics = createAreaGraphic({ name, start, end, color, id }, setCurSprite);
|
if (graphics) {
|
mapContainer.addChild(graphics);
|
}
|
});
|
if (callback) {
|
callback(areas);
|
}
|
});
|
};
|
|
export const clearAreas = () => {
|
if (!mapContainer) return;
|
for (let i = mapContainer.children.length - 1; i >= 0; i--) {
|
const child = mapContainer.children[i];
|
if (child?.data?.type === DEVICE_TYPE.AREA) {
|
mapContainer.removeChild(child);
|
child.destroy({ children: true, texture: false, baseTexture: false });
|
}
|
}
|
};
|
|
const createAreaGraphic = ({ name, start, end, color, id }, setCurSprite) => {
|
if (!mapContainer) return null;
|
const from = start || { x: 0, y: 0 };
|
const to = end || { x: 0, y: 0 };
|
const areaColor = color || AREA_COLOR;
|
|
const draft = new PIXI.Graphics();
|
draft.name = id ? `area_${id}` : 'area_' + generateID();
|
draft.zIndex = 0;
|
if (setCurSprite) {
|
draft.zIndex = DEVICE_Z_INDEX.AREA;
|
}
|
draft.lineStyle(1 / Math.abs(mapContainer.scale.x || 1), AREA_BORDER_COLOR, 0.9);
|
draft.beginFill(areaColor, 0.18);
|
draft.drawRect(
|
Math.min(from.x, to.x),
|
Math.min(from.y, to.y),
|
Math.abs(from.x - to.x),
|
Math.abs(from.y - to.y),
|
);
|
draft.endFill();
|
addAreaLabel(draft, name, from, to);
|
draft.data = { ...(draft.data || {}), type: DEVICE_TYPE.AREA, name, color: areaColor, id, start: from, end: to };
|
draft.eventMode = 'static';
|
draft.cursor = 'pointer';
|
if (setCurSprite) {
|
draft.off('click');
|
draft.on('click', () => setCurSprite(draft));
|
}
|
return draft;
|
};
|
|
export const startAreaDrawing = ({ promptText, onComplete, onFinish, setCurSprite } = {}) => {
|
if (!mapContainer || !mapContainer.parent) {
|
return false;
|
}
|
if (areaDrawingCleanup) {
|
areaDrawingCleanup();
|
}
|
|
const stage = mapContainer.parent;
|
stage.off('mousedown');
|
const draft = new PIXI.Graphics();
|
draft.name = 'area_' + generateID();
|
draft.zIndex = DEVICE_Z_INDEX.AREA;
|
|
let drawing = false;
|
let startPoint = null;
|
const areaColor = AREA_COLOR;
|
const originalCursor = stage.cursor;
|
stage.cursor = 'crosshair';
|
|
const drawRect = (from, to) => {
|
draft.clear();
|
const strokeColor = areaColor;
|
draft.lineStyle(2 / Math.abs(mapContainer.scale.x || 1), AREA_BORDER_COLOR, 0.9);
|
draft.beginFill(strokeColor, 0.18);
|
draft.drawRect(
|
Math.min(from.x, to.x),
|
Math.min(from.y, to.y),
|
Math.abs(from.x - to.x),
|
Math.abs(from.y - to.y),
|
);
|
draft.endFill();
|
};
|
|
const cleanupListeners = () => {
|
stage.off('pointermove', handleMove);
|
stage.off('pointerup', handleUp);
|
stage.off('pointerdown', handleDown);
|
areaDrawingCleanup = null;
|
stage.cursor = originalCursor;
|
if (onFinish) {
|
onFinish();
|
}
|
};
|
areaDrawingCleanup = cleanupListeners;
|
|
const handleDown = (event) => {
|
if (event.button !== undefined && event.button !== 0) {
|
return;
|
}
|
drawing = true;
|
startPoint = mapContainer.toLocal(event.data.global);
|
mapContainer.addChild(draft);
|
};
|
|
const handleMove = (event) => {
|
if (!drawing || !startPoint) {
|
return;
|
}
|
const cur = mapContainer.toLocal(event.data.global);
|
drawRect(startPoint, cur);
|
};
|
|
const handleUp = (event) => {
|
if (!drawing || !startPoint) {
|
return;
|
}
|
drawing = false;
|
const endPoint = mapContainer.toLocal(event.data.global);
|
drawRect(startPoint, endPoint);
|
cleanupListeners();
|
|
const areaName = prompt(promptText || 'Please enter area name');
|
if (!areaName) {
|
mapContainer.removeChild(draft);
|
draft.destroy({ children: true, texture: false, baseTexture: false });
|
return;
|
}
|
|
addAreaLabel(draft, areaName, startPoint, endPoint);
|
draft.data = { ...(draft.data || {}), type: DEVICE_TYPE.AREA, name: areaName, color: areaColor, start: startPoint, end: endPoint };
|
draft.eventMode = 'static';
|
draft.cursor = 'pointer';
|
if (setCurSprite) {
|
draft.off('click');
|
draft.on('click', () => setCurSprite(draft));
|
}
|
|
if (onComplete) {
|
onComplete({
|
name: areaName,
|
start: startPoint,
|
end: endPoint,
|
color: areaColor,
|
graphics: draft
|
});
|
}
|
};
|
|
stage.on('pointerdown', handleDown);
|
stage.on('pointermove', handleMove);
|
stage.on('pointerup', handleUp);
|
return true;
|
};
|
|
export const cancelAreaDrawing = () => {
|
if (areaDrawingCleanup) {
|
areaDrawingCleanup();
|
}
|
};
|
|
export const showAreas = (curZone, setShowAreas, setLoading) => {
|
setLoading(true);
|
loadAreas(curZone, null, (areas) => {
|
setLoading(false);
|
setShowAreas(true);
|
})
|
};
|
|
export const hideAreas = (curZone, setShowAreas) => {
|
clearAreas();
|
setShowAreas(false);
|
};
|
|
export const focusAreaSprite = (sprite, rightPanelWidth) => {
|
if (!sprite || !app || !mapContainer) {
|
return;
|
}
|
|
const data = sprite.data || {};
|
const start = data.start;
|
const end = data.end;
|
const currentScale = Math.abs(mapContainer.scale.x || 1);
|
const boundsBefore = sprite.getBounds();
|
const width = start && end ? Math.abs(end.x - start.x) : boundsBefore.width / currentScale;
|
const height = start && end ? Math.abs(end.y - start.y) : boundsBefore.height / currentScale;
|
|
const paddedWidth = (width || 1000) * 1.25;
|
const paddedHeight = (height || 1000) * 1.25;
|
const viewportWidth = app.renderer.width || 1920;
|
const viewportHeight = app.renderer.height || 1080;
|
const effectiveViewportWidth = Math.max(1, viewportWidth - rightPanelWidth);
|
|
let focusScale = Math.min(
|
(effectiveViewportWidth * 0.65) / paddedWidth,
|
(viewportHeight * 0.65) / paddedHeight
|
);
|
focusScale = Math.min(Math.max(focusScale, 0.03), 0.25);
|
|
mapContainer.scale.set(MAP_MIRROR ? -focusScale : focusScale, focusScale);
|
mapContainer.position.set(0, 0);
|
|
const bounds = sprite.getBounds();
|
const centerX = bounds.x + bounds.width / 2;
|
const centerY = bounds.y + bounds.height / 2;
|
const visibleCenterX = (viewportWidth - rightPanelWidth) / 2;
|
|
const targetPos = {
|
x: visibleCenterX - centerX,
|
y: viewportHeight / 2 - centerY,
|
};
|
|
new TWEEDLE.Tween(mapContainer.position)
|
.easing(TWEEDLE.Easing.Quadratic.Out)
|
.to(targetPos, 500)
|
.start();
|
};
|
