idioms/idiom/assets/module_game/game/PlayerData.ts

import { ch } from "../../ch/ch";
import { gui } from "../../core/ui/ui";
import { Container } from "../../core/util_class/Container";
import GameData from "../../core/util_class/GameData";
import { UINotify } from "../../module_basic/ui_notify/UINotify";
import { Start } from "../../start/Start";
import { Layout_Main } from "../ui/UI_Main/Layout_Main";
import { UI_Main } from "../ui/UI_Main/UI_Main";

//定义事件
interface event_protocol {
    item_count(type: number, count: number): void;//道具数量改变
}

//排行榜key
export enum rand_type {
    floor = "floor",//最高层数
}

//自定义数据
export enum data_type {
    last_gift_sidebar = 'last_gift_sidebar',//最后一次侧边栏时间
    max_floor = 'max_floor',//最高层数
    coin = 'coin',//铜币
}

//每日数据
export enum day_data_type {
    isFavorite = 'isFavorite',//是否收藏
    pass_level = 'pass_level',//通关
    combine_num = 'combine_num',//匹配成语
    login_num = 'login_num',//登录奖励
    use_item = 'use_item',//使用道具
    watch_ad = 'watch_ad',//观看广告
    task_reward_state = 'task_reward_state',//任务奖励是否领取
}

//每周数据
export enum week_data_type {
    sign_day = 'sign_day',//签到奖励
}

//每月数据
export enum month_data_type {

}

export default class PlayerData extends GameData<data_type, day_data_type, week_data_type, month_data_type> {
    private static _instance: PlayerData;
    public event = ch.get_new_event<event_protocol>();
    //道具容器
    private items: Container = new Container();


    public static getInstance(gid: string, uid: string): PlayerData {
        if (!this._instance) {
            this._instance = new PlayerData(gid, uid, "PlayerData",
                new Map([
                    [data_type.max_floor, { min: 0 }],
                    [data_type.coin, { min: 0 }]
                ]),
                new Map([
                    [day_data_type.isFavorite, { min: 0 }],
                    [day_data_type.pass_level, { min: 0, max: 5 }],
                    [day_data_type.combine_num, { min: 0, max: 100 }],
                    [day_data_type.login_num, { min: 0, max: 1 }],
                    [day_data_type.use_item, { min: 0, max: 3 }],
                    [day_data_type.watch_ad, { min: 0, max: 8 }],
                ]),

                new Map([
                    [week_data_type.sign_day, { min: 0, max: 7 }],
                ]));
        }
        return this._instance;
    }

    //数据初始化
    protected on_init(): void {
        ch.sign.init(2, null, 7);
        this.items.addItem({ type: 1, count: 1 });
        this.items.addItem({ type: 2, count: 1 });
        this.items.addItem({ type: 3, count: 1 });
        this.items.addItem({ type: 5, count: 1 });
        //道具初始化
        ch.log.log("道具初始化", this);
    }

    //序列化加入自定义数据
    protected on_serialize(data: { [key: string]: number | string | any; }): void {
        data.sign = ch.sign.getSignData();
        data.items = this.items.serialize();
    }

    //反序列化加入自定义数据
    protected on_unserialize(data: { [key: string]: number | string | any; }): void {
        this.items.unserialize(data.items);
        ch.sign.init(2, data.sign, 7);
    }

    //是否使用远程数据
    protected on_check(local: any, remote: any): boolean {
        return true;
    }


    /**使用道具*/
    async use_item(type: number, count: number = 1) {
        // if (GameLink.getInst().state != GameState.wait) return;
        const layout = gui.get(UI_Main).getLayout<Layout_Main>();
        let ret = this.items.useCount(type, count);
        if (ret) {
            let b = true;
            if (type == 1) {
                layout.Container.eliminate();
            } else if (type == 2) {
                layout.Container.shuffle();
            } else if (type == 3) {
                layout.Container.Empty();
            }
            if (!b) {
                this.items.addCount(type, count);
            } else {
                this.set_use_item_num(1);
                this.event.emit(this.event.key.item_count, ret.type, ret.count);
                this.setDirty();
            }
        }
    }
    /**增加道具*/
    add_item(type: number, count: number = 1): void {
        let ret = this.items.addCount(type, count);
        if (ret) {
            this.event.emit(this.event.key.item_count, ret.type, ret.count);
            this.setDirty();
        }
    }
    set_item(type: number, count: number = 4): void {
        const c = this.get_item(type);
        if (type < count) {
            this.add_item(type, count - c);
        }
    }
    get_item(type: number): number {
        return this.items.getCount(type);
    }

