dzkcc-mflow 0.0.21 → 0.0.23

package/dist/libs/indicator/RedDotManager.js

@@ -0,0 +1,124 @@
+import { RedDotNode } from './RedDotNode.js';
+
+/**
+ * 红点管理器,管理整个游戏的红点系统
+ */
+class RedDotManager {
+    constructor() {
+        this._root = null;
+        this._nodeCache = new Map();
+    }
+    initialize() {
+        this._root = new RedDotNode('root');
+        this._nodeCache.set('root', this._root);
+        console.log('RedDotManager 初始化完成');
+    }
+    dispose() {
+        this._root.destroy();
+        this._nodeCache.clear();
+    }
+    /**
+     * 获取或创建红点节点
+     * @param path 节点路径，如 'main/bag/weapon'
+     */
+    _getOrCreateNode(path) {
+        // 标准化路径
+        path = this._normalizePath(path);
+        // 检查缓存
+        if (this._nodeCache.has(path)) {
+            return this._nodeCache.get(path);
+        }
+        // 分割路径
+        const parts = path.split('/');
+        let currentNode = this._root;
+        let currentPath = 'root';
+        // 逐级创建节点
+        for (const part of parts) {
+            if (!part)
+                continue;
+            currentPath = currentPath === 'root' ? part : `${currentPath}/${part}`;
+            let childNode = currentNode.getChild(part);
+            if (!childNode) {
+                childNode = new RedDotNode(currentPath);
+                currentNode.addChild(childNode);
+                this._nodeCache.set(currentPath, childNode);
+            }
+            currentNode = childNode;
+        }
+        return currentNode;
+    }
+    /**
+     * 设置红点数量
+     * @param path 节点路径
+     * @param count 红点数量
+     */
+    setCount(path, count) {
+        const node = this._getOrCreateNode(path);
+        node.setCount(count);
+    }
+    /**
+     * 增加红点数量
+     * @param path 节点路径
+     * @param delta 增量（可以为负数）
+     */
+    addCount(path, delta = 1) {
+        const node = this._getOrCreateNode(path);
+        node.addCount(delta);
+    }
+    /**
+     * 获取红点数量（包含子节点）
+     * @param path 节点路径
+     */
+    getCount(path) {
+        const node = this._nodeCache.get(this._normalizePath(path));
+        return node ? node.getTotalCount() : 0;
+    }
+    /**
+     * 是否有红点
+     * @param path 节点路径
+     */
+    hasRedDot(path) {
+        return this.getCount(path) > 0;
+    }
+    /**
+     * 清空红点
+     * @param path 节点路径
+     */
+    clearRedDot(path) {
+        const node = this._nodeCache.get(this._normalizePath(path));
+        if (node) {
+            node.clear();
+        }
+    }
+    /**
+     * 添加监听器
+     * @param path 节点路径
+     * @param listener 监听函数 (totalCount, selfCount) => void
+     */
+    on(path, listener) {
+        const node = this._getOrCreateNode(path);
+        node.addListener(listener);
+        // 立即触发一次，让监听者知道当前状态
+        listener(node.getTotalCount(), node.getCount());
+    }
+    /**
+     * 移除监听器
+     * @param path 节点路径
+     * @param listener 监听函数
+     */
+    off(path, listener) {
+        const node = this._nodeCache.get(this._normalizePath(path));
+        if (node) {
+            node.removeListener(listener);
+        }
+    }
+    /**
+     * 标准化路径
+     */
+    _normalizePath(path) {
+        // 移除开头和结尾的斜杠
+        return path.replace(/^\/+|\/+$/g, '');
+    }
+}
+
+export { RedDotManager };

