@chiyou/minigame-framework 1.0.0 → 1.0.2

package/assets/Scripts/Framework/Manager/SystemMgr.ts

@@ -0,0 +1,264 @@
+import { AbsPlatformAdapter } from "../Adapter/PlatformAdapter/AbsPlatformAdapter";
+import { PlatformAdapterBilibili } from "../Adapter/PlatformAdapter/PlatformAdapterBilibili";
+import { PlatformAdapterDesktopBrowser } from "../Adapter/PlatformAdapter/PlatformAdapterDesktopBrowser";
+import { PlatformAdapterDouYin } from "../Adapter/PlatformAdapter/PlatformAdapterDouYin";
+import { PlatformAdapterHonor } from "../Adapter/PlatformAdapter/PlatformAdapterHonor";
+import { PlatformAdapterHuaWei } from "../Adapter/PlatformAdapter/PlatformAdapterHuaWei";
+import { PlatformAdapterJingDong } from "../Adapter/PlatformAdapter/PlatformAdapterJingDong";
+import { PlatformAdapterKuaiShou } from "../Adapter/PlatformAdapter/PlatformAdapterKuaiShou";
+import { PlatformAdapterOppo } from "../Adapter/PlatformAdapter/PlatformAdapterOppo";
+import { PlatformAdapterTapTap } from "../Adapter/PlatformAdapter/PlatformAdapterTapTap";
+import { PlatformAdapterVivo } from "../Adapter/PlatformAdapter/PlatformAdapterVivo";
+import { PlatformAdapterWeiXin } from "../Adapter/PlatformAdapter/PlatformAdapterWeiXin";
+import { PlatformAdapterXiaoMi } from "../Adapter/PlatformAdapter/PlatformAdapterXiaoMi";
+import { PlatformAdapterZhiFuBao } from "../Adapter/PlatformAdapter/PlatformAdapterZhiFuBao";
+import { AppItem, CopyrightInfo, ICPItem, PlatformID } from "../Definition/SystemDefinition";
+import { LogUtils } from "../Utils/LogUtils";
+import { BaseMgr } from "./BaseMgr";
+
+export class SystemMgr extends BaseMgr {
+    public static Instance: SystemMgr = null;
+    static TAG: string = "SystemMgr";
+
+    private appItem: AppItem = null;
+    private copyrightInfo: CopyrightInfo = null;
+    private localGame: boolean = true;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (SystemMgr.Instance === null) {
+            SystemMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(appItem: AppItem, copyrightInfo: CopyrightInfo): void {
+        this.appItem = appItem;
+        this.copyrightInfo = copyrightInfo;
+
+        let currPlatformID: PlatformID = BaseMgr.Instance.getCurrentPlatformID();
+
+        if (this.appItem !== null && this.appItem.appIDMap !== null &&
+            this.appItem.appIDMap.has(currPlatformID)) {
+            LogUtils.Instance.log(SystemMgr.TAG, "appID=" + this.appItem.appIDMap.get(currPlatformID));
+        }
+
+        if (this.copyrightInfo && this.copyrightInfo.icpMap &&
+            this.copyrightInfo.icpMap.has(currPlatformID)) {
+            let icpItem: ICPItem = this.copyrightInfo.icpMap.get(currPlatformID);
+            if (icpItem !== null) {
+                this.localGame = icpItem.isLocalGame;
+            }
+        }
+        LogUtils.Instance.log(SystemMgr.TAG, "isLocalGame=" + this.localGame);
+        
+        let platformAdapterImpl: AbsPlatformAdapter = null;
+        switch(currPlatformID) {
+            case PlatformID.ID_H5_DesktopBrowser:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterDesktopBrowser);
+                break;
+            case PlatformID.ID_MiniGame_WeiXin:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterWeiXin);
+                break;
+            case PlatformID.ID_MiniGame_DouYin:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterDouYin);
+                break;
+            case PlatformID.ID_MiniGame_KuaiShou:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterKuaiShou);
+                break;
+            case PlatformID.ID_MiniGame_ZhiFuBao:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterZhiFuBao);
+                break;
+            case PlatformID.ID_MiniGame_Bilibili:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterBilibili);
+                break;
+            case PlatformID.ID_MiniGame_TapTap:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterTapTap);
+                break;
+            case PlatformID.ID_MiniGame_JingDong:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterJingDong);
+                break;
+            case PlatformID.ID_QuickGame_XiaoMi:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterXiaoMi);
+                break;
+            case PlatformID.ID_QuickGame_Oppo:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterOppo);
+                break;
+            case PlatformID.ID_QuickGame_Honor:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterHonor);
+                break;
+            case PlatformID.ID_QuickGame_Vivo:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterVivo);
+                break;
+            case PlatformID.ID_QuickGame_HuaWei:
+                platformAdapterImpl = this.node.addComponent(PlatformAdapterHuaWei);
+                break;
+            default:
+                break;
+        }
+        if (platformAdapterImpl !== null) {
+            BaseMgr.Instance.setPlatformAdapter(platformAdapterImpl);
+        }
+
+        if (this.getPlatformAdapter() !== null) {
+            this.getPlatformAdapter().onInit(this);
+        }
+
+        LogUtils.Instance.log(SystemMgr.TAG, "init() finished.");
+    }
+
+    public getAppItem(): AppItem {
+        return this.appItem;
+    }
+
+    public isLocalGame(): boolean {
+        return this.localGame;
+    }
+
+    public getScreenBrightness(callback: Function): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        this.getPlatformAdapter().getScreenBrightness(callback);
+    }
+
+    public setScreenBrightness(value: number): void {
+        if (value < 0) {
+            value = 0;
+        }
+        if (value > 1) {
+            value = 1;
+        }
+
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        this.getPlatformAdapter().setScreenBrightness(value);
+    }
+
+    public setKeepScreenOn(keepScreenOn: boolean): void {
+        if (this.getPlatformAdapter() === null) {
+            return null;
+        }
+
+        this.getPlatformAdapter().setKeepScreenOn(keepScreenOn);
+    }
+
+    public exitGame(): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        this.getPlatformAdapter().exitGame();
+    }
+
+    public getSDKVersion(): string {
+        if (this.getPlatformAdapter() === null) {
+            return "";
+        }
+
+        return this.getPlatformAdapter().getSDKVersion();
+    }
+
+    public navigateToMiniProgram(appid: string, path?: string): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        this.getPlatformAdapter().navigateToMiniProgram(appid, path);
+    }
+
+    public reportEvent(eventId: string, data: JSON): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        this.getPlatformAdapter().reportEvent(eventId, data);
+    }
+
+    public supportRequest(): boolean {
+        let platformSupport: boolean = false;
+        switch (this.getCurrentPlatformID()) {
+            case PlatformID.ID_QuickGame_Oppo:
+            case PlatformID.ID_QuickGame_Honor:
+            case PlatformID.ID_QuickGame_HuaWei:
+                platformSupport = false;
+                break;
+            default:
+                platformSupport = true;
+                break;
+        }
+
+        return platformSupport && !this.isLocalGame();
+    }
+
+    public requestGet(path: string, requestParams: Map<string, string>|null, success: Function, fail: Function): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        if (success === null || fail === null) {
+            return;
+        }
+
+        if (!this.supportRequest()) {
+            fail();
+            return;
+        }
+
+        let url = path;
+        if (requestParams && requestParams.size > 0) {
+            let paramIndex = 0;
+
+            for (let entry of requestParams.entries()) {
+                paramIndex++;
+                url += (paramIndex === 1) ? "?" : "&";
+                url += entry[0] + "=" + entry[1];
+            }
+        }
+        LogUtils.Instance.log(SystemMgr.TAG, "requestGet", url);
+
+        this.getPlatformAdapter().requestGet(url, success, fail);
+    }
+
+    public requestPost(path: string, data: string, success: Function, fail: Function): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        if (success === null || fail === null) {
+            return;
+        }
+
+        if (!this.supportRequest()) {
+            fail();
+            return;
+        }
+
+        LogUtils.Instance.log(SystemMgr.TAG, "requestPost", path, data);
+
+        this.getPlatformAdapter().requestPost(path, data, success, fail);
+    }
+
+    public downloadFile(fileUrl: string, success: Function, fail: Function): void {
+        if (this.getPlatformAdapter() === null) {
+            return;
+        }
+
+        if (success === null || fail === null) {
+            return;
+        }
+
+        if (!this.supportRequest()) {
+            fail();
+            return;
+        }
+
+        this.getPlatformAdapter().downloadFile(fileUrl, success, fail);
+    }
+}

