jzhj2024server/Gameserver/App/process/FightProc.php

<?php

namespace loyalsoft;

/**
 * 战斗模块
 * @author c'y'zhao
 */
class FightProc {

    public const TowerGateId = 940011999;

    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    public static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::fight_settle:                                         # 6801 主线战斗结算
                return FightProc::Settle();
            case CmdCode::fight_PassGateTsPrizeReceive:                         # 6802 章节宝箱的领取
                return FightProc::PassGateTsPrizeReceive();
            case CmdCode::fight_selectGate:                                     # 6803 主线剧情关卡选择
                return FightProc::SelectGate();
            case CmdCode::fight_gateChallengeRewards:                           # 6804 挑战关卡: 领取奖励
                return FightProc::GateChallengeRewards();
            case CmdCode::fihgt_towerStart:                                     # 6805 挑战关卡: 开始挑战
                return FightProc::ChallengeGateStartFight();
            case CmdCode::fight_plotSav:                                        # 6806 主线剧情(已播放)回存
                return FightProc::PlotSav();
            case CmdCode::fight_sweep:                                          # 6807 主线扫荡
                return FightProc::FightSweep();
            case CmdCode::fight_startFight:                                     # 6808 主线剧情关卡开始挑战
                return self::StartFight();
            case CmdCode::fight_tower_RefreshSkills:                            # 6809 挑战关卡: 刷新初始技能
                return self::TowerRefreshSkills();
            case CmdCode::fight_tower_updatelocklist:                           # 6810 挑战关卡: 更新技能锁定列表
                return self::TowerUpdateLockskillList();
            case CmdCode::fight_rankInfo:                                       # 6811 获取主线关卡排行榜信息
                return self::GetRankInfo();
            case CmdCode::fight_rank_uidEquipInfo:                              # 6812 获取主线关卡榜内玩家的装备信息
                return self::GetUidEquipInfo_Rank();
            case CmdCode::fight_rank_GetMainGateRankRewardInfo:                 # 6813 获取通关荣誉榜信息
                return self::GetmainGate_RankRewardInfo();
            case CmdCode::fight_rank_GetFightPowerRankRewardInfo:               # 6814 获取战力荣誉榜信息
                return self::GetFightPower_RankRewardInfo();
            case CmdCode::fight_rank_ReceiveRankReward_MainGate:                # 6815 领取通关荣誉榜奖励
                return self::ReceiveRankReward_MainGate();
            case CmdCode::fight_rank_ReceiveRankReward_FightPower:              # 6816 领取战力荣誉榜奖励
                return self::ReceiveRankReward_FightPower();
            default:
                Err(ErrCode::cmd_err);
        }
    }

    /**
     * 6807 扫荡
     * @return type
     */
    public static function FightSweep() {
        //list($gateId) = req()->paras;
        my_Assert(ctx()->gates->UnlockedGatesMaxId != 0, ErrCode::gate_NoSweep);
        $mo = GameConfig::gate_getItem(ctx()->gates->UnlockedGatesMaxId);
        $costTili = glc()->sweep_cost_tili;
        my_Assert(ctx()->baseInfo->tili >= $costTili, ErrCode::notenough_tili);
        $max = glc()->sweepMaxNum;
        my_Assert(ctx()->gates->fightSweepNum < $max, ErrCode::gate_SweepMaxNum_limit);
        ctx()->gates->fightSweepNum += 1;
        ctx()->baseInfo->Consume_tili($costTili);
        $prizeArr = array();
        $prizeArr[] = $mo->reward_win;
        if ($mo->sweep_gold != null) {
            $goodsStr = self::sweepRandReward($mo->sweep_gold);
            $prizeArr[] = $goodsStr;
            StoreProc::AddMultiItemInStore($goodsStr);
        }

        if ($mo->sweep_tuzhi != null) {
            $goodsStr = self::sweepRandReward($mo->sweep_tuzhi);
            $prizeArr[] = $goodsStr;
            StoreProc::AddMultiItemInStore($goodsStr);
        }

        if ($mo->sweep_gem != null) {
            $goodsStr = self::sweepRandReward($mo->sweep_gem);
            $list = explode(',', $goodsStr);
            $posId = rand(1, 6);
            $qual = $list[0];
            $dic = GameConfig::gem();

            foreach ($dic as $key => $gemMo) {
                if ($gemMo->qual == $qual && $gemMo->position == $posId) {
                    $prizeArr[] = $gemMo->typeId . ',' . $list[1];
                    StoreProc::PutGemInStore($gemMo->typeId, $list[1]);
                    break;
                }
            }
        }

        if ($mo->sweep_qiling != null) {
            $goodsStr = self::sweepRandReward($mo->sweep_qiling);
            $prizeArr[] = $goodsStr;
            StoreProc::AddMultiItemInStore($goodsStr);
        }

        UserProc::updateUserInfo();
        $ret = array(
            'tili' => ctx()->baseInfo->tili,
            'fightSweepNum' => ctx()->gates->fightSweepNum,
            'prizeArr' => $prizeArr,
            'store' => ctx()->store,
            'task' => ctx()->task,
        );
        return Resp::ok($ret);
    }

    static function sweepRandReward($rewardStr) {
        $ctxArr = explode(';', $rewardStr);
        $numArr = explode('-', $ctxArr[0]);
        $num = rand($numArr[0], $numArr[1]);

        $randNum = rand(1, 100);
        $start = 0;
        $end = 0;

        $res = "";
        $itemArr = explode(',', $ctxArr[1]);
        foreach ($itemArr as $str) {
            $arr = explode(':', $str);
            $itemId = $arr[0];
            $per = $arr[1];

            $end += $per;
            if ($randNum >= $start && $randNum < $end) {
                $res = $itemId;
                break;
            }
            $start = $end;
        }

        return $res . ',' . $num;
    }

    /**
     * 6808 开始挑战 (主线关卡:扣除体力, 挑战关卡: 增加次数)
     */
    private static function StartFight() {
        list($gateId, $layerNum) = req()->paras;
        my_Assert($gateId > 0, ErrCode::paras_err);
        $mo = GameConfig::gate_getItem($gateId);
        my_Assert(null != $mo, ErrCode::err_const_no);

        if (Ints::Slice($gateId, 0, 1) == 9) {                                  # 爬塔模式
//            list($layerNum) = req()->paras;
            if ($layerNum != ctx()->gates()->TowerGateInfo()->CurLayer) {       # 起始层数校验
                Err(ErrCode::tower_layerNum);
            }
            if (ctx()->gates()->TowerGateInfo()->TodayChanNum < 1) {           # 剩余次数校验
                Err(ErrCode::tower_timeNo);
            }
            ctx()->gates()->TowerGateInfo()->TodayChanNum--;                        # 增加次数
        } else {                                                                # 主线剧情
            my_Assert(ctx()->base()->Consume_tili($mo->cost_tili), ErrCode::notenough_tili);
        }
        UserProc::updateUserInfo();
        return Resp::ok(array("tili" => ctx()->baseInfo->tili, "tili_ts" => ctx()->baseInfo->tili_ts));
    }

    /**
     * [废弃] 6807 巡逻奖励领取
     * @return type
     */
    public static function XunluoPrizeReceived() {
        list($type) = req()->paras;

        $gateId = ctx()->gates->UnlockedGatesMaxId;
        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);

        if ($type == 1) {//巡逻
            $curTs = now();
            $startTs = ctx()->gates->xunluo_StartTs;
            $ts = $curTs - $startTs;
            $ts2 = intval($ts / 60); //总的分钟数

            $fenzhong = intval($ts2 / 10); //有几个10分钟
            $gold = 0;
            $exp = 0;
            $price = "";
            if ($fenzhong > 0) {
                $gold = intval($gateMo->gold_xunluo / 6 * $fenzhong);
                $exp = intval($gateMo->exp_xunluo / 6 * $fenzhong);
                $price = "1," . $gold . ';' . "4," . $exp;
            }

            $itemStr = explode(';', $gateMo->xunluo_item_ts);
            $itemId = 0;
            $itemNum = 0;

            $tempTs = 0;
            foreach ($itemStr as $s) {
                $arr = explode('-', $s);
                $tsItemArr = explode(',', $arr[0]);
                $sTs = $tsItemArr[0]; //开始时间
                $eTs = $tsItemArr[1]; //终止时间
                $produceTs = $tsItemArr[2]; //间隔
                while (true) {
                    $tempTs += $produceTs;
                    if ($tempTs <= $eTs && $tempTs <= $ts2) {
                        $sList = explode(',', $arr[1]);
                        $itemId = $sList[0];
                        $itemNum += $sList[1];
                    }

                    if ($tempTs >= $ts2) {
                        break;
                    }

                    if ($tempTs >= $eTs) {
                        $tempTs = $eTs;
                        break;
                    }
                }

                if ($tempTs >= $ts2) {
                    break;
                }
            }
            if ($itemNum > 0) {
                $price = $price . ";" . $itemId . ',' . $itemNum;
            }

            //---------------------------
            $tuzhiStr = explode(';', $gateMo->xunluo_tuzhi_ts);
            $tuzhiId = 0;
            $tuzhiNum = 0;

            $tempTs2 = 0;
            foreach ($tuzhiStr as $s) {
                $arr = explode('-', $s);
                $tsItemArr = explode(',', $arr[0]);
                $sTs = $tsItemArr[0]; //开始时间
                $eTs = $tsItemArr[1]; //终止时间
                $produceTs = $tsItemArr[2]; //间隔

                while (true) {
                    $tempTs2 += $produceTs;
                    if ($tempTs2 <= $eTs && $tempTs2 <= $ts2) {
                        $sList = explode(',', $arr[1]);
                        $tuzhiId = $sList[0];
                        $tuzhiNum += $sList[1];
                    }

                    if ($tempTs2 >= $ts2) {
                        break;
                    }

                    if ($tempTs2 >= $eTs) {
                        $tempTs2 = $eTs;
                        break;
                    }
                }

                if ($tempTs2 >= $ts2) {
                    break;
                }
            }
            if ($tuzhiNum > 0) {
                $price = $price . ";" . $tuzhiId . ',' . $tuzhiNum;
            }

            //---------------------
            $equipStr = explode(';', $gateMo->xunluo_equip_ts);
            $equipId = 0;
            $equipNum = 0;

            $tempTs3 = 0;
            foreach ($equipStr as $s) {
                $arr = explode('-', $s);
                $tsItemArr = explode(',', $arr[0]);
                $sTs = $tsItemArr[0]; //开始时间
                $eTs = $tsItemArr[1]; //终止时间
                $produceTs = $tsItemArr[2]; //间隔

                while (true) {
                    $tempTs3 += $produceTs;
                    if ($tempTs3 <= $eTs && $tempTs3 <= $ts2) {
                        $sList = explode(',', $arr[1]);
                        $equipId = $sList[0];
                        $equipNum += $sList[1];
                    }

                    if ($tempTs3 >= $ts2) {
                        break;
                    }

                    if ($tempTs3 >= $eTs) {
                        $tempTs3 = $eTs;
                        break;
                    }
                }

                if ($tempTs3 >= $ts2) {
                    break;
                }
            }
            if ($equipNum > 0) {
                $price = $price . ";" . $equipId . ',' . $equipNum;
            }
            StoreProc::AddMultiItemInStore($price);
            ctx()->gates->xunluo_StartTs = now();
        } else {//快速巡逻
            my_Assert(ctx()->gates->xunluo_quick_buyRecord < $gateMo->xueluo_quick_num, ErrCode::err_const_no);
            ctx()->gates->xunluo_quick_buyRecord += 1;
            ctx()->baseInfo->Consume_tili(15);
            StoreProc::AddMultiItemInStore($gateMo->xueluo_quick_reward);
        }

        UserProc::updateUserInfo();
        $ret = array(
            'tili' => ctx()->baseInfo->tili,
            'gates' => ctx()->gates,
        );
        return Resp::ok($ret);
    }

    public static function FightDailyClear() {
        //ctx()->gates->xunluo_quick_buyRecord = 0;
        ctx()->gates->fightSweepNum = 0;
        ctx()->gates()->TowerGateInfo()->RefreshSkillTimes = 0;
        ctx()->gates()->TowerGateInfo()->TodayChanNum = glc()->tower_daily_chanceNum;
    }

    /**
     * 6806 剧情回存
     * @return type
     */
    public static function PlotSav() {
        list($gateId) = req()->paras;

        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::err_const_no);
        ctx()->gates->GateList->$gateId->plotStart = 1;

        UserProc::updateUserInfo();
        $ret = array(
            'ok' => 1,
        );
        return Resp::ok($ret);
    }

