@cc-component/cc-core 1.2.8

package/assets/core/home/TimeManager.ts

@@ -0,0 +1,486 @@
+// TimeManager.ts - 多视图倒计时管理器
+
+import { game } from "cc";
+import { Component } from "cc";
+
+
+/**
+ * 倒计时管理器 - 支持多个视图同时显示不同的倒计时
+ */
+export class TimeManager {
+    private countdowns: Map<string, CountdownInfo> = new Map();
+    timers = new Map();
+
+    /** 服务器时间 */
+    private date_s: Date = new Date();
+    /** 服务器初始时间 */
+    private date_s_start: Date = new Date();
+    /** 服务器时间后修正时间 */
+    private polymeric_s: number = 0;
+    /** 客户端时间 */
+    private date_c: Date = new Date();
+
+
+    constructor() {
+    }
+
+
+    /**
+     * 创建或更新倒计时
+     * @param key 倒计时唯一标识符
+     * @param minutes 倒计时分钟数 (例如: 30表示30分钟, 20表示20分钟)
+     * @param onTick 倒计时更新回调
+     * @param onComplete 倒计时完成回调
+     * @param autoStart 是否自动开始，默认true
+     */
+    start(
+        key: string,
+        minutes: number,
+        onTick?: (remaining: number, formattedTime: string) => void,
+        onComplete?: () => void,
+        autoStart: boolean = true
+    ): CountdownTimer {
+        // 如果已存在相同key的倒计时，先停止它
+        if (this.countdowns.has(key)) {
+            this.removeCountdown(key);
+        }
+
+        const timer = new CountdownTimer(minutes, onTick, onComplete);
+        const countdownInfo: CountdownInfo = {
+            timer,
+            minutes,
+            onTick,
+            onComplete
+        };
+
+        this.countdowns.set(key, countdownInfo);
+
+        if (!autoStart) {
+            timer.pause();
+        }
+
+        return timer;
+    }
+
+    /**
+     * 创建30分钟倒计时
+     * @param key 倒计时唯一标识符
+     * @param onTick 倒计时更新回调
+     * @param onComplete 倒计时完成回调
+     */
+    setup30MinCountdown(
+        key: string,
+        onTick?: (remaining: number, formattedTime: string) => void,
+        onComplete?: () => void
+    ): CountdownTimer {
+        return this.start(key, 30, onTick, onComplete);
+    }
+
+    /**
+     * 创建20分钟倒计时
+     * @param key 倒计时唯一标识符
+     * @param onTick 倒计时更新回调
+     * @param onComplete 倒计时完成回调
+     */
+    setup20MinCountdown(
+        key: string,
+        onTick?: (remaining: number, formattedTime: string) => void,
+        onComplete?: () => void
+    ): CountdownTimer {
+        return this.start(key, 20, onTick, onComplete);
+    }
+
+    /**
+     * 更新现有倒计时的时间
+     * @param key 倒计时唯一标识符
+     * @param minutes 新的分钟数
+     */
+    updateCountdownTime(key: string, minutes: number): boolean {
+        const countdownInfo = this.countdowns.get(key);
+        if (!countdownInfo) {
+            console.warn(`倒计时 ${key} 不存在`);
+            return false;
+        }
+
+        // 保存当前状态
+        const wasPaused = countdownInfo.timer.isPaused();
+        const elapsed = countdownInfo.timer.getElapsedSeconds();
+
+        // 停止当前倒计时
+        countdownInfo.timer.stop();
+
+        // 创建新的倒计时
+        const newTimer = new CountdownTimer(
+            minutes,
+            countdownInfo.onTick,
+            countdownInfo.onComplete
+        );
+
+        // 如果之前已暂停，则新倒计时也暂停
+        if (wasPaused) {
+            newTimer.pause();
+        }
+
+        // 更新存储信息
+        countdownInfo.timer = newTimer;
+        countdownInfo.minutes = minutes;
+
+        return true;
+    }
+
+    /**
+     * 暂停倒计时
+     * @param key 倒计时唯一标识符
+     */
+    pauseCountdown(key: string): boolean {
+        const countdownInfo = this.countdowns.get(key);
+        if (countdownInfo) {
+            countdownInfo.timer.pause();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 恢复倒计时
+     * @param key 倒计时唯一标识符
+     */
+    resumeCountdown(key: string): boolean {
+        const countdownInfo = this.countdowns.get(key);
+        if (countdownInfo) {
+            countdownInfo.timer.resume();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 停止并移除倒计时
+     * @param key 倒计时唯一标识符
+     */
+    removeCountdown(key: string): boolean {
+        const countdownInfo = this.countdowns.get(key);
+        if (countdownInfo) {
+            countdownInfo.timer.stop();
+            this.countdowns.delete(key);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 获取倒计时对象
+     * @param key 倒计时唯一标识符
+     */
+    getCountdown(key: string): CountdownTimer | undefined {
+        const countdownInfo = this.countdowns.get(key);
+        return countdownInfo ? countdownInfo.timer : undefined;
+    }
+
+    public formatTime(seconds: number): string {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+
+        if (hours > 0) {
+            return `${padStart(hours, 2)}:${padStart(minutes, 2)}:${padStart(secs, 2)}`;
+        } else {
+            return `${padStart(minutes, 2)}:${padStart(secs, 2)}`;
+        }
+    }
+
+    /**
+     * 获取所有倒计时的键名
+     */
+    getAllCountdownKeys(): string[] {
+        return Array.from(this.countdowns.keys());
+    }
+
+    /**
+     * 停止所有倒计时
+     */
+    removeAllCountdowns(): void {
+        this.countdowns.forEach(info => info.timer.stop());
+        this.countdowns.clear();
+    }
+
+    /**
+     * 检查倒计时是否存在
+     * @param key 倒计时唯一标识符
+     */
+    hasCountdown(key: string): boolean {
+        return this.countdowns.has(key);
+    }
+
+    //#region 暂停和恢复计时器
+
+
+
+    setTimeout(callback, delay) {
+        const timerId = window.setTimeout(() => {
+            callback();
+            this.timers.delete(timerId);  // 定时器执行后，从Map中删除
+        }, delay);
+
+        this.timers.set(timerId, () => window.clearTimeout(timerId));
+        return timerId;
+    }
+
+    clearTimeout(timerId) {
+        if (this.timers.has(timerId)) {
+            this.timers.get(timerId)();
+            this.timers.delete(timerId);  // 从Map中删除定时器
+        }
+    }
+
+    clearAllTimeouts() {
+        this.timers.forEach(clearFn => clearFn());  // 调用所有清除函数
+        this.timers.clear();  // 清空Map
+    }
+    setTimeCount(interval: number, times: number, callback: () => void): void {
+        let count = 0;
+        const timerId = window.setInterval(() => {
+            if (count < times) {
+                callback();
+                count++;
+            } else {
+                window.clearInterval(timerId);
+                this.timers.delete(timerId);  // 清除定时器后，从Map中删除
+            }
+        }, interval);
+
+        this.timers.set(timerId, () => window.clearInterval(timerId));
+    }
+
+
+
+    /**等代秒*/
+    async Await(time: number, com?: Component): Promise<void> {
+        var promise = new Promise<void>(resolve => {
+            if (com) {
+                com.scheduleOnce(resolve, time)
+            } else {
+                setTimeout(resolve, time * 1000)
+            }
+        });
+        return promise;
+    }
+
+    /**等代毫秒*/
+    async AwaitMS(time: number): Promise<void> {
+        var promise = new Promise<void>(resolve => {
+            setTimeout(resolve, time)
+        });
+        return promise;
+    }
+
+    //#region 时间同步
+    /**
+     * 服务器时间与本地时间同步
+     * @param value   服务器时间刻度
+     */
+    setServerTime(value: number): void {
+        this.polymeric_s = this.getTime();
+        this.date_s_start.setTime(value);
+    }
+
+    /** 获取写服务器同步的时间刻度 */
+    getServerTime(): number {
+        return this.date_s_start.getTime() + this.getTime() - this.polymeric_s;
+    }
+
+    /** 获取服务器时间对象 */
+    getServerDate(): Date {
+        this.date_s.setTime(this.getServerTime());
+        return this.date_s;
+    }
+
+    /** 获取本地时间刻度 */
+    getClientTime(): number {
+        return Date.now();
+    }
+
+    /** 获取本地时间对象 */
+    getClientDate(): Date {
+        this.date_c.setTime(this.getClientTime());
+        return this.date_c;
+    }
+
+    /** 获取游戏开始到现在逝去的时间 */
+    getTime(): number {
+        return game.totalTime;
+    }
+
+}
+
+// 倒计时信息接口
+interface CountdownInfo {
+    timer: CountdownTimer;
+    minutes: number;
+    onTick?: (remaining: number, formattedTime: string) => void;
+    onComplete?: () => void;
+}
+
+/**
+ * 字符串补零工具函数（替代 padStart）
+ * @param str 要补零的字符串
+ * @param targetLength 目标长度
+ * @param padString 补充字符，默认为'0'
+ */
+function padStart(str: string | number, targetLength: number, padString: string = '0'): string {
+    let result = String(str);
+    while (result.length < targetLength) {
+        result = padString + result;
+    }
+    return result;
+}
+
+/**
+ * 倒计时计时器类
+ */
+export class CountdownTimer {
+    private endTime: number;
+    private intervalId: any = null;
+    private paused: boolean = false;
+    private pauseTime: number = 0;
+    private remainingWhenPaused: number = 0;
+    private onTick?: (remaining: number, formattedTime: string) => void;
+    private onComplete?: () => void;
+    private totalSeconds: number;
+    private startTime: number;
+
+    constructor(
+        seconds: number,
+        onTick?: (remaining: number, formattedTime: string) => void,
+        onComplete?: () => void
+    ) {
+        this.totalSeconds = seconds;
+        this.onTick = onTick;
+        this.onComplete = onComplete;
+        this.startTime = Date.now();
+        this.endTime = this.startTime + (seconds * 1000);
+        this.start();
+    }
+
+    private start() {
+        // 立即触发一次回调
+        this.tick();
+
+        this.intervalId = setInterval(() => {
+            this.tick();
+        }, 1000);
+    }
+
+    private tick() {
+        if (this.paused) return;
+
+        const now = Date.now();
+        const remaining = Math.max(0, Math.ceil((this.endTime - now) / 1000));
+
+        const formattedTime = this.formatTime(remaining);
+
+        if (this.onTick) {
+            this.onTick(remaining, formattedTime);
+        }
+
+        if (remaining <= 0) {
+            if (this.onComplete) {
+                this.onComplete();
+            }
+            this.stop();
+        }
+    }
+
+    public formatTime(seconds: number): string {
+        const hours = Math.floor(seconds / 3600);
+        const minutes = Math.floor((seconds % 3600) / 60);
+        const secs = seconds % 60;
+
+        if (hours > 0) {
+            return `${padStart(hours, 2)}:${padStart(minutes, 2)}:${padStart(secs, 2)}`;
+        } else {
+            return `${padStart(minutes, 2)}:${padStart(secs, 2)}`;
+        }
+    }
+
+    /**
+     * 暂停倒计时
+     */
+    pause(): void {
+        if (!this.paused) {
+            this.paused = true;
+            this.pauseTime = Date.now();
+            this.remainingWhenPaused = Math.max(0, Math.floor((this.endTime - this.pauseTime) / 1000));
+        }
+    }
+
+    /**
+     * 恢复倒计时
+     */
+    resume(): void {
+        if (this.paused) {
+            this.paused = false;
+            const timePassed = Date.now() - this.pauseTime;
+            this.endTime += timePassed; // 调整结束时间以补偿暂停期间
+        }
+    }
+
+    /**
+     * 停止并清理倒计时
+     */
+    stop(): void {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+
+    /**
+     * 获取剩余秒数
+     */
+    getRemainingSeconds(): number {
+        if (this.paused) {
+            return this.remainingWhenPaused;
+        }
+        return Math.max(0, Math.floor((this.endTime - Date.now()) / 1000));
+    }
+
+    /**
+     * 获取格式化的时间字符串
+     */
+    getFormattedTime(): string {
+        const seconds = this.getRemainingSeconds();
+        return this.formatTime(seconds);
+    }
+
+    /**
+     * 获取总时长（秒）
+     */
+    getTotalSeconds(): number {
+        return this.totalSeconds;
+    }
+
+    /**
+     * 获取已用时间（秒）
+     */
+    getElapsedSeconds(): number {
+        return this.totalSeconds - this.getRemainingSeconds();
+    }
+
+    /**
+     * 检查是否已暂停
+     */
+    isPaused(): boolean {
+        return this.paused;
+    }
+
+    /**
+     * 检查是否已完成
+     */
+    isFinished(): boolean {
+        return this.getRemainingSeconds() <= 0;
+    }
+
+
+
+}

package/assets/core/home/TimeManager.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "1d58f6af-af0a-43b0-9600-d0f6693ed342",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/Tools.ts

@@ -0,0 +1,103 @@
+
+import { Button, Toggle, PageView, ToggleContainer, EventHandler, js } from 'cc';
+import { _decorator, Component, Node } from 'cc';
+const { ccclass, property } = _decorator;
+
+/**
+ * Predefined variables
+ * Name = Tools
+ * DateTime = Fri Mar 24 2023 14:15:55 GMT+0800 (中国标准时间)
+ * Author = yf123mb
+ * FileBasename = Tools.ts
+ * FileBasenameNoExtension = Tools
+ * URL = db://assets/tools/Tools/Tools.ts
+ * ManualUrl = https://docs.cocos.com/creator/3.4/manual/zh/
+ *
+ */
+
+export enum NodeLayer {
+    bg = 1 << 0,
+    preogess = 1 << 1,
+    reconnect = 1 << 2,
+    tip = 1 << 3,
+    Player_4 = 1 << 4,
+};
+
+@ccclass('Tools')
+export class Tools {
+
+    static SetNodeLayer(node: Node, layer: number) {
+        for (var i = 0; i < node.children.length; i++) {
+            let item = node.children[i];
+            item.layer = layer
+            if (item.children.length > 0) {
+                this.SetNodeLayer(item, layer)
+            }
+        }
+    }
+}
+
+
+declare module "cc" {
+    interface Asset {
+        /**资源路径 */
+        asset_path: string;
+    }
+}
+/**
+  * 
+  * @param eventName 绑定点击事件
+  */
+export function BindEventClick(target: Node, delegate: Component, func_name?: string) {
+    const node = target;
+    let comp: Button | Toggle | PageView | ToggleContainer = node.getComponent(Button);
+    if (!comp) {
+        comp = node.getComponent(Toggle)
+
+    }
+    if (!comp) {
+        comp = node.getComponent(ToggleContainer)
+    }
+    if (!comp) {
+        comp = node.getComponent(PageView)
+    }
+
+    if (!comp) {
+        console.error(`没有找到按钮组件,需要手动添加组件到节点 ${target.name}`);
+        return;
+    }
+    //  const call_name = "bindClick_"+target.name;
+    //(delegate as any)[call_name] = call;
+    const clickEventHandler = new EventHandler();
+    clickEventHandler.target = delegate.node; // 这个 node 节点是你的事件处理代码组件所属的节点
+
+    clickEventHandler.component = js.getClassName(delegate)//delegate.constructor.name;// 这个是脚本类名
+    clickEventHandler.handler = (func_name ?? node.name)
+    //console.error("按钮",delegate.constructor.name,node.name)
+    //clickEventHandler.customEventData = 'foobar';
+
+    // 绑定播放点击按钮音效事件
+    // const clickEventHandler_sound = new EventHandler();
+    // clickEventHandler_sound.target = delegate.node; // 这个 node 节点是你的事件处理代码组件所属的节点
+    // clickEventHandler_sound.component = js.getClassName(delegate)//delegate.constructor.name;// 这个是脚本类名
+    // clickEventHandler_sound.handler = "playClickSound"
+
+    if (comp instanceof Toggle) {
+        comp.checkEvents = [];
+        comp.checkEvents.push(clickEventHandler);
+        //comp.checkEvents.push(clickEventHandler_sound);
+    } else if (comp instanceof PageView) {
+        comp.pageEvents = [];
+        comp.pageEvents.push(clickEventHandler);
+        // (comp as PageView).pageEvents.push(clickEventHandler_sound);
+    }
+    else if (comp instanceof ToggleContainer) {
+        comp.checkEvents = [];
+        comp.checkEvents.push(clickEventHandler);
+    }
+    else {
+        comp.clickEvents = [];
+        comp.clickEvents.push(clickEventHandler);
+        //comp.clickEvents.push(clickEventHandler_sound);
+    }
+}

package/assets/core/home/Tools.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f4785e7e-5318-4dfd-b07c-e46baac7e500",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/prefabs.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.2.0",
+  "importer": "directory",
+  "imported": true,
+  "uuid": "9cd4d838-4fc3-4219-b8c4-d9f14eae73bf",
+  "files": [],
+  "subMetas": {},
+  "userData": {
+    "compressionType": {},
+    "isRemoteBundle": {}
+  }
+}

package/assets/core/home/util/EncryptUtil.ts

@@ -0,0 +1,60 @@
+/**
+ *
+ * @file EncryptUtil.ts
+ * @author yangfan
+ * @description 一些加密解密方法
+ *
+ */
+
+export module EncryptUtil {
+
+    export const KEY = "abc1236f7f8fcbcb";
+
+    /**
+     * AES 加密
+     * @param msg 
+     * @param key 
+     * @param iv 
+     * @returns 
+     */
+    export function aesEncrypt(msg: string, key?: string, iv?: string): string {
+
+        let _iv = "";
+        let _key = "";
+
+        // let encrypt = CryptoJS.AES.encrypt(msg, utf8Parse(KEY), {
+        //     iv: utf8Parse(_iv),
+        //     mode: CryptoJS.mode.ECB,
+        //     padding: CryptoJS.pad.Pkcs7
+        // });
+        let encrypt = CryptoJS.AES.encrypt(msg, utf8Parse(KEY), {
+            iv: utf8Parse(_iv),
+            mode: CryptoJS.mode.ECB,
+            padding: CryptoJS.pad.Pkcs7
+        });
+        return encrypt.toString();
+    }
+
+    /**
+     * AES 解密
+     * @param str 
+     * @param key 
+     * @param iv 
+     * @returns 
+     */
+    export function aesDecrypt(str: string, key?: string, iv?: string): string {
+        let _iv = "";
+        let _key = "";
+        let decrypt = CryptoJS.AES.decrypt(str, utf8Parse(KEY), {
+            iv: utf8Parse(_iv),
+            mode: CryptoJS.mode.CBC,
+            padding: CryptoJS.pad.Pkcs7
+        });
+        return CryptoJS.enc.Utf8.stringify(decrypt);
+    }
+
+    function utf8Parse(utf8Str: string): string {
+        return CryptoJS.enc.Utf8.parse(utf8Str);
+    }
+
+}

package/assets/core/home/util/EncryptUtil.ts.meta

@@ -0,0 +1,11 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "5f7a4f0d-1802-46f7-a768-134a4d2b59e1",
+  "files": [],
+  "subMetas": {},
+  "userData": {
+    "simulateGlobals": []
+  }
+}