@chiyou/minigame-framework 1.0.0

package/dist/Framework/Manager/AudioMgr.d.ts

@@ -0,0 +1,28 @@
+import { BaseMgr } from "./BaseMgr";
+export declare class AudioMgr extends BaseMgr {
+    static Instance: AudioMgr;
+    static TAG: string;
+    private effectSwitch;
+    private effectAudioSource;
+    private musicSwitch;
+    private musicAudioSource;
+    onLoad(): void;
+    init(): void;
+    getEffectSwitch(): boolean;
+    getMusicSwitch(): boolean;
+    toggleEffectSwitch(): void;
+    private initEffectSwitch;
+    private turnOnEffect;
+    private turnOffEffect;
+    playEffect(url: string): void;
+    supportMusic(): boolean;
+    toggleMusicSwitch(): void;
+    private initMusicSwitch;
+    private turnOnMusic;
+    private turnOffMusic;
+    playMusic(url: string): void;
+    private _playMusic;
+    private _stopMusic;
+    pauseMusic(): void;
+    resumeMusic(): void;
+}

package/dist/Framework/Manager/AudioMgr.js

@@ -0,0 +1,265 @@
+import { 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 {
+    constructor() {
+        super(...arguments);
+        this.effectSwitch = false;
+        this.effectAudioSource = null;
+        this.musicSwitch = false;
+        this.musicAudioSource = null;
+    }
+    onLoad() {
+        super.onLoad();
+        if (AudioMgr.Instance === null) {
+            AudioMgr.Instance = this;
+        }
+        else {
+            this.destroy();
+            return;
+        }
+    }
+    init() {
+        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 = 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 = 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.");
+    }
+    getEffectSwitch() {
+        return this.effectSwitch;
+    }
+    getMusicSwitch() {
+        return this.musicSwitch;
+    }
+    toggleEffectSwitch() {
+        if (!this.effectSwitch) {
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "1");
+            this.turnOnEffect();
+        }
+        else {
+            localStorage.setItem(FrameworkBase.LocalStorage.Key_AudioMgr_EffectSwitch, "0");
+            this.turnOffEffect();
+        }
+    }
+    initEffectSwitch(status) {
+        if (status) {
+            this.turnOnEffect();
+        }
+        else {
+            this.turnOffEffect();
+        }
+    }
+    turnOnEffect() {
+        if (this.effectSwitch) {
+            return;
+        }
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOnEffect()");
+        this.effectSwitch = true;
+        this.effectAudioSource.volume = 1;
+    }
+    turnOffEffect() {
+        if (!this.effectSwitch) {
+            return;
+        }
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOffEffect()");
+        this.effectSwitch = false;
+        this.effectAudioSource.volume = 0;
+    }
+    playEffect(url) {
+        if (!this.effectSwitch) {
+            return;
+        }
+        let 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);
+    }
+    supportMusic() {
+        if (this.getCurrentPlatformID() === PlatformID.ID_MiniGame_ZhiFuBao) {
+            return false;
+        }
+        return true;
+    }
+    toggleMusicSwitch() {
+        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");
+        }
+    }
+    initMusicSwitch(status) {
+        if (status) {
+            this.turnOnMusic();
+        }
+        else {
+            this.turnOffMusic();
+        }
+    }
+    turnOnMusic() {
+        if (!this.supportMusic()) {
+            return;
+        }
+        if (this.musicSwitch) {
+            return;
+        }
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOnMusic()");
+        this.musicSwitch = true;
+        this.musicAudioSource.volume = 1;
+        this._playMusic();
+    }
+    turnOffMusic() {
+        if (!this.supportMusic()) {
+            return;
+        }
+        if (!this.musicSwitch) {
+            return;
+        }
+        LogUtils.Instance.log(AudioMgr.TAG, "turnOffMusic()");
+        this.musicSwitch = false;
+        this.musicAudioSource.volume = 0;
+        this._stopMusic();
+    }
+    playMusic(url) {
+        if (!this.supportMusic()) {
+            return;
+        }
+        let 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();
+    }
+    _playMusic() {
+        if (!this.musicSwitch) {
+            return;
+        }
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+        this.musicAudioSource.loop = true;
+        this.musicAudioSource.play();
+    }
+    _stopMusic() {
+        this.musicAudioSource.stop();
+    }
+    pauseMusic() {
+        if (!this.supportMusic()) {
+            return;
+        }
+        if (!this.musicSwitch) {
+            return;
+        }
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+        this.musicAudioSource.pause();
+    }
+    resumeMusic() {
+        if (!this.supportMusic()) {
+            return;
+        }
+        if (!this.musicSwitch) {
+            return;
+        }
+        if (this.musicAudioSource.clip === null) {
+            return;
+        }
+        this.musicAudioSource.play();
+    }
+}
+AudioMgr.Instance = null;
+AudioMgr.TAG = "AudioMgr";

package/dist/Framework/Manager/BaseMgr.d.ts