// <editor-fold defaultstate="collapsed" desc="挑战模块">

    /**
     * 6810 挑战关卡: 更新锁定技能列表
     */
    public static function TowerUpdateLockskillList() {
        list($li_zd, $li_bd, $li_zds, $li_bds) = req()->paras;                  # 参数解析
        $t = ctx()->gates()->TowerGateInfo();                                   # 记忆技能刷新结果
        $t->skill_zhudong = $li_zd;
        $t->skill_beidong = $li_bd;
        $t->skill_zhudong_lockState = $li_zds;
        $t->skill_beidong_lockState = $li_bds;
        UserProc::updateUserInfo();
        return Resp::ok();
    }

    /**
     * 6809 挑战关卡: 刷新初始技能(扣除免费次数/cost)
     */
    public static function TowerRefreshSkills() {
        list($isFree, $li_zd, $li_bd, $li_zds, $li_bds) = req()->paras;         # 参数解析
        if ($isFree) {
            if (ctx()->gates()->TowerGateInfo()->RefreshSkillTimes >= glc()->tower_daily_refreshChanceNum) {
                Err(ErrCode::tower_refreshNo);                                  # 免费次数不足
            }
        } else {
            list($type, $num) = explode(':', glc()->tower_refreshCost);         # 二级货币类型(1:金币,2:元宝):数量
            if ($type == 1) {                                                   # 金币
                my_Assert(ctx()->base()->Consume_Gold($num), ErrCode::notenough_gold_msg);
            } else if ($type == 2) {                                            # 元宝
                my_Assert(ctx()->base()->Consume_Cash($num), ErrCode::notenough_cash_msg);
            } else {
                Err(ErrCode::err_const_no, "检查刷新扣费配置信息!");
            }
        }
        $t = ctx()->gates()->TowerGateInfo();                                   # 记忆技能刷新结果
        $t->RefreshSkillTimes++;
        $t->skill_zhudong = $li_zd;
        $t->skill_beidong = $li_bd;
        $t->skill_zhudong_lockState = $li_zds;
        $t->skill_beidong_lockState = $li_bds;
        UserProc::updateUserInfo();

        $ret = array(
            'task' => ctx()->task,
        );
        return Resp::ok($ret);
    }

    /**
     * 6805
     * @return type
     * @deprecated since version 2024年5月17日 已合并到6801
     */
    public static function ChallengeGateStartFight() {
//        list($layerNum) = req()->paras;
//        if ($layerNum != ctx()->gates()->TowerGateInfo()->CurLayer) {           # 起始层数校验
//            return Resp::err(ErrCode::tower_layerNum);
//        }
//        if (ctx()->gates()->TowerGateInfo()->TodayChanNum < 1) {                # 剩余次数校验
//            return Resp::err(ErrCode::tower_timeNo);
//        }
//        ctx()->gates()->TowerGateInfo()->TodayChanNum--;                        # 增加次数
//        UserProc::updateUserInfo();
//        return Resp::ok();
    }

    /**
     * 6804 挑战关卡: 奖励领取
     * @return type
     */
    public static function GateChallengeRewards() {
        list($finalLayer) = req()->paras;                                       # 战斗结束时的层数

        $lastLayer = ctx()->gates()->TowerGateInfo()->CurLayer;
        $arr = GameConfig::waves_getItemArray(self::TowerGateId);
        if ($finalLayer > $lastLayer) {
            foreach ($arr as $layerId => $layerMo) {
                if ($layerId >= $lastLayer && $layerId < $finalLayer) {
                    my_Assert($layerMo != null, ErrCode::err_const_no);
                    StoreProc::AddMultiItemInStore($layerMo->rewards);              # 发放奖励
                }
            }
            ctx()->gates()->TowerGateInfo()->CurLayer = $finalLayer;
            UserProc::updateUserInfo();
            $ret = array(
                'store' => ctx()->store,
                'gold' => ctx()->base()->gold,
                'cash' => ctx()->base()->cash,
                'task' => ctx()->task,
            );
            return Resp::ok($ret);
        }
        return Resp::err(ErrCode::tower_rewardNo);                              # 没有奖励
    }

