@chiyou/minigame-framework 1.0.0 → 1.0.2

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f0f3f233-9b1c-4e3e-8ca1-8de53bbaf818",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,296 @@
+import { AudioClip, AudioSource } from "cc";
+import { LogUtils } from "../Utils/LogUtils";
+import { ResMgr } from "./ResMgr";
+import { PlatformID } from "../Definition/SystemDefinition";
+import { FrameworkBase } from "../Definition/FrameworkBase";
+import { BaseMgr } from "./BaseMgr";
+
+export class AudioMgr extends BaseMgr {
+    public static Instance: AudioMgr = null;
+    static TAG: string = "AudioMgr";
+
+    private effectSwitch: boolean = false;
+    private effectAudioSource: AudioSource = null;
+
+    private musicSwitch: boolean = false;
+    private musicAudioSource: AudioSource = null;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (AudioMgr.Instance === null) {
+            AudioMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this.effectAudioSource = this.node.addComponent(AudioSource);
+        this.musicAudioSource = this.node.addComponent(AudioSource);
+
+        this.effectSwitch = false;
+        this.effectAudioSource.volume = 0;
+
+        this.musicSwitch = false;
+        this.musicAudioSource.volume = 0;
+
+        let effectStatus: boolean = true;
+        let effectSwitch = localStorage.getItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch);
+        let effectSwitchOld = localStorage.getItem(FrameworkBase.LocalStorage.Key_Settings_EffectSwitch);
+        
+        if (effectSwitch !== null && effectSwitch !== "") {
+            if (effectSwitch === "0") {
+                effectStatus = false;
+            } else if (effectSwitch === "1") {
+                effectStatus = true;
+            } else {
+                effectStatus = true;
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+            }
+        } else if (effectSwitchOld !== null && effectSwitchOld !== "") {
+            if (effectSwitchOld === "0") {
+                effectStatus = false;
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "0");
+            } else if (effectSwitchOld === "1") {
+                effectStatus = true;
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+            } else {
+                effectStatus = true;
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+            }
+            localStorage.removeItem(FrameworkBase.LocalStorage.Key_Settings_EffectSwitch);
+        } else {
+            effectStatus = true;
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+        }
+        this.initEffectSwitch(effectStatus);
+
+        let musicStatus: boolean = true;
+        let musicSwitch = localStorage.getItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch);
+        let musicSwitchOld = localStorage.getItem(FrameworkBase.LocalStorage.Key_Settings_MusicSwitch);
+        
+        if (!this.supportMusic()) {
+            musicStatus = false;
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "0");
+        } else {
+            if (musicSwitch !== null && musicSwitch !== "") {
+                if (musicSwitch === "0") {
+                    musicStatus = false;
+                } else if (musicSwitch === "1") {
+                    musicStatus = true;
+                } else {
+                    musicStatus = true;
+                    localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "1");
+                }
+            } else if (musicSwitchOld !== null && musicSwitchOld !== "") {
+                if (musicSwitchOld === "0") {
+                    musicStatus = false;
+                    localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "0");
+                } else if (musicSwitchOld === "1") {
+                    musicStatus = true;
+                    localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "1");
+                } else {
+                    musicStatus = true;
+                    localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "1");
+                }
+                localStorage.removeItem(FrameworkBase.LocalStorage.Key_Settings_MusicSwitch);
+            } else {
+                musicStatus = true;
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "1");
+            }
+        }
+        this.initMusicSwitch(musicStatus);
+        
+        LogUtils.Instance.log(AudioMgr.TAG, "init() finished.");
+    }
+
+    public getEffectSwitch(): boolean {
+        return this.effectSwitch;
+    }
+
+    public getMusicSwitch(): boolean {
+        return this.musicSwitch;
+    }
+
+    public toggleEffectSwitch(): void {
+        if (!this.effectSwitch) {
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+            this.turnOnEffect();
+        } else {
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "0");
+            this.turnOffEffect();
+        }
+    }
+
+    private initEffectSwitch(status: boolean) {
+        if (status) {
+            this.turnOnEffect();
+        } else {
+            this.turnOffEffect();
+        }
+    }
+
+    private turnOnEffect(): void {
+        if (this.effectSwitch) {
+            return;
+        }
+
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOnEffect()");
+
+        this.effectSwitch = true;
+        this.effectAudioSource.volume = 1;
+    }
+
+    private turnOffEffect(): void {
+        if (!this.effectSwitch) {
+            return;
+        }
+
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOffEffect()");
+
+        this.effectSwitch = false;
+        this.effectAudioSource.volume = 0;
+    }
+
+    public playEffect(url: string) {
+        if (!this.effectSwitch) {
+            return;
+        }
+
+        let audioClip: AudioClip = ResMgr.Instance.getAsset("Sounds", url);
+        if (audioClip == null) {
+            LogUtils.Instance.log(AudioMgr.TAG, "playEffect() error Sounds: " + url + "not loaded");
+            return;
+        }
+        this.effectAudioSource.playOneShot(audioClip);
+    }
+
+    public supportMusic(): boolean {
+        if (this.getCurrentPlatformID() === PlatformID.ID_MiniGame_ZhiFuBao) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public toggleMusicSwitch(): void {
+        if (this.supportMusic()) {
+            if (!this.musicSwitch) {
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "1");
+                this.turnOnMusic();
+            } else {
+                localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "0");
+                this.turnOffMusic();
+            }
+        } else {
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_MusicSwitch, "0");
+        }
+    }
+
+    private initMusicSwitch(status: boolean) {
+        if (status) {
+            this.turnOnMusic();
+        } else {
+            this.turnOffMusic();
+        }
+    }
+
+    private turnOnMusic(): void {
+        if (!this.supportMusic()) {
+            return;
+        }
+
+        if (this.musicSwitch) {
+            return;
+        }
+
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOnMusic()");
+
+        this.musicSwitch = true;
+        this.musicAudioSource.volume = 1;
+
+        this._playMusic();
+    }
+
+    private turnOffMusic(): void {
+        if (!this.supportMusic()) {
+            return;
+        }
+
+        if (!this.musicSwitch) {
+            return;
+        }
+
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOffMusic()");
+
+        this.musicSwitch = false;
+        this.musicAudioSource.volume = 0;
+
+        this._stopMusic();
+    }
+
+    public playMusic(url: string) {
+        if (!this.supportMusic()) {
+            return;
+        }
+
+        let audioClip: AudioClip = ResMgr.Instance.getAsset("Sounds", url);
+        if (audioClip == null) {
+            LogUtils.Instance.log(AudioMgr.TAG, "playBgMusic() error Sounds: " + url + "not loaded");
+            return;
+        }
+        this.musicAudioSource.clip = audioClip;
+
+        this._playMusic();
+    }
+
+    private _playMusic(): void {
+        if (!this.musicSwitch) {
+            return;
+        }
+
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+
+        this.musicAudioSource.loop = true;
+        this.musicAudioSource.play();
+    }
+
+    private _stopMusic(): void {
+        this.musicAudioSource.stop();
+    }
+
+    public pauseMusic(): void {
+        if (!this.supportMusic()) {
+            return;
+        }
+
+        if (!this.musicSwitch) {
+            return;
+        }
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+
+        this.musicAudioSource.pause();
+    }
+
+    public resumeMusic(): void {
+        if (!this.supportMusic()) {
+            return;
+        }
+
+        if (!this.musicSwitch) {
+            return;
+        }
+
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+
+        this.musicAudioSource.play();
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f4a022c4-714c-4773-b59d-b142fb602016",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,130 @@
+import { Component, sys } from "cc";
+import { PlatformID } from "../Definition/SystemDefinition";
+import { LogUtils } from "../Utils/LogUtils";
+import { AbsAdAdapter } from "../Adapter/AdAdapter/AbsAdAdapter";
+import { AbsPlatformAdapter } from "../Adapter/PlatformAdapter/AbsPlatformAdapter";
+
+export abstract class BaseMgr extends Component {
+    public static Instance: BaseMgr = null;
+    static TAG: string = "BaseMgr";
+
+    private static currentPlatformID: PlatformID = PlatformID.ID_UNKNOWN;
+
+    private static platformAdapterImpl: AbsPlatformAdapter = null;
+    private static adAdapterImpl: AbsAdAdapter = null;
+
+    onLoad(): void {
+        if (BaseMgr.Instance !== null) {
+            return;
+        }
+
+        this.onInit();
+    }
+
+    private onInit(): void {
+        BaseMgr.Instance = this;
+
+        let sysPlatform: any = sys.platform;
+        LogUtils.Instance.log(BaseMgr.TAG, "sysPlatform=" + sysPlatform);        
+
+        BaseMgr.currentPlatformID = PlatformID.ID_UNKNOWN;
+
+        if (sysPlatform === sys.Platform.DESKTOP_BROWSER) {
+            BaseMgr.currentPlatformID = PlatformID.ID_H5_DesktopBrowser;
+        }
+
+        try {
+            if (window["wx"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_WeiXin;
+            }
+        } catch (e) {
+        }
+        
+        try {
+            if (window["tt"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_DouYin;
+            }
+        } catch (e) {
+        }
+
+        try {
+            if (window["ks"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_KuaiShou;
+            }
+        } catch (e) {
+        }
+
+        try {
+            if (window["my"]) {
+                if (sysPlatform === sys.Platform.ALIPAY_MINI_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_ZhiFuBao;
+                }
+            }
+        } catch (e) {
+        }
+
+        try {
+            if (window["bl"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_Bilibili;
+            }
+        } catch (e) {
+        }
+
+        try {
+            if (window["tap"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_TapTap;
+            }
+        } catch (e) {
+        }
+
+        try {
+            if (window["jd"]) {
+                BaseMgr.currentPlatformID = PlatformID.ID_MiniGame_JingDong;
+            }
+        } catch (e) {
+
+        }
+
+        try {
+            if (window["qg"]) {
+                if (sysPlatform === sys.Platform.XIAOMI_QUICK_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_QuickGame_XiaoMi;
+                } else if (sysPlatform === sys.Platform.OPPO_MINI_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_QuickGame_Oppo;
+                } else if (sysPlatform === sys.Platform.HONOR_MINI_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_QuickGame_Honor;
+                } else if (sysPlatform === sys.Platform.VIVO_MINI_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_QuickGame_Vivo;
+                } else if (sysPlatform === sys.Platform.HUAWEI_QUICK_GAME) {
+                    BaseMgr.currentPlatformID = PlatformID.ID_QuickGame_HuaWei;
+                }
+            }
+        } catch (e) {
+            
+        }
+
+        LogUtils.Instance.log(BaseMgr.TAG, "currentPlatformID=" + BaseMgr.currentPlatformID + ", ID=" + PlatformID[BaseMgr.currentPlatformID]);
+
+        LogUtils.Instance.log(BaseMgr.TAG, "init() finished.");
+    }
+
+    public getCurrentPlatformID(): PlatformID {
+        return BaseMgr.currentPlatformID;
+    }
+
+    public setPlatformAdapter(platformAdapterImpl: AbsPlatformAdapter): void {
+        BaseMgr.platformAdapterImpl = platformAdapterImpl;
+    }
+
+    public setAdAdapter(adAdapterImpl: AbsAdAdapter): void {
+        BaseMgr.adAdapterImpl = adAdapterImpl;
+    }
+
+    public getPlatformAdapter(): AbsPlatformAdapter {
+        return BaseMgr.platformAdapterImpl;
+    }
+
+    public getAdAdapter(): AbsAdAdapter {
+        return BaseMgr.adAdapterImpl;
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "56f6c091-3b2c-4c6f-88d5-f1e167df66ec",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

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

@@ -0,0 +1,102 @@
+import { LogUtils } from '../Utils/LogUtils';
+import { BaseMgr } from './BaseMgr';
+
+export class EventItem {
+    name: string = "";
+    callback: Function = null;
+    target: any = null;
+
+    constructor(name: string, callback: Function, target: any) {
+        this.name = name;
+        this.callback = callback;
+        this.target = target;
+    }
+}
+
+export class EventMgr extends BaseMgr {
+    public static Instance: EventMgr = null;
+    static TAG: string = "EventMgr";
+
+    private eventList: Map<string, Array<EventItem>> = null;
+
+    onLoad(): void {
+        super.onLoad();
+
+        if (EventMgr.Instance === null) {
+            EventMgr.Instance = this;
+        } else {
+            this.destroy();
+            return;
+        }
+    }
+
+    public init(): void {
+        this.eventList = new Map<string, Array<EventItem>>();
+
+        LogUtils.Instance.log(EventMgr.TAG, "init() finished.");
+    }
+
+    public on(eventName: string, callback: Function, target: any):void {        
+        let array: Array<EventItem> = null;
+        if (this.eventList.has(eventName)) {
+            array = this.eventList.get(eventName);
+        }
+        if (array === null) {
+            array = new Array<EventItem>();
+        } else {
+            for (let i = 0; i < array.length; i++) {
+                let item = array[i];
+                if (item.callback === callback && item.target === target) {
+                    return;
+                }
+            }
+        }
+
+        let eventItem = new EventItem(eventName, callback, target);
+        array.push(eventItem);
+        this.eventList.set(eventName, array);
+    }
+
+    public off(eventName: string, callback: Function, target: any):void {
+        let array: Array<EventItem> = null;
+        if (this.eventList.has(eventName)) {
+            array = this.eventList.get(eventName);
+        }
+
+        if (array === null) {
+            return;
+        }
+
+        for (let i = 0; i < array.length; i++) {
+            let item = array[i];
+            if (item.callback === callback && item.target === target) {
+                array.splice(i, 1);
+            }
+        } 
+
+        this.eventList.set(eventName, array);
+    }
+
+    public offAll(eventName: string) {
+        if (this.eventList.has(eventName)) {
+            this.eventList.delete(eventName);
+        }
+    }
+
+    public emit(eventName: string, ...data: any) {
+        let array: Array<EventItem> = null;
+        if (this.eventList.has(eventName)) {
+            array = this.eventList.get(eventName);
+        }
+        if (array === null || array.length === 0) {
+            return;
+        }
+
+        for (let i = 0; i < array.length; i++) {
+            let item = array[i];
+            if (item.callback && item.target) {
+                item.callback.apply(item.target, data);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "f754a0fa-0299-4198-8c23-82a2cbed80b9",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}