drgame-cc 1.0.16 → 1.0.18

package/drscript/virtualgamepad/VirtualGamepadManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "596407cd-6484-4191-b3fa-85b15281cda5",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/drscript/virtualgamepad/VirtualGamepadView.ts

@@ -0,0 +1,346 @@
+import VirtualGamepadManager, { VirtualGamepadControlInput, VirtualGamepadMoveInput, VirtualGamepadStatus } from "./VirtualGamepadManager";
+
+const FIGHT_UI_OK_LONG_PRESS_SECONDS = 1.25;
+const VIRTUAL_GAMEPAD_TOP_Z_INDEX = cc.macro.MAX_ZINDEX;
+const VIRTUAL_GAMEPAD_PANEL_WIDTH = 420;
+const VIRTUAL_GAMEPAD_PANEL_HEIGHT = 450;
+const VIRTUAL_GAMEPAD_SUN_CODE_SIZE = 230;
+const VIRTUAL_GAMEPAD_BADGE_WIDTH = 230;
+const VIRTUAL_GAMEPAD_BADGE_HEIGHT = 48;
+
+export class VirtualGamepadView extends cc.Component {
+    private _virtualGamepadPanel: cc.Node | null = null;
+    private _virtualGamepadBadge: cc.Node | null = null;
+    private _virtualGamepadSunCodeSprite: cc.Sprite | null = null;
+    private _virtualGamepadSunCodeLoadingLabel: cc.Label | null = null;
+    private _virtualGamepadSunCodeSource: string = "";
+    private _virtualGamepadSunCodeLoading: string = "";
+    private _virtualGamepadSunCodeLoadSerial: number = 0;
+    private _virtualGamepadStatusLabel: cc.Label | null = null;
+    private _virtualGamepadRoomLabel: cc.Label | null = null;
+    private _virtualGamepadIdentityLabel: cc.Label | null = null;
+    private _virtualGamepadBadgeLabel: cc.Label | null = null;
+    private _virtualGamepadStatusHandler: ((status: VirtualGamepadStatus) => void) | null = null;
+    private _virtualGamepadMoveHandler: ((input: VirtualGamepadMoveInput) => void) | null = null;
+    private _virtualGamepadConfirmHandler: ((pressed: boolean, raw?: any) => void) | null = null;
+    private _virtualGamepadControlHandler: ((input: VirtualGamepadControlInput) => void) | null = null;
+    private _virtualGamepadButtonHandler: ((input: VirtualGamepadControlInput) => void) | null = null;
+    private _virtualGamepadBackHandler: ((input: VirtualGamepadControlInput) => void) | null = null;
+    private _virtualGamepadMoving: boolean = false;
+
+    protected onEnable(): void {
+        this.registerVirtualGamepadView();
+        this.registerVirtualGamepadInput();
+    }
+
+    protected onDisable(): void {
+        this.unregisterVirtualGamepadView();
+        this.unregisterVirtualGamepadInput();
+    }
+
+    private registerVirtualGamepadView() {
+        this.ensureVirtualGamepadNodes();
+        if (!this._virtualGamepadStatusHandler) {
+            this._virtualGamepadStatusHandler = (status: VirtualGamepadStatus) => this.refreshVirtualGamepadView(status);
+            VirtualGamepadManager.getInstance().onStatus(this._virtualGamepadStatusHandler);
+        }
+        VirtualGamepadManager.getInstance().start();
+        this.refreshVirtualGamepadView(VirtualGamepadManager.getInstance().getStatus());
+    }
+
+    private unregisterVirtualGamepadView() {
+        if (this._virtualGamepadStatusHandler) {
+            VirtualGamepadManager.getInstance().offStatus(this._virtualGamepadStatusHandler);
+            this._virtualGamepadStatusHandler = null;
+        }
+        VirtualGamepadManager.getInstance().setGameState("ended");
+        VirtualGamepadManager.getInstance().stop();
+        if (this._virtualGamepadPanel && this._virtualGamepadPanel.isValid) {
+            this._virtualGamepadPanel.destroy();
+        }
+        if (this._virtualGamepadBadge && this._virtualGamepadBadge.isValid) {
+            this._virtualGamepadBadge.destroy();
+        }
+        this._virtualGamepadPanel = null;
+        this._virtualGamepadBadge = null;
+        this._virtualGamepadSunCodeSprite = null;
+        this._virtualGamepadSunCodeLoadingLabel = null;
+        this._virtualGamepadSunCodeSource = "";
+        this._virtualGamepadSunCodeLoading = "";
+        this._virtualGamepadSunCodeLoadSerial++;
+        this._virtualGamepadStatusLabel = null;
+        this._virtualGamepadRoomLabel = null;
+        this._virtualGamepadIdentityLabel = null;
+        this._virtualGamepadBadgeLabel = null;
+    }
+
+    private registerVirtualGamepadInput() {
+        // if (!this._virtualGamepadMoveHandler) {
+        //     this._virtualGamepadMoveHandler = (input: VirtualGamepadMoveInput) => this.applyVirtualGamepadMove(input);
+        //     VirtualGamepadManager.getInstance().onMove(this._virtualGamepadMoveHandler);
+        // }
+        // if (!this._virtualGamepadConfirmHandler) {
+        //     this._virtualGamepadConfirmHandler = (pressed: boolean, raw?: any) => this.applyVirtualGamepadConfirm(pressed, raw);
+        //     VirtualGamepadManager.getInstance().onConfirm(this._virtualGamepadConfirmHandler);
+        // }
+        // if (!this._virtualGamepadControlHandler) {
+        //     this._virtualGamepadControlHandler = (input: VirtualGamepadControlInput) => this.logVirtualGamepadControlInput(input);
+        //     VirtualGamepadManager.getInstance().onControl(this._virtualGamepadControlHandler);
+        // }
+        // if (!this._virtualGamepadButtonHandler) {
+        //     this._virtualGamepadButtonHandler = (input: VirtualGamepadControlInput) => this.applyVirtualGamepadButton(input);
+        //     VirtualGamepadManager.getInstance().onButton(this._virtualGamepadButtonHandler);
+        // }
+        // if (!this._virtualGamepadBackHandler) {
+        //     this._virtualGamepadBackHandler = (input: VirtualGamepadControlInput) => this.applyVirtualGamepadBack(input);
+        //     VirtualGamepadManager.getInstance().onBack(this._virtualGamepadBackHandler);
+        // }
+    }
+
+    private unregisterVirtualGamepadInput() {
+        if (this._virtualGamepadMoveHandler) {
+            VirtualGamepadManager.getInstance().offMove(this._virtualGamepadMoveHandler);
+            this._virtualGamepadMoveHandler = null;
+        }
+        if (this._virtualGamepadConfirmHandler) {
+            VirtualGamepadManager.getInstance().offConfirm(this._virtualGamepadConfirmHandler);
+            this._virtualGamepadConfirmHandler = null;
+        }
+        if (this._virtualGamepadControlHandler) {
+            VirtualGamepadManager.getInstance().offControl(this._virtualGamepadControlHandler);
+            this._virtualGamepadControlHandler = null;
+        }
+        if (this._virtualGamepadButtonHandler) {
+            VirtualGamepadManager.getInstance().offButton(this._virtualGamepadButtonHandler);
+            this._virtualGamepadButtonHandler = null;
+        }
+        if (this._virtualGamepadBackHandler) {
+            VirtualGamepadManager.getInstance().offBack(this._virtualGamepadBackHandler);
+            this._virtualGamepadBackHandler = null;
+        }
+    }
+
+    private ensureVirtualGamepadNodes() {
+        if (this._virtualGamepadPanel && this._virtualGamepadPanel.isValid) {
+            this.refreshVirtualGamepadLayout();
+            return;
+        }
+        this._virtualGamepadPanel = new cc.Node("virtualGamepadPanel");
+        this._virtualGamepadPanel.setContentSize(VIRTUAL_GAMEPAD_PANEL_WIDTH, VIRTUAL_GAMEPAD_PANEL_HEIGHT);
+        this._virtualGamepadPanel.zIndex = VIRTUAL_GAMEPAD_TOP_Z_INDEX;
+        this._virtualGamepadPanel.parent = this.getVirtualGamepadTopParent();
+        this.drawRectBg(this._virtualGamepadPanel, VIRTUAL_GAMEPAD_PANEL_WIDTH, VIRTUAL_GAMEPAD_PANEL_HEIGHT, new cc.Color(12, 20, 32, 242));
+
+        let accent = new cc.Node("accent");
+        accent.parent = this._virtualGamepadPanel;
+        accent.y = VIRTUAL_GAMEPAD_PANEL_HEIGHT * 0.5 - 3;
+        this.drawRectBg(accent, VIRTUAL_GAMEPAD_PANEL_WIDTH, 6, new cc.Color(38, 190, 196, 255));
+
+        let title = this.createVirtualGamepadLabel("title", "手机虚拟手柄", 28, cc.Color.WHITE);
+        title.node.parent = this._virtualGamepadPanel;
+        title.node.y = 192;
+
+        let subtitle = this.createVirtualGamepadLabel("subtitle", "微信扫码，手机即手柄", 17, new cc.Color(87, 214, 205, 255));
+        subtitle.node.parent = this._virtualGamepadPanel;
+        subtitle.node.y = 158;
+
+        let qrFrame = new cc.Node("qrFrame");
+        qrFrame.parent = this._virtualGamepadPanel;
+        qrFrame.y = 18;
+        this.drawVirtualGamepadQrFrame(qrFrame, 246);
+
+        let sunCodeNode = new cc.Node("sunCode");
+        sunCodeNode.parent = qrFrame;
+        sunCodeNode.zIndex = 1;
+        sunCodeNode.setContentSize(VIRTUAL_GAMEPAD_SUN_CODE_SIZE, VIRTUAL_GAMEPAD_SUN_CODE_SIZE);
+        this._virtualGamepadSunCodeSprite = sunCodeNode.addComponent(cc.Sprite);
+        this._virtualGamepadSunCodeSprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+        this._virtualGamepadSunCodeSprite.node.active = false;
+
+        this._virtualGamepadSunCodeLoadingLabel = this.createVirtualGamepadLabel(
+            "sunCodeLoading",
+            "太阳码生成中\n请稍候...",
+            19,
+            new cc.Color(75, 101, 130, 255)
+        );
+        this._virtualGamepadSunCodeLoadingLabel.node.parent = qrFrame;
+        this._virtualGamepadSunCodeLoadingLabel.node.setContentSize(210, 72);
+
+        this._virtualGamepadStatusLabel = this.createVirtualGamepadLabel("status", "等待手柄扫码连接", 20, new cc.Color(255, 210, 82, 255));
+        this._virtualGamepadStatusLabel.node.parent = this._virtualGamepadPanel;
+        this._virtualGamepadStatusLabel.node.y = -124;
+
+        this._virtualGamepadRoomLabel = this.createVirtualGamepadLabel("room", "", 16, new cc.Color(193, 207, 226, 255));
+        this._virtualGamepadRoomLabel.node.parent = this._virtualGamepadPanel;
+        this._virtualGamepadRoomLabel.node.y = -156;
+
+        this._virtualGamepadIdentityLabel = this.createVirtualGamepadLabel("identity", "", 16, new cc.Color(141, 163, 191, 255));
+        this._virtualGamepadIdentityLabel.node.parent = this._virtualGamepadPanel;
+        this._virtualGamepadIdentityLabel.node.y = -184;
+
+        this._virtualGamepadBadge = new cc.Node("virtualGamepadBadge");
+        this._virtualGamepadBadge.setContentSize(VIRTUAL_GAMEPAD_BADGE_WIDTH, VIRTUAL_GAMEPAD_BADGE_HEIGHT);
+        this._virtualGamepadBadge.zIndex = VIRTUAL_GAMEPAD_TOP_Z_INDEX;
+        this._virtualGamepadBadge.parent = this.getVirtualGamepadTopParent();
+        this.drawRectBg(this._virtualGamepadBadge, 230, 48, new cc.Color(24, 160, 91, 238));
+        this._virtualGamepadBadgeLabel = this.createVirtualGamepadLabel("badgeText", "手柄已连接", 20, cc.Color.WHITE);
+        this._virtualGamepadBadgeLabel.node.parent = this._virtualGamepadBadge;
+        this._virtualGamepadBadge.active = false;
+
+        this.refreshVirtualGamepadLayout();
+        this.bringVirtualGamepadToTop();
+        this.scheduleOnce(() => this.bringVirtualGamepadToTop(), 0);
+    }
+
+    private refreshVirtualGamepadLayout() {
+        let size: cc.Size = cc.winSize;
+        if (this._virtualGamepadPanel) {
+            this._virtualGamepadPanel.x = size.width - VIRTUAL_GAMEPAD_PANEL_WIDTH / 2;
+            this._virtualGamepadPanel.y = size.height - VIRTUAL_GAMEPAD_PANEL_HEIGHT / 2;
+        }
+        if (this._virtualGamepadBadge) {
+            this._virtualGamepadBadge.x = size.width - VIRTUAL_GAMEPAD_BADGE_WIDTH / 2;
+            this._virtualGamepadBadge.y = size.height - VIRTUAL_GAMEPAD_BADGE_HEIGHT / 2;
+        }
+        this.bringVirtualGamepadToTop();
+    }
+
+    private refreshVirtualGamepadView(status: VirtualGamepadStatus) {
+        this.ensureVirtualGamepadNodes();
+        this.refreshVirtualGamepadSunCode(status);
+        if (this._virtualGamepadStatusLabel) {
+            this._virtualGamepadStatusLabel.string = status.statusText;
+            this._virtualGamepadStatusLabel.node.color = this.getVirtualGamepadStatusColor(status);
+        }
+        if (this._virtualGamepadRoomLabel) {
+            this._virtualGamepadRoomLabel.string = "房间  " + status.roomId;
+        }
+        if (this._virtualGamepadIdentityLabel) {
+            this._virtualGamepadIdentityLabel.string = "身份  " + status.identityText;
+        }
+        if (this._virtualGamepadBadgeLabel) {
+            this._virtualGamepadBadgeLabel.string = status.statusText;
+        }
+        if (this._virtualGamepadPanel) {
+            this._virtualGamepadPanel.active = !status.controllerConnected;
+        }
+        if (this._virtualGamepadBadge) {
+            this._virtualGamepadBadge.active = status.controllerConnected;
+        }
+        this.bringVirtualGamepadToTop();
+    }
+
+    private refreshVirtualGamepadSunCode(status: VirtualGamepadStatus) {
+        let sprite = this._virtualGamepadSunCodeSprite;
+        let loadingLabel = this._virtualGamepadSunCodeLoadingLabel;
+        let source = status.sunCodeState == "ready" ? status.sunCodeDataUrl : "";
+        if (!sprite || !sprite.node || !cc.isValid(sprite.node)) return;
+        if (!source) {
+            sprite.node.active = false;
+            if (loadingLabel && loadingLabel.node && cc.isValid(loadingLabel.node)) {
+                loadingLabel.string = "太阳码生成中\n请稍候...";
+                loadingLabel.node.active = true;
+            }
+            return;
+        }
+        if (this._virtualGamepadSunCodeSource == source && sprite.spriteFrame) {
+            sprite.node.active = true;
+            if (loadingLabel && loadingLabel.node) loadingLabel.node.active = false;
+            return;
+        }
+        if (this._virtualGamepadSunCodeLoading == source) return;
+
+        sprite.node.active = false;
+        if (loadingLabel && loadingLabel.node && cc.isValid(loadingLabel.node)) {
+            loadingLabel.string = "太阳码加载中\n请稍候...";
+            loadingLabel.node.active = true;
+        }
+        this._virtualGamepadSunCodeLoading = source;
+        let loadSerial = ++this._virtualGamepadSunCodeLoadSerial;
+        let imageType = source.indexOf("data:image/png") == 0 ? "png" : "jpg";
+        cc.loader.load({ url: source, type: imageType }, (error: Error, texture: cc.Texture2D) => {
+            if (loadSerial != this._virtualGamepadSunCodeLoadSerial) return;
+            this._virtualGamepadSunCodeLoading = "";
+            let currentSprite = this._virtualGamepadSunCodeSprite;
+            if (error || !texture || !currentSprite || !currentSprite.node || !cc.isValid(currentSprite.node)) {
+                console.warn("[VirtualGamepad][SunCode] image decode failed", error && (error.message || error));
+                return;
+            }
+            currentSprite.spriteFrame = new cc.SpriteFrame(texture);
+            currentSprite.sizeMode = cc.Sprite.SizeMode.CUSTOM;
+            currentSprite.node.setContentSize(VIRTUAL_GAMEPAD_SUN_CODE_SIZE, VIRTUAL_GAMEPAD_SUN_CODE_SIZE);
+            currentSprite.node.active = true;
+            let currentLoadingLabel = this._virtualGamepadSunCodeLoadingLabel;
+            if (currentLoadingLabel && currentLoadingLabel.node && cc.isValid(currentLoadingLabel.node)) {
+                currentLoadingLabel.node.active = false;
+            }
+            this._virtualGamepadSunCodeSource = source;
+        });
+    }
+
+    private getVirtualGamepadTopParent(): cc.Node {
+        return cc.director.getScene() || this.node.parent || this.node;
+    }
+
+    private bringVirtualGamepadToTop() {
+        this.placeVirtualGamepadNodeOnTop(this._virtualGamepadPanel);
+        this.placeVirtualGamepadNodeOnTop(this._virtualGamepadBadge);
+    }
+
+    private placeVirtualGamepadNodeOnTop(node: cc.Node | null) {
+        if (!node || !cc.isValid(node)) return;
+        let topParent = this.getVirtualGamepadTopParent();
+        if (topParent && cc.isValid(topParent) && node.parent != topParent) {
+            let worldPos = node.convertToWorldSpaceAR(cc.Vec2.ZERO);
+            node.parent = topParent;
+            node.setPosition(topParent.convertToNodeSpaceAR(worldPos));
+        }
+        if (node.zIndex != VIRTUAL_GAMEPAD_TOP_Z_INDEX) {
+            node.zIndex = VIRTUAL_GAMEPAD_TOP_Z_INDEX;
+        }
+        if (node.parent && node.getSiblingIndex() != node.parent.childrenCount - 1) {
+            node.setSiblingIndex(node.parent.childrenCount - 1);
+        }
+    }
+
+    private createVirtualGamepadLabel(name: string, text: string, fontSize: number, color: cc.Color): cc.Label {
+        let node = new cc.Node(name);
+        node.setContentSize(390, fontSize + 10);
+        let label = node.addComponent(cc.Label);
+        label.string = text;
+        label.fontSize = fontSize;
+        label.lineHeight = fontSize + 8;
+        label.horizontalAlign = cc.Label.HorizontalAlign.CENTER;
+        label.verticalAlign = cc.Label.VerticalAlign.CENTER;
+        label.overflow = cc.Label.Overflow.SHRINK;
+        label.node.color = color;
+        return label;
+    }
+
+    private getVirtualGamepadStatusColor(status: VirtualGamepadStatus): cc.Color {
+        if (status.controllerConnected) return new cc.Color(83, 218, 141, 255);
+        if (status.connectionState == "error") return new cc.Color(255, 112, 112, 255);
+        if (status.connectionState == "open" || status.connectionState == "joined") return new cc.Color(87, 214, 205, 255);
+        return new cc.Color(255, 210, 82, 255);
+    }
+
+    private drawVirtualGamepadQrFrame(node: cc.Node, size: number) {
+        node.setContentSize(size, size);
+        let graphics = node.addComponent(cc.Graphics);
+        graphics.fillColor = cc.Color.WHITE;
+        graphics.rect(-size * 0.5, -size * 0.5, size, size);
+        graphics.fill();
+        graphics.lineWidth = 2;
+        graphics.strokeColor = new cc.Color(87, 214, 205, 255);
+        graphics.rect(-size * 0.5, -size * 0.5, size, size);
+        graphics.stroke();
+    }
+
+    private drawRectBg(node: cc.Node, width: number, height: number, color: cc.Color) {
+        let graphics = node.getComponent(cc.Graphics) || node.addComponent(cc.Graphics);
+        graphics.clear();
+        graphics.fillColor = color;
+        graphics.rect(-width * node.anchorX, -height * node.anchorY, width, height);
+        graphics.fill();
+    }
+}