// </editor-fold>

    /**
     * 6803 关卡选择
     * @return type
     */
    public static function SelectGate() {
        list($gateId) = req()->paras;

        ctx()->gates->CurrentGateId = $gateId;

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
        );
        return Resp::ok($ret);
    }

    /**
     * 6802 章节宝箱的领取
     * @return type
     */
    public static function PassGateTsPrizeReceive() {
        list($gateId, $index) = req()->paras;

        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);

        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
        $gateInfo = ctx()->gates->GateList->$gateId;

        $tag = false;
        $prize = "";
        $mask = 0;
        switch ($index) {
            case 1:
                $ts = $gateMo->first_ts1 * 60;
                if ($gateInfo->MaxSeconds >= $ts) {
                    $tag = true;
                }
                $mask = 1;
                $prize = $gateMo->first_reward1;
                break;
            case 2:
                $ts = $gateMo->first_ts2 * 60;
                if ($gateInfo->MaxSeconds >= $ts) {
                    $tag = true;
                }
                $mask = 2;
                $prize = $gateMo->first_reward2;
                break;
            case 3:
                if ($gateInfo->pass > 0) {
                    $tag = true;
                }
                $mask = 3;
                $prize = $gateMo->first_reward3;
                break;
            default:
                break;
        }

        if ($tag) {
            my_Assert($mask > $gateInfo->FirstReward, ErrCode::gate_GatePriceHasReceive);
            $gateInfo->FirstReward = $mask;
            StoreProc::AddMultiItemInStore($prize);
        }
        ctx()->gates->GateList->$gateId = $gateInfo;

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
            'store' => ctx()->store,
            'task' => ctx()->task,
            'gold' => ctx()->baseInfo->gold,
        );
        return Resp::ok($ret);
    }

    /**
     * [6801]关卡战斗结算
     * @return type
     */
    public static function Settle() {
        list($resultType, $gateId, $gold, $curTs, $pickups,
                $finalLayer, $finalHpPercent, $killMonsterNum, $killBossNum) = req()->paras;
        # 客户端需要增加参数: killmonserNum,killBosssNum, finalHpPercent(最终血量百分比)
        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);
        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
        $gateInfo = ctx()->gates->GateList->$gateId;
        $ts = $gateInfo->MaxSeconds;
        if ($curTs >= $ts) {
            $gateInfo->MaxSeconds = $curTs;
        }
        if ($resultType) {                                                      # 胜利
            if (ctx()->gates->GateList->$gateId->pass == 0) {
                ctx()->gates->GateList->$gateId->pass = 1;
                TaskProc::Day7TaskReset($gateId);                               # 刷新七日任务
                $maxGateId = ctx()->gates->maxPassGateId();
                if ($maxGateId > 0) {
                    self::Ranking_MainGateIndex($maxGateId);
                }
            }

            TaskProc::OnPassGate_X($gateId);                                    # 刷新任务进度: 通关第X关

            if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainStoryGate) {
                ctx()->gates()->UnlockNextPlotGate();                           # 解锁下一主线关卡
//                ctx()->gates()->UnlockMainChallengeGate($gateId);              # 挑战关卡解锁逻辑. -gwang 2024年4月15日
            } else {                                                            # 不是主线关卡, 暂时没有其他逻辑
            }
