@cc-component/cc-core 1.2.8

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "49a06417-7524-4309-a366-0f7261b05ed8",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ResUtil.ts

@@ -0,0 +1,132 @@
+/**
+ *
+ * @file ResUtil.ts
+ * @author dream
+ * @description Cocos方法整合，如果Cocos版本升级，造成API修改，仅需修改此处
+ *
+ */
+
+import { Asset, assetManager, AssetManager, ImageAsset, resources, Texture2D } from "cc";
+
+export type Constructor<T extends Asset> = new () => T;
+
+export const headImgExt = ".head";
+
+export module ResUtil {
+
+    /**
+     * @description 原生加载资源
+     * @param object {url: 远程地址 option: 参数类型}
+     * @returns 
+     */
+    export function loadRemote<T extends Asset>(object: { url: string, option?: any }) {
+        if (null == object.option) {
+            object.option = {};
+        }
+      
+        const { url, option } = object;
+        return new Promise((resolve, reject) => {
+            assetManager.loadRemote(url, option, (err: Error | null, asset: T) => {
+                resolve && resolve(err ? null : asset);
+            });
+        });
+
+    }
+
+    /**
+     * 加载bundle
+     * @param bundleName 
+     * @returns 
+     */
+    export function loadBundle(bundleName: string) {
+        return new Promise((resolve, reject) => {
+            assetManager.loadBundle(bundleName, (err, bundle) => {
+                resolve && resolve(err ? null : bundle);
+            });
+        });
+    }
+
+    function getBundle(bundleName?: string, bundle?: AssetManager.Bundle) {
+        if (!bundle) {
+            if (null == bundleName || '' === bundleName) {
+                bundle = resources;
+            } else {
+                bundle = assetManager.getBundle(bundleName)!;
+            }
+        }
+        return bundle;
+    }
+
+    /**
+     * 加载资源
+     * @param option 
+     * @returns 
+     */
+    export function loadAsset<T extends Asset>(option: { path: string, bundleName?: string, bundle?: AssetManager.Bundle, type: Constructor<T> }) {
+        const bundle = getBundle(option.bundleName, option.bundle);
+        const asset = bundle.get(option.path, option.type);
+        if (null != asset) {
+            return Promise.resolve(asset);
+        }
+        return new Promise((resolve, reject) => {
+            bundle.load(option.path, option.type, (err, asset: T) => {
+                resolve(err ? null : asset);
+            });
+        });
+    }
+
+    /**
+     * 自定义头像加载流程
+     * 加载头像使用 ResUtil.loadRemote({url, option:{ext:headImgExt}})
+     */
+    export function registerHeadImgLoader() {
+        assetManager.downloader.register(headImgExt, (content, options, onComplete) => {
+            onComplete(null, content);
+        });
+        assetManager.parser.register(headImgExt, downloadDomImage);
+        assetManager.factory.register(headImgExt, createTexture);
+    }
+
+    function createTexture(id: string, data: any, options: any, onComplete: Function) {
+        let out: Texture2D | null = null;
+        let err: Error | null = null;
+        try {
+            out = new Texture2D();
+            const imageAsset = new ImageAsset(data);
+            out.image = imageAsset;
+        } catch (e) {
+            err = e as any as Error;
+        }
+        onComplete && onComplete(err, out);
+    }
+
+    function downloadDomImage(url: string, options: any, onComplete: Function) {
+
+  
+        const img = new Image();
+        if (window.location.protocol !== 'file:') {
+            img.crossOrigin = 'anonymous';
+        }
+        function loadCallback() {
+            img.removeEventListener('load', loadCallback);
+            img.removeEventListener('error', errorCallback);
+            if (onComplete) {
+                onComplete(null, img);
+            }
+        }
+
+        function errorCallback() {
+            img.removeEventListener('load', loadCallback);
+            img.removeEventListener('error', errorCallback);
+            if (onComplete) {
+                onComplete(new Error(url));
+            }
+        }
+
+        img.addEventListener('load', loadCallback);
+        img.addEventListener('error', errorCallback);
+        img.src = url;
+        return img;
+    }
+
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "02922e2c-51f4-411c-b344-f20c2e98489e",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/ResourceManager.ts

@@ -0,0 +1,430 @@
+import { AssetManager } from 'cc';
+import { director } from 'cc';
+import { SpriteAtlas } from 'cc';
+import { __private } from 'cc';
+import { isValid } from 'cc';
+import { SceneAsset } from 'cc';
+import { assetManager, Asset, Node, SpriteFrame, Constructor } from 'cc';
+import { DEBUG } from 'cc/env';
+import { ResConfig } from '../config/CommonEnum';
+
+export enum AssetType {
+    SpriteFrame = 1,
+    Prefab = 2,
+    Scene = 3,
+    AudioClip = 4,
+    SpriteAtlas = 5,
+    TextAsset = 6,
+    JsonAsset = 7,
+    Font = 8,
+    Material = 9,
+    AnimationClip = 10,
+    EffectAsset = 11,
+    Texture2D = 12,
+    RawAsset = 13,
+}
+export type AssetsType<T = Asset> = __private.__types_globals__Constructor<T> | null;
+
+export class ResourceManager {
+    private static _instance: ResourceManager;
+    private loadedAssets: Map<string, { refCount, asset: Asset; bundleName: string }> = new Map(); // 记录已加载的资源及其所属 Bundle
+
+    timeout: any;;
+    private constructor() { }
+
+    public static get instance(): ResourceManager {
+        if (!ResourceManager._instance) {
+            ResourceManager._instance = new ResourceManager();
+        }
+        return ResourceManager._instance;
+    }
+
+    /**
+     * 记录加载的资源
+     * @param path 资源路径
+     * @param asset 资源对象
+     * @param bundleName Bundle 名称
+     */
+    public trackAsset(path: string, asset: Asset, bundleName: string): void {
+        let key = this.getAssetKey(path, bundleName);
+        if (!this.loadedAssets.has(key)) {
+            asset.asset_path = key;
+            this.loadedAssets.set(key, { refCount: 1, asset, bundleName });
+            asset.addRef(); // 增加引用计数
+        }
+    }
+
+    /**
+     * 根据路径和 Bundle 名称获取已加载的资源
+     * @param path 资源路径
+     * @param bundleName Bundle 名称
+     * @returns 资源对象，如果未加载则返回 null
+     */
+    public getAsset(path: string, bundleName: string): Asset | null {
+        const asset = assetManager.getBundle(bundleName).get(path);
+
+        return asset;
+    }
+
+    /**
+     * 根据路径和 Bundle 名称释放资源
+     * @param path 资源路径
+     * @param bundleName Bundle 名称
+     */
+    public releaseAssetPath(path: string, bundleName: string): void {
+        const key = this.getAssetKey(path, bundleName);
+        const record = this.loadedAssets.get(key);
+        if (record) {
+            let { asset } = record;
+            record.refCount--;
+            ResourceManager.instance.LogAssets(bundleName)
+            if (record.refCount <= 0) {
+                asset.decRef(); // 减少引用计数
+                this.loadedAssets.delete(key);
+
+            }
+        }
+    }
+
+    /**
+  * 根据路径和 Bundle 名称释放资源
+  * @param path 资源路径
+  * @param bundleName Bundle 名称
+  */
+    public releaseAsset(node: Node, bundleName: string): void {
+        const key = this.assetPath(node)
+        const record = this.loadedAssets.get(key);
+        if (record) {
+            const { asset } = record;
+            record.refCount--;
+            ResourceManager.instance.LogAssets(bundleName)
+
+            if (record.refCount <= 0) {
+                asset.decRef(); // 减少引用计数
+                this.loadedAssets.delete(key);
+
+            }
+        }
+    }
+
+    assetPath(node: Node) {
+        return (node["_prefab"]["asset"] as Asset).asset_path;
+    }
+
+
+    /**
+     * 根据 Bundle 名称释放资源
+     * @param bundleName Bundle 名称
+     */
+    public releaseAssetsByBundle(bundleName: string): void {
+        const loadedAssets = new Map(this.loadedAssets)
+        loadedAssets.forEach((record, key) => {
+            if (record.bundleName === bundleName) {
+                const { asset } = record;
+                record.refCount--;
+                ResourceManager.instance.LogAssets(bundleName)
+                if (record.refCount <= 0) {
+                    asset.decRef(); // 减少引用计数
+                    //assetManager.releaseAsset(asset);
+                    this.loadedAssets.delete(key);
+                    if (asset.refCount > 0) {
+                        const sys_key = asset.asset_path.replace(asset.asset_path.split(':').shift(), "sys")
+                        if (!this.loadedAssets.has(sys_key)) {
+                            this.loadedAssets.set(sys_key, { refCount: asset.refCount, asset, bundleName: "sys:" + bundleName });
+                        }
+                    } else {
+                        const sys_key = asset.asset_path.replace(asset.asset_path.split(':').shift(), "sys:" + bundleName)
+                        if (this.loadedAssets.has(sys_key)) {
+                            this.loadedAssets.delete(sys_key);
+                        }
+                    }
+                }
+            }
+        });
+        //等待系统 释放资源
+        clearTimeout(this.timeout)
+        this.timeout = setTimeout(() => {
+            loadedAssets.forEach((record, key) => {
+                if (record.bundleName.includes("sys:")) {
+                    const { asset } = record;
+                    //console.error(asset.refCount, asset.name)
+                    if (asset.refCount <= 0) {
+                        const asset_info: { uuid: string, path: string } = assetManager.getBundle(record.bundleName.split(":").pop()).getAssetInfo(asset.uuid) as { uuid: string, path: string }
+                        const sys_key = "sys:" + asset_info.path
+                        if (this.loadedAssets.has(sys_key)) {
+                            this.loadedAssets.delete(sys_key);
+                        }
+                    }
+                }
+            });
+        }, 500)
+        //   ResourceManager.instance.LogAssetsAll()
+    }
+
+    private remove_list: Map<string, { asset: Asset; bundleName: string }> = new Map(); // 记录已加载的资源及其所属 Bundle
+
+    /**
+     * 释放所有加载的资源
+     */
+    public releaseAllAssets(): void {
+        this.loadedAssets.forEach((record) => {
+            const { asset } = record;
+            assetManager.releaseAsset(asset);
+        });
+        this.loadedAssets.clear(); // 清空记录
+    }
+
+    /**
+     * 获取当前加载的资源数量
+     */
+    public getLoadedAssetCount(): number {
+        return this.loadedAssets.size;
+    }
+
+
+    /**
+     * 生成资源的唯一键
+     * @param path 资源路径
+     * @param bundleName Bundle 名称
+     * @returns 资源的唯一键
+     */
+    private getAssetKey(path: string, bundleName: string): string {
+        path = path.replace("/spriteFrame", "")
+        return `${bundleName}:${path}`;
+    }
+
+    LogAssets(bundleName: string) {
+        if (!DEBUG) {
+            return;
+        }
+        return
+        if (!ResConfig.DEBUG) {
+            return;
+        }
+        let list: { name: string, refCount: number }[] = []
+        this.loadedAssets.forEach((record, key) => {
+            if (record.bundleName === bundleName) {
+                const { asset } = record;
+                list.push({ name: asset.name, refCount: asset.refCount })
+            }
+        });
+        console.warn("资源计数：\n", list)
+    }
+
+    LogAssetsAll() {
+        if (!DEBUG) {
+            return;
+        }
+        if (!ResConfig.DEBUG) {
+            return;
+        }
+
+        setTimeout(() => {
+            let bundle_map: Map<string, { bundle_name: string, name: string, refCount: number, refCountAsset: number }[]> = new Map()
+            this.loadedAssets.forEach((record, key) => {
+                if (!bundle_map.has(record.bundleName)) {
+                    bundle_map.set(record.bundleName, [])
+                }
+                const list = bundle_map.get(record.bundleName)
+                const { asset, refCount } = record;
+                list.push({ bundle_name: record.bundleName, name: asset.name, refCount: refCount, refCountAsset: asset.refCount })
+            });
+            console.warn("资源计数：\n", Array.from(bundle_map.values()))
+
+            console.warn("资源总数：", assetManager.assets.count)
+            console.warn("资源总数：", assetManager.assets)
+        }, 500)
+
+    }
+
+
+
+
+
+
+    //=====================
+
+    /**
+     * 加载资源并自动记录
+     * @param bundleName Bundle 名称
+     * @param path 资源路径
+     * @param type 资源类型
+     * @returns 加载的资源
+     */
+    public static getAsset<T extends Asset>(bundleName: string, path: string, type: any) {
+        const bundle = assetManager.getBundle(bundleName);
+        if (!bundle) {
+            throw new Error(`Bundle "${bundleName}" is not loaded.`);
+        }
+        try {
+            // 检查资源是否已加载
+            let asset = bundle.get(path);
+            if (!asset || asset.name === '') {
+                asset = bundle.get(path + '/spriteFrame');
+            }
+            if (!asset || asset.name === '') {
+                //console.error('getAsset报错了1：', bundleName, path)
+            }
+            return asset as T
+        } catch (error) {
+            console.error('报错了：', path)
+        }
+
+        return null;
+    }
+    public static async loadAsset<T extends Asset>(
+        bundleName: string,
+        path: string,
+        type?: any
+    ): Promise<T> {
+        let bundle = assetManager.getBundle(bundleName);
+        if (!bundle) {
+            bundle = await new Promise<AssetManager.Bundle>((resolve, reject) => {
+                assetManager.loadBundle(bundleName, (err, bundle) => {
+                    if (err) {
+                        console.error(`${bundleName}加载失败`);
+                        reject(err);
+                        return;
+                    }
+                    resolve(bundle);
+                });
+            });
+        }
+        // 检查资源是否已加载
+        let asset = bundle.get(path);
+
+        if (asset) {
+            //console.log('已加载==', asset.refCount)
+            // 记录加载的资源
+            ResourceManager.instance.trackAsset(path, asset, bundleName);
+            ResourceManager.instance.LogAssets(bundleName)
+            return asset as T;
+        }
+
+        // 加载资源
+        return new Promise<T>((resolve, reject) => {
+            bundle.load(path, (err, asset) => {
+                if (err) {
+                    console.error(`${bundleName}-加载资源失败: ${path}`);
+                    resolve(null);
+                    return;
+                }
+                console.log('--加载', path)
+                // 记录加载的资源
+                ResourceManager.instance.trackAsset(path, asset, bundleName);
+                ResourceManager.instance.LogAssets(bundleName)
+
+                resolve(asset as T);
+            });
+        });
+    }
+
+    // ab.preloadDir("home", (finished: number, total: number, item: any) => {
+    //     pre(parseInt((finished / total * 100).toFixed(1)));
+    // }, () => {
+
+    // })
+
+    static async loadBundle(name: string): Promise<AssetManager.Bundle> {
+
+        const ab = assetManager.getBundle(name)
+        if (ab) {
+            return ab
+        } else {
+            var promise = new Promise<AssetManager.Bundle>(resolve => {
+                //加载bundle——预制体
+                assetManager.loadBundle(name, (err, ab: AssetManager.Bundle) => {
+                    if (err) {
+                        console.warn(`bundle名称：${name} `, err);
+                        return;
+                    }
+                    resolve(ab);
+                });
+            });
+            return promise;
+        }
+    }
+
+    static async preloadDir(bundleName: string, dirName: string, pre: Function) {
+        return new Promise<void>(resolve => {
+            assetManager.getBundle(bundleName).preloadDir(dirName, (finished: number, total: number, item: any) => {
+                pre(Math.floor((finished / total * 100)));
+            }, async () => {
+                resolve();
+            })
+        });
+    }
+
+
+    static async loadDir(bundleName: string, dirName: string, type: any, pre: Function) {
+        return new Promise<void>(resolve => {
+            //console.warn(bundleName, dirName)
+
+            assetManager.getBundle(bundleName).loadDir(dirName, type, (finished: number, total: number, item: any) => {
+                pre(Math.floor((finished / total * 100)));
+            }, async (error, assets) => {
+                // 记录加载的资源
+                assets.forEach(asset => {
+                    const asset_info: { uuid: string, path: string } = assetManager.getBundle(bundleName).getAssetInfo(asset.uuid) as { uuid: string, path: string }
+                    //console.warn(asset_info.path)
+                    ResourceManager.instance.trackAsset(asset_info.path, asset, bundleName);
+                });
+                resolve();
+            })
+        });
+    }
+
+
+    static runScene(scene: SceneAsset) {
+        director.runScene(scene);
+    }
+    ///加载场景
+    static async loadScene(bundleName: string, name: string, pre: Function): Promise<SceneAsset> {
+        var promise = new Promise<SceneAsset>(async resolve => {
+            let bundle = assetManager.getBundle(bundleName)
+            //   console.warn("-111-加载c错了=", bun);
+            if (!bundle) {
+                bundle = await new Promise<any>(resolve => {
+                    assetManager.loadBundle(bundleName, (err, bundle) => {
+                        resolve(bundle)
+                    });
+                })
+            }
+            if (bundle) {
+                bundle.loadScene(name, SceneAsset, (finished: number, total: number, item: any) => {
+                    pre(Math.floor((finished / total * 100)));
+                }, (err, prefab) => {
+                    if (err) {
+                        console.warn("--加载c错了=", bundleName, name, err);
+                    }
+                    resolve(prefab);
+                });
+            } else {
+                resolve(null)
+            }
+        });
+        return promise;
+    }
+
+    ///加载场景
+    static async preloadScene(bundleName: string, name: string, pre: Function): Promise<SceneAsset> {
+        var promise = new Promise<SceneAsset>(resolve => {
+            const bun = assetManager.getBundle(bundleName)
+            if (bun) {
+                bun.preloadScene(name, SceneAsset, (finished: number, total: number, item: any) => {
+                    pre(Math.floor((finished / total * 100)));
+                }, (err) => {
+                    if (err) {
+                        console.warn("预加载c错了=", bundleName, name, err);
+                    }
+                    resolve(null)
+                });
+            } else {
+                resolve(null)
+            }
+        });
+        return promise;
+    }
+
+
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "d08bdc4d-8ce1-4da2-a96f-f9dac911d36d",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/core/home/StateMachine.ts

@@ -0,0 +1,93 @@
+// 抽象状态基类
+abstract class GameState {
+    delegate: IStateMachine;
+    constructor(delegate: IStateMachine) {
+        this.delegate = delegate;
+    }
+
+    abstract enter(): void;
+    abstract execute(): void;
+    exit(): void {
+        console.log(`${this.constructor.name} 状态退出`);
+    }
+}
+export interface IStateMachine {
+    /**下一个状态 */
+    next(): void;
+    /**跳转到指定状态 */
+    goToState(index: number): void;
+}
+
+// 状态机类
+export class StateMachine implements IStateMachine {
+    public states: GameState[];
+    private currentStateIndex: number = 0;
+    constructor() {
+
+    }
+    private transitionToState(index: number) {
+        const currentState = this.states[this.currentStateIndex];
+        currentState.exit();
+        this.currentStateIndex = index;
+        this.states[this.currentStateIndex].enter();
+        this.states[this.currentStateIndex].execute();
+    }
+
+    public next() {
+        this.transitionToState(this.currentStateIndex + 1);
+    }
+
+    public goToState(index: number) {
+        if (index >= 0 && index < this.states.length) {
+            this.transitionToState(index);
+        }
+    }
+}
+
+export class GameController {
+
+}
+
+// 具体状态类：开始游戏
+export class StartGameState extends GameState {
+    enter() { console.log("进入游戏..."); }
+    execute() {
+        console.log("准备开始游戏...");
+        setTimeout(() => this.delegate.next(), 1000); // 自动进入下一个状态
+    }
+}
+
+// 具体状态类：游戏中
+export class InGameState extends GameState {
+    enter() { console.log("进入游戏中..."); }
+    execute() {
+        console.log("正在游戏中...");
+        setTimeout(() => this.delegate.next(), 1000);
+    }
+}
+
+// 具体状态类：弹出选择框
+export class PopupState extends GameState {
+    enter() { console.log("弹出选择框..."); }
+    execute() {
+        console.log("等待玩家选择...");
+        setTimeout(() => {
+            const choice = prompt("请选择 (确认/取消): ");
+            this.onUserChoice(choice || "取消");
+        }, 1000);
+    }
+
+    private onUserChoice(choice: string): void {
+        if (choice === "确认") {
+            this.delegate.goToState(0)
+        } else {
+            this.delegate.next()
+        }
+    }
+}
+
+// 具体状态类：结束游戏
+export class EndGameState extends GameState {
+    enter() { console.log("游戏结束..."); }
+    execute() { console.log("感谢您的游玩！"); }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "333715ab-606b-4338-bfa5-8764dee9f716",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}