package/assets/Scripts/Framework/Manager/SystemMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "861b3bac-0239-4f50-9bf1-80fdfdca9fb1",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Manager/TimerMgr.ts

@@ -0,0 +1,80 @@
+import { LogUtils } from "../Utils/LogUtils";
+import { BaseMgr } from "./BaseMgr";
+
+interface ITimer {
+    tick: number;
+    interval: number;
+    repeat: number;
+    func: Function;
+    target: Object;
+}
+
+export class TimerMgr extends BaseMgr {    
+    public static Instance: TimerMgr = null;
+    static TAG: string = "TimerMgr";
+
+    private timers: ITimer[] = [];
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (TimerMgr.Instance === null) {
+            TimerMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this.timers = [];
+
+        LogUtils.Instance.log(TimerMgr.TAG, "init() finished.");
+    }
+
+    public addTimer(delay: number, interval: number, repeat: number, func: Function, target: Object) {
+        if (repeat === 0) {
+            return;
+        }
+
+        this.removeTimer(func, target);
+
+        this.timers.push({
+            tick: 0 - delay,
+            interval: interval,
+            repeat: repeat,
+            func: func,
+            target: target,
+        });
+
+    }
+
+    public removeTimer(func: Function, target: Object) {
+        for (let index = 0; index < this.timers.length; index++) {
+            const item = this.timers[index];
+            if (item.func === func && item.target === target) {
+                this.timers.splice(index, 1);
+                break;
+            }
+        }
+    }
+
+    protected update(dt: number): void {
+        for (let index = 0; index < this.timers.length; index++) {
+            const item = this.timers[index];
+            item.tick += dt * 1000;
+            if (item.tick >= item.interval) {
+                item.tick -= item.interval;
+                item.func.call(item.target);
+
+                if (item.repeat > 0) {
+                    item.repeat--;
+                    if (item.repeat === 0) {
+                        this.timers.splice(index, 1);
+                        index--;
+                    }
+                }
+            }
+        }
+    }
+}