//            StoreProc::AddMultiItemInStore($gateMo->reward_win);                # 发放胜利奖励(2024.5.30 过期)
        }
//        else {                                                                # 失败
////            StoreProc::AddMultiItemInStore($gateMo->reward_fail);               # 发放失败奖励(2024.5.30 过期)
//        }

        StoreProc::AddMultiItemInStore($pickups);                               # 战场拾取道具直接入背包
        ctx()->base()->Add_Gold($gold);                                         # 战场拾取的金币直接入背包
        //ctx()->base()->Add_Exp($exp);
        $waveMo = GameConfig::waveItem_getItem($gateId, $finalLayer);
        my_Assert(null != $waveMo, ErrCode::err_const_no);
        ctx()->base()->Add_Exp($waveMo->rewardExp);                             # 指挥官经验
        ctx()->base()->Add_Gold($waveMo->rewardGold);                           # 金币奖励
        $pickups .= ";1," . $gold + $waveMo->rewardGold;
        # 图纸奖励: 数量min-max, 部位随机
        if (strlen($waveMo->rewardTuZhi) > 0 && str_contains($waveMo->rewardTuZhi, '-')) {
            list($tz_min, $tz_max) = explode('-', $waveMo->rewardTuZhi);        # 图纸数量
            $tz_n = rand($tz_min, $tz_max);
            # 图纸部位数据源 1001, 1002, 1003, 1004, 1005, 1006
            for ($i = 0; $i < $tz_n; $i++) {
                $id = 1000 + rand(1, 6);
                StoreProc::AddMultiItemInStore("$id,1");                        # 获得图纸
                $pickups .= ";$id,1";
            }
        }
        # 宝石奖励: 数量min-max;品质:权重,品质:权重...
        if (strlen($waveMo->rewardGem) > 0) {
            list($gs_num, $gs_props) = explode(';', $waveMo->rewardGem);
            list($gem_min, $gem_max) = explode('-', $gs_num);                   # 宝石数量
            $gem_n = rand($gem_min, $gem_max);
            $arr = explode(",", $gs_props);
            $pool = array();
            $n = 0;
            foreach ($arr as $str) {
                list($qual, $props) = explode(':', $str);
                $pool[] = array('q' => $qual, 'p' => $props);
                $n += $props;
            }
            for ($i = 0; $i < $gem_n; $i++) {                                   # 随机n块宝石
                $r = rand(0, $n);                                                  # 投色子
                $l = 0;
                foreach ($pool as $item) {
                    if ($r < ($l + $item->p)) {
                        $gemId = $item->q * 10000 + rand(1, 6) * 1000;
                        StoreProc::PutGemInStore($gemId);                       # 发放宝石并退出本次投色子
                        $pickups .= ";$gemId,1";
                        break;
                    }
                    $l += $item->p;                                             # 累计到下一段
                }
            }
        }

        if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainStoryGate) {            # 主线剧情,
            TaskProc::OnFightNumMainGate();
        } else if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainChallengeGate) { # 主线剧情对应的难度挑战
            TaskProc::OnFightNumChallengeGate();
        }
        TaskProc::OnKillCommonNumMonster($killMonsterNum);
        TaskProc::OnKillleaderNumMonster($killBossNum);

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
            'store' => ctx()->store,
            'task' => ctx()->task,
            'baseInfo' => ctx()->base(),
            'gold' => $gold + $waveMo->rewardGold,
            'exp' => $waveMo->rewardExp,
            'rewardStr' => $pickups
        );
        return Resp::ok($ret);
    }

    /**
     * [6801]关卡战斗结算
     * @return type
     */
    public static function Settle_bak() {
        list($resultType, $gateId, $gold, $curTs, $pickups) = req()->paras;
        # 客户端需要增加参数: killmonserNum,killBosssNum, finalHpPercent(最终血量百分比)
        $gateMo = GameConfig::gate_getItem($gateId);
        my_Assert($gateMo != null, ErrCode::err_const_no);
        my_Assert(StlUtil::dictHasProperty(ctx()->gates->GateList, $gateId), ErrCode::gate_NoUserGateInfo);
        $gateInfo = ctx()->gates->GateList->$gateId;
        $ts = $gateInfo->MaxSeconds;
        if ($curTs >= $ts) {
            $gateInfo->MaxSeconds = $curTs;
        }
        if ($resultType) {                                                      # 胜利
            if (ctx()->gates->GateList->$gateId->pass == 0) {
                ctx()->gates->GateList->$gateId->pass = 1;
                TaskProc::Day7TaskReset($gateId);
            }
            TaskProc::OnPassGate_X($gateId);
            StoreProc::AddMultiItemInStore($gateMo->reward_win);
            if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainStoryGate) {
                ctx()->gates->UnlockNextPlotGate();
                $dic = GameConfig::gate();
                $index = 0;                                                   # 挑战关卡解锁逻辑. -gwang 2024年4月15日
                foreach ($dic as $id => $item) {
                    if (Ins_GateInfo::GateTypeFromId($id) == Enum_GateType::MainChallengeGate && $item->challengeGateId == $gateId) {
                        $index += 1;
                        $gate = new Ins_GateInfo();
                        $gate->GateId = $id;
                        ctx()->gates->GateList->$id = $gate;
                    }
                    if ($index >= 3) {
                        break;
                    }
                }
            } else {

            }
        } else {                                                                # 失败
            StoreProc::AddMultiItemInStore($gateMo->reward_fail);
        }

        StoreProc::AddMultiItemInStore($pickups);                               # 战场拾取道具
        ctx()->baseInfo->Add_Gold($gold);
        //ctx()->baseInfo->Add_Exp($exp);

        if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainStoryGate) {
            TaskProc::OnFightNumMainGate();
        } else if (Ins_GateInfo::GateTypeFromId($gateId) == Enum_GateType::MainChallengeGate) {
            TaskProc::OnFightNumChallengeGate();
        }
        TaskProc::OnKillCommonNumMonster(1000);
        TaskProc::OnKillleaderNumMonster(500);

        UserProc::updateUserInfo();
        $ret = array(
            'gates' => ctx()->gates,
            'store' => ctx()->store,
            'task' => ctx()->task,
        );
        return Resp::ok($ret);
    }

