From 1bc33546a044cbc84dd9595c19dbcd9a4e309fc9 Mon Sep 17 00:00:00 2001
From: vincentlu <t1341870251@gmail.com>
Date: 星期六, 10 一月 2026 14:06:10 +0800
Subject: [PATCH] #
---
zy-acs-flow/src/map/tool.js | 1213 ++++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 files changed, 1,147 insertions(+), 66 deletions(-)
diff --git a/zy-acs-flow/src/map/tool.js b/zy-acs-flow/src/map/tool.js
index 8cf5173..abc1b4f 100644
--- a/zy-acs-flow/src/map/tool.js
+++ b/zy-acs-flow/src/map/tool.js
@@ -1,75 +1,174 @@
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';
+// asr
+import ASREmptyNoBattery from '/map/asr/ASREmptyNoBattery.svg';
+import ASREmptyHalfBattery from '/map/asr/ASREmptyHalfBattery.svg';
+import ASREmptyFullBattery from '/map/asr/ASREmptyFullBattery.svg';
+import ASRLoadedNoBattery from '/map/asr/ASRLoadedNoBattery.svg';
+import ASRLoadedHalfBattery from '/map/asr/ASRLoadedHalfBattery.svg';
+import ASRLoadedFullBattery from '/map/asr/ASRLoadedFullBattery.svg';
-let app, mapContainer;
-
-export function setApp(param) {
- app = param;
-}
-
-export function setMapContainer(param) {
- mapContainer = param;
-}
+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 const getRealPosition = (x, y) => {
- const rect = app.view.getBoundingClientRect();
- return {
- mapX: (x - rect.left) / mapContainer.scale.x - mapContainer.x / mapContainer.scale.x,
- mapY: (y - rect.top) / mapContainer.scale.y - mapContainer.y / mapContainer.scale.y
+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 generateSprite = (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, agvModel) => {
let sprite;
switch (deviceType) {
case DEVICE_TYPE.SHELF:
- sprite = new PIXI.Sprite(PIXI.Texture.from(shelf, { resourceOptions: { scale: 5 } }));
- sprite.width = 50;
- sprite.height = 50;
+ 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.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: 5 } }));
- sprite.width = 112;
- sprite.height = 63;
+ 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.zIndex = DEVICE_Z_INDEX.AGV;
+
+ if (agvModel === 'HEAVY_LOAD_STACKING_ROBOT') {
+ sprite.scale.set(13, 11);
+ } else {
+ sprite.width = 750;
+ sprite.height = 1300;
+ }
+ 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) => {
@@ -80,59 +179,23 @@
sprite.alpha = 1;
}
-export const beMovable = (sprite) => {
- sprite.off('pointerup');
- sprite.off('pointermove');
- sprite.off('pointerdown');
- 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 spriteListBeMovable = (selectedSprites, endFn) => {
if (selectedSprites && selectedSprites.length > 0) {
let batchMove = false;
let batchMoveStartPos = null;
const batchMoving = (event) => {
- const scale = mapContainer.scale.x;
+ const scaleX = mapContainer.scale.x;
+ const scaleY = mapContainer.scale.y;
if (batchMove && batchMoveStartPos) {
// offset move val
var mouseMovement = {
- x: (event.global.x - batchMoveStartPos.x) / scale,
- y: (event.global.y - batchMoveStartPos.y) / scale
+ 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;
+ sprite.position.x = sprite.batchMoveStartPos.x - mouseMovement.x;
+ sprite.position.y = sprite.batchMoveStartPos.y - mouseMovement.y;
}
}
}
@@ -172,6 +235,17 @@
}
}
+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();
@@ -182,9 +256,417 @@
&& 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;
+ }
+ const data = sprite.data || (sprite.data = {});
+
+ if (data.rotationTween) {
+ data.rotationTween.stop();
+ data.rotationTween = null;
+ }
+ // 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;
+
+ const rotationTween = new TWEEDLE.Tween(sprite)
+ .to({ rotation: endRotation }, ANIMATE_DURING_TIME)
+ .easing(TWEEDLE.Easing.Linear.None)
+ .onUpdate(() => {
+ // agv
+ if (sprite.updateTextRotation) {
+ sprite.updateTextRotation();
+ }
+ })
+ .start();
+ data.rotationTween = rotationTween;
+ rotationTween.onComplete(() => {
+ if (data.rotationTween === rotationTween) {
+ data.rotationTween = null;
+ }
+ });
+};
+
+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) => {
@@ -193,4 +675,603 @@
parentElement.style.paddingLeft = param;
parentElement.style.paddingRight = param;
}
-}
\ No newline at end of file
+}
+
+// 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 = (agvModel, agvStatusMode) => {
+ if (!agvModel) {
+ console.error("failed to load agv model");
+ return;
+ }
+ if (agvModel === 'HEAVY_LOAD_STACKING_ROBOT') {
+ switch (agvStatusMode) {
+ case AGV_STATUS_MODE.EMPTY_NO_BATTERY:
+ return ASREmptyNoBattery;
+ case AGV_STATUS_MODE.EMPTY_HALF_BATTERY:
+ return ASREmptyHalfBattery;
+ case AGV_STATUS_MODE.EMPTY_FULL_BATTERY:
+ return ASREmptyFullBattery;
+ case AGV_STATUS_MODE.LOADED_NO_BATTERY:
+ return ASRLoadedNoBattery;
+ case AGV_STATUS_MODE.LOADED_HALF_BATTERY:
+ return ASRLoadedHalfBattery;
+ case AGV_STATUS_MODE.LOADED_FULL_BATTERY:
+ return ASRLoadedFullBattery;
+ default:
+ return;
+ }
+ } else {
+ 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, agvModel, 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(agvModel, agvStatusMode);
+ agvSprite = generateSprite(DEVICE_TYPE.AGV, agvTexture, agvModel);
+
+ initSprite(agvSprite, DEVICE_TYPE.AGV);
+
+ agvSprite.data.no = agvNo;
+ agvSprite.data.model = agvModel;
+ 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);
+ if (agvModel === 'HEAVY_LOAD_STACKING_ROBOT') {
+ agvText.position.set(0, 20);
+ }
+ agvText.scale.set(MAP_MIRROR ? -1 : 1, 1)
+ agvSprite.addChild(agvText);
+
+ agvSprite.updateTextRotation = () => {
+ if (agvText && agvSprite) {
+ agvText.rotation = -agvSprite.rotation - rotationParseNum(MAP_DEFAULT_ROTATION);
+ // agvText.rotation = -agvSprite.rotation - rotationParseNum(MAP_DEFAULT_ROTATION + 180);
+ }
+ };
+ 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);
+
+ if (agvSprite.data.moveTween) {
+ agvSprite.data.moveTween.stop();
+ agvSprite.data.moveTween = null;
+ }
+
+ const moveTween = new TWEEDLE.Tween(agvSprite.position)
+ .to({
+ x: codeSprite.position.x,
+ y: codeSprite.position.y
+ }, ANIMATE_DURING_TIME)
+ .easing(TWEEDLE.Easing.Linear.None)
+ .start();
+ agvSprite.data.moveTween = moveTween;
+ moveTween.onComplete(() => {
+ if (agvSprite.data?.moveTween === moveTween) {
+ agvSprite.data.moveTween = null;
+ }
+ });
+}
+
+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.moveTween) {
+ child.data.moveTween.stop();
+ child.data.moveTween = null;
+ }
+ if (child.data.rotationTween) {
+ child.data.rotationTween.stop();
+ child.data.rotationTween = null;
+ }
+ 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 };
+ if (setCurSprite) {
+ draft.cursor = 'pointer';
+ draft.eventMode = 'static';
+ }
+ 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();
+};
--
Gitblit v1.9.1