    //获取签到天数
    public get_sign(): number {
        return this.week_data.get(week_data_type.sign_day);
    }

    //设置签到天数
    public set_sign(count: number) {
        this.week_data.set(week_data_type.sign_day, count);
    }

    //获取是否当日首次通过收藏进入
    public get_is_favorite(): number {
        return this.day_data.get(day_data_type.isFavorite);
    }

    //设置已从收藏进入
    public set_is_favorite(): void {
        this.day_data.set(day_data_type.isFavorite, 1);
        this.setDirty();
    }

    //获取关卡数
    public get_max_floor(): number {
        return this.data.get(data_type.max_floor);
    }

    //设置关卡数
    public set_max_floor(floor: number): void {
        this.data.set(data_type.max_floor, floor);
    }

    //获取金币数量
    public get_coin(): number {
        return this.data.get(data_type.coin);
    }

    //设置金币数量
    public set_coin(coin: number): void {
        this.data.set(data_type.coin, coin);
        this.setDirty();
    }

    //获取今日通关数
    public get_pass_level(): number {
        return this.day_data.get(day_data_type.pass_level);
    }

    //设置今日通关数
    public set_pass_level(level: number): void {
        this.day_data.add(day_data_type.pass_level, level);
    }

    //获取匹配成语数量
    public get_combine_num(): number {
        return this.day_data.get(day_data_type.combine_num);
    }

    //设置匹配成语数量
    public set_combine_num(num: number): void {
        this.day_data.add(day_data_type.combine_num, num);
        this.setDirty();
    }

    //获取登录次数
    public get_login_num(): number {
        return this.day_data.get(day_data_type.login_num);
    }

    //设置登录次数
    public set_login_num(num: number): void {
        this.day_data.add(day_data_type.login_num, num);
        this.setDirty();
    }

    //获取今日使用道具数量
    public get_use_item_num(): number {
        return this.day_data.get(day_data_type.use_item);
    }

    //设置今日使用道具数量
    public set_use_item_num(num: number): void {
        this.day_data.add(day_data_type.use_item, num);
    }

    //获取今日广告观看数量
    public get_watch_ad_num(): number {
        return this.day_data.get(day_data_type.watch_ad);
    }

    //设置今日广告观看数量
    public set_watch_ad_num(num: number): void {
        this.day_data.add(day_data_type.watch_ad, num);
        this.setDirty();
    }

    //获取任务奖励状态
    public get_task_state(): number {
        return this.day_data.get_Array(day_data_type.task_reward_state);
    }

    //设置任务奖励状态
    public set_task_state(task_state: any): void {
        this.day_data.set_Array(day_data_type.task_reward_state, task_state);
    }

    //////////////////////////////////////////////////////////////////////////////////////////
    protected async load_data(): Promise<{ [key: string]: any; }> {
        return super.load_data();
    }

    public user_info: { uid: string, nickName: string, avatar: string, province: string };
    public get nickName(): string {
        return this.user_info.nickName;
    }

    public get avatarUrl(): string {
        return this.user_info.avatar;
    }

    public async init_user_info() {
        this.user_info = {
            uid: this.uid,
            nickName: ch.sdk.get_player_info().nickName,
            avatar: ch.sdk.get_player_info().avatarUrl,
            province: ch.sdk.get_player_info().province
        }
    }

    protected async save_data(save_data: { [key: string]: any; }): Promise<boolean> {
        return super.save_data(save_data);
    }

    public async save_rank_floor() {
        const floor = this.data.get(data_type.max_floor);
        ch.sdk.saveRankData(rand_type.floor, floor, ch.sdk.updateType.none, 0, { province: this.user_info.province });
    }

    public async get_rank_floor(): Promise<{ list: any[], owner: any, index: number }> {
        let index = 0;
        const d = await ch.sdk.loadRankData(rand_type.floor, ch.sdk.updateType.none, 100, true, false);
            console.log("排行榜", d);
            if (d.data.own) {
                for (let i = 0; i < d.data.list.length; i++) {
                    if (d.data.own.userId === d.data.list[i].userId) {
                        index = i + 1;
                    }
                }
            } else {
                index = 101;
            }
            return { list: d.data.list, owner: d.data.own, index: index };
    }

    async loadPfInfo(): Promise<boolean> {
        return new Promise(async (resolve) => {
            let k = await ch.sdk.getUserInfo();
            if (k) {
                resolve(true);
            } else {
                UINotify.show("需要授权");
                resolve(false);
            }
        })
    }

}