// <editor-fold defaultstate="collapsed" desc="排行榜">

    /**
     * 参与主线关卡排行榜
     * @param type $gateIndex
     */
    public static function Ranking_MainGateIndex($maxGateIndex) {
        $memKey = MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid);
        $mem = gMem();

        $uid = req()->uid;
        $arr = array();
        $arr["$uid"] = $maxGateIndex;
        $mem->zadd($memKey, $arr);

        $length = $mem->zlen($memKey);
        if ($length > glc()->Rank_MainGateIndex_OnListRank) {
            $num = $length - glc()->Rank_MainGateIndex_OnListRank;
            $mem->zremrangebyrank($memKey, 0, $num - 1);
        }
    }

    /**
     * 战力榜
     * @param type $gateIndex
     */
    public static function Ranking_FightPower() {
        $memKey = MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid);
        $mem = gMem();
        $arr = array();
        $uid = req()->uid;
        $power = 10;
        $arr["$uid"] = $power;
        $mem->zadd($memKey, $arr);

        $length = $mem->zlen($memKey);
        if ($length > glc()->Rank_FightPower_OnListRank) {
            $num = $length - glc()->Rank_FightPower_OnListRank;
            $mem->zremrangebyrank($memKey, 0, $num - 1);
        }
    }

    /**
     * 6811 获取主线关卡排行榜信息
     * @return type
     */
    public static function GetRankInfo() {
        list($type) = req()->paras;

        $selfIsHasRank = 0; //本人是否上榜 0未上榜没有排名 1上榜则selfRank就是排名
        $selfExtraInfo = 0;
        $isExistFinishReward = false;
        if ($type == 1) {
            $list = gMem()->zrevrange(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), 0, glc()->Rank_MainGateIndex_OnListRank, true);
            $selfExtraInfo = ctx()->gates->UnlockedGatesMaxId;

            $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
            $dic = gMem()->hgetall($memKey);
            foreach ($dic as $gateId => $ins_rank) {
                if (!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate)) {
                    $isExistFinishReward = true;
                    break;
                }
            }
        } else {
            $list = gMem()->zrevrange(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), 0, glc()->Rank_FightPower_OnListRank, true);
            $selfExtraInfo = 0; //战力还没有

            $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
            $dic = gMem()->hgetall($memKey);
            foreach ($dic as $fightPower => $ins_rank) {
                if (!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower)) {
                    $isExistFinishReward = true;
                    break;
                }
            }
        }

        $selfRank = self::initOtherUidRankInfo(req()->uid, $selfExtraInfo);

        $retArr = array();
        if (count($list) > 0) {
            foreach ($list as $uid => $score) {
                $rankInfo = self::initOtherUidRankInfo($uid, $score);
                if ($rankInfo->uid == req()->uid) {
                    $selfIsHasRank = 1;
                    $selfRank = $rankInfo;
                }

                $retArr[] = $rankInfo;
            }
        }

        UserProc::updateUserInfo();
        $ret = array(
            'rankInfo' => $retArr,
            'selfRank' => $selfRank,
            'selfIsHasRank' => $selfIsHasRank,
            'isExistFinishReward' => $isExistFinishReward,
        );
        return Resp::ok($ret);
    }

    /**
     * 初始化玩家rank
     * @param type $uid
     * @param type $score
     * @return \loyalsoft\Ins_rank
     */
    static function initOtherUidRankInfo($uid, $score) {
        $ins_rank = new Ins_rank();
        $lv = gMem()->zrank(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), $uid);
        if ($lv == null) {
            $lv = 0;
        }
        $ins_rank->rank = $lv + 1;
        $ins_rank->uid = $uid;
        $userInfo = UserProc::getUserGame(req()->zoneid, $uid);
        $ins_rank->name = $userInfo->baseInfo->name;
        $ins_rank->headImg = $userInfo->baseInfo->headImg;

        $ins_rank->score = $score;
        return $ins_rank;
    }

    /**
     * 6812 获取排行榜内玩家的装备信息
     * @return type
     */
    public static function GetUidEquipInfo_Rank() {
        list($uid) = req()->paras;
        $userInfo = UserProc::getUserGame(req()->zoneid, $uid);

        $store = $userInfo->store;
        $heros = $userInfo->heros;

        UserProc::updateUserInfo();
        $ret = array(
            'store' => $store,
            'heros' => $heros,
        );
        return Resp::ok($ret);
    }

    /**
     * 通关奖励是否达成
     * @param type $maxGateIndex
     */
    public static function IsAchievedMainGate_PassReward($maxGateIndex) {
        $rewards = GameConfig::rank_passgatereward();

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        foreach ($rewards as $passGateId => $mo) {
            if ($passGateId == $maxGateIndex && !gMem()->hexists($memKey, $maxGateIndex)) {
                $ins_rank = new Ins_rank();
                $ins_rank->uid = req()->uid;
                $ins_rank->name = ctx()->baseInfo->name;
                $ins_rank->headImg = ctx()->baseInfo->headImg;
                $ins_rank->score = $passGateId;
                gMem()->hset($memKey, $maxGateIndex, $ins_rank);
                break;
            }
        }
    }

    /*
     * 战力奖励是否达成
     */

    public static function IsAchievedFightPower_PassReward() {
        $power = 0; //临时
        $rewards = GameConfig::rank_fightpowerreward();

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        foreach ($rewards as $fightPower => $mo) {
            if ($power >= $fightPower && !gMem()->hexists($memKey, $fightPower)) {
                $ins_rank = new Ins_rank();
                $ins_rank->uid = req()->uid;
                $ins_rank->name = ctx()->baseInfo->name;
                $ins_rank->headImg = ctx()->baseInfo->headImg;
                $ins_rank->score = $fightPower;
                gMem()->hset($memKey, $fightPower, $ins_rank);
            }
        }
    }

    /**
     * 6813
     * @return type
     */
    public static function GetmainGate_RankRewardInfo() {
        //list($type) = req()->paras;

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);