package/drscript/virtualgamepad/VirtualGamepadView.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a71f17d4-d8dd-449b-8939-f06c68bb4eb6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drgame-cc",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "道然游戏适配包",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,10 +29,10 @@
     "gulp-inject-string": "^1.1.2",
     "gulp-minify": "^3.1.0",
     "gulp-typescript": "^6.0.0-alpha.1",
-    "rimraf": "^5.0.0",
-    "typescript": "5.9.3"
+    "rimraf": "^5.0.0"
   },
   "dependencies": {
+    "typescript": "5.9.3",
     "fs-extra": "^11.2.0"
   },
   "peerDependencies": {
@@ -42,7 +42,7 @@
     "drres/**/*",
     "drscript/**/*",
     "build-templates/**/*",
-    "scripts/postinstall.js",
+    "scripts/**/*",
     "bin/**/*"
   ],
   "engines": {

package/scripts/sync-back.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const fs = require('fs');
+const fse = require('fs-extra');
+
+// ============================================================
+// 1. 包自身根目录 / 宿主项目根目录
+// ============================================================
+const pkgRoot = path.resolve(__dirname, '..');
+const projectRoot = path.resolve(__dirname, '..', '..', '..');
+
+// ============================================================
+// 2. 解析命令行参数（与 postinstall.js 一致）
+//    支持: <path> | --cocos-path <path> | --cocos-path=<path> | -p <path>
+// ============================================================
+function resolveCocosPath(argv) {
+    const args = argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('--cocos-path=')) {
+            return a.slice('--cocos-path='.length);
+        }
+        if (a === '--cocos-path' || a === '-p') {
+            const next = args[i + 1];
+            if (next && !next.startsWith('-')) {
+                return next;
+            }
+        } else if (!a.startsWith('-') && a.length > 0) {
+            return a;
+        }
+    }
+    return null;
+}
+
+const argPath = resolveCocosPath(process.argv);
+let COCOS_ROOT = argPath || projectRoot;
+if (!path.isAbsolute(COCOS_ROOT)) {
+    COCOS_ROOT = path.resolve(process.cwd(), COCOS_ROOT);
+}
+
+console.log('开始反向同步（Cocos 项目 -> npm 包）');
+console.log(`源目录(宿主): ${COCOS_ROOT}`);
+console.log(`目标目录(包): ${pkgRoot}`);
+console.log(`Cocos 路径来源: ${argPath ? '命令行参数' : '默认（node_modules 父目录）'}`);
+
+// ============================================================
+// 3. 反向拷贝：与 postinstall.js 完全对称
+//    COCOS_ROOT/build-templates          -> pkgRoot/build-templates
+//    COCOS_ROOT/assets/resources/drres   -> pkgRoot/drres
+//    COCOS_ROOT/assets/drscript          -> pkgRoot/drscript
+// ============================================================
+const jobs = [
+    {
+        name: 'build-templates',
+        src: path.join(COCOS_ROOT, 'build-templates'),
+        dest: path.join(pkgRoot, 'build-templates'),
+    },
+    {
+        name: 'drres',
+        src: path.join(COCOS_ROOT, 'assets', 'resources', 'drres'),
+        dest: path.join(pkgRoot, 'drres'),
+    },
+    {
+        name: 'drscript',
+        src: path.join(COCOS_ROOT, 'assets', 'drscript'),
+        dest: path.join(pkgRoot, 'drscript'),
+    },
+];
+
+try {
+    for (const job of jobs) {
+        if (fs.existsSync(job.src)) {
+            fse.copySync(job.src, job.dest, { overwrite: true });
+            console.log(`[OK] ${job.name} 反向同步完成`);
+        } else {
+            console.log(`[SKIP] 源目录不存在，跳过: ${job.src}`);
+        }
+    }
+    console.log('反向同步完成！');
+} catch (error) {
+    console.error('反向同步失败：', error.message);
+    console.error(error.stack);
+    process.exit(1);
+}