package/assets/Scripts/Framework/Manager/TimerMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "e6dcf6b2-6ec4-4909-a212-a2f5db2e9f55",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/Scripts/Framework/Manager/UIMgr.ts

@@ -0,0 +1,267 @@
+import { Component, Node, Button, Prefab, instantiate, screen, UITransform, v3, view, ResolutionPolicy, math, Tween, tween, Label, UIComponent, Color, UIOpacity, Sprite, SpriteFrame, BlockInputEvents, Texture2D, gfx, Vec3, v2 } from 'cc';
+import { ResMgr } from './ResMgr';
+import { LogUtils } from '../Utils/LogUtils';
+import { ToastDuration } from '../Definition/UIDefinition';
+import { BaseMgr } from './BaseMgr';
+
+export class UICtrl extends Component {
+    protected views: Map<string, Node> = new Map<string, Node>();
+
+    onLoad(): void {
+        this.views = new Map<string, Node>();
+        this.load_all_object(this.node, "");
+    }
+
+    private load_all_object(root: Node, path: string): void {
+        for (let i = 0; i < root.children.length; i++) {
+            this.views.set(path + root.children[i].name, root.children[i]);
+            this.load_all_object(root.children[i], path + root.children[i].name + "/");
+        }
+    }
+
+    public set_button_listener(view_name: string, clickListener: Function, target?: Component) {
+        let view_node: Node = this.views.get(view_name);
+
+        if (!view_node) {
+            return;
+        }
+
+        let button: Button = view_node.getComponent(Button);
+        if (!button) {
+            return;
+        }
+
+        button.node.on("click", clickListener, target);
+    }
+}
+
+export class UIMgr extends BaseMgr {
+    public static Instance: UIMgr = null;
+    static TAG: string = "UIMgr";
+
+    private canvas: Node = null;
+    private uiMap: Map<string, Array<Node>> = null;
+
+    private windowWidth: number = 0;
+    private windowHeight: number = 0;
+
+    private node_toastRoot: Node = null;
+    private tween_toast: Tween<Node> = null;
+
+    private node_dialogRoot: Node = null;
+
+    public print(): void {
+        LogUtils.Instance.log("", this.uiMap);
+    }
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (UIMgr.Instance === null) {
+            UIMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this.canvas = this.node.parent;
+        this.uiMap = new Map<string, Array<Node>>();
+
+        let designSize: math.Size = view.getDesignResolutionSize();
+        view.setDesignResolutionSize(designSize.width, designSize.height, ResolutionPolicy.SHOW_ALL);
+
+        this.windowWidth = screen.windowSize.width;
+        this.windowHeight = screen.windowSize.height;
+
+        this.node_toastRoot = null;
+        this.tween_toast = null;
+
+        LogUtils.Instance.log(UIMgr.TAG, "init() finished.");
+    }
+
+    public create_ui(ui_name: string, parent?: Node): Node {
+        let uiPrefab: Prefab = ResMgr.Instance.getAsset("GUI", "UIPrefabs/" + ui_name);
+        if (!uiPrefab) {
+            return null;
+        }
+
+        let uiNode: Node = instantiate(uiPrefab);
+        if (!uiNode) {
+            return null;
+        }
+
+        if (parent) {
+            parent.addChild(uiNode);
+        }
+
+        uiNode.addComponent(ui_name + "_Ctrl");
+        
+        let array: Array<Node> = null;
+        if (this.uiMap.has(ui_name)) {
+            array = this.uiMap.get(ui_name);  
+        }
+        if (array === null) {
+            array = new Array<Node>();
+        }
+        array.push(uiNode);
+        
+        this.uiMap.set(ui_name, array);
+
+        return uiNode;
+    }
+
+    public destroy_ui(ui_name: string, node: Node) {       
+        if (this.uiMap.has(ui_name)) {
+            let array: Array<Node> = this.uiMap.get(ui_name);
+            
+            if (array !== null) {
+                let index = array.indexOf(node);
+                if (index >= 0) {
+                    node.removeFromParent();
+                    node.destroy();
+                    array.splice(index, 1);
+                }
+            }
+
+            if (array === null || array.length === 0) {
+                this.uiMap.delete(ui_name);
+            } else {
+                this.uiMap.set(ui_name, array);
+            }
+        }
+    }
+
+    public destroy_ui_all(ui_name: string) {
+        if (this.uiMap.has(ui_name)) {
+            let array: Array<Node> = this.uiMap.get(ui_name);
+            if (array !== null) {
+                for (let i = 0; i < array.length; i++) {
+                    let node: Node = array[i];
+                    node.removeFromParent();
+                    node.destroy();
+                }
+            }
+            this.uiMap.delete(ui_name);
+        }
+    }
+
+    public clear_ui_all() {
+        for (let ui_name of this.uiMap.keys()) {
+            this.destroy_ui_all(ui_name);
+        }
+    }
+
+    public adaptScreen(node: Node) {
+        // 用于背景适配整个屏幕
+        let nodeWidth = node.getComponent(UITransform).width;
+        let nodeHeight = node.getComponent(UITransform).height;
+
+        let scrScaleForShowAll = Math.min(this.windowWidth / nodeWidth, this.windowHeight / nodeHeight);
+        let realWidth = nodeWidth * scrScaleForShowAll;
+        let realHeight = nodeHeight * scrScaleForShowAll;
+
+        let scaleRatio = Math.max(this.windowWidth / realWidth, this.windowHeight / realHeight);
+        node.scale = v3(scaleRatio, scaleRatio, 1);
+    }
+
+    public setToastRootNode(node: Node): void {
+        this.node_toastRoot = node;
+    }
+
+    public showToast(content: string, toastDuration: ToastDuration = ToastDuration.Duration_Short): void {
+        if (this.node_toastRoot === null) {
+            return;
+        }
+
+        if (this.tween_toast !== null) {
+            this.tween_toast.stop();
+            this.tween_toast = null;
+        }
+
+        let showTime: number = 1.5;
+        if (toastDuration === ToastDuration.Duration_Long) {
+            showTime = 3;
+        }
+
+        let labelComponent: Label = this.node_toastRoot.getChildByName("Label").getComponent(Label);
+        labelComponent.string = content;
+        labelComponent.updateRenderData(true);
+        let textWidth: number = labelComponent.node.getComponent(UITransform).contentSize.width;
+
+        this.node_toastRoot.active = true;
+        this.node_toastRoot.getComponent(UITransform).width = textWidth + 80;
+        this.tween_toast = tween(this.node_toastRoot)
+            .delay(showTime)
+            .call(() => {
+                this.tween_toast = null;
+                this.node_toastRoot.active = false;
+            });
+        this.tween_toast.start();
+    }
+
+    public setDialogRootNode(node: Node): void {
+        this.node_dialogRoot = node;
+    }
+
+    public openDialog(ui_name: string, maskColor?: Color): Node {
+        if (!maskColor) {
+            maskColor = new Color(51, 51, 51, 230);
+        }
+
+        const whitePixelData = new Uint8Array([maskColor.r, maskColor.g, maskColor.b, maskColor.a]);
+        const texture = new Texture2D();
+        texture.reset({
+            width: 1,
+            height: 1,
+        });
+        texture.uploadData(whitePixelData);
+        let sf: SpriteFrame = new SpriteFrame();
+        sf.texture = texture;
+
+        let node_mask: Node = new Node("Node_Mask");
+        let sprite: Sprite = node_mask.addComponent(Sprite);
+        sprite.spriteFrame = sf;
+
+        let designSize: math.Size = view.getDesignResolutionSize();
+        node_mask.getComponent(UITransform).width = designSize.width;
+        node_mask.getComponent(UITransform).height = designSize.height;
+        UIMgr.Instance.adaptScreen(node_mask);
+
+        node_mask.addComponent(BlockInputEvents);
+
+        let node_agent: Node = new Node();
+        node_agent.addChild(node_mask);
+
+        let node_dialog: Node = this.create_ui(ui_name, node_agent);
+        if (node_dialog) {
+            this.node_dialogRoot.addChild(node_agent);
+            this.node_dialogRoot.active = true;
+        } else {
+            node_agent.destroy();
+        }
+
+        return node_dialog;
+    }
+
+    public closeDialog(ui_name: string, node: Node): void {
+        let hasNode: boolean = false;
+        if (this.uiMap.has(ui_name)) {
+            let array: Array<Node> = this.uiMap.get(ui_name);
+            
+            if (array !== null) {
+                let index = array.indexOf(node);
+                if (index >= 0) {
+                    hasNode = true;
+                }
+            }
+        }
+
+        if (hasNode) {
+            let node_agent: Node = node.parent;
+            this.destroy_ui(ui_name, node); 
+            node_agent.destroy();                       
+        }
+    }
+}

package/assets/Scripts/Framework/Manager/UIMgr.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "c6656c73-1e27-4334-b04e-bdbb9c702827",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}