//        $retArr = new \stdClass();
//        foreach ($dic as $gateId => $uid) {
//            $ins_rank = new Ins_rank();
//            $ins_rank->uid = $uid;
//            $userInfo = UserProc::getUserGame(req()->zoneid, $uid);
//            $ins_rank->name = $userInfo->baseInfo->name;
//            $ins_rank->headImg = $userInfo->baseInfo->headImg;
//            $ins_rank->score = $gateId;
//            $retArr->$gateId = $ins_rank;
//        }

        UserProc::updateUserInfo();
        $ret = array(
            'rankReward' => $dic,
        );
        return Resp::ok($ret);
    }

    /**
     * 6814
     * @return type
     */
    public static function GetFightPower_RankRewardInfo() {
        //list($type) = req()->paras;

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey);

//        $retArr = new \stdClass();
//        foreach ($dic as $fightPower => $uid) {
//            $ins_rank = new Ins_rank();
//            $ins_rank->uid = $uid;
//            $userInfo = UserProc::getUserGame(req()->zoneid, $uid);
//            $ins_rank->name = $userInfo->baseInfo->name;
//            $ins_rank->headImg = $userInfo->baseInfo->headImg;
//            $ins_rank->score = $fightPower;
//            $retArr->$fightPower = $ins_rank;
//        }


        UserProc::updateUserInfo();
        $ret = array(
            'rankReward' => $dic,
        );
        return Resp::ok($ret);
    }

    /**
     * 6815 领取通关荣誉榜奖励
     * @return type
     */
    public static function ReceiveRankReward_MainGate() {
        list($gateId) = req()->paras;

        my_Assert(!in_array($gateId, ctx()->privateState->rankReward_drawed_MainGate), ErrCode::rankReward_HasReceive);

        $mo = GameConfig::rank_passgatereward_getItem($gateId);
        my_Assert($mo != null, ErrCode::err_const_no);

        $memKey = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        if (gMem()->hexists($memKey, $gateId)) {
            StoreProc::AddMultiItemInStore($mo->reward);
            ctx()->privateState->rankReward_drawed_MainGate[] = $gateId;
        }

        UserProc::updateUserInfo();
        $ret = array();
        return Resp::ok($ret);
    }

    /**
     * 6816 领取战力荣誉榜奖励
     * @return type
     */
    public static function ReceiveRankReward_FightPower() {
        list($fightPower) = req()->paras;

        my_Assert(!in_array($fightPower, ctx()->privateState->rankReward_drawed_fightPower), ErrCode::rankReward_HasReceive);

        $mo = GameConfig::rank_passgatereward_getItem($fightPower);
        my_Assert($mo != null, ErrCode::err_const_no);

        $memKey = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        if (gMem()->hexists($memKey, $fightPower)) {
            StoreProc::AddMultiItemInStore($mo->reward);
            ctx()->privateState->rankReward_drawed_fightPower[] = $fightPower;
        }

        UserProc::updateUserInfo();
        $ret = array();
        return Resp::ok($ret);
    }
    /*
     * 删除排行榜内注销账号的玩家
     */
    public static function DeleteRankInvalidUser($uid) {
        gMem()->zrem(MemKey_GameRun::Rank_MainGateIndex_Zone_zset(req()->zoneid), $uid);    
        gMem()->zrem(MemKey_GameRun::Rank_FightPower_Zone_zset(req()->zoneid), $uid);    
    }
    /*
     * 排行玩家头像变动
     */
    public static function UpdateRankUserHeadImg($uid,$headImg) {
        $memKey1 = MemKey_GameRun::RankReward_MainGateIndex_Zone_hash(req()->zoneid);
        $dic = gMem()->hgetall($memKey1);
        foreach ($dic as $gateId => $ins_rank) {
            if($ins_rank->uid == $uid){
                $ins_rank->headImg = $headImg;              
                gMem()->hset($memKey1, $gateId, $ins_rank);
            }                     
        }
        
        $memKey2 = MemKey_GameRun::RankReward_FightPower_Zone_hash(req()->zoneid);
        $dic2 = gMem()->hgetall($memKey2);
        foreach ($dic2 as $fightPower => $ins_rank) {
            if($ins_rank->uid == $uid){
                $ins_rank->headImg = $headImg; 
                gMem()->hset($memKey2, $fightPower, $ins_rank);
            } 
        }
    }

    // </editor-fold>
}