package/dist/libs/indicator/RedDotNode.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 红点节点
+ * 采用树形结构，支持父子关系和自动向上传递
+ */
+export declare class RedDotNode {
+    private path;
+    private count;
+    private totalCount;
+    private parent;
+    private children;
+    private listeners;
+    constructor(path: string);
+    /**
+     * 获取路径
+     */
+    getPath(): string;
+    /**
+     * 设置红点数量（只影响当前节点）
+     */
+    setCount(count: number): void;
+    /**
+     * 增加红点数量
+     */
+    addCount(delta: number): void;
+    /**
+     * 获取红点数量（只包含自身）
+     */
+    getCount(): number;
+    /**
+     * 获取总红点数量（包含所有子节点）
+     */
+    getTotalCount(): number;
+    /**
+     * 是否有红点（包含子节点）
+     */
+    hasRedDot(): boolean;
+    /**
+     * 添加子节点
+     */
+    addChild(child: RedDotNode): void;
+    /**
+     * 获取子节点
+     */
+    getChild(name: string): RedDotNode | undefined;
+    /**
+     * 添加监听器
+     */
+    addListener(listener: Function): void;
+    /**
+     * 移除监听器
+     */
+    removeListener(listener: Function): void;
+    /**
+     * 更新总数（包含所有子节点）
+     */
+    private updateTotalCount;
+    /**
+     * 通知所有监听器
+     */
+    private notifyListeners;
+    /**
+     * 清空红点（包含所有子节点）
+     */
+    clear(): void;
+    /**
+     * 销毁节点
+     */
+    destroy(): void;
+}

package/dist/libs/indicator/RedDotNode.js

@@ -0,0 +1,135 @@
+/**
+ * 红点节点
+ * 采用树形结构，支持父子关系和自动向上传递
+ */
+class RedDotNode {
+    constructor(path) {
+        this.count = 0; // 红点数量（自身）
+        this.totalCount = 0; // 红点数量（包含子节点）
+        this.parent = null; // 父节点
+        this.children = new Map(); // 子节点
+        this.listeners = new Set(); // 监听器
+        this.path = path;
+    }
+    /**
+     * 获取路径
+     */
+    getPath() {
+        return this.path;
+    }
+    /**
+     * 设置红点数量（只影响当前节点）
+     */
+    setCount(count) {
+        if (this.count === count)
+            return;
+        this.count;
+        this.count = Math.max(0, count);
+        // 重新计算总数
+        this.updateTotalCount();
+    }
+    /**
+     * 增加红点数量
+     */
+    addCount(delta) {
+        this.setCount(this.count + delta);
+    }
+    /**
+     * 获取红点数量（只包含自身）
+     */
+    getCount() {
+        return this.count;
+    }
+    /**
+     * 获取总红点数量（包含所有子节点）
+     */
+    getTotalCount() {
+        return this.totalCount;
+    }
+    /**
+     * 是否有红点（包含子节点）
+     */
+    hasRedDot() {
+        return this.totalCount > 0;
+    }
+    /**
+     * 添加子节点
+     */
+    addChild(child) {
+        const childName = child.getPath().split('/').pop();
+        this.children.set(childName, child);
+        child.parent = this;
+        // 子节点变化时，更新自己的总数
+        this.updateTotalCount();
+    }
+    /**
+     * 获取子节点
+     */
+    getChild(name) {
+        return this.children.get(name);
+    }
+    /**
+     * 添加监听器
+     */
+    addListener(listener) {
+        this.listeners.add(listener);
+    }
+    /**
+     * 移除监听器
+     */
+    removeListener(listener) {
+        this.listeners.delete(listener);
+    }
+    /**
+     * 更新总数（包含所有子节点）
+     */
+    updateTotalCount() {
+        const oldTotalCount = this.totalCount;
+        // 计算新的总数：自身数量 + 所有子节点的总数
+        let newTotalCount = this.count;
+        this.children.forEach(child => {
+            newTotalCount += child.getTotalCount();
+        });
+        this.totalCount = newTotalCount;
+        // 如果总数发生变化
+        if (oldTotalCount !== newTotalCount) {
+            // 通知监听器
+            this.notifyListeners();
+            // 向上传递给父节点
+            if (this.parent) {
+                this.parent.updateTotalCount();
+            }
+        }
+    }
+    /**
+     * 通知所有监听器
+     */
+    notifyListeners() {
+        this.listeners.forEach(listener => {
+            try {
+                listener(this.totalCount, this.count);
+            }
+            catch (error) {
+                console.error(`红点监听器执行错误 [${this.path}]:`, error);
+            }
+        });
+    }
+    /**
+     * 清空红点（包含所有子节点）
+     */
+    clear() {
+        this.setCount(0);
+        this.children.forEach(child => child.clear());
+    }
+    /**
+     * 销毁节点
+     */
+    destroy() {
+        this.listeners.clear();
+        this.children.forEach(child => child.destroy());
+        this.children.clear();
+        this.parent = null;
+    }
+}
+
+export { RedDotNode };

