idioms/idiom/assets/ch/net/NetPlayer.ts

import { NetBase } from "./NetBase";
type EventNames<Map extends chsdk.OmitIndex<chsdk.EventsMap>> = Extract<keyof Map, string>;
type StartEventNames<Map extends chsdk.OmitIndex<chsdk.EventsMap>, Prefix extends string> = Extract<keyof Map, string> extends infer K ? K extends `${Prefix}${string}` ? K : never : never;
type EventParamFrist<Map extends chsdk.OmitIndex<chsdk.EventsMap>, Ev extends EventNames<Map>> = Ev extends keyof Map
    ? Map[Ev] extends (...args: infer Params) => any ? Params extends [infer First, ...any[]] ? First : never : never : never;
type PickEvent<T, Prefix1 extends string, Prefix2 extends string> = Pick<T, Extract<keyof T, `${Prefix1}${string}` | `${Prefix2}${string}`>>;
/**网络玩家*/
export class NetPlayer<GD> extends NetBase {
    public readonly evt = chsdk.get_new_event<PickEvent<GD, 'p_', 'online' | 'finish' | 'ready'>>();
    private _location: number = 0;
    private _online: boolean = true;
    private _ready: boolean = false;
    private _score: number = 0;
    public get score(): number { return this._score };
    private _rank: number = 0;
    public get rank(): number { return this._rank };
    private _totalRank: number = 0;
    public get totalRank(): number { return this._totalRank };
    private _ishost: boolean = true;
    /**房间位置0开头*/
    public get location(): number { return this._location };
    private _userData: { gid: string, head: string, hid: number, ip: string, loginTime: number, nickName: string, openId: string, option: string, pf: string, registerTime: number, userId: number };
    public get gid(): string { return this._userData.gid };
    public get head(): string { return this._userData.head };
    public get hid(): number { return this._userData.hid };
    public get province(): string { return chsdk.provinceCode2Name(this._userData.hid) ?? '其它' };
    public get ip(): string { return this._userData.ip };
    public get loginTime(): number { return this._userData.loginTime };
    public get nickName(): string { return this._userData.nickName || '玩家' + this._userData.userId };
    public get openId(): string { return this._userData.openId };
    public get option(): string { return this._userData.option };
    public get pf(): string { return this._userData.pf };
    public get userId(): number { return this._userData.userId };
    public get registerTime(): number { return this._userData.registerTime };
    /**是否是主机*/
    public get isHost(): boolean { return this._ishost };
    /**是否准备*/
    public get ready(): boolean { return this._ready };
    /**是否在线*/
    public get online(): boolean { return this._online };
    /**是否能开启匹配*/
    public get canMatch(): boolean { return this.online && this.ready };
    private _rankInfo: { LowerRank: number, Rank: number, Star: number } | null;
    /**段位信息*/
    public get level(): { LowerRank: number, Rank: number, Star: number } | null { return this._rankInfo };
    /**是否是当前玩家自己 */
    public get isOwn(): boolean { return chsdk.get_uid() === this.userId; }
    /**是否是AI */
    public get isAI(): boolean { return this._userData.userId < 8888; };
    private _canAI: boolean = false;
    /**是否有控制当前AI权限*/
    public get canAI(): boolean { return this._canAI; };
    /**是否有此玩家数据权限*/
    public get isPermission(): boolean { return this.isOwn || this._canAI; };
    public init(pd: { location: number, status: boolean, userData: any, rank: number, TotalRank: number, score: number, teamReady?: boolean; gameData?: any, userRank?: any }): void {
        this._location = pd.location;
        this._online = pd.status ?? true;
        this._ready = pd.teamReady;
        this._score = pd.score;
        this._rank = pd.rank;
        this._totalRank = pd.TotalRank;
        this._userData = pd.userData;
        this._userData.hid = Number.parseInt(pd.userData.hid);
        this._userData.loginTime = Number.parseInt(pd.userData.loginTime);
        this._userData.registerTime = Number.parseInt(pd.userData.registerTime);
        this._userData.userId = Number.parseInt(pd.userData.userId);
        this._rankInfo = pd.userRank;
        if (pd.gameData) this.initValue(pd.gameData);
    }
    private set_level(level: { LowerRank: number, Rank: number, Star: number }, rank: number, score: number, totalRank: number): void {
        this._rankInfo = level;
        this._rank = rank;
        this._totalRank = totalRank;
        this._score = score;
    }
    private set_host(isHost: boolean, ownHost: boolean): void {
        this._ishost = isHost;
        this._canAI = this.isAI && ownHost;
    }

    private change_online(ol: boolean): void {
        this._online = ol;
        (this.evt as any)._emit('online', this._online);
    }
    private change_ready(ready: boolean): void {
        this._ready = ready;
        (this.evt as any)._emit('ready', this._ready);
    }
    /**修改某个键的值*/
    public setValue<T extends StartEventNames<GD, 'p_'>, T2 extends EventParamFrist<GD, T>>(key: T, data: T2): void {
        if (!this.isPermission) return;
        let old = super.getValue(key);
        if (old) {
            if (typeof old === "object") {
                //old = JSON.parse(JSON.stringify(old));
            } else if (data === old) {
                return;
            }
        }
        super.setValue(key, data);
        super.setValueDirty(key, data);
        (this.evt as any)._emit(key, data, old);
    }
    /**获取数据的值*/
    public getValue<T extends StartEventNames<GD, 'p_'>, T2 extends EventParamFrist<GD, T>>(key: T): T2 {
        return super.getValue(key);
    }
    //服务器发送过来的数据
    private server_change(data: { [key: string]: any }): void {
        if (this.isPermission) return;
        Object.keys(data).forEach(key => {
            const old = super.getValue(key);
            super.setValue(key, data[key]);
            (this.evt as any)._emit(key, data[key], old);
        });
    }
    private setFinish(rank: number): void {
        this._rank = rank;
        (this.evt as any)._emit('finish', this._rank);
    }
    private _finsh_tag: boolean = false;
    /**玩家完成游戏 不是自己或主机没有权限*/
    public finishGame(): void {
        if (!this.isPermission) return;
        this._finsh_tag = true;
    }
    private doFinishGame(f: (id: string) => void): void {
        if (this._finsh_tag) f(this.Id);
        this._finsh_tag = false;
    }
    public dispose(): void {
        super.dispose();
        this.evt.clearAll();
    }
}