xy-server/game/object/MagicWorldMgr.ts

import WorldStar from "./WorldStar";
import NpcMgr from "../core/NpcMgr";
import PlayerMgr from "./PlayerMgr";
import SatAssembly from "../activity/SatAssembly";
import SKLogger from "../gear/SKLogger";
import SKDataUtil from "../gear/SKDataUtil";

// 逐鹿恶鬼
export default class MagicWorldMgr {

    private static _shared: MagicWorldMgr;

    static get shared(): MagicWorldMgr {
        if (!this._shared) {
            this._shared = new MagicWorldMgr();
        }
        return this._shared;
    }

    vecMagic: any[];
    refresh_timer: any;
    constructor() {
        this.vecMagic = [];
        this.refresh_timer = 0;
    }

    IsMagic(nOnlyID: any): boolean {
        for (let it in this.vecMagic) {
            let pStar = this.vecMagic[it];
            if (pStar.nOnlyID == nOnlyID)
                return true;
        }
        return false;
    }

    onCreateWorldMagic(count: number) {
        this.vecMagic = [];

        this.refresh_timer = setTimeout(() => {
            this.refresh_timer = 0;
            this.checkAndCreateWordMagic(count);
        }, 60 * 1000);
        this.checkAndCreateWordMagic(count);
    }

    FindStar(nOnlyID: any): any {
        for (let it in this.vecMagic) {
            if (this.vecMagic[it].nOnlyID == nOnlyID)
                return this.vecMagic[it];
        }
        console.log("未找到恶鬼ID=",SKDataUtil.toJson(this.vecMagic,"[]"))
        return null;
    }

    // 发起挑战
    ApplyChallenge(nNpcOnlyID: any, roleId: any): number {
        let pBomb = this.FindStar(nNpcOnlyID);
        if (null == pBomb) {
            return 1;
        }
        if (pBomb.vecApply.length > 0) {
            return 2;
        }
        pBomb.vecApply.push(roleId);
        let pSelf = this;
        setTimeout(() => {
            pSelf.trigleStarBattle(nNpcOnlyID, roleId);
        }, 800);
        return 0;
    }

    // 挑战失败
    ChallengeFail(npc_onlyid: any, battle: any) {
        let pBomb = this.FindStar(npc_onlyid);
        if (null == pBomb) {
            return;
        }
        this.matchReward(battle,0);
        pBomb.Reset();
    }

    // 检查创造怪物
    checkAndCreateWordMagic(count: number) {
        if (this.refresh_timer == 0) {
            this.refresh_timer = setTimeout(() => {
                this.refresh_timer = 0;
                this.checkAndCreateWordMagic(count);
            }, 60 * 1 * 1000);
        }
        // 证道恶鬼-上古战场
        for (let i = 0; i < count; i++) {
            this.vecMagic.push(new WorldStar(82022, 4004, 1, 2));
        }
        for (let it in this.vecMagic) {
            let pWBomb = this.vecMagic[it];
            pWBomb.Reset();
            if (pWBomb.nOnlyID > 0) {
                continue;
            }
            let stPos = pWBomb.GetPos();
            pWBomb.nOnlyID = NpcMgr.shared.CreateNpc(pWBomb.nNpc, stPos.map, stPos.x, stPos.y, {
                nKind: 0,
                nID: 0
            }, 0);
        }
        SKLogger.info(`恶鬼数量：${this.vecMagic.length}`)
    }


    // 触发战斗
    trigleStarBattle(nNpcOnlyID: any, roleId: any) {
        let pStar = this.FindStar(nNpcOnlyID);
        if (null == pStar)
            return;

        if (pStar.vecApply.length <= 0)
            return;

        let pNpc = NpcMgr.shared.findNpc(nNpcOnlyID);
        if (null == pNpc)
            return;

        let pPlayer = PlayerMgr.shared.getPlayerByRoleId(roleId);
        if (null == pPlayer)
            return;

        let pBattle = pPlayer.monsterBattle(pNpc.monster_group);
        if (null == pBattle)
            return;

        pBattle.source = nNpcOnlyID;
    }

    // 清理恶鬼
    CheckWorldMagicDead(nOnlyID: any, battle: any) {
        for (let it in this.vecMagic) {
            let pWBomb = this.vecMagic[it];
            if (pWBomb.nOnlyID != nOnlyID)
                continue;

            pWBomb.nOnlyID = 0;
            NpcMgr.shared.DeleteNpc(nOnlyID);
            this.matchReward(battle,1);
            break;
        }
    }


    // 清理所有恶鬼
    CheckWorldMagicDeadAll() {
        //关闭定时器
        clearInterval(this.refresh_timer);
        this.refresh_timer = 1;
        SKLogger.info(`清理所有恶鬼！`)
        for (let it in this.vecMagic) {
            let pWBomb = this.vecMagic[it];
            NpcMgr.shared.DeleteNpc(pWBomb.nOnlyID);
            pWBomb.nOnlyID = 0;
        }
        this.vecMagic = [];
    }

    matchReward(battle: any, isWin: number){
        if (battle != null && battle.campA != undefined){
            for (let role of battle.campA.broles) {
                // 获取当前队伍
                if (role.living_type == 1){
                    if (role.source != null && role.source != undefined) {
                        let player = PlayerMgr.shared.getPlayerByRoleId(role.source.roleid);
                        if (player != null){
                            SatAssembly.shared.sendReward(player.teamid, isWin,1);
                            break;
                        }
                    }

                }
            }
        }
    }
}