package/dist/libs/indicator/UIRedDot.d.ts

@@ -0,0 +1,28 @@
+import { Component, Node, Label } from 'cc';
+/**
+ * 红点显示组件
+ * 挂载到需要显示红点的 UI 节点上
+ */
+export declare class UIRedDot extends Component {
+    redDotNode: Node;
+    showCount: boolean;
+    countLabel: Label | null;
+    maxCount: number;
+    redDotPath: string;
+    private _listener;
+    onLoad(): void;
+    start(): void;
+    onDestroy(): void;
+    /**
+     * 绑定红点路径
+     */
+    bindPath(path: string): void;
+    /**
+     * 解绑
+     */
+    unbind(): void;
+    /**
+     * 更新显示
+     */
+    private _updateDisplay;
+}

package/dist/libs/indicator/UIRedDot.js

@@ -0,0 +1,101 @@
+import { __decorate, __metadata } from '../../_virtual/_tslib.js';
+import { _decorator, Node, Label, Component } from 'cc';
+
+const { ccclass, property } = _decorator;
+/**
+ * 红点显示组件
+ * 挂载到需要显示红点的 UI 节点上
+ */
+let UIRedDot = class UIRedDot extends Component {
+    constructor() {
+        super(...arguments);
+        this.redDotNode = null; // 红点节点（圆点或图标）
+        this.showCount = true;
+        this.countLabel = null; // 数字标签（可选）
+        this.maxCount = 99;
+        this.redDotPath = '';
+        this._listener = null;
+    }
+    onLoad() {
+        if (!this.redDotNode) {
+            console.error('RedDotComponent: redDotNode 未设置');
+            return;
+        }
+        // 初始时隐藏红点
+        this.redDotNode.active = false;
+    }
+    start() {
+        if (this.redDotPath) {
+            this.bindPath(this.redDotPath);
+        }
+    }
+    onDestroy() {
+        this.unbind();
+    }
+    /**
+     * 绑定红点路径
+     */
+    bindPath(path) {
+        this.unbind();
+        this.redDotPath = path;
+        // 创建监听器
+        this._listener = (totalCount, selfCount) => {
+            this._updateDisplay(totalCount);
+        };
+        // 添加监听
+        mf.reddot.on(path, this._listener);
+    }
+    /**
+     * 解绑
+     */
+    unbind() {
+        if (this._listener && this.redDotPath) {
+            mf.reddot.off(this.redDotPath, this._listener);
+            this._listener = null;
+        }
+    }
+    /**
+     * 更新显示
+     */
+    _updateDisplay(count) {
+        if (!this.redDotNode)
+            return;
+        // 显示/隐藏红点
+        this.redDotNode.active = count > 0;
+        // 更新数字
+        if (this.countLabel && this.showCount) {
+            if (count > this.maxCount) {
+                this.countLabel.string = `${this.maxCount}+`;
+            }
+            else {
+                this.countLabel.string = count.toString();
+            }
+            this.countLabel.node.active = count > 0;
+        }
+    }
+};
+__decorate([
+    property(Node),
+    __metadata("design:type", Node)
+], UIRedDot.prototype, "redDotNode", void 0);
+__decorate([
+    property({ tooltip: '是否显示数字' }),
+    __metadata("design:type", Boolean)
+], UIRedDot.prototype, "showCount", void 0);
+__decorate([
+    property(Label),
+    __metadata("design:type", Object)
+], UIRedDot.prototype, "countLabel", void 0);
+__decorate([
+    property({ tooltip: '最大显示数字，超过显示 99+' }),
+    __metadata("design:type", Number)
+], UIRedDot.prototype, "maxCount", void 0);
+__decorate([
+    property({ tooltip: '红点路径，如 main/bag/weapon' }),
+    __metadata("design:type", String)
+], UIRedDot.prototype, "redDotPath", void 0);
+UIRedDot = __decorate([
+    ccclass('UIRedDot')
+], UIRedDot);
+
+export { UIRedDot };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dzkcc-mflow",
-    "version": "0.0.21",
+    "version": "0.0.23",
     "description": "A modular design and process management framework developed for the cocos engine, suitable for decoupling and dependency injection.",
     "author": "duanzhk",
     "license": "MIT",