@@ -0,0 +1,18 @@
+import { Component } from "cc";
+import { PlatformID } from "../Definition/SystemDefinition";
+import { AbsAdAdapter } from "../Adapter/AdAdapter/AbsAdAdapter";
+import { AbsPlatformAdapter } from "../Adapter/PlatformAdapter/AbsPlatformAdapter";
+export declare abstract class BaseMgr extends Component {
+    static Instance: BaseMgr;
+    static TAG: string;
+    private static currentPlatformID;
+    private static platformAdapterImpl;
+    private static adAdapterImpl;
+    onLoad(): void;
+    private onInit;
+    getCurrentPlatformID(): PlatformID;
+    setPlatformAdapter(platformAdapterImpl: AbsPlatformAdapter): void;
+    setAdAdapter(adAdapterImpl: AbsAdAdapter): void;
+    getPlatformAdapter(): AbsPlatformAdapter;
+    getAdAdapter(): AbsAdAdapter;
+}

package/dist/Framework/Manager/BaseMgr.js

@@ -0,0 +1,114 @@
+import { Component, sys } from "cc";
+import { PlatformID } from "../Definition/SystemDefinition";
+import { LogUtils } from "../Utils/LogUtils";
+export class BaseMgr extends Component {
+    onLoad() {
+        if (BaseMgr.Instance !== null) {
+            return;
+        }
+        this.onInit();
+    }
+    onInit() {
+        BaseMgr.Instance = this;
+        let sysPlatform = 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.");
+    }
+    getCurrentPlatformID() {
+        return BaseMgr.currentPlatformID;
+    }
+    setPlatformAdapter(platformAdapterImpl) {
+        BaseMgr.platformAdapterImpl = platformAdapterImpl;
+    }
+    setAdAdapter(adAdapterImpl) {
+        BaseMgr.adAdapterImpl = adAdapterImpl;
+    }
+    getPlatformAdapter() {
+        return BaseMgr.platformAdapterImpl;
+    }
+    getAdAdapter() {
+        return BaseMgr.adAdapterImpl;
+    }
+}
+BaseMgr.Instance = null;
+BaseMgr.TAG = "BaseMgr";
+BaseMgr.currentPlatformID = PlatformID.ID_UNKNOWN;
+BaseMgr.platformAdapterImpl = null;
+BaseMgr.adAdapterImpl = null;

package/dist/Framework/Manager/EventMgr.d.ts

@@ -0,0 +1,18 @@
+import { BaseMgr } from './BaseMgr';
+export declare class EventItem {
+    name: string;
+    callback: Function;
+    target: any;
+    constructor(name: string, callback: Function, target: any);
+}
+export declare class EventMgr extends BaseMgr {
+    static Instance: EventMgr;
+    static TAG: string;
+    private eventList;
+    onLoad(): void;
+    init(): void;
+    on(eventName: string, callback: Function, target: any): void;
+    off(eventName: string, callback: Function, target: any): void;
+    offAll(eventName: string): void;
+    emit(eventName: string, ...data: any): void;
+}

package/dist/Framework/Manager/EventMgr.js

@@ -0,0 +1,90 @@
+import { LogUtils } from '../Utils/LogUtils';
+import { BaseMgr } from './BaseMgr';
+export class EventItem {
+    constructor(name, callback, target) {
+        this.name = "";
+        this.callback = null;
+        this.target = null;
+        this.name = name;
+        this.callback = callback;
+        this.target = target;
+    }
+}
+export class EventMgr extends BaseMgr {
+    constructor() {
+        super(...arguments);
+        this.eventList = null;
+    }
+    onLoad() {
+        super.onLoad();
+        if (EventMgr.Instance === null) {
+            EventMgr.Instance = this;
+        }
+        else {
+            this.destroy();
+            return;
+        }
+    }
+    init() {
+        this.eventList = new Map();
+        LogUtils.Instance.log(EventMgr.TAG, "init() finished.");
+    }
+    on(eventName, callback, target) {
+        let array = null;
+        if (this.eventList.has(eventName)) {
+            array = this.eventList.get(eventName);
+        }
+        if (array === null) {
+            array = new Array();
+        }
+        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);
+    }
+    off(eventName, callback, target) {
+        let array = 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);
+    }
+    offAll(eventName) {
+        if (this.eventList.has(eventName)) {
+            this.eventList.delete(eventName);
+        }
+    }
+    emit(eventName, ...data) {
+        let array = 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);
+            }
+        }
+    }
+}
+EventMgr.Instance = null;
+EventMgr.TAG = "EventMgr";

package/dist/Framework/Manager/ExcelMgr.d.ts

@@ -0,0 +1,24 @@
+import { BaseMgr } from './BaseMgr';
+export declare class ExcelMgr extends BaseMgr {
+    static Instance: ExcelMgr;
+    static TAG: string;
+    onLoad(): void;
+    init(): void;
+    loadCallback: Function;
+    cntLoad: number;
+    curLoad: number;
+    csvTablesLoaded: any;
+    csvTables: any;
+    csvTableForArr: any;
+    tableCast: any;
+    tableComment: any;
+    addTable(tableName: string, tableContent: string, force?: boolean): void;
+    getTableArr(tableName: string): any;
+    getTable(tableName: string): any;
+    queryOne(tableName: string, key: string, value: any): any;
+    queryByID(tableName: string, ID: string): any;
+    queryAll(tableName: string, key: string, value: any): {};
+    queryIn(tableName: string, key: string, values: Array<any>): {};
+    queryByCondition(tableName: string, condition: any): {};
+    queryOneByCondition(tableName: string, condition: any): any;
+}